当我们调用一个方法时会把该方法的参数和返回结果最为一个键值对存放在缓存中，等下次利用同样的参数来调用该方法时将不会再执行，而是直接从缓存中获取结果进行返回。

  1.  <dependency>
  2.       <groupId>org.springframework.boot</groupId>
  3.       <artifactId>spring-boot-starter-cache</artifactId>
  4.   </dependency>
  6. #指定缓存类型
  7. spring:
  8.   cache:
  9.      type: redis
  11. #启动类开启缓存注解
  12. @EnableCaching
  1. #缓存配置  修改序列化器、缓存过期时间、缓存key生成规则
  2. @Configuration
  3. public class CacheConfig {
  4.     @Bean
  5.     public KeyGenerator DefaultKeyGenerator(){
  6.         return new KeyGenerator() {
  7.             @Override
  8.             public Object generate(Object o, Method method, Object... objects) {
  9.                 return o.getClass().getSimpleName() + "_"
  10.                         + method.getName() + "_"
  11.                         + StringUtils.arrayToDelimitedString(objects, "_");
  12.             }
  13.         };
  14.     }
  16.     @Bean
  17.     @Primary
  18.     public RedisCacheManager cacheManager1Hour(RedisConnectionFactory connectionFactory) {
  19.         RedisCacheConfiguration config =
  20.                 instanceConfig(3600L);
  21.         return
  22.                 RedisCacheManager.builder(connectionFactory)
  23.                         .cacheDefaults(config)
  24.                         .transactionAware()
  25.                         .build();
  26.     }
  28.     @Bean
  29.     public RedisCacheManager cacheManager1Day(RedisConnectionFactory connectionFactory) {
  30.         RedisCacheConfiguration config =
  31.                 instanceConfig(3600 * 24L);
  32.         return
  33.                 RedisCacheManager.builder(connectionFactory)
  34.                         .cacheDefaults(config)
  35.                         .transactionAware()
  36.                         .build();
  37.     }
  39.     private RedisCacheConfiguration instanceConfig(Long ttl) {
  40.         Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer =
  41.                 new Jackson2JsonRedisSerializer<>(Object.class);
  42.         ObjectMapper objectMapper = new ObjectMapper();
  44.         objectMapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
  45.         objectMapper.registerModule(new JavaTimeModule());
  46.         // 去掉各种@JsonSerialize注解的解析
  48.         objectMapper.configure(MapperFeature.USE_ANNOTATIONS, false);
  49.         // 只针对⾮空的值进⾏序列化
  51.         objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
  52.         // 将类型序列化到属性json字符串中
  54.         objectMapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance,
  55.                 ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
  57.         jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
  58.         return
  59.                 RedisCacheConfiguration.defaultCacheConfig()
  60.                         .entryTtl(Duration.ofSeconds(ttl))
  61.                         .disableCachingNullValues()
  62.                         .serializeValuesWith(RedisSerializationContext.
  63.                         SerializationPair.fromSerializer(jackson2JsonRedisSerializer));
  64.     }
  65. }

常用注解

Cacheable

缓存标注对象的返回结果，标注在⽅法上缓存该⽅法的返回值，标注在类上缓存该类所有的⽅法返回值。
value 缓存名称，可以有多个key 缓存的key规则，可以⽤springEL表达式，默认是⽅法参数组合；cacheManager缓存管理器；condition 缓存条件，使⽤springEL编写，返回true才缓存

  1. @Cacheable(value = "Article",keyGenerator = "DefaultKeyGenerator",
  2.            cacheManager = "cacheManager1Day")

CachePut

用于更新操作时，同时把缓存中的数据更新；注意key值要和缓存里面的key保持一致

CacheEvict

用于删除操作时，同时把缓存中的数据删除

参数：

  • beforeInvocation = false
    • 缓存的清除是否在⽅法之前执⾏ ,默认代表缓存清除 操作是在⽅法执⾏之后执⾏; 如果出现异常缓存就不会清除
  • beforeInvocation = true
    • 代表清除缓存操作是在⽅法运⾏之前执⾏，⽆论⽅法是否出现异常，缓存都清除

Caching

允许在同⼀⽅法上使⽤多个嵌套的@Cacheable、@CachePut和@CacheEvict注释；可以同时生效

  1. @Caching(
  2.      cacheable = {
  3.          @Cacheable(value ="product",keyGenerator = "xdclassKeyGenerator")
  4.      },
  5.       put = {
  6.          @CachePut(value ="product",key = "#id"),
  7.          @CachePut(value ="product",key = "'stock:'+#id")
  8.      }
  9.  )