springboot中Redis的Lettuce客戶端和jedis客戶端

1、引入客戶端依賴

        <!--jedis客戶端依賴-->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
        </dependency>


        <!--默認使用lettuce客戶端-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
            <version>2.1.4.RELEASE</version>
        </dependency>

2、RedisTemplate 自定義對象定義

@Configuration
public class BackupRedisConfig {

    //Redis數據庫索引
    @Value("${spring.redis.database}")
    Integer database;
    //Redis服務器地址
    @Value("${spring.backup.redis.host}")
    String host;
    // Redis服務器連接端口
    @Value("${spring.redis.port}")
    Integer port;
    //Redis服務器連接密碼
    @Value("${spring.backup.redis.password}")
    String password;

    //連接池最大連接數（使用負值表示沒有限制）
    @Value("${spring.redis.lettuce.pool.max-active}")
    Integer maxActive;
//連接池最大阻塞等待時間（使用負值表示沒有限制）
    @Value("${spring.backup.redis.lettuce.pool.max-wait}")
    Long maxWait;
    //連接池中的最大空閑連接
    @Value("${spring.redis.lettuce.pool.max-idle}")
    Integer maxIdle;
    //連接池中的最小空閑連接
    @Value("${spring.redis.lettuce.pool.min-idle}")
    Integer minIdle;
    // 連接超時時間（毫秒）
    @Value("${spring.backup.redis.timeout}")
    String timeout;



    @Bean("backupRedisTemplate")
    public RedisTemplate backupRedisTemplate() {
        //lettuce 客戶端連接池配置
        GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
        poolConfig.setMaxTotal(maxActive);
        poolConfig.setMaxWaitMillis(maxWait);
        poolConfig.setMaxIdle(maxIdle);
        poolConfig.setMinIdle(minIdle);
        //lettuce 客戶端配置
        RedisStandaloneConfiguration config = new RedisStandaloneConfiguration();
        config.setDatabase(database);
        config.setHostName(host);
        config.setPort(port);
        config.setPassword(password);

//      lettuce創建工廠
//        LettuceClientConfiguration clientConfiguration = LettucePoolingClientConfiguration.builder().poolConfig(poolConfig).build();
//        LettuceConnectionFactory factory = new LettuceConnectionFactory(config, clientConfiguration);
//        factory.afterPropertiesSet();

        //jedis連接池配置
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        jedisPoolConfig.setMaxIdle(maxIdle);
        jedisPoolConfig.setMaxWaitMillis(maxWait);
        jedisPoolConfig.setMaxTotal(maxActive);

        //創建jedis工廠
        JedisConnectionFactory factory = new JedisConnectionFactory(config);
        factory.setPoolConfig(jedisPoolConfig);

        //構建reids客戶端，只能指定其中1個工廠
        RedisTemplate redisTemplate = new RedisTemplate();
        redisTemplate.setConnectionFactory(factory);
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(new FastJsonRedisSerializer<>(Object.class));
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }


}

3、RedisTemplate 默認鏈接對象，指定reids序列化方式，自定義緩存注解讀寫機制@Cacheable

  a、實現RedisSerializer接口

public class FastJsonRedisSerializer<T> implements RedisSerializer<T> {

    public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");

    private Class<T> clazz;

    // 解決fastJson autoType is not support錯誤
    static {
        ParserConfig.getGlobalInstance().addAccept("com.qingclass.yiban");
    }

    public FastJsonRedisSerializer(Class<T> clazz) {
        super();
        this.clazz = clazz;
    }

    @Nullable
    @Override
    public byte[] serialize(T t) throws SerializationException {
        if (t == null) {
            return new byte[0];
        }
        return JSON.toJSONString(t, SerializerFeature.WriteClassName).getBytes(DEFAULT_CHARSET);
    }

    @Nullable
    @Override
    public T deserialize(byte[] bytes) throws SerializationException {
        if (bytes == null || bytes.length <= 0) {
            return null;
        }
        String str = new String(bytes, DEFAULT_CHARSET);
        return JSON.parseObject(str, clazz);
    }

}

b、指定reids序列化方式，自定義緩存注解讀寫機制@Cacheable

@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {

    /**
     * 設置reids 鏈接序列化
     * @param factory
     * @return
     */
    @Bean
    public RedisTemplate redisTemplate(LettuceConnectionFactory factory) {
        RedisTemplate redisTemplate = new RedisTemplate();
        redisTemplate.setConnectionFactory(factory);
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(getJsonRedisSerializer());
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }

    /**
     * 指定緩存管理器，讀寫機制
     * @param factory
     * @return
     */
    @Bean
    public CacheManager cacheManager(LettuceConnectionFactory factory) {
        // 默認過期時間1小時
        RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig().disableKeyPrefix()
                .entryTtl(Duration.ofHours(CacheTtl.ONE_HOUR.getTime()))
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(getJsonRedisSerializer()));
        return RedisCacheManager
                .builder(RedisCacheWriter.nonLockingRedisCacheWriter(factory))
                .cacheDefaults(redisCacheConfiguration)
                .withInitialCacheConfigurations(getRedisCacheConfigurationMap())
                .build();
    }

    private Map<String, RedisCacheConfiguration> getRedisCacheConfigurationMap() {
        Map<String, RedisCacheConfiguration> redisCacheConfigurationMap = new HashMap<>(CacheTtl.values().length);
        for (CacheTtl cacheTtl : CacheTtl.values()) {
            redisCacheConfigurationMap.put(cacheTtl.getValue(), this.getRedisCacheConfigurationWithTtl(cacheTtl.getTime()));
        }
        return redisCacheConfigurationMap;
    }

    private RedisCacheConfiguration getRedisCacheConfigurationWithTtl(Integer hours) {
        RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig().disableKeyPrefix()
                .entryTtl(Duration.ofHours(hours))
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(getJsonRedisSerializer()));
        return redisCacheConfiguration;
    }

    private FastJsonRedisSerializer getJsonRedisSerializer() {
        return new FastJsonRedisSerializer<>(Object.class);
    }

}

 

* spring boot在1.x.x的版本時默認使用的jedis客戶端，
* 現在是2.x.x版本默認使用的lettuce客戶端
* 詳情鏈接 https://www.cnblogs.com/taiyonghai/p/9454764.html