SpringCache缓存处理

1. 先导入springCache的缓存依赖  除了缓存的依赖和redis的依赖，下面的其他依赖可加可不加

2. <!--SpringCache配置-->
           <dependency>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-starter-cache</artifactId>
           </dependency>
           <!-- 因为lettuce导致堆外内存溢出 这里暂时排除他 使用jedis -->
           <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>
   
           <dependency>
               <groupId>redis.clients</groupId>
               <artifactId>jedis</artifactId>
           </dependency>
           <!--使用redissonzuowei suo-->
           <dependency>
               <groupId>org.redisson</groupId>
               <artifactId>redisson</artifactId>
               <version>3.12.0</version>
           </dependency>

3. 首先在启动的主类里面开启缓存注解  @EnableCaching
   
   

4. 手写一个缓存的配置类，主要是修改存储的key,value的数据序列化

5. package com.atguigu.gulimall.product.config;
   
   import org.springframework.boot.autoconfigure.cache.CacheProperties;
   import org.springframework.cache.annotation.Cacheable;
   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;
   
   /**
    * @Author: LiuLi
    * @Description:
    * @Date: Create in 11:21 2020/7/29
    */
   @Configuration
   @EnableCaching
   public class MyCacheConfig {
   
       @Bean
       RedisCacheConfiguration redisCacheConfiguration(CacheProperties cacheProperties) {
           RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig();
   
           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;
       }
   }

6. 在yml或者properties中进行配置

7. #在yml中redis的配置
   spring:
     redis:
       host: 192.168.56.10
       port: 6379
   
   
   #在properties中的springCache的配置
   # 使用redis进行缓存
   spring.cache.type=redis
   #设置缓存的存活时间(1h)
   spring.cache.redis.time-to-live=3600000
   # 配置缓存名的前缀 如果没配置则使用缓存名作为前缀
   #spring.cache.redis.key-prefix=CACHE_
   # 配置前缀是否生效  默认为ture
   #spring.cache.redis.use-key-prefix=false
   # 是否缓存空值 默认为true
   spring.cache.redis.cache-null-values=true

8. 对@Cacheable() ,@CacheEvict(),@CachePut()和@Caching()进行运用
9.  @Cacheable(value = {"category"}, key = "#root.methodName")首先存储缓存
   1. value：是缓存的分区名称   key：是将方法名当做缓存key ，缓存的值则是方法的返回数据
10. @CachePut()  则是双写模式，它是可以注解在修改，删除或是添加的方法上面，前提是方法得有返回的数据　　
11. @CacheEvict(value = "category", allEntries = true)  // 失效模式　
    1. 这个模式是注解在方法上，然后再进行删除，修改或是添加的时候将缓存进行分区的清理，其中category就是缓存存储的一个区　　　
12. @Caching(evict = {   @CacheEvict(value = "category", key = "'getLevelCategorys'"),   @CacheEvict(value = "category", key = "'getCatalogJson'")    })
    1. 同时进行多种缓存操作，这里是进行修改操作时删除缓存,可以一个或者多个区的缓存数据
13. 　具体的使用如下代码 :

　　　

    /**
     * 级联更新所有关联数据
     *
     * @param * @param category
     * @return void
     *
     * @CacheEvict(value="",key="''") 失效模式
     * @Caching(evict = {@CacheEvict,@CacheEvict}) 同时进行多种缓存操作，这里是进行修改操作时删除缓存
     * @CacheEvict(value = "category", allEntries = true) // 进行分区的缓存清除
     *
     */
//    @Caching(evict = {
//            @CacheEvict(value = "category", key = "'getLevelCategorys'"),
//            @CacheEvict(value = "category", key = "'getCatalogJson'")
//    })  这里的@Caching()和@CacheEvict()前者是可以进行多种缓存操作，后者是进行缓存的区域清理，所以注释了前者

    @CacheEvict(value = "category", allEntries = true) // 进行分区的缓存清除
    @Transactional
    @Override
    public void updateCascade(CategoryEntity category) {
        this.updateById(category);
        categoryBrandRelationService.updateCategory(category.getCatId(), category.getName());
    }

    // 每个需要缓存的数据我们指定来方法那个名字的缓存，【缓存的分区，按照业务类型进行分】
    @Cacheable(value = {"category"}, key = "#root.methodName") // 代表需要对当前的方法结果进行缓存，如果缓存中有，那么就不进行缓存，如果没有则进入方法进行结果的缓存
    @Override
    public List<CategoryEntity> getLevelCategorys() {
        long l = System.currentTimeMillis();
        List<CategoryEntity> ctegoryEntityList = baseMapper.selectList(new QueryWrapper<CategoryEntity>().eq("parent_cid", 0));
        System.out.println("消耗时间:" + (System.currentTimeMillis() - l));
        return ctegoryEntityList;
    }

　

　　　　　　　　　　　　　

@CacheEvict(value = "category", key = "'getLevelCategorys'"),