【Spring Boot 源码解读】之 【为何引入了 Jedis 依赖最后用的还是 Lettuce 客户端？】

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.clientsgroupId>
    <artifactId>jedisartifactId>
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.bootgroupId>
    <artifactId>spring-boot-starter-data-redisartifactId>
    <exclusions>
        <exclusion>
            <groupId>io.lettucegroupId>
            <artifactId>lettuce-coreartifactId>
        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