最近比较忙，没时间更新了。上一篇文章我说了如何使用Redis做缓存，文末我稍微提到了SpringBoot对缓存的支持。本篇文章就针对SpringBoot说一下如何使用。
1、SpringBoot对缓存的支持
SpringBoot对缓存的支持我们需要引入包：
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-cache</artifactId>
</dependency>
<!-- 如果需要集成redis,需要再加入redis包 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-pool2</artifactId>
<version>2.4.2</version>
</dependency>
缓存的支持是依靠接口：org.springframework.cache.annotation.CachingConfigurer的实现。所以我们使用SpringBoot自定义缓存只需要实现CachingConfigurer接口，并给出合理的实现即可。所以我们通常使用缓存如Ecache，Redis等较好的缓存框架都是已经实现了的。默认情况下SpringBoot同样是使用本地缓存，可以通过配置文件配置缓存配置项。具体如何配置请参考我的上篇文章：如何使用Redis做缓存
SpringBoot为我们做了很多事情，我们使用缓存只需要了解3个注解：@Cacheable, @CachePut, @CacheEvict。Cacheable作用是读取缓存，CachePut是放置缓存，CacheEvict作用是清除缓存。
2、Cacheable注解
这个注解我们会相对熟悉，在上一篇文章中我们就说过这个注解的使用，这里再复制粘贴一下：
/**
* 就直接占着源码说了
*/
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface Cacheable {
/**
* 设置使用换成的名称，这两个值是一样的，我们通过这个值来区分不同缓存的配置
* 比如我们可以设置不同的cacheName来设置缓存时间、设置不同的key生成策略等。
*/
@AliasFor("cacheNames")
String[] value() default {};
@AliasFor("value")
String[] cacheNames() default {};
/**
* 设置key生成策略，支持spel表达式，且存在root方法，可以通过#root.method,#root.target等使用root对象
* 同样可以固定缓存key为固定字符串。
* 如果不设置，SpringBoot提供默认的key生成策略。
*/
String key() default "";
/**
* 在注解中指定key生成器
*/
String keyGenerator() default "";
/**
* 在注解中制定此注解使用的缓存管理器
*/
String cacheManager() default "";
/**
* 在注解中指定此注解的缓存解析器，和缓存管理器互斥
*/
String cacheResolver() default "";
/**
* 设置使用缓存条件，使用Spel表达式解析。如果表达式返回false，则这次执行不走缓存逻辑
*/
String condition() default "";
/**
* 设置不缓存条件，Spel表达式。如果表达式返回true，则不对缓存结果进行缓存。
* 这个和condition()的区别是在于执行时机不同，condition方法是在执行方法前调用，而unless方法是在执行目标方法后调用。
*/
String unless() default "";
/**
* 采用同步的方式，默认false
*/
boolean sync() default false;
}
此注解主要描述缓存的使用策略
举个栗子：
public static final String D1 = "cache_1d";
@Cacheable(value = CacheTimes.D1, key = "#root.methodName", unless = "#result == null || #result.size() < 1", condition = "#skip != null")
public List<String> getList(String skip) {
return Arrays.stream(UUID.randomUUID().toString().split("-")).collect(Collectors.toList());
}
上述例子使用了@Cacheable注解，解析一下：
- value="cache_1d"是我定义的缓存值，这个配置设置了缓存1天。
- 自定义缓存key，key为方法名。同样可以使用keyGenerator设置key生成策略，不过我觉得使用spel表达式更加灵活，如果使用keyGenerator，keyGenerator的实现类需要实现org.springframework.cache.interceptor.KeyGenerator接口，具体的实现方法实现在generate方法中。
- unless的意思就是如果返回结果是null数组或数组大小是0，则不缓存此结果。
- condition则判定了是否走换成逻辑，如果skip是null，即condition是false，就不去读取缓存，而是直接执行目标方法。
- 如过有需求，你们可以指定cacheManager或cacheResolver。比如默认使用的是RedisCacheManager，然而某个缓存不需要使用Redis即可，可以单独使用Ecache，则可以在注解中指定Ecache的cachemanager。
3、CachePut注解
上面我们说CachePut注解作用是放置缓存。有点别扭，意思就是CachePut注解能够设置一些满足条件的缓存。虽然说我们通常用它来更新缓存（假如使用Redis做缓存，可以用它来设置redis的值。虽然能实现，但是还是不建议用这个去设置Redis的值哈，因为那样使用违反了注解的本身的意思，别人看了种以为它是缓存咋办），但我认为不能说成更新缓存，更新的意思是必须要有然后改变其值。
CachePut的源码和Cacheable基本一致
public @interface CachePut {
@AliasFor("cacheNames")
String[] value() default {};
@AliasFor("value")
String[] cacheNames() default {};
String key() default "";
String condition() default "";
String unless() default "";
String keyGenerator() default "";
String cacheManager() default "";
String cacheResolver() default "";
}
同理Cacheable，CachePut注解生效是在满足condition()true和unless()false的情况。
用法举栗子
@CachePut(value = CacheTimes.D1, key = "#root.methodName", unless = "#result == null || #result.size() < 1", condition = "#condition" )
public List<String> setListCache(List<String> list, boolean condition){
if(list != null && list.size() > 0){
return list;
}
return Arrays.stream(UUID.randomUUID().toString().split("-")).collect(Collectors.toList());
}
上例中unless和condition和Cacheable用法一致，不同的就是CachePut注解的方法被调用时不会去读取缓存中存储的数据，只是在调用结束判断是否将数据写入缓存。即满足参数condition=true，return value is not NullList，就会以key=setListCache将执行结果存入缓存中。
如果key设置和Cacheable缓存的key相同，那么方法调用结束就会更新缓存。
千奇百怪：使用CachePut给Redis赋值（其实就是凑凑字数，既然是缓存的注解，那么咱们还是只用来做缓存更好，并且，缓存也不一定用的就是Redis，哈哈哈哈哈哈哈）
@CachePut(value = CacheTimes.D1, key = "#key")
public Object setKV(String key, Object value){
return value;
}
如果你这样使用了，那么应要注意你的value这个缓存的过期时间，和CacheEvict注解的使用。。。。
4、CacheEvict注解
CacheEvict注解在相对于前两个注解，多了两个属性：allEntries和beforeInvocation
public @interface CacheEvict {
/** 是否删除所有缓存 */
boolean allEntries() default false;
/** 在方法执行前/后进行删除缓存操作 */
boolean beforeInvocation() default false;
@AliasFor("cacheNames")
String[] value() default {};
@AliasFor("value")
String[] cacheNames() default {};
String key() default "";
String condition() default "";
String keyGenerator() default "";
String cacheManager() default "";
String cacheResolver() default "";
}
参数：allEntries
allEntries参数作用是删除所有缓存数据，默认是false，让我们指定key去删除匹配的缓存。详细看下面两个例子：
- 删除全部缓存数据
@CacheEvict(value = CacheTimes.D1, condition = "#condition", allEntries = true)
public void clearCache(boolean condition){
……
}
上面的方法的意思就是说当参数condition=true时，CacheEvict注解开始生效，因为allEntries=true，所以会删除value=CacheTimes.D1下所有的缓存数据。
比如之前在CacheTime.D1下设置了缓存："a"="b","c"="c","d"="d"，在调用了clearCache方法之后，上述缓存将全部被删除。
- 指定key删除
@CacheEvict(value = CacheTimes.D1, allEntries = false, key = "#key")
public void clearCache(String key){
}
如果在allEntries=false的情况下，CacheEvict将会删除制定key的键值。理应在指定key的情况下，allEntries应当为false；否则指定的key将无效。
那么当allEntries=true的时候，springboot是怎么判断应当删除哪条数据的呢？
这个我们要先搞清楚缓存的key生成策略：默认情况下，缓存会拿注解中的value值作为前缀+"::"+你自定义的key生成策略作为这个缓存的真实key。当我们调用CacheEvict注解中allEntries的值为true时，springboot就会根据上述的key生成策略去匹配缓存系统中的数据，即以注解中value值为前缀的key去删除。
那么就会存在这样一个问题：假如我们重写了上述的key生成策略，使得缓存在生成key时没有前缀，那么删除时会发生什么？
答案就是你想象的那样：会删除缓存系统中所有的数据，如果缓存使用的是redis，那么redis中所有的数据将被清空。
参数：beforeInvocation
既然是缓存，我们就应当更加全面的去操作缓存。那么假设我们对某个User表做了缓存，当添加数据时，我们使用Cacheable去设置缓存；读取时同样根据Cacheable策略去取出数据；当修改时，我们使用CachePut去更新缓存；当删除时，我们理应使用CacheEvict去删除缓存。这时就会存在一个问题：在调用方法删除某条id=123的用户记录时，由于业务原因出现异常（是否删除成功状态未知），那么这时，这个缓存我们应不应当清理。
这种情况下beforeInvocation给我们了选择。当beforeInvocation=true时，SpringBoot先进行缓存操作（先删除缓存）在执行方法逻辑。当beforeInvocation=false时，先执行方法业务逻辑，再删除缓存。（当然，业务正常执行的时候都无所谓）
当业务出现异常时，我们要么选择删除缓存，要么不删除。
- 缓存操作在前（先删除缓存，再执行逻辑，不管是否异常，缓存已经清空）
@CacheEvict(value = CacheTimes.D1, condition = "#condition", beforeInvocation = true, allEntries = true)
public void clearCache(boolean condition){
throw new RuntimeException("exception");
}
- 缓存操作在后（默认，出现异常不删除缓存）
@CacheEvict(value = CacheTimes.D1, condition = "#condition"，beforeInvocation = false， allEntries = true)
public void clearCache(boolean condition){
throw new RuntimeException("exception");
}
5、Caching注解实现复杂缓存逻辑
缓存就是读写更新，那么上面三个注解已经够了，Caching是干什么的呢？
public @interface Caching {
Cacheable[] cacheable() default {};
CachePut[] put() default {};
CacheEvict[] evict() default {};
}
Caching注解中包含了Cacheable、CachePut、CacheEvict三个注解。所以我们很应该能够想象得到，在Caching中能够使用多个缓存注解，主要是为了实现一些复杂的缓存逻辑，且不需要在多个方法上去实现。
这个没啥好说的，简洁明了。
6、常见的（我碰到的）业务实现使用。。。
1、对mysql某个表进行缓存
这种逻辑通常不会使用单机缓存，而经常使用一个单独的缓存系统：比如Redis、elasticsearch去作为缓存，因为要保持数据的一直性。
class user{......}
//存储数据库的同时，存储到缓存
@CachePut(value = "user", condition = "#user != null", key = "#user.id")
public User insert(User user){
jdbc.insert(user)
return user;
}
//读取,如果缓存过期，则重新查数据，重新写入缓存
@Cacheable(value = "user", condition = "#userId != null", key = "#userId", unless = "#result != null")
public User select(Integer userId){
User user = jdbc.select(userId);
return user;
}
//删除数据时同样清除缓存
@CacheEvict(value = "user", condition = "#userId != null", key = "#userId", allEntries = false, beforeInvocation = true)
public void delete(Integer userId){
jdbc.delete(userId);
}
2、对复杂查询逻辑进行缓存
通常我们一个restful接口会存在非常复杂的逻辑，导致接口请求时间过长，这时我们会考虑将接口中的数据做缓存，而不是每次进入都重新走一边业务。而业务多变，在整个接口中设置我们可能不仅仅去读取缓存，或许可以根据参数的不同我们需要同时实现缓存的更新和清理。demo如下：
@Caching(
cacheable = {
@Cacheable(value = CacheTimes.D1, key = "#root.methodName + #userId", condition = "#update == null", unless = "#result != null || #result.size() < 1"),
@Cacheable(value = CacheTimes.D7, key = "#root.methodName + #userId", condition = "#update == null", unless = "#result != null", cacheManager = "cacheManager")
},
put = {
@CachePut(value = CacheTimes.D1, key = "#root.methodName + #userId", condition = "#update != null && #update.size() > 0"),
@CachePut(value = CacheTimes.D7, key = "#root.methodName + #userId", condition = "#update != null", cacheManager = "cacheManager")
}
)
public List<Object> recommend(String userId, List<Object> update){
if(update != null && update.size > 0){
return update;
}
List<Object> l1 = selectTable1(userId);
List<Object> l2 = selectTable2(userId);
List<Object> l3 = selectTable3(userId);
List<Object> l4 = selectTable4(userId);
List<Object> l5 = selectTable5(userId);
List<Object> result = new ArrayList();
result.addAll(l1);
result.addAll(l2);
result.addAll(l3);
result.addAll(l4);
result.addAll(l5);
return converVo(result);
}
1、如上述demo，当参数update不是null时我们直接返回了update的值，update不是null触发了CachePut注解，我们会更新两个缓存，一个是默认的缓存更新管理器，一个指定了缓存管理器。
2、那么当符合Cachebale注解的时候呢？我们上面定义了两个Cacheable注解，当两个都满足注解条件，而且两个缓存中的值是不同的，会报异常吗？当然不会，当出现两个的时候读取缓存时，SpringBoot会返回你第一个注解的值。
3、如果参数同时符合CachePut和Cacheable的时候呢？通过测试，我发现如果同时慢住这两个注解的条件，会以CachePut的优先级更高，所以1. 会更新缓存；2. 返回的结果是更新后的缓存。
4、如果我再加了个CacheEvict，会不会清空缓存？
当然会。
3、更多还在你的实践，有错误欢迎指导，有扩展欢迎大家评论。
好了，这个就到此结束了，欢迎大家给出意见。发表自己的建议，如需要补充，评论去也同时可见。拜拜。
想当初是打算一周一篇文章的，但是不太好搞啊，真的是脑袋本，面对着电脑想不出应该怎么说好这一句话，写了删，然后再写，诺，现在才写成这么样子，真羡慕那些文笔不错的同学，能够出口成章准确表达出自己的意思也能够让他人更好的理解。
给自己拉个赞吧：欢迎点赞关注和评论，更希望本篇文章你看完之后有所收获。
