SpringCache简单应用

整合及自定义使用

1，引入依赖：

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-cache</artifactId>
</dependency>

2，写配置;

      1>自动配置了哪些：CacheAutoConfiguration回导入RedisConfiguration,并且配好了自动管理器RedisCacheManager

       2>配置Redis作为缓存

       自定义部分：

       1，指定生成的缓存使用的key，key属性指定接受SpEL

       2,指定缓存数据的存活时间

       3，将数据保存为json格式

spring.cache.type=redis

spring.cache.redis.time-to-live=3600000
#spring.cache.redis.key-prefix=CACHE_
spring.cache.redis.use-key-prefix=true
#\u662F\u5426\u7F13\u5B58\u7A7A\u503C\uFF0C\u9632\u6B62\u7F13\u5B58\u7A7F\u900F
spring.cache.redis.cache-null-values=true

3.测试缓存：

相关注解:

// 每一个需要缓存的数据我们都来指定要放到哪个名字的缓存【缓存的分区（按照业务类型分）】
    @Cacheable(value = {"category"}, key = "#root.method.name", sync = true) //代表当前方法的结果需要缓存，如果缓存中有，方法不会调用，如果缓存中没有，调用方法将结果放入缓存
    @Override
    public List<CategoryEntity> getCatLevelOneList() {
        System.out.println("getCatLevelOneList...");
        //long l = System.currentTimeMillis();
        List<CategoryEntity> categoryEntityList = baseMapper.selectList(new QueryWrapper<CategoryEntity>().eq("parent_cid", 0));
//        System.out.println(categoryEntityList);
        return categoryEntityList;
    }

SpringCache的默认行为;

1>如果缓存中有，方法不用调用

2>key默认自动生成，缓存的名字SimpleKey{}(自主生成的KEY值)

3>缓存的value值默认使用jdk的序列化机制，将序列化后的数据存到redis

4>默认的TTL为-1，即永不过期

4，原理：

CacheAutoConfiguration- ---》RedisConfiguration---》配好了自动管理器RedisCacheManager

----》初始化所有的缓存---》每个缓存决定使用什么配置----》如果RedisConfiguration有就用已有的，没有就用默认配置

-----》想改缓存配置，只要给容器中添加一个RedisConfiguration即可-----》就会应用到当前RedisCacheManager管理的所有缓存分区中

import org.springframework.boot.autoconfigure.cache.CacheProperties;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.cache.CacheManager;
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.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.serializer.*;

/**
 * @description
 * @author: wei-xhh
 * @create: 2020-07-10
 **/
@EnableConfigurationProperties(CacheProperties.class)
@EnableCaching
@Configuration
public class MyCacheConfig {

    @Bean
    public CacheManager cacheManager(RedisConnectionFactory factory, CacheProperties cacheProperties) {

        // 配置序列化
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
                .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();
        }

        RedisCacheManager cacheManager = RedisCacheManager.builder(factory)
                .cacheDefaults(config)
                .build();
        return cacheManager;
    }
}