Redis 简介

什么是 Redis

Redis 是目前使用的非常广泛的免费开源内存数据库，是一个高性能的 key-value 数据库。
Redis 与其他 key-value 缓存（如 Memcached ）相比有以下三个特点:

1.Redis 支持数据的持久化，它可以将内存中的数据保存在磁盘中，重启的时候可以再次加载进行使用。 2.Redis 不仅仅支持简单的 key-value 类型的数据，同时还提供 list，set，zset，hash 等数据结构的存储。

3.Redis 支持数据的备份，即 master-slave 模式的数据备份。
Redis 优势如下：

1.性能极高。Redis 能读的速度是 110000 次/s，写的速度是 81000 次/s。

2.丰富的数据类型。Redis 支持二进制案例的 Strings，Lists，Sets 及 Ordered Sets 数据类型操作。
3.原子性。Redis 所有的操作都是原子性的，意思是要么成功执行要么失败完全不执行。单个操作是原子性的，多个操作也是，通过 MULTI 和 EXEC 指令抱起来。
4.丰富的特性。Redis 还支持 publish/subscribe，通知，key 过期等特性。

Spring Boot 集成 Redis

1.在项目中添加依赖

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <modelVersion>4.0.0</modelVersion>
  6.     <parent>
  7.         <groupId>org.springframework.boot</groupId>
  8.         <artifactId>spring-boot-starter-parent</artifactId>
  9.         <version>2.1.9.RELEASE</version>
  10.         <relativePath /> <!-- lookup parent from repository -->
  11.     </parent>
  12.     <groupId>cn.zwqh</groupId>
  13.     <artifactId>spring-boot-redis</artifactId>
  14.     <version>0.0.1-SNAPSHOT</version>
  15.     <name>spring-boot-redis</name>
  16.     <description>spring-boot-redis</description>
  17.     <properties>
  18.         <java.version>1.8</java.version>
  19.     </properties>
  20.     <dependencies>
  21.         <dependency>
  22.             <groupId>org.springframework.boot</groupId>
  23.             <artifactId>spring-boot-starter-web</artifactId>
  24.         </dependency>
  25.         <dependency>
  26.             <groupId>org.springframework.boot</groupId>
  27.             <artifactId>spring-boot-starter-test</artifactId>
  28.             <scope>test</scope>
  29.         </dependency>
  30.         <!-- Redis -->
  31.         <dependency>
  32.             <groupId>org.springframework.boot</groupId>
  33.             <artifactId>spring-boot-starter-data-redis</artifactId>
  34.         </dependency>
  36.     </dependencies>
  37.     <build>
  38.         <plugins>
  39.             <plugin>
  40.                 <groupId>org.springframework.boot</groupId>
  41.                 <artifactId>spring-boot-maven-plugin</artifactId>
  42.             </plugin>
  43.         </plugins>
  44.     </build>
  45. </project>

查看 jar 包时发现，Spring Data Redis 下 org.springframework.data.redis.connection 包路径下面默认有两个包 jedis 和 lettuce，这说明 Spring Boot 已经默认包装适配了这两个 Redis 客户端。

在 springboot 1.5.x版本的默认的Redis客户端是 Jedis实现的，springboot 2.x版本中默认客户端是用 lettuce实现的。

Lettuce 与 Jedis 比较

Lettuce 和 Jedis 的都是连接 Redis Server的客户端。

Jedis 在实现上是直连 redis server，多线程环境下非线程安全，除非使用连接池，为每个 redis实例增加物理连接。

Lettuce 是 一种可伸缩，线程安全，完全非阻塞的Redis客户端，多个线程可以共享一个RedisConnection,它利用Netty NIO 框架来高效地管理多个连接，从而提供了异步和同步数据访问方式，用于构建非阻塞的反应性应用程序。

下面我们分别使用 Lettuce 和 Jedis 来集成 Redis 服务

2. Lettuce 集成 Redis 服务

导入依赖

由于 Spring Boot 2.X 默认集成了 Lettuce ，所以无需导入。

application.properties配置文件

  1. ################ Redis 基础配置 ##############
  2. # Redis数据库索引（默认为0）
  3. spring.redis.database=0  
  4. # Redis服务器地址
  5. spring.redis.host=127.0.0.1
  6. # Redis服务器连接端口
  7. spring.redis.port=6379  
  8. # Redis服务器连接密码（默认为空）
  9. spring.redis.password=zwqh
  10. # 链接超时时间 单位 ms（毫秒）
  11. spring.redis.timeout=3000
  12. ################ Redis 线程池设置 ##############
  13. # 连接池最大连接数（使用负值表示没有限制） 默认 8
  14. spring.redis.lettuce.pool.max-active=8
  15. # 连接池最大阻塞等待时间（使用负值表示没有限制） 默认 -1
  16. spring.redis.lettuce.pool.max-wait=-1
  17. # 连接池中的最大空闲连接 默认 8
  18. spring.redis.lettuce.pool.max-idle=8
  19. # 连接池中的最小空闲连接 默认 0
  20. spring.redis.lettuce.pool.min-idle=0

自定义 RedisTemplate

默认情况下的模板只能支持 RedisTemplate<String,String>，只能存入字符串，很多时候，我们需要自定义 RedisTemplate ，设置序列化器，这样我们可以很方便的操作实例对象。如下所示：

  1. @Configuration
  2. public class LettuceRedisConfig {
  3.     @Bean
  4.     public RedisTemplate<String, Serializable> redisTemplate(LettuceConnectionFactory connectionFactory) {
  5.         RedisTemplate<String, Serializable> redisTemplate = new RedisTemplate<>();
  6.         redisTemplate.setKeySerializer(new StringRedisSerializer());
  7.         redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
  8.         redisTemplate.setConnectionFactory(connectionFactory);
  9.         return redisTemplate;
  10.     }
  11. }

序列化实体类

  1. public class UserEntity implements Serializable {
  2.     /**
  3.      * 
  4.      */
  5.     private static final long serialVersionUID = 5237730257103305078L;
  7.     private Long id;
  8.     private String userName;
  9.     private String userSex;
  10.     public Long getId() {
  11.         return id;
  12.     }
  13.     public void setId(Long id) {
  14.         this.id = id;
  15.     }
  16.     public String getUserName() {
  17.         return userName;
  18.     }
  19.     public void setUserName(String userName) {
  20.         this.userName = userName;
  21.     }
  22.     public String getUserSex() {
  23.         return userSex;
  24.     }
  25.     public void setUserSex(String userSex) {
  26.         this.userSex = userSex;
  27.     }
  29. }

单元测试

  1. @RunWith(SpringRunner.class)
  2. @SpringBootTest
  3. public class SpringBootRedisApplicationTests {
  4.     @Autowired
  5.     private RedisTemplate<String, String> strRedisTemplate;
  6.     @Autowired
  7.     private RedisTemplate<String, Serializable> serializableRedisTemplate;
  9.     @Test
  10.     public void testString() {
  11.         strRedisTemplate.opsForValue().set("strKey", "zwqh");
  12.         System.out.println(strRedisTemplate.opsForValue().get("strKey"));
  13.     }
  15.     @Test
  16.     public void testSerializable() {
  17.         UserEntity user=new UserEntity();
  18.         user.setId(1L);
  19.         user.setUserName("朝雾轻寒");
  20.         user.setUserSex("男");        
  21.         serializableRedisTemplate.opsForValue().set("user", user);        
  22.         UserEntity user2 = (UserEntity) serializableRedisTemplate.opsForValue().get("user");
  23.         System.out.println("user:"+user2.getId()+","+user2.getUserName()+","+user2.getUserSex());
  24.     }
  25. }

执行结果如下：
Spring Boot 集成 Redis - 图1
得到我们预期的结果。

3.Jedis 集成 Redis 服务

pom 文件

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <modelVersion>4.0.0</modelVersion>
  6.     <parent>
  7.         <groupId>org.springframework.boot</groupId>
  8.         <artifactId>spring-boot-starter-parent</artifactId>
  9.         <version>2.1.9.RELEASE</version>
  10.         <relativePath /> <!-- lookup parent from repository -->
  11.     </parent>
  12.     <groupId>cn.zwqh</groupId>
  13.     <artifactId>spring-boot-redis</artifactId>
  14.     <version>0.0.1-SNAPSHOT</version>
  15.     <name>spring-boot-redis</name>
  16.     <description>spring-boot-redis</description>
  17.     <properties>
  18.         <java.version>1.8</java.version>
  19.     </properties>
  20.     <dependencies>
  21.         <dependency>
  22.             <groupId>org.springframework.boot</groupId>
  23.             <artifactId>spring-boot-starter-web</artifactId>
  24.         </dependency>
  25.         <dependency>
  26.             <groupId>org.springframework.boot</groupId>
  27.             <artifactId>spring-boot-starter-test</artifactId>
  28.             <scope>test</scope>
  29.         </dependency>
  30.         <!-- Redis -->
  31.         <dependency>
  32.             <groupId>org.springframework.boot</groupId>
  33.             <artifactId>spring-boot-starter-data-redis</artifactId>
  34.             <exclusions>
  35.                 <!-- 排除lettuce包 -->
  36.                 <exclusion>
  37.                     <groupId>io.lettuce</groupId>
  38.                     <artifactId>lettuce-core</artifactId>
  39.                 </exclusion>
  40.             </exclusions>
  41.         </dependency>
  42.         <!-- 添加jedis客户端 -->
  43.         <dependency>
  44.             <groupId>redis.clients</groupId>
  45.             <artifactId>jedis</artifactId>
  46.         </dependency>
  48.     </dependencies>
  49.     <build>
  50.         <plugins>
  51.             <plugin>
  52.                 <groupId>org.springframework.boot</groupId>
  53.                 <artifactId>spring-boot-maven-plugin</artifactId>
  54.             </plugin>
  55.         </plugins>
  56.     </build>
  57. </project>

application.properties配置文件

  1. ################ Redis 基础配置 ##############
  2. # Redis数据库索引（默认为0）
  3. spring.redis.database=0  
  4. # Redis服务器地址
  5. spring.redis.host=127.0.0.1
  6. # Redis服务器连接端口
  7. spring.redis.port=6379  
  8. # Redis服务器连接密码（默认为空）
  9. spring.redis.password=zwqh
  10. # 链接超时时间 单位 ms（毫秒）
  11. spring.redis.timeout=3000
  12. ################ Redis 线程池设置 ##############
  13. # 连接池最大连接数（使用负值表示没有限制） 默认 8
  14. spring.redis.jedis.pool.max-active=8
  15. # 连接池最大阻塞等待时间（使用负值表示没有限制） 默认 -1
  16. spring.redis.jedis.pool.max-wait=-1
  17. # 连接池中的最大空闲连接 默认 8
  18. spring.redis.jedis.pool.max-idle=8
  19. # 连接池中的最小空闲连接 默认 0
  20. spring.redis.jedis.pool.min-idle=0

JedisRedisConfig

  1. @Configuration
  2. public class JedisRedisConfig {
  3.     @Value("${spring.redis.database}")
  4.     private int database;
  5.     @Value("${spring.redis.host}")
  6.     private String host;
  7.     @Value("${spring.redis.port}")
  8.     private int port;
  9.     @Value("${spring.redis.password}")
  10.     private String password;
  11.     @Value("${spring.redis.timeout}")
  12.     private int timeout;
  13.     @Value("${spring.redis.jedis.pool.max-active}")
  14.     private int maxActive;
  15.     @Value("${spring.redis.jedis.pool.max-wait}")
  16.     private long maxWaitMillis;
  17.     @Value("${spring.redis.jedis.pool.max-idle}")
  18.     private int maxIdle;
  19.     @Value("${spring.redis.jedis.pool.min-idle}")
  20.     private int minIdle;
  21.     /**
  22.      * 连接池配置信息
  23.      */
  24.     @Bean
  25.     public JedisPoolConfig jedisPoolConfig() {
  26.         JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
  27.         // 最大连接数
  28.         jedisPoolConfig.setMaxTotal(maxActive);
  29.         // 当池内没有可用连接时，最大等待时间
  30.         jedisPoolConfig.setMaxWaitMillis(maxWaitMillis);
  31.         // 最大空闲连接数
  32.         jedisPoolConfig.setMinIdle(maxIdle);
  33.         // 最小空闲连接数
  34.         jedisPoolConfig.setMinIdle(minIdle);
  35.         // 其他属性可以自行添加
  36.         return jedisPoolConfig;
  37.     }
  38.     /**
  39.      * Jedis 连接
  40.      * 
  41.      * @param jedisPoolConfig
  42.      * @return
  43.      */
  44.     @Bean
  45.     public JedisConnectionFactory jedisConnectionFactory(JedisPoolConfig jedisPoolConfig) {
  46.         JedisClientConfiguration jedisClientConfiguration = JedisClientConfiguration.builder().usePooling()
  47.                 .poolConfig(jedisPoolConfig).and().readTimeout(Duration.ofMillis(timeout)).build();
  48.         RedisStandaloneConfiguration redisStandaloneConfiguration = new RedisStandaloneConfiguration();
  49.         redisStandaloneConfiguration.setHostName(host);
  50.         redisStandaloneConfiguration.setPort(port);
  51.         redisStandaloneConfiguration.setPassword(RedisPassword.of(password));
  52.         return new JedisConnectionFactory(redisStandaloneConfiguration, jedisClientConfiguration);
  53.     }
  54.     /**
  55.      * 缓存管理器
  56.      * 
  57.      * @param connectionFactory
  58.      * @return
  59.      */
  60.     @Bean
  61.     public RedisCacheManager cacheManager(RedisConnectionFactory connectionFactory) {
  62.         return RedisCacheManager.create(connectionFactory);
  63.     }
  64.     @Bean
  65.     public RedisTemplate<String, Serializable> redisTemplate(JedisConnectionFactory connectionFactory) {
  66.         RedisTemplate<String, Serializable> redisTemplate = new RedisTemplate<>();
  67.         redisTemplate.setKeySerializer(new StringRedisSerializer());
  68.         redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
  69.         redisTemplate.setConnectionFactory(jedisConnectionFactory(jedisPoolConfig()));
  70.         return redisTemplate;
  71.     }
  72. }

单元测试同上

出现预期结果。

总结

上面介绍了 Spring Boot 2.X 如何通过 Lettuce 和 Jedis 来集成 Redis 服务，按项目需求，我们也可以自定义操作类来实现数据操作。