阅读量:1
1.简介
2.SpringCache 整合
简化缓存开发
1.导入依赖
<!-- spring cache --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-cache</artifactId> </dependency> 2.redis 作为缓存场景
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency>3. 配置类
1.自动配置
自动配置了哪些
CacheAutoConfiguration 自动导入 RedisCacheConfiguration
自动配好了缓存管理器 RedisCacheManager
2.手动需要得yaml配置
spring: #缓存 cache: type: redis3.测试 使用缓存
1.开启缓存
1.使用redis作为缓存
spring: #缓存 cache: type: redis@EnableCaching //放在主启动类上2.使用注解就可以完成缓存
//每一个需要缓存的数据我们都来指定要放到哪个名字的缓存 [缓存的分区(按照业务类型分区)] @Cacheable({"category"}) //代表这个数据是可以缓存的 当前方法的结果需要缓存，如果缓存中有，方法不用调用。 //如果缓存中没有，调用方法，将方法结果放入缓存 @Override public List<CategoryEntity> getLevel1Category() { System.out.println("调用了数据库getLevel1Category"); List<CategoryEntity> parentCid = this.list(new QueryWrapper<CategoryEntity>().eq("parent_cid", 0)); return parentCid; }
//默认行为 //1.如果缓存中有，方法不用调用 //2.key默认自动生成 : 缓存的名字::SimpleKey []（自主生产的key的值） //3.缓存的value的值 默认使用JDK序列化机制 将序列化后的数据存入Redis //4.默认ttl时间 -1;
//自定义 //1. 指定生成的缓存使用的key key 属性指定，接受一个SPEL 表达式 ${} #{} //2. 指定缓存的过期时间 yml 配置文件中修改ttl //3. 将数据存入JSON标准格式 
public String mycategorykey="我自定义的key"; @Override // @Cacheable(value = {"category"}, key = "'level1Category'") // @Cacheable(value = {"category"}, key = "#root.method.name")//root是当前上下文的意思 method 是方法 可以有参数 各种东西 @Cacheable(value = {"category"}, key = "#root.target.mycategorykey")//root 可以拿到当前对象 当前方法 当前参数 public List<CategoryEntity> getLevel1Category() { System.out.println("调用了数据库getLevel1Category"); List<CategoryEntity> parentCid = this.list(new QueryWrapper<CategoryEntity>().eq("parent_cid", 0)); return parentCid; }
2.自定义缓存设置
保存的数据为json格式
1.讲一下 缓存redis配置类的 原理
CacheAutoConfiguration->RedisCacheConfiguration->自动配置了缓存管理器 RedisCacheManager->初始化所有的缓存->每个缓存觉得使用什么配置->如果RedisCacheConfiguration有在 容器中自己 配置，就要用自己的配置，否则就用默认的配置
所以，我们只需要给容器中放入一个RedisCacheConfiguration即可
就会应用到当前缓存管理器的所有缓存中
2.配置类
package com.jmj.gulimall.product.config; import org.springframework.boot.autoconfigure.cache.CacheProperties; import org.springframework.cache.annotation.EnableCaching; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.data.redis.cache.RedisCacheConfiguration; import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer; import org.springframework.data.redis.serializer.RedisSerializationContext; import org.springframework.data.redis.serializer.StringRedisSerializer; @Configuration @EnableCaching public class MyCacheConfig { /** * 给了默认配置文件就不生效了 * 因为 条件判断了 if config !=null 就返回 * 也不需要加@EnableConfigurationProperties(CacheProperties.class) * 因为默认自动装配类已经加入这个 * @return */ @Bean public RedisCacheConfiguration redisCacheConfiguration( CacheProperties cacheProperties ) { RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig(); /** * public RedisCacheConfiguration entryTtl(Duration ttl) { 是new新对象 得要覆盖上 * return new RedisCacheConfiguration(ttl, cacheNullValues, usePrefix, keyPrefix, keySerializationPair, * valueSerializationPair, conversionService); * } */ config = config.serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer())); 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; } } #配置数据源 spring: #缓存 cache: redis: time-to-live: 36000000 #单位 ms 先设定一个小时过期时间 use-key-prefix: false #不使用，原来的前缀就没有了 key是什么 就是什么 key-prefix: CACHE_ #所有Key都设置一个前缀来区分 如果指定了 前缀就用指定的，没有就用默认的 name::[] cache-null-values: true #是否缓存入空值 可以解决缓存穿透 type: redis3.实现
//每一个需要缓存的数据我们都来指定要放到哪个名字的缓存 [缓存的分区(按照业务类型分区)] //代表这个数据是可以缓存的 当前方法的结果需要缓存，如果缓存中有，方法不用调用。 //如果缓存中没有，调用方法，将方法结果放入缓存 //默认行为 //1.如果缓存中有，方法不用调用 //2.key默认自动生成 : 缓存的名字::SimpleKey []（自主生产的key的值） //3.缓存的value的值 默认使用JDK序列化机制 将序列化后的数据存入Redis //4.默认ttl时间 -1; //自定义 //1. 指定生成的缓存使用的key key 属性指定，接受一个SPEL 表达式 #{} //2. 指定缓存的过期时间 yml 配置文件中修改ttl //3. 将数据存入JSON标准格式 public String mycategorykey="我自定义的key"; @Override // @Cacheable(value = {"category"}, key = "'level1Category'") // @Cacheable(value = {"category"}, key = "#root.method.name")//root是当前上下文的意思 method 是方法 可以有参数 各种东西 @Cacheable(value = {"category"}, key = "#root.target.mycategorykey")//root 可以拿到当前对象 当前方法 当前参数 public List<CategoryEntity> getLevel1Category() { System.out.println("调用了数据库getLevel1Category");//线程不安全,需要加分布式锁和读写锁 List<CategoryEntity> parentCid = this.list(new QueryWrapper<CategoryEntity>().eq("parent_cid", 0)); return parentCid; }1.删除缓存
/** * 级联更新所有关联数据 * @param category * @throws Exception */ @CacheEvict(value = "category", key = "'category::tree'")//删除缓存 @Override @Transactional(rollbackFor = Exception.class) public void updateDetails(List<CategoryEntity> category) throws Exception { category.stream().filter(c -> StringUtils.isNotBlank(c.getName())).forEach(c -> { List<CategoryBrandRelationEntity> updateList = categoryBrandRelationService .list(new QueryWrapper<CategoryBrandRelationEntity>().eq("catelog_id", c.getCatId())) .stream().peek(r -> r.setCatelogName(c.getName())).collect(Collectors.toList()); categoryBrandRelationService.updateBatchById(updateList); }); this.updateBatchById(category); }2.存入
@Override @Cacheable(value = {"category"}, key = "'category::tree'") public List<CategoryEntity> listWithTree() { //1.查出所有分类 System.out.println("三级分类查询数据库"); List<CategoryEntity> all = this.list(); //2.组装成父子的属性结构 List<CategoryEntity> level1Menus = all .stream() .filter(c -> c.getParentCid().equals(0L)) .map(categoryEntity -> categoryEntity.setChildren(getChildrenCategory(all, categoryEntity.getCatId()))) //大于放后面 升序 .sorted(Comparator.comparing(CategoryEntity::getSort)) .collect(Collectors.toList()); return level1Menus; }3.要操作多个
// @CacheEvict(value = "category", key = "'category::tree'")//删除缓存 //如果多操作的话 @Caching(evict = { @CacheEvict(value = "category", key = "'category::tree'"), @CacheEvict(value = "category", key = "#root.target.mycategorykey") }) @Override @Transactional(rollbackFor = Exception.class) public void updateDetails(List<CategoryEntity> category) throws Exception { category.stream().filter(c -> StringUtils.isNotBlank(c.getName())).forEach(c -> { List<CategoryBrandRelationEntity> updateList = categoryBrandRelationService .list(new QueryWrapper<CategoryBrandRelationEntity>().eq("catelog_id", c.getCatId())) .stream().peek(r -> r.setCatelogName(c.getName())).collect(Collectors.toList()); categoryBrandRelationService.updateBatchById(updateList); }); this.updateBatchById(category); }4.删除这个分区下所有数据 (失效模式)
存储同一类型的数据，都可以指定一个分区
@CacheEvict(value = "category", allEntries = true)// 设定了 use-key-prefix: false 这个如果没有这个分类，将全部缓存删除use-key-prefix必须要为true 和 key-prefix: 不设置 这个才有用
5.双写模式
@CachePut//双写模式
3.SpringCache的不足
基本都能解决，唯独缓存击穿特别一点
这样就是加了个本地锁，本地也就是放一个过来
@Override @Cacheable(value = {"category"}, key = "'tree'",sync = true) public List<CategoryEntity> listWithTree() { //1.查出所有分类 System.out.println("三级分类查询数据库"); List<CategoryEntity> all = this.list(); //2.组装成父子的属性结构 List<CategoryEntity> level1Menus = all .stream() .filter(c -> c.getParentCid().equals(0L)) .map(categoryEntity -> categoryEntity.setChildren(getChildrenCategory(all, categoryEntity.getCatId()))) //大于放后面 升序 .sorted(Comparator.comparing(CategoryEntity::getSort)) .collect(Collectors.toList()); return level1Menus; }只有cacheable 查询注解的时候 才能够加锁
虽然加的是本地锁，但是一台服务器只能一个访问，也是够用了
4.总结
常规数据（读多写少，即时性，一致性要求不高的数据 ）：完全可以使用springcache(写模式：只有数据有过期时间 就完全足够了 这样可以保证数据的最终一致性)
特殊数据 （特殊设计）例如 canal 感知数据库去更新 缓存
