Spring Boot与Redis深度整合：实战指南

Spring Boot 整合 Redis 相当简单，它利用了 Spring Data Redis 项目，使得我们可以在 Spring Boot 应用中轻松地操作 Redis。以下是如何整合 Redis 到 Spring Boot 应用的基本步骤：

1. 添加依赖

首先，在你的 pom.xml 文件中添加 Spring Boot Data Redis 的依赖：

 
  1. <dependencies>
  2. <!-- 其他依赖 -->
  3. <dependency>
  4. <groupId>org.springframework.boot</groupId>
  5. <artifactId>spring-boot-starter-data-redis</artifactId>
  6. </dependency>
  7. <!-- 如果使用Lettuce作为Redis客户端，需要添加此依赖 -->
  8. <dependency>
  9. <groupId>io.lettuce</groupId>
  10. <artifactId>lettuce-core</artifactId>
  11. </dependency>
  12. <!-- 如果使用Jedis作为Redis客户端，需要添加此依赖 -->
  13. <dependency>
  14. <groupId>redis.clients</groupId>
  15. <artifactId>jedis</artifactId>
  16. </dependency>
  17. </dependencies>
 

注意：Lettuce和Jedis是Spring Boot支持的两个主要的Redis客户端，你可以选择其中一个。在Spring Boot 2.x中，默认使用Lettuce。 

2. 配置 Redis

在 application.properties 或 application.yml 文件中添加 Redis 的配置信息：

application.properties 示例

 
  1. spring.redis.host=localhost
  2. spring.redis.port=6379
  3. spring.redis.password= # 如果设置了密码，则填写密码
  4. spring.redis.database=0 # Redis数据库索引（默认为0）
  5. spring.redis.jedis.pool.max-active=8 # 连接池最大连接数（使用Jedis时）
  6. spring.redis.jedis.pool.max-wait=-1ms # 连接池最大阻塞等待时间（使用Jedis时）
  7. spring.redis.jedis.pool.max-idle=8 # 连接池中的最大空闲连接（使用Jedis时）
  8. spring.redis.jedis.pool.min-idle=0 # 连接池中的最小空闲连接（使用Jedis时）
  9. spring.redis.lettuce.pool.max-active=8 # 连接池最大连接数（使用Lettuce时）
  10. spring.redis.lettuce.pool.max-wait=-1ms # 连接池最大阻塞等待时间（使用Lettuce时）
  11. spring.redis.lettuce.pool.max-idle=8 # 连接池中的最大空闲连接（使用Lettuce时）
  12. spring.redis.lettuce.pool.min-idle=0 # 连接池中的最小空闲连接（使用Lettuce时）
 

application.yml 示例

 
  1. spring:
  2. redis:
  3. host: localhost
  4. port: 6379
  5. password: # 如果设置了密码，则填写密码
  6. database: 0 # Redis数据库索引（默认为0）
  7. jedis:
  8. pool:
  9. max-active: 8 # 连接池最大连接数（使用Jedis时）
  10. max-wait: -1ms # 连接池最大阻塞等待时间（使用Jedis时）
  11. max-idle: 8 # 连接池中的最大空闲连接（使用Jedis时）
  12. min-idle: 0 # 连接池中的最小空闲连接（使用Jedis时）
  13. lettuce:
  14. pool:
  15. max-active: 8 # 连接池最大连接数（使用Lettuce时）
  16. max-wait: -1ms # 连接池最大阻塞等待时间（使用Lettuce时）
  17. max-idle: 8 # 连接池中的最大空闲连接（使用Lettuce时）
  18. min-idle: 0 # 连接池中的最小空闲连接（使用Lettuce时）
 

这里要说的是：

Lettuce和Jedis两者都是Java连接Redis的客户端

选择使用Lettuce而不是Jedis的原因如下：

线程安全性：
  • Lettuce 是基于 Netty 构建的，它使用异步和事件驱动的方式处理连接。因此，它可以在多个线程之间共享一个连接而不需要额外的同步，因此在高并发环境下更高效。
  • Jedis 是基于阻塞 I/O 的，并且不是线程安全的，如果在多个线程中共享同一个 Jedis 实例，需要使用连接池进行同步管理，这可能引入额外的复杂性。
连接方式：
  • Lettuce 支持基于 Reactive Streams 的响应式编程模型，能够更好地与 Spring Reactor、Project Reactor 等框架集成，提供异步和非阻塞的操作。
  • Jedis 是同步的，并且在执行某些操作时会阻塞线程，这可能会影响应用程序的性能和响应性。
性能和扩展性：
  • Lettuce 的设计目标是高性能和扩展性，它可以更好地利用 Redis 4.0 中引入的一些新特性（如 Redis Sentinel 和 Redis Cluster）。
  • Jedis 的设计目标更偏向于简单易用，对于一些特殊的 Redis 集群模式可能支持不够完善。
维护和更新：
  • Lettuce 是一个活跃的项目，并且持续地得到更新和改进。
  • Jedis 在某些方面已经相对稳定，并且在一段时间内没有大的更新。

3. 创建 Redis 配置类

如果需要自定义 Redis 的配置（比如序列化器），可以创建一个配置类：

 
  1. import org.springframework.context.annotation.Bean;
  2. import org.springframework.context.annotation.Configuration;
  3. import org.springframework.data.redis.connection.RedisConnectionFactory;
  4. import org.springframework.data.redis.core.RedisTemplate;
  5. import org.springframework.data.redis.serializer.StringRedisSerializer;
  6.  
  7. @Configuration
  8. public class RedisConfig {
  9.  
  10. @Bean
  11. public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
  12. RedisTemplate<String, Object> template = new RedisTemplate<>();
  13. template.setConnectionFactory(redisConnectionFactory);
  14.  
  15. // 使用 StringRedisSerializer 来序列化和反序列化 key 值
  16. template.setKeySerializer(new StringRedisSerializer());
  17. // 使用 JdkSerializationRedisSerializer 来序列化和反序列化 value 值
  18. // 你也可以自定义序列化器
  19. template.setValueSerializer(new GenericToStringSerializer<>(Object.class));
  20.  
  21. template.afterPropertiesSet();
  22. return template;
  23. }
  24. }
 

4. 使用 RedisTemplate 或 StringRedisTemplate

在 Spring Boot 应用中，你可以注入 RedisTemplate 或 StringRedisTemplate 来操作 Redis：

 
  1. import org.springframework.beans.factory.annotation.Autowired;
  2. import org.springframework.data.redis.core.RedisTemplate;
  3. import org.springframework.stereotype.Service;
  4.  
  5. @Service
  6. public class RedisService {
  7.  
  8. private final RedisTemplate<String, Object> redisTemplate;
  9.  
  10. @Autowired
  11. public RedisService(RedisTemplate<String, Object> redisTemplate) {
  12. this.redisTemplate = redisTemplate;
  13. }
  14.  
  15. public void setValue(String key, Object value) {
  16. redisTemplate.opsForValue().set(key, value);
  17. }
  18.  
  19. public Object getValue(String key) {
  20. return redisTemplate.opsForValue().get(key);
  21. }
  22.  
  23. // 其他操作...
  24. }
 

5. 编写测试

 
  1. import org.junit.jupiter.api.Test;
  2. import org.springframework.beans.factory.annotation.Autowired;
  3. import org.springframework.boot.test.context.SpringBootTest;
  4. import org.springframework.data.redis.core.StringRedisTemplate;
  5.  
  6. import java.util.concurrent.TimeUnit;
  7.  
  8. @SpringBootTest
  9. public class RedisTest {
  10. @Autowired
  11. private StringRedisTemplate stringRedisTemplate;
  12.  
  13. @Test
  14. //测试redis
  15. void contextLoads2() {
  16. //添加缓存键值对name:mijiu并设置过期时间为1小时
  17. stringRedisTemplate.opsForValue().set("name","mijiu",10, TimeUnit.SECONDS);
  18. System.out.println(stringRedisTemplate.opsForValue().get("name"));
  19.  
  20. }
  21.  
 
posted @ 2024-07-01 10:20  CharyGao  阅读(209)  评论(0)    收藏  举报