从入门到真香！用好Spring-Cache公司再也不用担心我搞不定AOP了！

}

测试

@Override
public void run(String… args) {
logger.info(“… Fetching books”);
logger.info(“isbn-1234 -->” + bookRepository.getByIsbn(“isbn-1234”));
logger.info(“isbn-4567 -->” + bookRepository.getByIsbn(“isbn-4567”));
logger.info(“isbn-1234 -->” + bookRepository.getByIsbn(“isbn-1234”));
logger.info(“isbn-4567 -->” + bookRepository.getByIsbn(“isbn-4567”));
logger.info(“isbn-1234 -->” + bookRepository.getByIsbn(“isbn-1234”));
logger.info(“isbn-1234 -->” + bookRepository.getByIsbn(“isbn-1234”));
}

测试一下，可以发现。第一次和第二次（第二次参数和第一次不同）调用getByIsbn方法，会等待3秒，而后面四个调用，都会立即返回。

常用注解

Spring Cache有几个常用注解，分别为@Cacheable、@CachePut、@CacheEvict、@Caching、 @CacheConfig。除了最后一个CacheConfig外，其余四个都可以用在类上或者方法级别上，如果用在类上，就是对该类的所有public方法生效，下面分别介绍一下这几个注解。

@Cacheable

@Cacheble注解表示这个方法有了缓存的功能，方法的返回值会被缓存下来，下一次调用该方法前，会去检查是否缓存中已经有值，如果有就直接返回，不调用方法。如果没有，就调用方法，然后把结果缓存起来。这个注解一般用在查询方法上。

@CachePut

加了@CachePut注解的方法，会把方法的返回值put到缓存里面缓存起来，供其它地方使用。它通常用在新增方法上。

@CacheEvict

使用了CacheEvict注解的方法，会清空指定缓存。一般用在更新或者删除的方法上。

@Caching

Java注解的机制决定了，一个方法上只能有一个相同的注解生效。那有时候可能一个方法会操作多个缓存（这个在删除缓存操作中比较常见，在添加操作中不太常见）。

Spring Cache当然也考虑到了这种情况，@Caching注解就是用来解决这类情况的，大家一看它的源码就明白了。

public @interface Caching {
Cacheable[] cacheable() default {};
CachePut[] put() default {};
CacheEvict[] evict() default {};
}

@CacheConfig

前面提到的四个注解，都是Spring Cache常用的注解。每个注解都有很多可以配置的属性，这个我们在下一节再详细解释。但这几个注解通常都是作用在方法上的，而有些配置可能又是一个类通用的，这种情况就可以使用@CacheConfig了，它是一个类级别的注解，可以在类级别上配置cacheNames、keyGenerator、cacheManager、cacheResolver等。

常用注解的配置

这部分我们最好是结合源码来看，才能更好地理解这些配置的运作机制。

源码：解析注解的时机

这一节主要是源码解析，有点晦涩，对源码不感兴趣的同学可以跳过。但如果想要弄清楚Spring Cache运作的原理，还是推荐一看的。

前面提到的几个注解@Cacheable、@CachePut、@CacheEvict、@CacheConfig，都有一些可配置的属性。这些配置的属性都可以在抽象类CacheOperation及其子类中可以找到。它们大概是这样的关系：

看到这里不得不佩服，这继承用得，妙啊。

解析每个注解的代码在SpringCacheAnnotationParser类中可以找到，比如parseEvictAnnotation方法，里面就有这么一句：

builder.setCacheWide(cacheEvict.allEntries());

明明注解里叫allEntries，但是CacheEvictOperation里却叫cacheWide？看了下作者，都是多个作者，但第一作者都是一个叫Costin Leau的哥们，我对这个命名还是有一点小小的困惑。。。看来大佬们写代码也会有命名不一致的问题

那这个SpringCacheAnnotationParser是在什么时候被调用的呢？很简单，我们在这个类的某个方法上打个断点，然后debug就行了，比如parseCacheableAnnotation方法。

在debug界面，可以看到调用链非常长，前面是我们熟悉的IOC注册Bean的一个流程，直到我们看到了一个叫做AbstractAutowireCapableBeanFactory的BeanFactory，然后这个类在创建Bean的时候会去找是否有Advisor。正好Spring Cache源码里就定义了这么一个Advisor：BeanFactoryCacheOperationSourceAdvisor。

这个Advisor返回的PointCut是一个CacheOperationSourcePointcut，这个PointCut复写了matches方法，在里面去获取了一个CacheOperationSource，调用它的getCacheOperations方法。这个CacheOperationSource是个接口，主要的实现类是AnnotationCacheOperationSource。在findCacheOperations方法里，就会调用到我们最开始说的SpringCacheAnnotationParser了。

这样就完成了基于注解的解析。

入口：基于AOP的拦截器

那我们实际调用方法的时候，是怎么处理的呢？我们知道，使用了AOP的Bean，会生成一个代理对象，实际调用的时候，会执行这个代理对象的一系列的Interceptor。Spring Cache使用的是一个叫做CacheInterceptor的拦截器。我们如果加了缓存相应的注解，就会走到这个拦截器上。这个拦截器继承了CacheAspectSupport类，会执行这个类的execute方法，这个方法就是我们要分析的核心方法了。

@Cacheable的sync

我们继续看之前提到的execute方法，该方法首先会判断是否是同步。这里的同步配置是用的@Cacheable的sync属性，默认是false。如果配置了同步的话，多个线程尝试用相同的key去缓存拿数据的时候，会是一个同步的操作。

我们来看看同步操作的源码。如果判断当前需要同步操作（1），首先会去判断当前的condition是不是符合条件（2）。这里的condition也是@Cacheable中定义的一个配置，它是一个EL表达式，比如我们可以这样用来缓存id大于1的Book：

@Override
@Cacheable(cacheNames = “books”, condition = “#id > 1”, sync = true)
public Book getById(Long id) {
return new Book(String.valueOf(id), “some book”);
}

如果不符合条件，就不使用缓存，也不把结果放入缓存，直接跳到5。否则，尝试获取key（3）。在获取key的时候，会先判断用户有没有定义key，它也是一个EL表达式。如果没有的话，就用keyGenerator生成一个key：

@Nullable
protected Object generateKey(@Nullable Object result) {
if (StringUtils.hasText(this.metadata.operation.getKey())) {
EvaluationContext evaluationContext = createEvaluationContext(result);
return evaluator.key(this.metadata.operation.getKey(), this.metadata.methodKey, evaluationContext);
}
return this.metadata.keyGenerator.generate(this.target, this.metadata.method, this.args);
}

我们可以用这种方式手动指定根据id生成book-1，book-2这样的key：

@Override
@Cacheable(cacheNames = “books”, sync = true, key = “‘book-’ + #id”)
public Book getById(Long id) {
return new Book(String.valueOf(id), “some book”);
}

这里的key是一个Object对象，如果我们不在注解上面指定key，会使用keyGenerator生成的key。默认的keyGenerator是SimpleKeyGenerator，它生成的是一个SimpleKey对象，方法也很简单，如果没有入参，就返回一个EMPTY的对象，如果有入参，且只有一个入参，并且不是空或者数组，就用这个参数（注意这里用的是参数本身，而不是SimpleKey对象。否则，用所有入参包一个SimpleKey。

源码：

@Override
public Object generate(Object target, Method method, Object… params) {
return generateKey(params);
}

/**

• Generate a key based on the specified parameters.
  */
  public static Object generateKey(Object… params) {
  if (params.length == 0) {
  return SimpleKey.EMPTY;
  }
  if (params.length == 1) {
  Object param = params[0];
  if (param != null && !param.getClass().isArray()) {
  return param;
  }
  }
  return new SimpleKey(params);
  }

看到这里你一定有一个疑问吧，这里只用入参，没有类名和方法名的区别，那如果两个方法入参一样，岂不是key冲突了？

你的感觉没错，大家可以试一下这两个方法：

// 定义两个参数都是String的方法
@Override
@Cacheable(cacheNames = “books”, sync = true)
public Book getByIsbn(String isbn) {
simulateSlowService();
return new Book(isbn, “Some book”);
}

@Override
@Cacheable(cacheNames = “books”, sync = true)
public String test(String test) {
return test;
}

// 调用这两个方法，用相同的参数"test"
logger.info(“test getByIsbn -->” + bookRepository.getByIsbn(“test”));
logger.info(“test test -->” + bookRepository.test(“test”));

你会发现两次生成的key相同，然后在调用test方法的时候，控制台会报错：

Caused by: java.lang.ClassCastException: class com.example.caching.Book cannot be cast to class java.lang.String (com.example.caching.Book is in unnamed module of loader ‘app’; java.lang.String is in module java.base of loader ‘bootstrap’)
at com.sun.proxy.$Proxy33.test(Unknown Source) ~[na:na]
at com.example.caching.AppRunner.run(AppRunner.java:23) ~[main/:na]
at org.springframework.boot.SpringApplication.callRunner(SpringApplication.java:795) ~[spring-boot-2.3.2.RELEASE.jar:2.3.2.RELEASE]
… 5 common frames omitted

Book不能强转成String，因为我们第一次调用getByIsbn方法的时候，生成的key是test，然后换成了返回值Book对象到缓存里面。而调用test方法的时候，生成的key还是test，就会取出Book，但是test方法的返回值是String，所以会尝试强转到String，结果发现强转失败。

我们可以自定义一个keyGenerator来解决这个问题：

@Component
public class MyKeyGenerator implements KeyGenerator {
@Override
public Object generate(Object target, Method method, Object… params) {
return target.getClass().getName() + method.getName() +
Stream.of(params).map(Object::toString).collect(Collectors.joining(“,”));
}
}

然后就可以在配置里面使用这个自定义的MyKeyGenerator了，再次运行程序，就不会出现上述问题。

@Override
@Cacheable(cacheNames = “books”, sync = true, keyGenerator = “myKeyGenerator”)
public Book getByIsbn(String isbn) {
simulateSlowService();
return new Book(isbn, “Some book”);
}

@Override
@Cacheable(cacheNames = “books”, sync = true, keyGenerator = “myKeyGenerator”)
public String test(String test) {
return test;
}

接着往下看，可以看到我们得到了一个Cache。这个Cache是在我们调用CacheAspectSupport的execute方法的时候，会new一个CacheOperationContext。在这个Context的构造方法里，会用cacheResolver去解析注解中的Cache，生成Cache对象。

默认的cacheResolver是SimpleCacheResolver，它从CacheOperation中取得配置的cacheNames，然后用cacheManager去get一个Cache。这里的cacheManager是用于管理Cache的一个容器，默认的cacheManager是ConcurrentMapCacheManager。听名字就知道是基于ConcurrentMap来做的了，底层是ConcurrentHashMap。

那这里的Cache是什么东西呢？Cache就对“缓存容器”的一个抽象，包含了缓存会用到的get、put、evict、putIfAbsent等方法。

小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级Java工程师，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Java开发全套学习资料》送给大家，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频

如果你觉得这些内容对你有帮助，可以添加下面V无偿领取！（备注Java）

结语

小编也是很有感触，如果一直都是在中小公司，没有接触过大型的互联网架构设计的话，只靠自己看书去提升可能一辈子都很难达到高级架构师的技术和认知高度。向厉害的人去学习是最有效减少时间摸索、精力浪费的方式。

我们选择的这个行业就一直要持续的学习，又很吃青春饭。

虽然大家可能经常见到说程序员年薪几十万，但这样的人毕竟不是大部份，要么是有名校光环，要么是在阿里华为这样的大企业。年龄一大，更有可能被裁。

送给每一位想学习Java小伙伴，用来提升自己。

本文到这里就结束了，喜欢的朋友可以帮忙点赞和评论一下，感谢支持！

，只靠自己看书去提升可能一辈子都很难达到高级架构师的技术和认知高度。向厉害的人去学习是最有效减少时间摸索、精力浪费的方式。

我们选择的这个行业就一直要持续的学习，又很吃青春饭。

虽然大家可能经常见到说程序员年薪几十万，但这样的人毕竟不是大部份，要么是有名校光环，要么是在阿里华为这样的大企业。年龄一大，更有可能被裁。

送给每一位想学习Java小伙伴，用来提升自己。

[外链图片转存中…(img-Yf9VUrgm-1710409597049)]

本文到这里就结束了，喜欢的朋友可以帮忙点赞和评论一下，感谢支持！

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录