SpringBoot整合redis做数据缓存

骑猪看日落 2023-02-15 10:09 31阅读 0赞

## Spring的支持 ##

Spring对redis的支持也是通过Spring Data Redis来实现的，Spring Data JPA为我们提供了链接相关的ConnectionFactory和数据库操作相关的RedisTemplate。

Spring Data Redis提供了两种JedisConnectionFactory和LettuceConnectionFactory。默认使用的是LettuceConnectionFactory。

Spring Data Redis为我们提供了RedisTemplate和StringRedisTemplate两个模板来进行数据操作，其中，StringRedisTemplate只针对键值都是字符串的数据进行操作。

StringRedisTemplate和RedisTemplate提供的主要数据访问方法如下：

<table> 
 <tbody> 
  <tr> 
   <td style="text-align:center;vertical-align:middle;">方法</td> 
   <td style="text-align:center;vertical-align:middle;">说明</td> 
  </tr> 
  <tr> 
   <td>opsForValue()</td> 
   <td>操作只有简单属性的数据</td> 
  </tr> 
  <tr> 
   <td>opsForList()</td> 
   <td>操作含有list的数据</td> 
  </tr> 
  <tr> 
   <td>opsForSet()</td> 
   <td>操作含有set的数据</td> 
  </tr> 
  <tr> 
   <td>opsForZSet()</td> 
   <td>操作含有ZSet的数据</td> 
  </tr> 
  <tr> 
   <td>opsForHash()</td> 
   <td>操作含有hash的数据</td> 
  </tr> 
 </tbody> 
</table>

当我们的数据存储到Redis的时候，我们的键（key）和值（value）都是通过Spring提供的Serializer序列化到数据库的。RedisTemplate默认使用的是JdkSerializationRedisSerializer，StringRedisTemplate默认使用的是StringRedisSerializer。

Spring Data JPA为我们提供了6中Serializer：GenericJackson2JsonRedisSerializer、GenericToStringSerializer、Jackson2JsonRedisSerializer、JdkSerializationRedisSerializer、OxmSerializer、StringRedisSerializer。

我们在做数据缓存的时候可以手动使用RedisTemplate来操作Redis数据库，也可以使用注解来操作。

*  ### 使用RedisTemplate来操作 ###

添加依赖

<dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-redis</artifactId>
            </dependency>

添加redis数据库连接

#==============spring cache redis==============
    spring.cache.type=redis
    spring.redis.host=localhost
    spring.redis.port=6379
    spring.redis.database=0
    spring.redis.password=

这里只是列举了几个主要的配置，其他的可以查看RedisProperties类，里面有redis的配置属性，还有它的默认值。

添加RedisTemplate的bean

@Bean
        public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
    
            RedisTemplate<Object, Object> template = new RedisTemplate<>();
            template.setConnectionFactory(redisConnectionFactory);
    
            //使用FastJsonRedisSerializer
    //        FastJsonRedisSerializer serializer = new FastJsonRedisSerializer(Object.class);
            Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
            ObjectMapper om = new ObjectMapper();
            om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
            om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
            jackson2JsonRedisSerializer.setObjectMapper(om);
            template.setKeySerializer(new StringRedisSerializer());
            template.setValueSerializer(jackson2JsonRedisSerializer);
    
            template.setHashKeySerializer(new StringRedisSerializer());
            template.setHashValueSerializer(jackson2JsonRedisSerializer);
    
            //开启事务支持
            template.setEnableTransactionSupport(true);
    
            template.afterPropertiesSet();
            return template;
        }

即使不添加redisTemplate的bean也可以直接注入。SpringBoot会为我们配置默认的RedisTemplate，SpringBoot默认的RedisTemplate使用的是JdkSerializationRedisSerializer，JdkSerializationRedisSerializer使用的是二进制形式存储数据，不便于观察，所以在这里改为使用Jackson2JsonRedisSerializer，当然还可以是用第三方FastJsonRedisSerializer。

public class RedisUserServiceImpl implements RedisUserService {
    
        @Autowired
        private UserMapper userMapper;
    
        @Autowired
        private RedisTemplate<Object, Object> redisTemplate;
    
    //    @Resource(name = "redisTemplate")
    //    ValueOperations<Object, Object> valOps;
    
        @Override
    
        public void saveUser(User user) {
            redisTemplate.opsForValue().set(user.getId(), user);
        }
    
        @Override
        public User findUserById(Long id) {
            User user = (User) redisTemplate.opsForValue().get("id");
            if (user == null) {
                user = userMapper.selectByPrimaryKey(id);
                // 将数据存入redis缓存
                redisTemplate.opsForValue().set(user.getId(), user);
    //            valOps.set(user.getId(), user);
    //            valOps.get(user.getId());
            }
            return user;
        }
    }

在Service里面注入RedisTemplate，来操作Redis数据库。

*  ## 使用注解的方式 ##

注解的使用可以参照[SpringBoot整合Cache缓存数据][SpringBoot_Cache]，这里只说一下cacheManager的配置。参照一下代码：

@Bean
        public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
            // 设置CacheManager的值序列化方式为Jackson2JsonRedisSerializer,默认就是使用StringRedisSerializer序列化key,JdkSerializationRedisSerializer序列化value
            Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>(
                    Object.class);
            ObjectMapper objectMapper = new ObjectMapper();
            objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
            objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
            jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
            // 配置value序列化方式为Jackson2JsonRedisSerializer,key序列化方式采用默认的StringRedisSerializer
            RedisCacheConfiguration cacheConfiguration = RedisCacheConfiguration.defaultCacheConfig().serializeValuesWith(
                    RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer));
            // 每一类信息进行缓存配置
            Map<String, RedisCacheConfiguration> redisCacheConfigurationMap = new HashMap<>();
            // 用户信息
            redisCacheConfigurationMap.put(RedisConstant.USER, cacheConfiguration.entryTtl(Duration.ofDays(10))
                    .disableCachingNullValues().prefixKeysWith(RedisConstant.USER));
    
            // 初始化一个RedisCacheWriter
            RedisCacheWriter redisCacheWriter = RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory);
            RedisCacheConfiguration defaultCacheConfig = RedisCacheConfiguration.defaultCacheConfig().serializeValuesWith(
                    RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer));
            // 设置默认超过期时间是1天(短时间的已经做了其他的处理,不会采用注解形式加入缓存)
            defaultCacheConfig.entryTtl(Duration.ofDays(1));
            // 初始化RedisCacheManager
            RedisCacheManager cacheManager = new RedisCacheManager(redisCacheWriter, defaultCacheConfig,
                    redisCacheConfigurationMap);
    //        RedisCacheManager cacheManager = new RedisCacheManager(redisCacheWriter, defaultCacheConfig);
            return cacheManager;
        }

cacheManager不是必须配置的，之前也说了SpringBoot默认使用的是JdkSerializationRedisSerializer，存入的是二进制数据，不便于查看，所以配置了cacheManager。

RedisCacheManager一共有6个构造方法，文中用到这个这个构造方法区别在于redisCacheConfigurationMap是给指定的缓存名的数据缓存做配置，defaultCacheConfig是缓存的默认配置。除过指定名字之外的其他缓存使用默认配置也就是defaultCacheConfig。

RedisCacheConfiguration的配置有很多文中是配置了序列化方式，缓存过期时间，禁止缓存空数据，key前缀，其他配置可以查看RedisCacheConfiguration类。

贴出其他代码

public class RedisConstant {
        /**
         * 存储用户信息前缀
         */
        public static final String USER = "user:";
    
        public static final String LOG = "log:";
    }

@Service
    public class UserServiceImpl implements UserService {
    
        @Autowired
        private UserMapper userMapper;
    
    
        @Override
        @Cacheable(value = RedisConstant.USER, key = "#user.id",unless = "#result==null")
        public User getUserById(User user) {
            return userMapper.selectByPrimaryKey(user.getId());
        }
    
        @Override
        @CachePut(value = RedisConstant.USER, key = "#user.id", condition = "#result!=null")
        public User save(User user) {
            userMapper.insertSelective(user);
            return user;
        }
    
        @Override
        @CacheEvict(value = "people")
        public void deleteById(User user) {
            userMapper.deleteByPrimaryKey(user.getId());
        }
    
    }

@Service
    public class LogServiceImpl implements LogService {
    
        @Autowired
        private LogMapper logMapper;
    
        @Override
        @Cacheable(value = RedisConstant.LOG, key = "#logId", unless = "#result==null")
        public Log findLogById(Long logId) {
            return logMapper.selectByPrimaryKey(logId);
        }
    }

[SpringBoot_Cache]: https://blog.csdn.net/qq_25453181/article/details/106393729