REDIS12_Spring Cache概述@Cacheable@CacheEvict@Caching@CachePut的使用

Posted 2022-02-24 所得皆惊喜

文章目录

• ①. Spring Cache概述
• ②. Spring cache入门案列@Cacheable
• ③. JSON格式转换、空值缓存
• ④. @CacheEvict、@Caching、@CachePut的使用
• ⑤. SpringCache原理与不足

①. Spring Cache概述

• ①. 如何找到Spring Cache的官方文档
  (https://docs.spring.io/spring-framework/docs/5.2.17.BUILD-SNAPSHOT/spring-framework-reference/integration.html#cache)
  

• ②.Spring 从 3.1开始定义了org.springframework.cache.Cache和 org.springframework.cache.Cache Manager接口来统一不同的缓存技术,并支持使用 JCache(JSR-107)注解简化我们开发

• ③. JSR-107 定义了5个核心接口来实现缓存操作,分别是CachingProvider, CacheManager, Cache, Entry和Expiry
  

• ④. 每次调用需要缓存功能的方法时,Spring会检查检查指定参数的指定的目标方法是否已经被调用过；如果有就直接从缓存中获取方法调用后的结果,如果没有就调用方法并缓存结果后返回给用户。下次调用直接从缓存中获取

• ⑤. SpringCache常用注解详解

注解	解释
@Cacheable	触发将数据保存到缓存的操作
@CacheEvict	触发将数据从缓存删除的操作
@CachePut	不影响方法执行更新缓存 双写模式
@Caching	组合以上多个操作
@CacheConfig	在类级别共享缓存的相同配置

②. Spring cache入门案列@Cacheable

• ①. 导入pom文件,在主启动类上添加@EnableCaching

<!--引入redis-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
    <exclusions>
        <exclusion>
            <groupId>io.lettuce</groupId>
            <artifactId>lettuce-core</artifactId>
        </exclusion>
    </exclusions>
</dependency>
<!--cache-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
</dependency>   

@EnableCaching
@SpringBootApplication
public class testSpringCache
    public static void main(String[] args) 
        SpringApplication.run(testSpringCache.class, args);
    

//application.properties
spring.cache.type=redis
#spring.cache.cache-names=

• ②. 业务类

 /**
  * @Cacheable
  *(代表当前方法的结果需要缓存,如果缓存中有,方法不用调用
  *如果缓存中没有,会调用方法,最后将方法的结果放入到缓存)
  *1、每一个需要缓存的数据我们都来指定要放到那个名字的缓存(缓存的分区,按照业务类型分)
  *2、默认行为
  *   (1). 如果缓存中有,方法不再调用
  *   (2). key是默认自动生成的,包含缓存名字::SimpleKey(自动生成的key值)
  *   (3). 缓存的value的值。默认使用jdk序列化机制,将序列化后的数据存到redis
  *   (4). 默认过期时间是 -1
  */
@Cacheable(value="category")
@Override
public List<CategoryEntity> getLevel1Category() 
    long l= System.currentTimeMillis();
    QueryWrapper<CategoryEntity> wrapper = new QueryWrapper<>();
    wrapper.eq("parent_cid",0);
    List<CategoryEntity> entities = baseMapper.selectList(wrapper);
    log.info("消耗时间:"+(System.currentTimeMillis()-l));
    return entities;

• ③. 测试得到的结果:

1. 如果缓存中有,方法不再调用
2. key是默认自动生成的,包含缓存名字::SimpleKey(自动生成的key值)
3. 缓存的value的值。默认使用jdk序列化机制,将序列化后的数据存到redis
4. 默认过期时间是 -1
   

• ④. 指定自己的key,并设置过期时间

//application.properties
spring.cache.type=redis
#spring.cache.cache-names=
#设置存活时间,ms为单位
spring.cache.redis.time-to-live=3600000

/**
自定义
(1). 指定生成缓存的key key属性指定,接收一个spl表达式
详细文档:https://docs.spring.io/spring-framework/docs/5.2.16.RELEASE/spring-framework-reference/integration.html#cache-spel-context
(2). 指定缓存的数据存活时间(在配置文件中修改了ttl)
*/

@Cacheable(value="category",key = "'Level1Categorys'")
@Override
public List<CategoryEntity> getLevel1Category() 
    long l= System.currentTimeMillis();
    QueryWrapper<CategoryEntity> wrapper = new QueryWrapper<>();
    wrapper.eq("parent_cid",0);
    List<CategoryEntity> entities = baseMapper.selectList(wrapper);
    log.info("消耗时间:"+(System.currentTimeMillis()-l));
    return entities;

• ⑤. 如果使用#root.method.name

  @Cacheable(value="category",key = "#root.method.name")

③. JSON格式转换、空值缓存

• ①. 上面的配置中,可以指定名称、并且过期时间已经配置了,关于JSON格式还没有解决

• ②. SpringCache的配置原理

*   CacheAutoConfiguration导入了RedisCacheConfiguration,RedisCacheConfiguration自动配置了缓存管理器RedisCacheManager
*   RedisCacheManager->初始化所有的缓存->每个缓存决定使用什么配置->按照配置文件中配置的名字进行初始化,决定用哪种配置(redisCacheConfiguration)
*   ->如果redisCacheConfiguration有就用自己有的,没有就用默认配置
*   ->想改配置,只需要给容器放一个RedisCacheConfiguration
*   ->就会应用到当前RedisCacheManager管理的所有缓存中(缓存分区)

• ③. 新建配置类,进行JSON格式转换

//application.properties
spring.cache.type=redis
#spring.cache.cache-names=
#设置存活时间,ms为单位
spring.cache.redis.time-to-live=3600000
#如果指定了前缀,就使用我们指定的前缀,如果没有就默认使用缓存的名字作为前缀
#CACHE_getLevel1Category
spring.cache.redis.key-prefix=CACHE_
#默认是使用前缀的
#如果开始了这个,那么缓存的key=getLevel1Category,没有CACHE
spring.cache.redis.use-key-prefix=false
#是否缓存空值,防止缓存穿透
spring.cache.redis.cache-null-values=true

@EnableConfigurationProperties(CacheProperties.class)
@EnableCaching
@Configuration
public class MyCacheConfig 
    /**
     * 要让配置文件中的配置生效,需要加上@EnableConfigurationProperties(CacheProperties.class)
     * @param cacheProperties
     * @return
     */
    @Bean
    RedisCacheConfiguration redisCacheConfiguration(CacheProperties cacheProperties)
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig();
        config = config.serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()));
        //值变成JSON格式
        config = config.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()));
        CacheProperties.Redis redisProperties = cacheProperties.getRedis();
        //将配置文件中的所有配置都生效
        if (redisProperties.getTimeToLive() != null) 
            config = config.entryTtl(redisProperties.getTimeToLive());
        
        if (redisProperties.getKeyPrefix() != null) 
            config = config.prefixKeysWith(redisProperties.getKeyPrefix());
        
        if (!redisProperties.isCacheNullValues()) 
            config = config.disableCachingNullValues();
        
        if (!redisProperties.isUseKeyPrefix()) 
            config = config.disableKeyPrefix();
        
        return config;
    

④. @CacheEvict、@Caching、@CachePut的使用

• ①. @CacheEvict:触发将数据从缓存删除的操作(相当于失效模式)

• ②. @Caching:组合以上多个操作

• ③. @CachePut:不影响方法执行更新缓存(双写模式) 需要有返回值

    /**
     * 存储同一个类型的数据,都可以指定成同一个分区。分区名默认就是缓存的前缀
     * (我们需要在配置文件中将前缀的使用关闭)
     * @param category
     */
    //@CacheEvict(value = "category",key = "'getLevel1Category'")
//    @Caching(evict = 
//            @CacheEvict(value = "category",key = "'getLevel1Category'"),
//            @CacheEvict(value = "category",key = "'getCatalogJson'")
//    )
    //删除category分区中所有的数据
    //@CacheEvict(value = "category",allEntries = true)//失效模式
    @Transactional
    @Override
    public void updateCasCade(CategoryEntity category) 
        this.updateById(category);
        categoryBrandRelationService.updateCategory(category.getCatId(),category.getName());
    

//application.properties
spring.cache.type=redis
#spring.cache.cache-names=
#设置存活时间,ms为单位
spring.cache.redis.time-to-live=3600000
#如果指定了前缀,就使用我们指定的前缀,如果没有就默认使用缓存的名字作为前缀
#CACHE_getLevel1Category
#spring.cache.redis.key-prefix=CACHE_
#默认是使用前缀的
#如果开始了这个,那么缓存的key=getLevel1Category,没有CACHE
#spring.cache.redis.use-key-prefix=false
#是否缓存空值,防止缓存穿透
spring.cache.redis.cache-null-values=true

⑤. SpringCache原理与不足

• ①. 读模式

1. 缓存穿透:查询一个null数据。解决方案:缓存空数据,可通过spring.cache.redis.cache-null-values=true
2. 缓存击穿:大量并发进来同时查询一个正好过期的数据。解决方案:加锁 ? 默认是无加锁的;
3. 使用sync = true来解决击穿问题
4. 缓存雪崩:大量的key同时过期。解决:加随机时间。

// 解决缓存击穿加锁 
@Cacheable(value="category",key = "#root.method.name",sync = true)

• ②. 写模式(缓存与数据库一致)

1. 读写加锁。
2. 引入Canal,感知到mysql的更新去更新Redis
3. 读多写多,直接去数据库查询就行

• ③. 总结

1. 常规数据(读多写少,即时性,一致性要求不高的数据,完全可以使用Spring-Cache):
2. 写模式(只要缓存的数据有过期时间就足够了)