SpringBoot整合使用Redis

简介

Redis（Remote Dictionary Server 远程字典服务）是一种开源的内存数据结构存储系统，因其高性能和丰富的数据结构支持，在缓存、会话管理、实时数据处理和消息队列等多个领域有广泛的应用。通过合理的设计和使用，Redis 能够显著提升系统的性能和可扩展性。Redis主要有如下特点：

1. 基于内存存储：相对MySQL等将数据存储在磁盘中的数据库，Redis将数据存储在内存中，省去磁盘I/O的消耗，从而提高性能
2. 丰富的数据结构：Redis支持多种类型的数据结构，常见数据类型有五种：字符串（String）、哈希（Hash）、列表（List）、集合（Set）、有序集合（zSet），还有三种特殊数据类型：地理位置（Geospatial）、（HyperLogLog ）和位存储（Bitmap）
3. 支持持久化：Redis支持RDB（快照）和AOF（）两种持久化机制，可以在数据存储在内存中的同时，将数据持久化到磁盘中，保证数据不丢失
4. 主从复制：支持主从复制，数据可以从主节点复制到多个从节点，从而提高数据的可用性和读取性能
5. I/O多路复用：IO多路复用其实就是一种同步IO模型，它实现了一个线程可以监视多个文件句柄；一旦某个文件句柄就绪，就能够通知应用程序进行相应的读写操作；没有文件句柄就绪时会阻塞应用程序。

基本使用

SpringBoot在1.×版本底层使用Jedis来连接Redis的，但在2.×版本后，默认使用Lettuce作为Redis的连接实现。两者的区别如下：

• Jedis: 使用同步API，操作简单，但Jedis实例不是线程安全的，需要为每个线程创建实例或使用线程池来保证线程安全，适合简单的、连接数较少的应用场景
• Lettuce: 提供同步、异步和响应式API，本身是线程安全的，不需要线程池，适合
  可以通过配置spring.redis.client-type属性值来指定使用Lettuce或Jedis作为连接实现。

1. 添加Maven依赖

   <dependencies>
       <!-- Spring Data Redis -->
       <dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-data-redis</artifactId>
       </dependency>
   </dependencies>
   

2. 添加Redis配置
   在application.properties或application.yml文件中添加Redis相关配置

   spring:
   	redis:
   		host: 127.0.0.1			# Redis服务器地址
   		port: 6379				# Redis服务器连接端口，默认6379
   		password: yourpassword 	# 如果没有设置密码，可省略
   		database: 0				# Redis数据库索引
   		timeout: 2000			# 连接超时时间（单位ms）
   		# 连接池配置
   		pool:
   			max-active: 8	# 最大连接数（负数表示没有限制）
   			max-wait: -1	# 最大阻塞等待时间（单位ms，负数表示没有限制）
   			max-idel: 8		# 最大空闲连接数，默认为8
   			min-idle: 0		# 最小空闲连接，默认为0
   

3. 在代码中添加Redis配置类

   @Configuration
   public class RedisConfig {
   
       @Autowired
       private MyRedisProperties myRedisProperties;
   
       @Bean
       public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
           RedisTemplate<String, Object> template = new RedisTemplate<>(redisConnectionFactory());
           template.setConnectionFactory(connectionFactory);
           // 使用 Jackson2JsonRedisSerializer 来序列化和反序列化 redis 的 value 值（默认使用 JDK 的序列化方式）
           Jackson2JsonRedisSerializer<Object> serializer = new Jackson2JsonRedisSerializer<>(Object.class);
           ObjectMapper objectMapper = new ObjectMapper();
           objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
           objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
           serializer.setObjectMapper(objectMapper);
           // 设置 value 的序列化器
           template.setValueSerializer(serializer);
           template.setHashValueSerializer(serializer);
           // 设置 key 的序列化器
           template.setKeySerializer(new StringRedisSerializer());
           template.setHashKeySerializer(new StringRedisSerializer());
           template.afterPropertiesSet();
           return template;
       }
       
       private RedisConnectionFactory redisConnectionFactory() {
           RedisStandaloneConfiguration standaloneConfiguration = new RedisStandaloneConfiguration();
           standaloneConfiguration.setHostName(myRedisProperties.getHost());
           standaloneConfiguration.setPort(myRedisProperties.getPort());
           standaloneConfiguration.setDatabase(myRedisProperties.getDatabase());
           standaloneConfiguration.setPassword(myRedisProperties.getPassword());
           JedisConnectionFactory jedisConnectionFactory = new JedisConnectionFactory(standaloneConfiguration);
           //进行连接池配置
           GenericObjectPoolConfig poolConfig = jedisConnectionFactory.getPoolConfig();
           if (poolConfig != null) {
               poolConfig.setMaxTotal(myRedisProperties.getPool().getMaxActive());
               poolConfig.setMaxIdle(myRedisProperties.getPool().getMaxIdle());
               poolConfig.setMinIdle(myRedisProperties.getPool().getMinIdle());
               poolConfig.setMaxWaitMillis(myRedisProperties.getPool().getMaxWait());
           }
           return jedisConnectionFactory;
       }
   }
   

4. 通过注入RedisTemplate进行Redis相关操作

   import org.springframework.beans.factory.annotation.Autowired;
   import org.springframework.data.redis.core.RedisTemplate;
   import org.springframework.stereotype.Service;
   
   @Service
   public class RedisService {
   
       @Autowired
       private RedisTemplate<String, Object> redisTemplate;
   
       public void setValue(String key, Object value) {
           redisTemplate.opsForValue().set(key, value);
       }
   
       public Object getValue(String key) {
           return redisTemplate.opsForValue().get(key);
       }
   }
   

   如果我们没有进行第三步添加Redis配置类的操作，也可以直接注入使用RedisTemplate来操作Redis。SpringBoot通过@ConditionalOnMissingBean注解判断当前是否显示地创建RedisConnectionFactory Bean和 RedisTemplate Bean，若没有则自动配置默认的连接工厂和序列化器。
   SpringBoot自动配置 Redis的具体流程如下：
   1. 加载配置属性
      RedisProperties 类会读取 application.properties 或 application.yml 中的 Redis 配置属性。这些属性可以包括 Redis 服务器地址、端口、密码等。
   2. 检查条件
      RedisAutoConfiguration 类使用条件注解来检查是否有自定义的 RedisConnectionFactory 和 RedisTemplate Bean。如果没有，这些类会自动创建默认的 Bean。
   3. 创建连接工厂
      根据配置的 Redis 客户端（Lettuce 或 Jedis），Spring Boot 会分别加载 LettuceConnectionConfiguration 或 JedisConnectionConfiguration 来创建 LettuceConnectionFactory 或 JedisConnectionFactory。
   4. 创建 RedisTemplate
      如果没有找到自定义的 RedisTemplate，Spring Boot 会自动创建一个默认的 RedisTemplate。同样地，如果没有找到自定义的 StringRedisTemplate，Spring Boot 也会创建一个默认的 StringRedisTemplate。

   @Bean
   @ConditionalOnMissingBean(RedisConnectionFactory.class)
   public LettuceConnectionFactory redisConnectionFactory() {
       return createLettuceConnectionFactory();
   }
   

   @Bean
   @ConditionalOnMissingBean(RedisConnectionFactory.class)
   public JedisConnectionFactory redisConnectionFactory() {
       return createJedisConnectionFactory();
   }
   

   @Bean
   @ConditionalOnMissingBean(name = "redisTemplate")
   public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
       RedisTemplate<Object, Object> template = new RedisTemplate<>();
       template.setConnectionFactory(redisConnectionFactory);
       return template;
   }