spring cache（一）介绍

一、介绍

1、背景

项目中使用最多的缓存技术就是Redis,用Redis就可以实现了，为什么需要使用spring cache？

先看下我们使用缓存步骤:

（1）查寻缓存中是否存在数据，如果存在则直接返回结果

（2）如果不存在则查询数据库，查询出结果后将结果存入缓存并返回结果

（3）数据更新时，先更新数据库

（4）然后更新缓存，或者直接删除缓存

可以看到逻辑都差不多，这样就出现大量重复的代码，而且缓存与业务耦合较深。Spring Cache则解决了这个问题，它利用AOP实现了基于注解的缓存功能，并且进行了合理的抽象，业务代码不用关心底层是使用了什么缓存框架，只需要简单地加一个注解，就能实现缓存功能了。

2、简介

spring cache官网Cache Abstraction :: Spring Framework

spEl语法说明==>官方文档

3、默认配置

在默认配置下，

springcache缓存的是用jdk序列化过的数据，我们通常是缓存Json字符串，因为使用Json能跨语言，跨平台进行交互,；

我们也可以修改他的默认配置，包括ttl（过期时间）、存储格式等。

二、原理

流程说明：
CacheAutoConfiguration => RedisCacheConfiguration =>
自动配置了RedisCacheManager => 初始化所有的缓存 =>
每个缓存决定使用什么配置=>
=>如果RredisCacheConfiguration有就用已有的，没有就用默认配置（CacheProperties）
=>想改缓存的配置，只要给容器中放一个RredisCacheConfiguration即可
=>就会应用到当前RedisCacheManager管理的所有缓存分区中

1、`CacheAutoConfiguration`

缓存的自动配置，用的类型是redis所以看 RedisCacheConfiguration

`2、CacheManager`

缓存管理者，类型是redis所以看 RedisCacheManager

`3、CacheProperties`

缓存默认配置

三、常用注解

1、@CacheConfig

在类级别共享缓存的相同配置。如果一个类中，多个方法都有同样的 cacheName，keyGenerator，cacheManager 和 cacheResolver，可以直接使用 @CacheConfig 注解在类上声明，这个类中的方法都会使用@CacheConfig 属性设置的相关配置。

@Component
@CacheConfig(cacheNames = "mall_cache")
public class CacheComponent {

	
    @Cacheable(key = "'perm-whitelist-'+#clientId", unless="#result == null")
    public List<String> cacheWriteList(String clientId){
    	...
    }
       
     @Cacheable(key = "'perm-cutom-aci-' + #tenantId + '-' + #roleId + '-' + #tenantLevel + '-' + #subType", unless="#result == null")
    public List<RequestDto> cacheRequest(Long tenantId,Long roleId,Integer tenantLevel,Integer subType){
        ...
    }
}

2、@Cacheable

触发将数据保存到缓存的操作(启动缓存)，有9给属性：value、 cacheNames、 key、 keyGenerator、 cacheManager、 cacheResolver、 condition、 unless、 sync。

2.1、value/cacheNames 属性

这两个属性代表的意义相同，根据@AliasFor注解就能看出来了。这两个属性都是用来指定缓存组件的名称，即将方法的返回结果放在哪个缓存中，属性定义为数组，可以指定多个缓存；

2.2、key

可以通过 key 属性来指定缓存数据所使用的的 key，默认使用的是方法调用传过来的参数作为 key。最终缓存中存储的内容格式为：Entry<key,value> 形式。

（1）如果请求没有参数：key=new SimpleKey()；

（2）如果请求有一个参数：key=参数的值

（3）如果请求有多个参数：key=newSimpleKey(params)； (你只要知道 key不会为空就行了)

key的实现有两种方式：

（1） SpEL 表达式

（2）使用 keyGenerator生成器的方式来指定 key，需要编写一个 keyGenerator ，将该生成器注册到 IOC 容器即可。

2.3、keyGenerator

key 的生成器。如果觉得通过参数的方式来指定比较麻烦，我们可以自己指定 key 的生成器的组件 id。key/keyGenerator属性：二选一使用。

import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.lang.reflect.Method;
import java.util.Arrays;

@Configuration
public class MyCacheConfig {

    @Bean("myKeyGenerator")
    public KeyGenerator keyGenerator(){
        return new KeyGenerator(){

            @Override
            public Object generate(Object target, Method method, Object... params) {
                return method.getName()+ Arrays.asList(params).toString();
            }
        };
    }

    /**
     * 支持 lambda 表达式编写
     */
    /*@Bean("myKeyGenerator")
    public KeyGenerator keyGenerator(){
        return ( target,  method, params)-> method.getName()+ Arrays.asList(params).toString();
    }*/
}

2.4、cacheManager

用来指定缓存管理器。针对不同的缓存技术，需要实现不同的 cacheManager，Spring 也为我们定义了如下的一些 cacheManger 实现（）

2.5、cacheResolver

该属性，用来指定缓存解析器。使用配置同 cacheManager 类似（cacheManager指定管理器/cacheResolver指定解析器它俩也是二选一使用）

2.6、condition

条件判断属性，用来指定符合指定的条件下才可以缓存。也可以通过 SpEL 表达式进行设置。这个配置规则和上面表格中的配置规则是相同的。

@Cacheable(value = "user",condition = "#id>0")//传入的 id 参数值>0才进行缓存
User getUser(Integer id);


@Cacheable(value = "user",condition = "#a0>1")//传入的第一个参数的值>1的时候才进行缓存
User getUser(Integer id);


@Cacheable(value = "user",condition = "#a0>1 and #root.methodName eq 'getUser'")//传入的第一个参数的值>1 且 方法名为 getUser 的时候才进行缓存
User getUser(Integer id);

2.7、unless

unless属性，意为"除非"的意思。即只有 unless 指定的条件为 true 时，方法的返回值才不会被缓存。可以在获取到结果后进行判断。

@Cacheable(value = "user",unless = "#result == null")//当方法返回值为 null 时，就不缓存
User getUser(Integer id);

@Cacheable(value = "user",unless = "#a0 == 1")//如果第一个参数的值是1,结果不缓存
User getUser(Integer id);

2.8、sync

该属性用来指定是否使用异步模式，该属性默认值为 false，默认为同步模式。异步模式指定 sync = true 即可，异步模式下 unless 属性不可用。

3、@CacheEvict

触发将数据从缓存删除的操纵(失效模式)。@CacheEvict 是用来标注在需要清除缓存元素的方法或类上的。当标记在一个类上时表示其中所有的方法的执行都会触发缓存的清除操作。属性有下面几个：

public @interface CacheEvict {
    @AliasFor("cacheNames")
    String[] value() default {};

    @AliasFor("value")
    String[] cacheNames() default {};

    String key() default "";

    String keyGenerator() default "";

    String cacheManager() default "";

    String cacheResolver() default "";

    String condition() default "";

    boolean allEntries() default false;

    boolean beforeInvocation() default false;
}

其他的几个和@Cacheable的属性差不多，这里看下上面没有介绍过的：
（1）allEntries：是否需要清除缓存中的所有元素。默认为 false ，表示不需要。当指定了 allEntries 为 true 时，Spring Cache将忽略指定的key，删除缓存中所有键；被注解的方法抛异常也能执行。
（2）beforeInvocation：是否在方法执行成功之后触发键删除操作，默认是在对应方法成功执行之后触发的，若此时方法抛出异常而未能成功返回，不会触发清除操作。指定该属性值为 true 时，Spring会在调用该方法之前清除缓存中的指定元素。

4、@CachePut

不影响方法执行更新缓存(双写模式)。

5、@Caching

组合以上多个操作(点击注解看源码就知道了，组合注解))。

public @interface Caching {
    Cacheable[] cacheable() default {};

    CachePut[] put() default {};

    CacheEvict[] evict() default {};
}

@Caching 注解可以在一个方法或者类上同时指定多个Spring Cache相关的注解。
其拥有三个属性：cacheable、put 和 evict，分别用于指定@Cacheable、@CachePut 和 @CacheEvict。对于一个数据变动，更新多个缓存的场景，可以通过 @Caching 来实现：

@Caching(cacheable = @Cacheable(cacheNames = "caching", key = "#age"), evict = @CacheEvict(cacheNames = "t4", key = "#age"))
public String caching(int age) {
    return "caching: " + age + "-->" + UUID.randomUUID().toString();
}

上面这个就是组合操作：从 caching::#age 缓存取数据，不存在时执行方法并写入缓存；删除缓存 t4::#age。