SpringBoot集成Redis环境搭建及配置详解_springboot redis 配置-CSDN博客

 

连接池选择及Jedis连接池参数配置建议_分布式缓存服务 DCS

官网 Drivers :: Spring Data Redis

1 总结

1:默认整合了两种连接池,lettuce 和 jedis ,默认使用 lettuce连接池(因为支持的功能多)

2:如果配置了自定义的RedisConnectionFactory ,Spring Boot就不会自动配置 RedisConnectionFactory

2:不配置序列化器,我们是无法看懂的

2 pom

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        <!--    <version>2.5.1</version>-->
        </dependency>
         <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
          <!--  <version>2.9.0</version>-->
        </dependency>

 配置jedis连接池时用

      <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
        </dependency>

3 简单使用(单机版)

配置文件

spring:
  application:
    name: redis
  redis:
    port: 6379
    database: 0
    # host: 192.168.135.10
    host: 127.0.0.1
    jedis:
      pool:
        max-active: 300
        max-idle: 300
        min-idle: 100
        max-wait: 5s
    lettuce:
      pool:
        max-active: 300
        max-idle: 300
        min-idle: 100
        max-wait: 5s
      shutdown-timeout: 100ms

 直接使用,设置值

    @Autowired
    RedisTemplate redisTemplate;
    @Test
    void contextLoads1() {
        //設置字符串 新值
        redisTemplate.opsForValue().set("ok","测试ok1");
        String ok = (String)redisTemplate.opsForValue().get("ok");
        System.out.println(ok);
    }

 因为未配置序列化器

默认加载哪个连接池

结论:不自定义连接池情况下,默认只会加载lettuce连接池

1:当我们配置文件配置了lettuce时,会加在配置单连接池中。

配置文件不会因为你配置 jedis 默认使用jedis连接池。

序列化器


import com.alibaba.fastjson.parser.ParserConfig;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.ListOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.data.redis.serializer.StringRedisSerializer;


@Configuration
public class RedisTemplateConfig {
    /**
     * 可以注入方式设置连接
     */
/*    @Autowired
    private RedisConnectionFactory factory;*/

    /**
     * RedisTemplate配置 改成json序列化模式用keys方法可取到值 否则取不到
     *
     */
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);
        FastJsonRedisSerializer<Object> fastJsonRedisSerializer = new FastJsonRedisSerializer<>(Object.class);
        // 全局开启AutoType,不建议使用
        // ParserConfig.getGlobalInstance().setAutoTypeSupport(true);
        // 建议使用这种方式,小范围指定白名单
        ParserConfig.getGlobalInstance().addAccept("com.demo.");
        // 设置值(value)的序列化采用FastJsonRedisSerializer。
        template.setValueSerializer(fastJsonRedisSerializer);
        template.setHashValueSerializer(fastJsonRedisSerializer);
        template.setDefaultSerializer(fastJsonRedisSerializer);
        // 设置键(key)的序列化采用StringRedisSerializer。
        template.setKeySerializer(new StringRedisSerializer());
        template.setHashKeySerializer(new StringRedisSerializer());
        template.afterPropertiesSet();
        return template;
    }
    /**
     * 可以删除
     */
    @Bean
    public ValueOperations valueOperations(RedisTemplate redisTemplate){
        return redisTemplate.opsForValue();
    }
    /**
     * 可以删除
     */
    @Bean
    public ListOperations listOperations(RedisTemplate redisTemplate){
        return redisTemplate.opsForList();
    }
    /**
     * 可以删除
     */
    @Bean
    public HashOperations hashOperations(RedisTemplate redisTemplate){
        return redisTemplate.opsForHash();
    }
}

 方式二

测试成功

4 自定义LettuceConnectionFactory

1:场景:配置文件中用户,密码是加密的,需要解密后 设置到连接池中。

2: 可以发现自定义配置参数会 覆盖配置文件的配置参数

import com.alibaba.fastjson.parser.ParserConfig;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.connection.lettuce.LettucePoolingClientConfiguration;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;



@Configuration  // 配置类
public class RedisConfig  {

    /**
     *  配置 Redis 连接工厂
     *  意义: LettuceConnectionFactory 是连接 Redis 服务器的入口,它使用了 Lettuce 客户端,并且配置了连接池来提高性能和资源管理
     * @return
     */
    @Bean
    public LettuceConnectionFactory redisConnectionFactory() {
        // 配置 Redis 服务器的连接信息 可以读取配置文件获取
        RedisStandaloneConfiguration redisStandaloneConfiguration = new RedisStandaloneConfiguration();
        redisStandaloneConfiguration.setHostName("localhost");
        redisStandaloneConfiguration.setPort(6379);
        // redisStandaloneConfiguration.setPassword("password"); // 取消注释以设置密码
        // 配置连接池
        GenericObjectPoolConfig<Object> poolConfig = new GenericObjectPoolConfig<>();
        poolConfig.setMaxTotal(10);       // 连接池中的最大连接数
        poolConfig.setMaxIdle(5);         // 连接池中的最大空闲连接数
        poolConfig.setMinIdle(1);         // 连接池中的最小空闲连接数
        poolConfig.setMaxWaitMillis(2000); // 连接池获取连接的最大等待时间
        // 创建一个带有连接池配置的 Lettuce 客户端配置
        LettucePoolingClientConfiguration lettucePoolingClientConfiguration =
            LettucePoolingClientConfiguration.builder()
                .poolConfig(poolConfig)
                .build();
        // 返回带有连接池配置的 Redis 连接工厂
        return new LettuceConnectionFactory(redisStandaloneConfiguration, lettucePoolingClientConfiguration);
    }



    @Bean
    public RedisTemplate<String, Object> redisTemplate(LettuceConnectionFactory factory) {
        /*    2.设置连接工厂: 使用前面定义的 LettuceConnectionFactory。
            3.设置序列化器: 设置键和值的序列化器,这里使用 StringRedisSerializer 来将键和值序列化为字符串。
         */
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);
        FastJsonRedisSerializer<Object> fastJsonRedisSerializer = new FastJsonRedisSerializer<>(Object.class);
        // 全局开启AutoType,不建议使用
        // ParserConfig.getGlobalInstance().setAutoTypeSupport(true);
        // 建议使用这种方式,小范围指定白名单
        ParserConfig.getGlobalInstance().addAccept("com.demo.");
        // 设置值(value)的序列化采用FastJsonRedisSerializer。
        template.setValueSerializer(fastJsonRedisSerializer);
        template.setHashValueSerializer(fastJsonRedisSerializer);
        template.setDefaultSerializer(fastJsonRedisSerializer);
        // 设置键(key)的序列化采用StringRedisSerializer。
        template.setKeySerializer(new StringRedisSerializer());
        template.setHashKeySerializer(new StringRedisSerializer());
        template.afterPropertiesSet();
        return template;
    }


}

 最终加载的是代码中自定义配置的连接池参数,而不是配置文件中配置。

5 自定义JedisConnectionFactory

1:配置了Jedis连接池后,用的就是Jedis了。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.env.Environment;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import redis.clients.jedis.JedisPoolConfig;

@Configuration
public class JedisConnectionConfig {
    @Autowired
   private Environment env;
    @Bean
    public JedisConnectionFactory redisConnectionFactory() {
        Integer port = Integer.valueOf(env.getProperty("spring.redis.port"));
        String host = env.getProperty("spring.redis.host");
        String password = env.getProperty("spring.redis.password");
        Integer database = Integer.valueOf(env.getProperty("spring.redis.database"));
        Integer maxActive = Integer.valueOf(env.getProperty("spring.redis.jedis.pool.max-active"));
        Integer maxIdle = Integer.valueOf(env.getProperty("spring.redis.jedis.pool.max-idle"));
        Integer minIdle = Integer.valueOf(env.getProperty("spring.redis.jedis.pool.min-idle"));
        JedisPoolConfig poolConfig = new JedisPoolConfig();
        //最大空闲数
        poolConfig.setMaxIdle(maxIdle);
        //最大连接数
        poolConfig.setMaxTotal(maxActive);
        //最大等待毫秒数
        poolConfig.setMaxWaitMillis(20000);
        poolConfig.setMinIdle(minIdle);
        poolConfig.setTestOnBorrow(true);
        RedisStandaloneConfiguration config = new RedisStandaloneConfiguration("server", 6379);
        config.setPort(port);
        config.setDatabase(database);
        config.setHostName(host);
        if (null != password) {
            config.setPassword(password);
        }
        JedisConnectionFactory jedisConnectionFactory = new JedisConnectionFactory(config);
        jedisConnectionFactory.setPoolConfig(poolConfig);
        return jedisConnectionFactory;
    }
}

点赞(0) 打赏

评论列表 共有 0 条评论

暂无评论

微信公众账号

微信扫一扫加关注

发表
评论
返回
顶部