前言

对于Java开发者来说，Jedis和Lettuce是两种非常常见的Redis客户端，他们可以帮助开发者更容易地在Java应用中使用Redis。然而，这两种客户端在设计和实现上有着许多不同之处，这就需要深入理解它们的差异，以便根据自己的需求做出合适的选择。

Lettuce 与Jedis 对比

使用Docker安装Redis

a123456@luludeMacBook-Pro-2 Dockerfile % docker run --name myReids -it -p 6379:6379 redis:5.0
1:C 22 Mar 2024 12:36:17.213 # oO0OoO0OoO0Oo Redis is starting oO0OoO0OoO0Oo
1:C 22 Mar 2024 12:36:17.213 # Redis version=5.0.14, bits=64, commit=00000000, modified=0, pid=1, just started
1:C 22 Mar 2024 12:36:17.213 # Warning: no config file specified, using the default config. In order to specify a config file use redis-server /path/to/redis.conf
                _._                                                  
           _.-``__ ''-._                                             
      _.-``    `.  `_.  ''-._           Redis 5.0.14 (00000000/0) 64 bit
  .-`` .-```.  ```\/    _.,_ ''-._                                   
 (    '      ,       .-`  | `,    )     Running in standalone mode
 |`-._`-...-` __...-.``-._|'` _.-'|     Port: 6379
 |    `-._   `._    /     _.-'    |     PID: 1
  `-._    `-._  `-./  _.-'    _.-'                                   
 |`-._`-._    `-.__.-'    _.-'_.-'|                                  
 |    `-._`-._        _.-'_.-'    |           http://redis.io        
  `-._    `-._`-.__.-'_.-'    _.-'                                   
 |`-._`-._    `-.__.-'    _.-'_.-'|                                  
 |    `-._`-._        _.-'_.-'    |                                  
  `-._    `-._`-.__.-'_.-'    _.-'                                   
      `-._    `-.__.-'    _.-'                                       
          `-._        _.-'                                           
              `-.__.-'                                               

1:M 22 Mar 2024 12:36:17.218 # Server initialized
1:M 22 Mar 2024 12:36:17.218 # WARNING you have Transparent Huge Pages (THP) support enabled in your kernel. This will create latency and memory usage issues with Redis. To fix this issue run the command 'echo never > /sys/kernel/mm/transparent_hugepage/enabled' as root, and add it to your /etc/rc.local in order to retain the setting after a reboot. Redis must be restarted after THP is disabled.
1:M 22 Mar 2024 12:36:17.218 * Ready to accept connections              

检查Redis是否启动成功

a123456@luludeMacBook-Pro-2 ~ % docker ps
CONTAINER ID   IMAGE       COMMAND                  CREATED          STATUS          PORTS                    NAMES
8a4ea1b7577c   redis:5.0   "docker-entrypoint.s…"   44 seconds ago   Up 43 seconds   0.0.0.0:6379->6379/tcp   myReids
4190cf0b96fe   ubuntu      "/bin/bash"              24 hours ago     Up 24 hours    

进入容器

a123456@luludeMacBook-Pro-2 ~ % docker exec -it myReids redis-cli
127.0.0.1:6379> 

Lettuce介绍

官网地址：Lettuce Reference Guide

Lettuce是基于Netty的，Netty是一个多线程的，事件驱动的I/O框架。这意味着Lettuce可以处理多个并发连接，因此它是线程安全的。例如，如果你有一个应用程序，它在多个线程中并发地访问Redis，你可以创建一个Lettuce连接实例，并且所有的线程都可以使用这个连接实例。这是因为Lettuce内部会处理并发访问，保证数据的一致性。

Lettuce入门

引入依赖：

<dependency>
    <groupId>io.lettuce</groupId>
    <artifactId>lettuce-core</artifactId>
    <version>6.3.2.RELEASE</version>
</dependency>

public class LettuceTest {
    public static void main(String[] args) {
        RedisURI redisURI = RedisURI.Builder.redis("localhost", 6379).build();

        RedisClient redisClient = RedisClient.create(redisURI);
        StatefulRedisConnection<String, String> connection = redisClient.connect();
        RedisCommands<String, String> syncCommands = connection.sync();

        syncCommands.set("lettuce", "Hello, Lettuce!");

        connection.close();
        redisClient.shutdown();
    }
}

a123456@luludeMacBook-Pro-2 ~ % docker exec -it myReids redis-cli
127.0.0.1:6379> get lettuce
"Hello, Lettuce!"
127.0.0.1:6379>

通过 Get 命令查询 lettuce 的值，设置lettuce值成功。

Jedis介绍

请参考：

Redis进阶九之SpringBoot配置多Redis源

Redis进阶十之JedisPool资源池优化

SpringBoot集成Redis (Lettuce)

POM文件

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-parent</artifactId>
        <version>2.3.1.RELEASE</version>
    </parent>

    <groupId>org.example</groupId>
    <artifactId>redistest</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <!-- lettuce pool 缓存连接池-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
            <version>2.8.1</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.24</version>
        </dependency>
    </dependencies>
</project>

CahceConfig 类

@Configuration
public class CacheConfig {
    @Bean(name = "poolConfig")
    @ConfigurationProperties(prefix = "spring.redis.lettuce.pool")
    public GenericObjectPoolConfig poolConfig() {
        return new GenericObjectPoolConfig();
    }

    /**
     * 配置自定义redisTemplate
     */
    @Bean
    public RedisTemplate<String, Object> redisTemplate(@Autowired LettuceConnectionFactory lettuceConnectionFactory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(lettuceConnectionFactory);
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        // 设置值（value）的序列化采用Jackson2JsonRedisSerializer。
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        // 设置键（key）的序列化采用StringRedisSerializer。
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());

        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }

    @Bean
    public LettuceConnectionFactory lettuceConnectionFactory(
            @Value("${spring.redis.host}") String host,
            @Value("${spring.redis.port}") int port,
            @Autowired @Qualifier("poolConfig") GenericObjectPoolConfig config) {

        RedisStandaloneConfiguration redisStandaloneConfiguration = new RedisStandaloneConfiguration();
        redisStandaloneConfiguration.setHostName(host);
        redisStandaloneConfiguration.setPort(port);
        LettuceClientConfiguration clientConfig = LettucePoolingClientConfiguration.builder()
                .commandTimeout(Duration.ofMillis(2000))
                .shutdownTimeout(Duration.ofMillis(30000))
                .poolConfig(config)
                .build();

        LettuceConnectionFactory factory = new LettuceConnectionFactory(redisStandaloneConfiguration, clientConfig);

        return factory;
    }
}

单元测试

@RunWith(SpringRunner.class)
@SpringBootTest(classes = WebApplication.class)
public class RedisTemplateTest {
    @Resource
    private RedisTemplate<String, Object> redisTemplate;

    @Test
    public void testRedis() {
        User user = new User(1L, "yangyang", 18);
        String cacheKey = "user:" + user.getId();
        redisTemplate.opsForValue().set(cacheKey, user);
    }
}

访问Redis

127.0.0.1:6379> get user:1
"{\"id\":1,\"name\":\"yangyang\",\"age\":18}"
127.0.0.1:6379>