springboot 集成 redis luttuce && redisson ，单机 && 集群模式(根据不同环境读取不同环境的配置)

luttuce 和redisson配置过程中实际上是独立的，他们两个可以同时集成，但是没有直接相关关系，配置相对独立。
所以分为Lettuce 和 Redisson 两套配置
父pom

            <!-- Spring Data Redis -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-redis</artifactId>
                <version>2.3.11.RELEASE</version>
            </dependency>
			<!--连接池 不集成redisTempate配置工厂类会报错-->
            <dependency>
                <groupId>org.apache.commons</groupId>
                <artifactId>commons-pool2</artifactId>
                <version>2.4.2</version>
            </dependency>
            <!-- Redisson -->
            <dependency>
                <groupId>org.redisson</groupId>
                <artifactId>redisson-spring-data-22</artifactId>
                <version>3.23.3</version>
            </dependency>

 

子pom

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson-spring-data-22</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>

lettuce
单机模式

cluster集群模式
lettuce yaml配置

配置文件

@Configuration
public class RedisConfig {

    @Bean
    RedisTemplate redisTemplate(LettuceConnectionFactory lettuceConnectionFactory){
        RedisTemplate redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(lettuceConnectionFactory);
        // 使用Jackson2JsonRedisSerializer 替换默认的JDKSerializationRedisSerializer 来序列化和反序列化redis 的value值
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        // hash的value序列化方式采用jackson
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }
}

Redisson
单机模式
新建yaml文件：

singleServerConfig:
  # 连接空闲超时，单位：毫秒
  idleConnectionTimeout: 10000
  # 连接超时，单位：毫秒
  connectTimeout: 10000
  # 命令等待超时，单位：毫秒 默认3000
  timeout: 3000
  # 命令失败重试次数
  retryAttempts: 3
  # 命令重试发送时间间隔，单位：毫秒
  retryInterval: 1500
  # 无密码则设置 null
  password: 123456
  # 单个连接最大订阅数量
  subscriptionsPerConnection: 5
  # 客户端名称
  clientName: null
  # redis 节点地址
  address: "redis://127.0.0.1:6379"
  # 从节点发布和订阅连接的最小空闲连接数
  subscriptionConnectionMinimumIdleSize: 1
  # 发布和订阅连接池大小
  subscriptionConnectionPoolSize: 50
  # 发布和订阅连接的最小空闲连接数
  connectionMinimumIdleSize: 32
  # 发布和订阅连接池大小
  connectionPoolSize: 64
  # 数据库编号
  database: 10
  # DNS监测时间间隔，单位：毫秒  在启用该功能以后，Redisson将会监测DNS的变化情况
  dnsMonitoringInterval: 5000
threads: 0
nettyThreads: 0
codec: !<org.redisson.codec.JsonJacksonCodec> {}
transportMode: "NIO"

集群模式
新建yaml文件：

clusterServersConfig:
  idleConnectionTimeout: 10000
  connectTimeout: 10000
  timeout: 3000
  retryAttempts: 3
  retryInterval: 1500
  password: xxxx
  subscriptionsPerConnection: 5
  clientName: null
  loadBalancer: !<org.redisson.connection.balancer.RoundRobinLoadBalancer> {}
  slaveSubscriptionConnectionMinimumIdleSize: 1
  slaveSubscriptionConnectionPoolSize: 50
  slaveConnectionMinimumIdleSize: 32
  slaveConnectionPoolSize: 64
  masterConnectionMinimumIdleSize: 32
  masterConnectionPoolSize: 64
  readMode: "SLAVE"
  nodeAddresses:
    - "redis://xxx:6379"
    - "redis://xxx:6379"
    - "redis://xxx:6379"
    - "redis://xxx:6379"
    - "redis://xxx:6379"
    - "redis://xxx:6379"
    - "redis://xxx:6379"
    - "redis://xxx:6379"
    - "redis://xxx:6379"
    - "redis://xxx:6379"
    - "redis://xxx:6379"
    - "redis://xxx:6379"
  scanInterval: 1000
threads: 0
nettyThreads: 0
codec: !<org.redisson.codec.JsonJacksonCodec> {}
"transportMode":"NIO"

redisson配置文件

@Configuration
public class RedissonConfig {
    @Value("${spring.profiles.active}")
    private String active;

    @Bean(destroyMethod="shutdown")
    public RedissonClient redissonClient() throws IOException {
        // 开发环境-单机模式
        if ("dev".equals(active)){
            Config config = Config.fromYAML(RedissonConfig.class.getClassLoader().getResource("redisson-single-dev.yaml"));
            return Redisson.create(config);
        }
        // 测试环境-测试cluster集群模式
        if ("test".equals(active)){
            Config config = Config.fromYAML(RedissonConfig.class.getClassLoader().getResource("redisson-cluster-test.yaml"));
            return Redisson.create(config);
        }
        // 开发环境-正式cluster集群模式
        if ("online".equals(active)){
            Config config = Config.fromYAML(RedissonConfig.class.getClassLoader().getResource("redisson-cluster-online.yaml"));
            return Redisson.create(config);
        }
        return null;
    }
}

1、redisTemplate是基于某个具体实现的再封装，比如说springBoot1.x时，具体实现是jedis；而到了springBoot2.x时，具体实现变成了lettuce。封装的好处就是隐藏了具体的实现，使调用更简单，但是有人测试过jedis效率要10-30倍的高于redisTemplate的执行效率，所以单从执行效率上来讲，jedis完爆redisTemplate。redisTemplate的好处就是基于springBoot自动装配的原理，使得整合redis时比较简单。

2、jedis作为老牌的redis客户端，采用同步阻塞式IO，采用线程池时是线程安全的。优点是简单、灵活、api全面，缺点是某些redis高级功能需要自己封装。

3、lettuce作为新式的redis客户端，基于netty采用异步非阻塞式IO，是线程安全的，优点是提供了很多redis高级功能，例如集群、哨兵、管道等，缺点是api抽象，学习成本高。lettuce好是好，但是jedis比他生得早。

4、redission作为redis的分布式客户端，同样基于netty采用异步非阻塞式IO，是线程安全的，优点是提供了很多redis的分布式操作和高级功能，缺点是api抽象，学习成本高。

中文文档：https://github.com/redisson/redisson/wiki

综上所述：单机并发量低时优先选择jedis，分布式高并发时优先选择redission。