Redis7——基础篇（八）

 前言：此篇文章系本人学习过程中记录下来的笔记，里面难免会有不少欠缺的地方，诚心期待大家多多给予指教。

基础篇：

1. Redis（一）
2. Redis（二）
3. Redis（三）
4. Redis（四）
5. Redis（五）
6. Redis（六）
7. Redis（七）

接上期内容：上期完成了Redis集群的学习。下面开始学习Java集成Redis，话不多说，直接发车。

---

一、Java连接Redis的四种方式

（一）、底层客户端库

1、Jedis

1.1、定义

Jedis是Redis官方推荐的Java客户端，它提供了一套简洁易用的 API，用于与Redis 进行交互。Jedis支持同步、异步和管道操作，能够满足不同场景下的需求。

---

1.2、优劣势

优势：

• 使用简单，学习成本低，对初学者友好。
• 同步阻塞 I/O，在单线程环境下使用方便。
• 与 Redis的命令对应性强，容易上手。

劣势：

• 在高并发场景下，由于同步阻塞 I/O 的特性，性能会受到一定影响。
• 多线程环境下，需要手动管理连接池，增加了开发复杂度。

---

2、Lettuce

2.1、定义

Lettuce是一个基于Netty的可伸缩线程安全的Redis客户端，它支持同步、异步和响应式编程模型。Lettuce的设计目标是提供高性能和可扩展性，适用于各种复杂的应用场景。

---

2.2、优劣势

优势：

• 基于Netty实现，支持异步 I/O，在高并发场景下性能表现出色。
• 线程安全，无需手动管理连接池。
• 支持多种编程模型，灵活性高。

劣势：

• 相比Jedis，学习成本较高。

• API相对复杂，对于简单场景可能显得过于繁琐。

---

（二）、上层框架封装

1、RedisTemplate

1.1、定义

RedisTemplate是Spring Data Redis 提供的一个高级封装，它简化了Java与Redis的交互操作。RedisTemplate提供了丰富的方法，支持各种数据结构的操作，并且可以方便地进行事务管理和序列化配置。

---

1.2、优劣势

优势：

• 与Spring 框架无缝集成，使用方便。
• 对各种数据结构的操作进行了封装，代码简洁。
• 支持事务管理和序列化配置，提高了应用的灵活性和可维护性。

劣势：

• 依赖Spring框架，如果项目中没有使用 Spring，引入RedisTemplate会增加项目的复杂度。
• 相比底层客户端库，性能上可能会有一定损耗。

2、Redisson

2.1、定义

Redisson是一个在Redis的基础上实现的Java驻内存数据网格（In-Memory Data Grid）。它不仅提供了一系列的分布式的Java常用对象，还提供了许多分布式服务，如分布式锁、分布式集合、分布式对象等，极大地简化了分布式系统的开发。

---

2.2、优劣势

优势：

• 提供了丰富的分布式服务，开箱即用，像分布式锁、分布式集合等，非常适合构建分布式系统。
• 对Redis功能进行了高度抽象和扩展，使用起来更加便捷。
• 支持多种序列化方式，兼容性好。

劣势：

• 相比直接使用 Redis 客户端，增加了一定的学习成本。
• 由于其功能丰富，依赖的包可能较多，在一些对依赖大小敏感的场景下不太适用。

---

二、实操

（一）、集成Jedis

1、新建项目

新建步骤略。最终效果图：

2、导入依赖

        <!--jedis--><dependency><groupId>redis.clients</groupId><artifactId>jedis</artifactId><version>5.2.0</version></dependency>

3、编写方法

3.1、连接redis单机

public class JedisDemoTest {public static void main(String[] args) {Jedis jedis = new Jedis("192.168.112.129", 6379);jedis.auth("root");jedis.set("k1", "你好jedis");System.out.println(jedis.get("k1"));//keySet<String> keys = jedis.keys("*");for (String key : keys) {System.out.println(key);}System.out.println("jedis.exists====>" + jedis.exists("k2"));System.out.println(jedis.ttl("k1"));//StringSystem.out.println(jedis.get("k1"));jedis.set("k4", "k4_redis");System.out.println("----------------------------------------");jedis.mset("str1", "v1", "str2", "v2", "str3", "v3");System.out.println(jedis.mget("str1", "str2", "str3"));//listSystem.out.println("----------------------------------------");jedis.lpush("myList", "v1", "v2", "v3", "v4", "v5");List<String> list = jedis.lrange("myList", 0, -1);for (String element : list) {System.out.println(element);}//setjedis.sadd("orders", "jd001");jedis.sadd("orders", "jd002");jedis.sadd("orders", "jd003");Set<String> set1 = jedis.smembers("orders");for (String string : set1) {System.out.println(string);}jedis.srem("orders", "jd002");System.out.println(jedis.smembers("orders").size());//hashjedis.hset("hash1", "userName", "lisi");System.out.println(jedis.hget("hash1", "userName"));Map<String, String> map = new HashMap<>();map.put("telephone", "138xxxxxxxx");map.put("address", "fatigue");map.put("email", "[e-mail]");//jedis.hmset("hash2", map);List<String> result = jedis.hmget("hash2", "telphone", "email");for (String element : result) {System.out.println(element);}//zSetjedis.zadd("zSet01", 60d, "v1");jedis.zadd("zSet01", 70d, "v2");jedis.zadd("zSet01", 80d, "v3");jedis.zadd("zSet01", 90d, "v4");List<String> zSet01 = jedis.zrange("zSet01", 0, -1);zSet01.forEach(System.out::println);// 关闭连接jedis.close();}
}

---

3.2、连接redis集群

public class JedisColonyDemoTest {public static void main(String[] args) {// 添加主节点HashSet<HostAndPort> jedisClusterNodes = new HashSet<>();jedisClusterNodes.add(new HostAndPort("192.168.112.129", 6379));jedisClusterNodes.add(new HostAndPort("192.168.112.130", 6381));jedisClusterNodes.add(new HostAndPort("192.168.112.129", 6380));// 连接redis集群JedisCluster cluster = new JedisCluster(jedisClusterNodes,"default","root");// 清除单机Redis设置的key// 如果用Jedis连接Redis集群模式下，// flushAll这类全局操作不能直接使用，在集群模式下对于一些全局操作命令（如 KEYS）的处理不够完善，// 没有内置的逻辑来处理 KEYS 命令在集群环境下的复杂性。for (HostAndPort node : jedisClusterNodes) {try (Jedis jedis = new Jedis(node.getHost(), node.getPort())) {jedis.auth("root");// 对每个节点执行 flushDB 命令jedis.flushDB();System.out.println("Flushed database on node: " + node);}}cluster.set("k1", "你好redis集群");System.out.println(cluster.get("k1"));System.out.println("cluster.exists====>" + cluster.exists("k2"));System.out.println(cluster.ttl("k1"));//StringSystem.out.println(cluster.get("k1"));cluster.set("k4", "k4_redis");System.out.println("----------------------------------------");cluster.mset("str1{x}", "v1", "str2{x}", "v2", "str3{x}", "v3");System.out.println(cluster.mget("str1{x}", "str2{x}", "str3{x}"));//listSystem.out.println("----------------------------------------");cluster.lpush("myList", "v1", "v2", "v3", "v4", "v5");List<String> list = cluster.lrange("myList", 0, -1);for (String element : list) {System.out.println(element);}//setcluster.sadd("orders", "jd001");cluster.sadd("orders", "jd002");cluster.sadd("orders", "jd003");Set<String> set1 = cluster.smembers("orders");for (String string : set1) {System.out.println(string);}cluster.srem("orders", "jd002");System.out.println(cluster.smembers("orders").size());//hashcluster.hset("hash1", "userName", "lisi");System.out.println(cluster.hget("hash1", "userName"));Map<String, String> map = new HashMap<>();map.put("telephone", "138xxxxxxxx");map.put("address", "fatigue");map.put("email", "[e-mail]");//cluster.hmset("hash2", map);List<String> result = cluster.hmget("hash2", "telphone", "email");for (String element : result) {System.out.println(element);}//zSetcluster.zadd("zSet01", 60d, "v1");cluster.zadd("zSet01", 70d, "v2");cluster.zadd("zSet01", 80d, "v3");cluster.zadd("zSet01", 90d, "v4");List<String> zSet01 = cluster.zrange("zSet01", 0, -1);zSet01.forEach(System.out::println);cluster.close();}
}

---

4、测试用例 

4.1、单机测试结果

 直接main方法启动，

redis客户端：

---

4.2、redis集群测试结果

控制台输入：

redis客户端：

---

（二）、集成Lettuce

1、导入依赖

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

 *注意：如果你的Springboot版本为3.4.3，那么导入这个依赖后，可能需要清除IDEA缓存，不然一直无法new RedisURI类。刷新过maven也没用，只有清除缓存重启后才成功，就很奇怪( ╯□╰ )。

---

2、编写方法

2.1、连接Redis单机

public class LettuceDemoTest {public static void main(String[] args) {// 构建 RedisURI 对象RedisURI uri = RedisURI.builder(RedisURI.create("redis://192.168.112.129")).withPort(6379).withAuthentication("default", "root").withDatabase(0).build();// 创建连接客户端RedisClient client = RedisClient.create(uri);StatefulRedisConnection<String, String> conn = client.connect();// 操作命令apiRedisCommands<String, String> commands = conn.sync();// 清空Jedis设置的keycommands.flushdb();//keysList<String> list = commands.keys("*");for (String s : list) {System.out.println(s);}//Stringcommands.set("k1", "hello Lettuce");String s1 = commands.get("k1");System.out.println("String s ===" + s1);//listcommands.lpush("myList2", "v1", "v2", "v3");List<String> list2 = commands.lrange("myList2", 0, -1);for (String s : list2) {System.out.println("list ssss===" + s);}//setcommands.sadd("mySet2", "v1", "v2", "v3");Set<String> set = commands.smembers("mySet2");for (String s : set) {System.out.println("set ssss===" + s);}//hashMap<String, String> map = new HashMap<>();map.put("k1", "138xxxxxxxx");map.put("k2", "fatigue");map.put("k3", "[e-mail]");//课后有问题请给我发邮件commands.hmset("myHash2", map);Map<String, String> retMap = commands.hgetall("myHash2");for (String k : retMap.keySet()) {System.out.println("hash  k=" + k + " , v==" + retMap.get(k));}//zSetcommands.zadd("myzSet2", 100.0, "s1", 110.0, "s2", 90.0, "s3");List<String> list3 = commands.zrange("myzSet2", 0, 10);for (String s : list3) {System.out.println("zSet ssss===" + s);}//sortSortArgs sortArgs = new SortArgs();sortArgs.alpha();sortArgs.desc();List<String> list4 = commands.sort("myList2", sortArgs);for (String s : list4) {System.out.println("sort ssss===" + s);}//关闭conn.close();client.shutdown();}
}

---

2.2、连接Redis集群

public class LettuceColonyDemoTest {public static void main(String[] args) {HashSet<RedisURI> uris = new HashSet<>();uris.add(RedisURI.builder().withHost("192.168.112.129").withPort(6379).withAuthentication("default", "root").build());uris.add(RedisURI.builder().withHost("192.168.112.130").withPort(6381).withAuthentication("default", "root").build());uris.add(RedisURI.builder().withHost("192.168.112.129").withPort(6380).withAuthentication("default", "root").build());RedisClusterClient client = RedisClusterClient.create(uris);StatefulRedisClusterConnection<String, String> con = client.connect();RedisAdvancedClusterCommands<String, String> clusterCommands = con.sync();// 清除单机Redis设置的key// Lettuce连接Redis集群模式下，能使用flushAll命令// 因为Lettuce内部实现了智能的路由机制，能够自动将 KEYS 命令分发到集群中的各个节点，并将结果聚合返回clusterCommands.flushallAsync();//keysList<String> list = clusterCommands.keys("*");for (String s : list) {System.out.println(s);}//StringclusterCommands.set("k1", "hello Lettuce");String s1 = clusterCommands.get("k1");System.out.println("redis集群===" + s1);//listclusterCommands.lpush("myList2", "v1", "v2", "v3");List<String> list2 = clusterCommands.lrange("myList2", 0, -1);for (String s : list2) {System.out.println("list ssss===" + s);}//setclusterCommands.sadd("mySet2", "v1", "v2", "v3");Set<String> set = clusterCommands.smembers("mySet2");for (String s : set) {System.out.println("set ssss===" + s);}//hashMap<String, String> map = new HashMap<>();map.put("k1", "138xxxxxxxx");map.put("k2", "fatigue");map.put("k3", "[e-mail]");//课后有问题请给我发邮件clusterCommands.hmset("myHash2", map);Map<String, String> retMap = clusterCommands.hgetall("myHash2");for (String k : retMap.keySet()) {System.out.println("hash  k=" + k + " , v==" + retMap.get(k));}//zSetclusterCommands.zadd("myzSet2", 100.0, "s1", 110.0, "s2", 90.0, "s3");List<String> list3 = clusterCommands.zrange("myzSet2", 0, 10);for (String s : list3) {System.out.println("zSet ssss===" + s);}//sortSortArgs sortArgs = new SortArgs();sortArgs.alpha();sortArgs.desc();List<String> list4 = clusterCommands.sort("myList2", sortArgs);for (String s : list4) {System.out.println("sort ssss===" + s);}//关闭con.close();client.shutdown();client.close();}
}

---

3、测试用例

3.1、单机测试结果

 控制台输出:

redis客户端：

---

3.2、redis集群测试结果

控制台输出：

redis客户端：

---

（三）、集成RedisTemplate

1、新建配置文件

新建application.properties文件：

server.port=8080
spring.application.name=RedisDemo
# ========================logging=====================
logging.level.root=info
logging.level.xxx.xx.xxx=info
logging.pattern.console=%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger- %msg%nlogging.file.name=D:/myLogs/RedisDemo.log
logging.pattern.file=%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger- %msg%n# ========================redis单机=====================
spring.data.redis.database=0
#修改为自己的真实IP
spring.data.redis.host=xxx.xxx.xxx.xxx
spring.data.redis.port=6379
spring.data.redis.password=xxxx
spring.data.redis.lettuce.pool.max-active=8
spring.data.redis.lettuce.pool.max-wait=-1ms
spring.data.redis.lettuce.pool.max-idle=8
spring.data.redis.lettuce.pool.min-idle=0

---

2、导入依赖

        <!--SpringBoot通用依赖模块--><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><!--SpringBoot与Redis整合依赖--><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-redis</artifactId></dependency><dependency><groupId>org.apache.commons</groupId><artifactId>commons-pool2</artifactId></dependency><!--日志--><dependency><groupId>org.apache.logging.log4j</groupId><artifactId>log4j-core</artifactId><version>2.24.3</version></dependency><!-- swagger3生成接口文档依赖--><dependency><groupId>org.springdoc</groupId><artifactId>springdoc-openapi-starter-webmvc-ui</artifactId><version>2.3.0</version></dependency><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId><version>1.18.30</version></dependency>

---

3、编写业务类

3.1、新建controller

@RestController
@Tag(name = "订单管理", description = "订单的创建和查询操作")
public class OrderController {@Resourceprivate OrderService orderService;/*** redis单机*/@RequestMapping(value = "/order/add", method = RequestMethod.POST)public void addOrder() {orderService.addOrder();}@RequestMapping(value = "/order/{id}", method = RequestMethod.GET)public String findUserById(@PathVariable Integer id) {return orderService.getOrderById(id);}/*** redis集群*/@RequestMapping(value = "/cluster/order/add", method = RequestMethod.POST)public void clusterAddOrder() {orderService.clusterAddOrder();}@RequestMapping(value = "cluster/order/{id}", method = RequestMethod.GET)public String clusterFindUserById(@PathVariable Integer id) {return orderService.clusterFindUserById(id);}
}

---

3.2、新建service

*注意：只编写String类型的数据操作，其他类型的API操作，私底下练习

@Service
@Slf4j
public class OrderService {public static final String ORDER_KEY = "order:";@Resourceprivate RedisTemplate<String, String> redisTemplate;public void addOrder() {int keyId = ThreadLocalRandom.current().nextInt(1000) + 1;String orderNo = UUID.randomUUID().toString();redisTemplate.opsForValue().set(ORDER_KEY + keyId, "订单编号" + orderNo);log.info("redis单机=====>编号{}的订单流水生成:{}", keyId, orderNo);}public String getOrderById(Integer id) {System.out.println(redisTemplate.opsForList().range("myList", 0, -1));HashMap<String, String> map = new HashMap<>();map.put("k1", "k2");map.put("k3", "k4");map.put("k5", "k6");redisTemplate.opsForValue().multiSet(map);return redisTemplate.opsForValue().get(ORDER_KEY + id);}public void clusterAddOrder() {int keyId = ThreadLocalRandom.current().nextInt(1000) + 1;String orderNo = UUID.randomUUID().toString();redisTemplate.opsForValue().set(ORDER_KEY + keyId, "订单编号" + orderNo);log.info("redis集群=====>编号{}的订单流水生成:{}", keyId, orderNo);}public String clusterFindUserById(Integer id) {return redisTemplate.opsForValue().get(ORDER_KEY + id);}
}

---

3.3、新建config

这个配置主要是生成接口文档。

@Configuration
public class OpenAPIConfig {@Beanpublic OpenAPI customOpenAPI() {String currentDate = DateTimeFormatter.ofPattern("yyyy-MM-dd").format(LocalDateTime.now());return new OpenAPI().info(new Info().title("springBoot利用swagger3构建api接口文档 " + "\t" + currentDate).description("springboot+redis整合").version("1.0").termsOfService("https://www.baidu.com/"));}
}

---

3.4、连接redis单机

---

3.5、连接redis集群

---

4、测试接口

启动项目，访问http://localhost:8080/swagger-ui/index.html

4.1、单机测试结果

控制台输出：

redis客户端：

Q：数据是存进去了，但是为啥是乱码的？在连接redis客户端的时候加上了--raw的参数还是乱码？为啥通过接口获取的数据是正常的，但是通过redis客户端去查看的又是乱码？

A：是因为序列化方式不一致造成。键(key)和值(value)都是通过spring提供的Serializer序列化到数据库的。RedisTemplate默认使用的是JdkSerializationRedisSerializer。解决办法就是统一序列化方式。

新建RedisConfig类：

@Configuration
public class RedisConfig {/***设置存储key的序列化方式* @param redisConnectionFactory 创建与Redis连接的工厂类*/@Beanpublic RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();redisTemplate.setConnectionFactory(redisConnectionFactory);//设置StringredisTemplate.setKeySerializer(new StringRedisSerializer());redisTemplate.setValueSerializer(new StringRedisSerializer());// 设置hash、set、zSet、list.....redisTemplate.afterPropertiesSet();return redisTemplate;}
}

重启项目，重新测试：

问题解决。

---

4.2、redis集群测试结果

修改application.properties文件，注释redis单机配置：

重启项目，进行测试：

redis客户端：

初步看来，连接redis集群没毛病。

---

Q：假设集群中，有主机服务宕机了，从机上位后，程序是否还能正常从redis集群获取与写入数据呢？

A：读能正常，但是写不正常

手动关闭6379，模拟测试一下。

是需要手动开启刷新节点拓扑网落的，

#支持集群拓扑动态感应刷新,自适应拓扑刷新是否使用所有可用的更新，默认false关闭
spring.data.redis.lettuce.cluster.refresh.adaptive=true
#定时刷新 毫秒
spring.data.redis.lettuce.cluster.refresh.period=2000

不然，当某个Master主机宕机后，虽然从机上位了，但还是不可用的（针对于这个key刚好落在宕机的Master上）。

---

（四）、集成Redisson

1、导入依赖

        <dependency><groupId>org.redisson</groupId><artifactId>redisson-spring-boot-starter</artifactId><version>3.45.0</version></dependency>

2、编写业务类

2.1、新建controller

@RestController
@Tag(name = "Redisson订单管理", description = "订单的创建和查询操作")
public class RedissonOrderController {@Resourceprivate RedissonOrderService redissonOrderService;/*** redisson连接redis单机*/@RequestMapping(value = "/redisson/order/add", method = RequestMethod.POST)public void redissonAddOrder() {redissonOrderService.redissonAddOrder();}@RequestMapping(value = "/redisson/order/{id}", method = RequestMethod.GET)public String redissonFindUserById(@PathVariable Integer id) {return redissonOrderService.redissonFindUserById(id);}/*** redisson连接redis集群*/@RequestMapping(value = "/redisson/cluster/order/add", method = RequestMethod.POST)public void redissonClusterAddOrder() {redissonOrderService.redissonClusterAddOrder();}@RequestMapping(value = "/redisson/cluster/order/{id}", method = RequestMethod.GET)public String redissonClusterFindUserById(@PathVariable Integer id) {return redissonOrderService.redissonClusterFindUserById(id);}}

---

2.2、新建service

*注意：只编写String类型的数据操作，其他类型的API操作，私底下练习。

@Service
@Slf4j
public class RedissonOrderService {public static final String ORDER_KEY = "order:";private final RedissonClient redissonSingleClient;private final RedissonClient redissonColonyClient;@Autowiredpublic RedissonOrderService(@Qualifier("redissonColonyClient") RedissonClient redissonColonyClient,@Qualifier("redissonSingleClient") RedissonClient redissonSingleClient) {this.redissonColonyClient = redissonColonyClient;this.redissonSingleClient = redissonSingleClient;}public void redissonAddOrder() {int keyId = ThreadLocalRandom.current().nextInt(1000) + 1;String orderNo = UUID.randomUUID().toString();redissonSingleClient.getBucket(ORDER_KEY + keyId).set("订单编号" + orderNo);log.info("redisson连接redis单机=====>编号{}的订单流水生成:{}", keyId, orderNo);}public String redissonFindUserById(Integer id) {RBucket<Object> bucket = redissonSingleClient.getBucket(ORDER_KEY + id);return (String) bucket.get();}public void redissonClusterAddOrder() {int keyId = ThreadLocalRandom.current().nextInt(1000) + 1;String orderNo = UUID.randomUUID().toString();redissonColonyClient.getBucket(ORDER_KEY + keyId).set("订单编号" + orderNo);log.info("redisson连接redis集群=====>编号{}的订单流水生成:{}", keyId, orderNo);}public String redissonClusterFindUserById(Integer id) {RBucket<Object> bucket = redissonColonyClient.getBucket(ORDER_KEY + id);return (String) bucket.get();}
}

---

2.3、新建config

@Configuration
public class RedissonConfig {/*** redisson连接redis单机*/@Bean(name = "redissonSingleClient")@Primarypublic RedissonClient redissonSingleClient() {Config config = new Config();// 单机模式config.useSingleServer().setAddress("redis://192.168.112.131:6381").setPassword("root");// 设置 JSON 序列化编解码器config.setCodec(new JsonJacksonCodec(new ObjectMapper()));return Redisson.create(config);}/*** redisson连接redis集群*/@Bean(name = "redissonColonyClient")public RedissonClient redissonColonyClient() {Config config = new Config();// 设置JSON序列化编解码器config.setCodec(new JsonJacksonCodec(new ObjectMapper()));// 集群模式config.useClusterServers().addNodeAddress("redis://192.168.112.129:6379","redis://192.168.112.129:6380","redis://192.168.112.130:6381","redis://192.168.112.130:6382","redis://192.168.112.131:6383","redis://192.168.112.131:6384").setScanInterval(2000)// 集群状态扫描间隔时间，单位是毫秒.setPassword("root");return Redisson.create(config);}
}

---

2.4、连接redis单机

---

2.5、连接redis集群

---

3、测试接口

3.1、单机测试结果

控制台输出：

redis客户端：

---

3.2、redis集群测试结果

控制台输出：

redis客户端：

---

三、总结

在Java开发中，与 Redis 进行高效整合是提升系统性能和可扩展性的关键环节。本文为你详细介绍四种主流的Java整合Redis的方式，涵盖底层客户端库Jedis和Lettuce，以及上层框架封装RedisTemplate和Redisson。

Jedis以其简单易懂的使用方式脱颖而出，对于刚刚接触 Redis 集成的初学者而言，它就像一位耐心的导师，引导着开发者逐步熟悉 Redis的操作。同时，由于其在单线程环境下表现稳定，成为单线程应用场景的理想选择。

Lettuce则凭借卓越的性能在高并发领域独树一帜。它基于 Netty 实现，具备出色的异步处理能力和线程安全性，能够在高并发的浪潮中稳健前行，为高并发场景提供强大的支持。

RedisTemplate与Spring框架深度融合，仿佛是为Spring项目量身定制的利器。在 Spring 项目中，使用RedisTemplate可以轻松地与其他Spring组件协同工作，极大地提高了开发效率，让开发者能够更加专注于业务逻辑的实现。

Redisson作为一个独立的框架，不依赖于任何特定的框架，它专注于分布式系统的开发，提供了丰富的分布式数据结构和服务，如分布式锁、分布式集合等，为分布式系统的搭建提供了全方位的解决方案。

在实际的项目开发中，我们应根据项目的具体需求和应用场景，审慎地选择合适的整合方式。希望本文能够帮助你更好地掌握 Java与Redis的集成技术，为项目注入强大的性能和可扩展性动力。

---

ps：努力到底，让持续学习成为贯穿一生的坚守。学习笔记持续更新中。。。。