Spring Cache + Redis 缓存数据

古城微笑少年丶 2023-10-12 10:15 24阅读 0赞

Spring Cache 是一个非常优秀的缓存组件。自Spring 3.1起，提供了类似于@Transactional注解事务的注解Cache支持，且提供了Cache抽象，方便切换各种底层Cache（如：redis）

使用Spring Cache的好处：

1，提供基本的Cache抽象，方便切换各种底层Cache；

2，通过注解Cache可以实现类似于事务一样，缓存逻辑透明的应用到我们的业务代码上，且只需要更少的代码就可以完成；

3，提供事务回滚时也自动回滚缓存；

4，支持比较复杂的缓存逻辑；

#### **实现方法：** ####

1、添加依赖

<dependency>
    	<groupId>org.springframework.boot</groupId>
    	<artifactId>spring-boot-starter-data-redis</artifactId>
    	</dependency>
    
    
    	<dependency>
    	<groupId>org.apache.commons</groupId>
    	<artifactId>commons-pool2</artifactId>
    	<version>2.6.0</version>
    </dependency>

2、添加Redis配置类

import com.fasterxml.jackson.annotation.JsonAutoDetect;
    import com.fasterxml.jackson.annotation.PropertyAccessor;
    import com.fasterxml.jackson.databind.ObjectMapper;
    import org.springframework.cache.CacheManager;
    import org.springframework.cache.annotation.EnableCaching;
    import org.springframework.cache.interceptor.KeyGenerator;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.data.redis.cache.RedisCacheConfiguration;
    import org.springframework.data.redis.cache.RedisCacheManager;
    import org.springframework.data.redis.connection.RedisConnectionFactory;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
    import org.springframework.data.redis.serializer.RedisSerializationContext;
    import org.springframework.data.redis.serializer.RedisSerializer;
    import org.springframework.data.redis.serializer.StringRedisSerializer;
    
    import java.lang.reflect.Method;
    import java.time.Duration;
    
    @Configuration
    @EnableCaching
    public class RedisConfig {
    
        /**
         * 自定义key规则
         * @return
         */
        @Bean
        public KeyGenerator keyGenerator() {
            return new KeyGenerator() {
                @Override
                public Object generate(Object target, Method method, Object... params) {
                    StringBuilder sb = new StringBuilder();
                    sb.append(target.getClass().getName());
                    sb.append(method.getName());
                    for (Object obj : params) {
                        sb.append(obj.toString());
                    }
                    return sb.toString();
                }
            };
        }
    
        /**
         * 设置RedisTemplate规则
         * @param redisConnectionFactory
         * @return
         */
        @Bean
        public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
            RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();
            redisTemplate.setConnectionFactory(redisConnectionFactory);
            Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
    
            //解决查询缓存转换异常的问题
            ObjectMapper om = new ObjectMapper();
            // 指定要序列化的域，field,get和set,以及修饰符范围，ANY是都有包括private和public
            om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
            // 指定序列化输入的类型，类必须是非final修饰的，final修饰的类，比如String,Integer等会跑出异常
            om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
            jackson2JsonRedisSerializer.setObjectMapper(om);
    
             //序列号key value
            redisTemplate.setKeySerializer(new StringRedisSerializer());
            redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
            redisTemplate.setHashKeySerializer(new StringRedisSerializer());
            redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
    
            redisTemplate.afterPropertiesSet();
            return redisTemplate;
        }
    
        /**
         * 设置CacheManager缓存规则
         * @param factory
         * @return
         */
        @Bean
        public CacheManager cacheManager(RedisConnectionFactory factory) {
            RedisSerializer<String> redisSerializer = new StringRedisSerializer();
            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);
    
              // 配置序列化（解决乱码的问题）,过期时间600秒
            RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                    .entryTtl(Duration.ofSeconds(600))
                    .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer))
                    .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer))
                    .disableCachingNullValues();
    
            RedisCacheManager cacheManager = RedisCacheManager.builder(factory)
                    .cacheDefaults(config)
                    .build();
            return cacheManager;
        }
    }

3、配置文件加上redis信息：

spring.redis.host=127.0.0.1
    spring.redis.port=6379
    spring.redis.database= 0
    spring.redis.timeout=1800000
    
    spring.redis.lettuce.pool.max-active=20
    spring.redis.lettuce.pool.max-wait=-1
    #最大阻塞等待时间(负数表示没限制)
    spring.redis.lettuce.pool.max-idle=5
    spring.redis.lettuce.pool.min-idle=0

4、在业务代码中使用Spring Cache注解进行缓存的基本操作，常用注解：

4.1 @Cacheable

根据方法对其返回结果进行缓存，下次请求时，如果缓存存在，则直接读取缓存数据返回；如果缓存不存在，则执行方法，并把返回的结果存入缓存中。一般用在查询方法上。

<table> 
 <thead> 
  <tr> 
   <td> <p style="margin-left:0;">属性/方法名</p> </td> 
   <td> <p style="margin-left:0;">解释</p> </td> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td> <p style="margin-left:0;">value</p> </td> 
   <td> <p style="margin-left:0;">缓存名，必填，它指定了你的缓存存放在哪块命名空间</p> </td> 
  </tr> 
  <tr> 
   <td> <p style="margin-left:0;">cacheNames</p> </td> 
   <td> <p style="margin-left:0;">与 value 差不多，二选一即可</p> </td> 
  </tr> 
  <tr> 
   <td> <p style="margin-left:0;">key</p> </td> 
   <td> <p style="margin-left:0;">可选属性，可以使用 SpEL 标签自定义缓存的key</p> </td> 
  </tr> 
 </tbody> 
</table>

使用示例：

@Cacheable(value = "user",keyGenerator ="keyGenerator")

4.2 @CachePut

使用该注解标志的方法，每次都会执行，并将结果存入指定的缓存中。其他方法可以直接从响应的缓存中读取缓存数据，而不需要再去查询数据库。一般用在新增方法上。

4.3 @CacheEvict

使用该注解标志的方法，会清空指定的缓存。一般用在更新或者删除方法上

查看源码，属性值如下：

<table> 
 <thead> 
  <tr> 
   <td> <p style="margin-left:0;">属性/方法名</p> </td> 
   <td style="width:253.5pt;"> <p style="margin-left:0;">解释</p> </td> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td> <p style="margin-left:0;">value</p> </td> 
   <td style="width:253.5pt;"> <p style="margin-left:0;">缓存名，必填，它指定了你的缓存存放在哪块命名空间</p> </td> 
  </tr> 
  <tr> 
   <td> <p style="margin-left:0;">cacheNames</p> </td> 
   <td style="width:253.5pt;"> <p style="margin-left:0;">与 value 差不多，二选一即可</p> </td> 
  </tr> 
  <tr> 
   <td> <p style="margin-left:0;">key</p> </td> 
   <td style="width:253.5pt;"> <p style="margin-left:0;">可选属性，可以使用 SpEL 标签自定义缓存的key</p> </td> 
  </tr> 
  <tr> 
   <td style="width:61.75pt;"> <p style="margin-left:0;">allEntries</p> </td> 
   <td style="width:253.5pt;"> <p style="margin-left:0;">是否清空所有缓存，默认为 false。如果指定为 true，则方法调用后将立即清空所有的缓存</p> </td> 
  </tr> 
  <tr> 
   <td style="width:61.75pt;"> <p style="margin-left:0;">beforeInvocation</p> </td> 
   <td style="width:253.5pt;"> <p style="margin-left:0;">是否在方法执行前就清空，默认为 false。如果指定为 true，则在方法执行前就会清空缓存</p> </td> 
  </tr> 
 </tbody> 
</table>

使用示例：

*/\*\*  
\* 导入  
 \* allEntries = true: 方法调用后清空***user***所有缓存  
 \* **@param** **file**  
\*/*  
@CacheEvict(value = **"user"**, allEntries=**true**)

PS:文章转载自尚硅谷教程