1、Spring Boot 2.x 的两种 Redis 客户端

首先，我们都知道，从 Spring Boot 2.x 开始 Lettuce 已取代 Jedis 成为首选 Redis 的客户端。当然 Spring Boot 2.x 仍然支持 Jedis，并且你可以任意切换客户端。至于为什么会使用 Lettuce 替换 Jedis，大家可自行上网搜索。

2、我就是要使用 Jedis ！

那么如果我们还是要在项目中使用 Jedis 作为 Redis 的客户端呢？是不是引入 Jedis 依赖即可？下面来试试。

引入依赖：

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

配置：

可以加上下面的关于连接池配置，或者不加，因为有默认值。

spring.redis.jedis.pool.max-active=10
spring.redis.jedis.pool.min-idle=1
.....

例子代码：

我们在访问接口时，打印 RedisTemplate 的 ConnectionFactory 即可知道使用的是哪个客户端。

/**
 * @author Howinfun
 * @desc
 * @date 2020/1/15
 */
@RestController
public class TestController {

    @Autowired
    private RedisTemplate redisTemplate;

    @GetMapping("/test")
    public String test(){
        System.out.println(redisTemplate.getConnectionFactory());
        return "hello";
    }
}

神奇的 Lettuce 客户端：

启动项目，访问接口，可是我们看到，控制台打印出来的竟然还是 Lettuce 的 ConnectionFactory。

org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory@21891c74

3、源码分析

Redis 的自动配置类：

首先看到 RedisAutoConfiguration

@Configuration
@ConditionalOnClass({RedisOperations.class})
@EnableConfigurationProperties({RedisProperties.class})
// 导入Lettuce和Jedis的连接配置类，而下面的创建RedisTemplate的RedisConnectionFactory在这两个配置类里都有生成。
@Import({LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class})
public class RedisAutoConfiguration {
    public RedisAutoConfiguration() {
    }

    @Bean
    @ConditionalOnMissingBean(
        name = {"redisTemplate"}
    )
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
        RedisTemplate<Object, Object> template = new RedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }

    @Bean
    @ConditionalOnMissingBean
    public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
        StringRedisTemplate template = new StringRedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }
}

Lettuce 的连接配置类：

然后到LettuceConnectionConfiguration

@Configuration
// 当存在RedisClient.class时执行。ps：RedisClient是Lettuce依赖里面的类
@ConditionalOnClass({RedisClient.class})
class LettuceConnectionConfiguration extends RedisConnectionConfiguration {
    // .... 省略 

    @Bean
    // 当Spring容器不存在RedisConnectionFactory类型的bean对象时执行
    @ConditionalOnMissingBean({RedisConnectionFactory.class})
    public LettuceConnectionFactory redisConnectionFactory(ClientResources clientResources) throws UnknownHostException {
        
        LettuceClientConfiguration clientConfig = this.getLettuceClientConfiguration(clientResources, this.properties.getLettuce().getPool());
        // 创建connectinFactory
        return this.createLettuceConnectionFactory(clientConfig);
    }

    // ..... 省略
}

Jedis 的连接配置类：

最后到JedisConnectionConfiguration

@Configuration
// 当同时存在GenericObjectPool.class, JedisConnection.class, Jedis.class时执行。ps：JedisConnection和Jedis都是Jedis依赖里面的类。GenericObjectPool是spring-boot-starter-data-redis里的类。
@ConditionalOnClass({GenericObjectPool.class, JedisConnection.class, Jedis.class})
class JedisConnectionConfiguration extends RedisConnectionConfiguration {
    
    // .... 省略

    @Bean
    // 当Spring容器不存在RedisConnectionFactory类型的bean对象时执行
    @ConditionalOnMissingBean({RedisConnectionFactory.class})
    public JedisConnectionFactory redisConnectionFactory() throws UnknownHostException {
        
        // 创建connectinFactory
        return this.createJedisConnectionFactory();
    }

    // .... 省略
}

总结：

从上面的源码分析可得。首先 Redis 的自动化配置依靠的是 RedisAutoConfiguration ，而 RedisAutoConfiguration 会按照顺序分别引入 LettuceConnectionConfiguration 和 JedisConnectionConfiguration 。而它们都会判断 Spring容器 中是否存在 ConnectionFactory ，不存在则创建。正是这个引入的顺序，导致 LettuceConnectionConfiguration 要先比 JedisConnectionConfiguration 执行，所以当 LettuceConnectionConfiguration 创建了 ConnectionFactory 后， JedisConnectionConfiguration 判断不为空而不继续创建了。所以即使我们引入了 Jedis 依赖，最后也还是使用 Lettuce 客户端。

ps： Spring Boot 2.x 使用 Lettuce 的原理：首先是依靠 @Import 的引入顺序，然后是 spring-boot-starter-data-redis 里有 Lettuce 的依赖，而没有 Jedis 的依赖 。

4、如何正确使用 Jedis 客户端

从上面的源码分析看到，我们有两种方案，不过前提都是先引入 Jedis 依赖。

第一：直接去掉 Lettuce 的依赖

使 LettuceConnectionConfiguration 不能生效，因为 @ConditionalOnClass({RedisClient.class}) 的不再成立，导致其不会生效执行。

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
    <exclusions>
        <exclusion>
            <groupId>io.lettuce</groupId>
            <artifactId>lettuce-core</artifactId>
        </exclusion>
    </exclusions>
</dependency>

第二：在启动类的 @SpringBootApplication 去掉 RedisAutoConfiguration ，然后自己自定义一个 RedisAutoConfiguration

在自定义的 RedisAutoConfiguration 中修改 @Import 关于两个客户端的 ConnectionConfiguration 的引入顺序即可。但是其实这样做很没必要，还不如直接去掉依赖。

@SpringBootApplication(exclude = RedisAutoConfiguration.class)

@Configuration
@ConditionalOnClass({RedisOperations.class})
@EnableConfigurationProperties({RedisProperties.class})
// 先 Jedis 后 Lettuce
@Import({JedisConnectionConfiguration.class, LettuceConnectionConfiguration.class})
public class MyRedisAutoConfiguration {
    public MyRedisAutoConfiguration() {
    }
    
    // ...... 省略
}

最后

我们可以看到控制台打印的终于是 JedisConnectionFactory了。

org.springframework.data.redis.connection.jedis.JedisConnectionFactory@16c9834c