SpringBoot中Cache

# SpringBoot中缓存 #

## 1.JSR107缓存接口 ##

* CachingProvider:定义了创建,配置,获取,管理和控制多个CacheManager,一个应用可以在运行期访问多个CachingProvider
* CacheManager:定义了创建,配置,获取,管理和控制多个唯一命名的Cache,这些Cache存在于CacheManager的上下文中,一个CacheManager仅被一个CachingProvider所拥有
* Cache:是一个类似于Map的数据结构并临时存储以key为索引的值,一个Cache仅被一个CacheManager所拥有
* Entry:是一个存储在Cache中的key-value键值对
* Expiry:每一个存储在Cache中的条目有一个定义的有效期.一旦超过这个时间.条目为过期的状态,一旦过期,条目将不可访问,更新和删除.缓存有效期可以通过ExpiryPolicy设置

## 2.Spring中缓存抽象 ##

### 1.缓存的功能 ###

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

### 2.缓存注解的作用 ###

* Cache:缓存接口,定义缓存操作,实现有:RedisCache,EhCacheCache,ConcurrentMapCache等
* CacheManager:缓存管理器,管理各种缓存(Cache)组件
* @Cacheable:主要针对方法配置,能够根据方法的请求参数对其结果进行缓存
* @CacheEvict:清空缓存
* @CachePut:保证方法被调用,又希望结果被缓存
* @EnableCaching:开启基于注解的缓存
* keyGenerator:缓存数据时key生产策略
* serialize:缓存数据时value序列化策略

### 3.@Cacheable,@CacheEvict,@CachePut注解主要参数 ###

* value:缓存名称,在spring配置文件中定义,必须指定至少一个
* key:缓存的key,可以为空,如果指定要按照SpEl表达式编写,如果不指定,则缺省按照方法的所有参数进行组合
* condition:缓存的条件,可以为空,使用SpEl编写,返回true或者false,只有为true才能进行缓存/清除缓存,在调用方法之前之后都能判断
* allEntries(@CacheEvict):是否清空所有缓存内容,缺省为false,如果指定为true,则方法调用后立即清空所有缓存
* beforeInvocation(@CacheEvict):是否在方法执行之前就清空,缺省为false,如果指定为true,则在方法还没有执行时就清空缓存,缺省情况下,如果方法执行抛出异常,则不会清空缓存
* unless:用于否决缓存,不像condition,该表达式只在方法执行之后判断,此时可以拿到返回值result进行判断,条件为true不会缓存,false才缓存

### 4.SPEL表达式获取值 ###

* 当前被调用的方法名:#root.methodName或者使用#root.method.name
* 当前被调用的目标对象:#root.target
* 当前被调用的目标对象类:#root.targetClass
* 当前被调用的方法的参数列表:#root.args[0]
* 当前方法调用使用的缓存列表(@Cacheable(value={"cache1", "cache2"})):#root.caches[0].name
* 方法参数的名字,可以直接 #参数名,也可以使用#p0或#a0, 0代表参数索引
* 方法执行后的返回值:#result

### 5.如何使用缓存 ###

1.在pom.xml文件中导入cache依赖
    
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-cache</artifactId>
    </dependency>

2.在启动类上添加@EnableCaching注解用来开启缓存

    /**
     * @author zhangbao
     * MapperScan注解用来扫描mybatis的mapper接口
     * EnableCaching注解用来开启缓存
     */
    @EnableCaching
    @SpringBootApplication
    @MapperScan("com.zhangbao.mapper")
    public class SpringBootCacheApplication {
    
        public static void main(String[] args) {
            SpringApplication.run(SpringBootCacheApplication.class, args);
        }
    
    }

3.在方法上面标注缓存注解

    @RestController
    public class EmployeeController {
    
        @Autowired
        private EmployeeService employeeService;
    
        @GetMapping("/getEmployeeById/{id}")
        @Cacheable(cacheNames = "emp")
        public Employee getEmployeeById(@PathVariable("id") Integer id) {
            System.out.println("查询" + id + "号员工!");
            return employeeService.getEmployeeById(id);
        }
    }

## 3.缓存运行原理 ##

1.首先看CacheAutoConfiguration类:

    @Configuration
    @ConditionalOnClass(CacheManager.class)
    @ConditionalOnBean(CacheAspectSupport.class)
    @ConditionalOnMissingBean(value = CacheManager.class, name = "cacheResolver")
    @EnableConfigurationProperties(CacheProperties.class)
    @AutoConfigureAfter({ CouchbaseAutoConfiguration.class, HazelcastAutoConfiguration.class,
            HibernateJpaAutoConfiguration.class, RedisAutoConfiguration.class })
    //导入了一个CacheConfigurationImportSelector组件
    @Import(CacheConfigurationImportSelector.class)
    public class CacheAutoConfiguration {

2.通过CacheConfigurationImportSelector组件在debug模式下看到缓存的配置类

    static class CacheConfigurationImportSelector implements ImportSelector {

        @Override
        public String[] selectImports(AnnotationMetadata importingClassMetadata) {
            CacheType[] types = CacheType.values();
            String[] imports = new String[types.length];
            for (int i = 0; i < types.length; i++) {
                imports[i] = CacheConfigurations.getConfigurationClass(types[i]);
            }
            return imports;
        }

    }

    1.org.springframework.boot.autoconfigure.cache.GenericCacheConfiguration
    2.org.springframework.boot.autoconfigure.cache.JCacheCacheConfiguration
    3.org.springframework.boot.autoconfigure.cache.EhCacheCacheConfiguration
    4.org.springframework.boot.autoconfigure.cache.HazelcastCacheConfiguration
    5.org.springframework.boot.autoconfigure.cache.InfinispanCacheConfiguration
    6.org.springframework.boot.autoconfigure.cache.CouchbaseCacheConfiguration
    7.org.springframework.boot.autoconfigure.cache.RedisCacheConfiguration
    8.org.springframework.boot.autoconfigure.cache.CaffeineCacheConfiguration
    9.org.springframework.boot.autoconfigure.cache.SimpleCacheConfiguration
    10.org.springframework.boot.autoconfigure.cache.NoOpCacheConfiguration

3.在application.yml配置文件中打开所有debug日志:debug=true
    
    # 打开所有的debug日志
    debug: true

4.在控制台上可以看到只有SimpleCacheConfiguration生效了

    生效的SimpleCacheConfiguration:
    SimpleCacheConfiguration matched:
      - Cache org.springframework.boot.autoconfigure.cache.SimpleCacheConfiguration automatic cache type (CacheCondition)
      - @ConditionalOnMissingBean (types: org.springframework.cache.CacheManager; SearchStrategy: all) did not find any beans (OnBeanCondition)

    没有生效的其它类:
    CaffeineCacheConfiguration:
      Did not match:
         - @ConditionalOnClass did not find required class 'com.github.benmanes.caffeine.cache.Caffeine' (OnClassCondition)

5.SimpleCacheConfiguration做了什么:

给容器中添加了一个CacheManager:ConcurrentMapCacheManager,这个CacheManager使用ConcurrentHashMap来存储缓存名和缓存

    @Configuration
    //容器中没有CacheManager该配置类才会生效
    @ConditionalOnMissingBean(CacheManager.class)
    @Conditional(CacheCondition.class)
    class SimpleCacheConfiguration {
    
        //缓存配置类
        private final CacheProperties cacheProperties;
    
        private final CacheManagerCustomizers customizerInvoker;
    
        SimpleCacheConfiguration(CacheProperties cacheProperties,
                CacheManagerCustomizers customizerInvoker) {
            this.cacheProperties = cacheProperties;
            this.customizerInvoker = customizerInvoker;
        }
    
        /**
         * 给容器中添加一个CacheManager:ConcurrentMapCacheManager
         */
        @Bean
        public ConcurrentMapCacheManager cacheManager() {
            ConcurrentMapCacheManager cacheManager = new ConcurrentMapCacheManager();
            List<String> cacheNames = this.cacheProperties.getCacheNames();
            if (!cacheNames.isEmpty()) {
                cacheManager.setCacheNames(cacheNames);
            }
            return this.customizerInvoker.customize(cacheManager);
        }
    
    }

6.ConcurrentMapCacheManager可以创建和获取一个Cache:ConcurrentMapCache

    //获取Cache
    public Cache getCache(String name) {
        Cache cache = this.cacheMap.get(name);
        if (cache == null && this.dynamic) {
            synchronized (this.cacheMap) {
                cache = this.cacheMap.get(name);
                if (cache == null) {
                    //创建Cache
                    cache = createConcurrentMapCache(name);
                    this.cacheMap.put(name, cache);
                }
            }
        }
        return cache;
    }

    //创建Cache
    protected Cache createConcurrentMapCache(String name) {
        SerializationDelegate actualSerialization = (isStoreByValue() ? this.serialization : null);
        //创建一个ConcurrentMapCache
        return new ConcurrentMapCache(name, new ConcurrentHashMap<>(256),
                isAllowNullValues(), actualSerialization);

    }
    
7.ConcurrentMapCache中实际的存储容器是一个类型为ConcurrentHashMap的字段store

    private final ConcurrentMap<Object, Object> store;

    public ConcurrentMapCache(String name) {
        this(name, new ConcurrentHashMap<>(256), true);
    }

8.从缓存中获取数据使用的是lookup方法

    protected Object lookup(Object key) {
        return this.store.get(key);
    }

9.将数据存储到缓存中使用的是put方法

    public void put(Object key, @Nullable Object value) {
        this.store.put(key, toStoreValue(value));
    }

10.从缓存中删除数据使用的是evict方法

    public void evict(Object key) {
        this.store.remove(key);
    }

## 4.缓存运行流程 ##

1.在调用方法之前先调用ConcurrentMapCacheManager获取cache
    
    public Cache getCache(String name) {
        Cache cache = this.cacheMap.get(name);
        if (cache == null && this.dynamic) {
            synchronized (this.cacheMap) {
                cache = this.cacheMap.get(name);
                if (cache == null) {
                    //如果缓存不存在就创建一个缓存
                    cache = createConcurrentMapCache(name);
                    this.cacheMap.put(name, cache);
                }
            }
        }
        return cache;
    }

2.从Cache中查找缓存,使用一个key(如果在使用缓存注解的时候没有指定key的名字,默认就是方法的参数),默认key的生成:

    Object key = generateKey(context, result);

    //这里的参数就是方法的参数
    public static Object generateKey(Object... params) {
        //如果没有参数,则生成一个空的SimpleKey对象
        if (params.length == 0) {
            return SimpleKey.EMPTY;
        }
        //如果只有一个参数,则key值就是这个参数
        if (params.length == 1) {
            Object param = params[0];
            if (param != null && !param.getClass().isArray()) {
                return param;
            }
        }
        //否则使用另外的规则生成key
        return new SimpleKey(params);
    }

3.根据key值从缓存中获取数据

    public ValueWrapper get(Object key) {
        Object value = lookup(key);
        return toValueWrapper(value);
    }

    protected Object lookup(Object key) {
        return this.store.get(key);
    }

4.缓存中如果没有查到值,就调用目标方法,获取目标方法返回值

5.再将目标方法返回值存入到缓存中

    public void put(Object key, @Nullable Object value) {
        this.store.put(key, toStoreValue(value));
    }

目标方法执行之前先从缓存中获取有没有这个数据,默认按照参数的值作为key去查询缓存,如果有则直接将这个数据返回,如果没有再调用目标方法,获取到目标方法的返回值后再将目标方法的返回值存入到缓存中,默认的key值是方法的参数

## 5.使用redis来缓存数据 ##

1.在pom.xml文件中引入redis的依赖

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

2.如果可以接受使用jdk默认的序列化方式将数据存储在redis中的方式,则只需要将需要存入到redis中的对象实现Serializable接口即可,剩余的步骤就和使用spring自带的缓存一样使用,原理在后面会进行分析

3.如果想要使用json格式将数据存储到redis中,请接着往下看:

3.1创建一个RedisTemplateConfig类用来修改SpringBoot默认给的配置

    //这是一个配置类,并需要继承CachingConfigurerSupport类,否则自定义的组件不会覆盖SpringBoot默认的组件
    @Configuration
    public class RedisTemplateConfig extends CachingConfigurerSupport {

3.2实现Json序列化

    @Bean
    public Jackson2JsonRedisSerializer valueSerializer() {
        Jackson2JsonRedisSerializer valueSerializer = new Jackson2JsonRedisSerializer(Object.class);

        ObjectMapper objectMapper = new ObjectMapper();
        //Jackson 使用 defaultTyping 实现通用的序列化和反序列化
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);

        valueSerializer.setObjectMapper(objectMapper);
        return valueSerializer;
    }

3.3自定义RedisTemplate的key和value序列化规则

    @Bean
    public RedisTemplate<Object, Object> redisTemplate(
            RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        
        //设置value的序列化规则
        redisTemplate.setValueSerializer(valueSerializer());
        //设置key的序列化规则
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        //设置默认的序列化规则(可不写)
        redisTemplate.setDefaultSerializer(valueSerializer());
        //非Spring提供的redisTemplate需要自己调用初始化方法
        redisTemplate.afterPropertiesSet();

        return redisTemplate;
    }

3.4自定义CacheManager,这里根据SpringBoot的版本分为1.x和2.x两种不同的处理方式

3.4.1 SpringBoot1.x:由于SpringBoot1.x中CacheManager的构造函数还是单参数的RedisTemplate,所以直接创建一个CacheManager返回就好

    @Bean
    public CacheManager cacheManager(RedisTemplate redisTemplate) {
        RedisCacheManager cacheManager = new RedisCacheManager(redisTemplate);
        //设置缓存管理器管理的缓存的过期时间, 单位：秒
        cacheManager.setDefaultExpiration(expireTime); 
        return cacheManager;
    }

3.4.2 在springboot2.x中，RedisCacheManager已经没有了单参数的构造方法,所以实现如下:
    
    @Bean
    public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
        RedisCacheWriter redisCacheWriter = RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory);

        //设置key的序列化规则
        RedisSerializationContext.SerializationPair<Object> valuePair = RedisSerializationContext
                .SerializationPair
                .fromSerializer(valueSerializer());

        //设置value的序列化规则
        RedisSerializationContext.SerializationPair<String> keyPair = RedisSerializationContext
                .SerializationPair
                .fromSerializer(new StringRedisSerializer());
        //serializeKeysWith和serializeValuesWith方法要在entryTtl之前执行
        RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration
                .defaultCacheConfig()
                .serializeKeysWith(keyPair)
                .serializeValuesWith(valuePair)
                .entryTtl(Duration.ofMinutes(1));

        return new RedisCacheManager(redisCacheWriter, redisCacheConfiguration);
    }

3.5 此时,SpringBoot中使用redis做缓存已经集成完毕

## 6.SpringBoot集成Redis做缓存使用jdk序列化方式为什么不用添加其它配置 ##

1.先看下RedisCacheConfiguration这个类,如果不存在CacheManager类则这个配置类生效,此时会自动配置一个RedisCacheManager,所以当使用jdk默认序列化的时候,不需要做任何配置即可使用

    @Configuration
    @ConditionalOnClass(RedisConnectionFactory.class)
    @AutoConfigureAfter(RedisAutoConfiguration.class)
    @ConditionalOnBean(RedisConnectionFactory.class)
    @ConditionalOnMissingBean(CacheManager.class)
    @Conditional(CacheCondition.class)
    class RedisCacheConfiguration {
    
        @Bean
        public RedisCacheManager cacheManager(RedisConnectionFactory redisConnectionFactory,
                ResourceLoader resourceLoader) {
            RedisCacheManagerBuilder builder = RedisCacheManager
                    .builder(redisConnectionFactory)
                    .cacheDefaults(determineConfiguration(resourceLoader.getClassLoader()));
            List<String> cacheNames = this.cacheProperties.getCacheNames();
            if (!cacheNames.isEmpty()) {
                builder.initialCacheNames(new LinkedHashSet<>(cacheNames));
            }
            return this.customizerInvoker.customize(builder.build());
        }