Spring Cache 带你飞(一)

Spring 3.1 版本引入基于 annotation 的 cache 技术，提供了一套抽象的缓存实现方案，通过注解方式使用缓存，基于配置的方式灵活使用不同缓存组件。代码具有相当的灵活性和扩展性，本文基于 Spring 5.x 源码一起分析 Spring Cache 的代码艺术。

开启 Spring Cache

想让 Spring 提供 Cache 能力很简单，只需要在启动类加上 @EnableCaching 注解即可：

@Configuration
@EnableCaching
public class ServerMain {}


通过在启动类上添加 EnableCaching 注解将 Cache 相关的组件注入到 Spring 启动中，通过 Proxy 或者 AspectJ 的方式获取 Cache 对应的执行信息。

如果你希望在启动时修改一些 Cache 底层对应的基础管理信息，可以通过在启动类上覆盖 CachingConfigurerSupport 提供的相关方法来实现：

@EnableCaching
@SpringBootApplication
public class WebDemoApplication extends CachingConfigurerSupport { public static void main(String[] args) {
SpringApplication.run(WebDemoApplication.class, args);
} @Override
public CacheManager cacheManager() {
return super.cacheManager();
} @Override
public KeyGenerator keyGenerator() {
return super.keyGenerator();
}
}


上面的示例代码中重写了 CacheManager 和 KeyGenerator 两个类的构建实现，分别实现的功能是 Cache 管理方式和 Cache key 生成方式。

从 Bean 加载机制了解 Spring 的 Cache 执行管理

从启动类入手我们很容易看到整体的 Cache 管理方式:

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import({CachingConfigurationSelector.class})
public @interface EnableCaching {
boolean proxyTargetClass() default false; AdviceMode mode() default AdviceMode.PROXY; int order() default 2147483647;
}


• proxyTargetClass：false，表示使用 JDK 代理，true 表示使用 cglib 代理。

• mode：指定 AOP 的模式，当值为 AdviceMode.PROXY 时表示使用 Spring aop，当值为当值为AdviceMode.ASPECTJ 时，表示使用 AspectJ。

EnableCaching 使用时导入 CachingConfigurationSelector 类，我们看看加载了什么信息：

public class CachingConfigurationSelector extends AdviceModeImportSelector<EnableCaching> { public String[] selectImports(AdviceMode adviceMode) {
switch(adviceMode) {
case PROXY:
return this.getProxyImports();
case ASPECTJ:
return this.getAspectJImports();
default:
return null;
}
}
......
......
...... static {
ClassLoader classLoader = CachingConfigurationSelector.class.getClassLoader();
jsr107Present = ClassUtils.isPresent("javax.cache.Cache", classLoader);
jcacheImplPresent = ClassUtils.isPresent("org.springframework.cache.jcache.config.ProxyJCacheConfiguration", classLoader);
}}


可以看到主要做了一件事，通过代理方式的不同加载对应的 CacheConfiguration :

• 如果是 JDK Proxy，加载 AutoProxyRegistrar 类和 ProxyCachingConfiguration 类；
• 如果是 AspectJ，则加载 AspectJCachingConfiguration 类。

Spring Boot 默认使用 JDK Proxy，我们就看 JDK Proxy 的使用。

AutoProxyRegistrar 的作用就是创建代理对象，内部通过调用 AopConfigUtils.registerAutoProxyCreatorIfNecessary(registry) 方法在 IOC 容器中注册一个 AutoProxyCreator。最终注入到容器中的 AutoProxyRegistrar 是一个 InfrastructureAdvisorAutoProxyCreator 类型：

@Nullable
public static BeanDefinition registerAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry, @Nullable Object source) {
return registerOrEscalateApcAsRequired(InfrastructureAdvisorAutoProxyCreator.class, registry, source);
}


InfrastructureAdvisorAutoProxyCreator 类型只会为基础设施类型的 Advisor 自动创建代理对象。它只会去找符合条件的 bean创建代理,从源码可见只有 role 为 BeanDefinition.ROLE_INFRASTRUCTURE 的满足条件。

ProxyCachingConfiguration 创建了 3 个 bean，CacheOperationSource 关注如何获取所有拦截的切面，

CacheInterceptor 解决要对拦截到的切面做什么。

public class ProxyCachingConfiguration extends AbstractCachingConfiguration { @Bean(
name = {"org.springframework.cache.config.internalCacheAdvisor"}
)
@Role(2)
public BeanFactoryCacheOperationSourceAdvisor cacheAdvisor(CacheOperationSource cacheOperationSource, CacheInterceptor cacheInterceptor) {
BeanFactoryCacheOperationSourceAdvisor advisor = new BeanFactoryCacheOperationSourceAdvisor();
advisor.setCacheOperationSource(cacheOperationSource);
advisor.setAdvice(cacheInterceptor);
if (this.enableCaching != null) {
advisor.setOrder((Integer)this.enableCaching.getNumber("order"));
} return advisor;
}
......
}


BeanFactoryCacheOperationSourceAdvisor 是 Spring Cache 自己实现的 Advisor，会对所有能取出 CacheOperation 的方法执行 CacheInterceptor 这个 Advice。

小知识：

Spring AOP 的创建过程本质是实现一个 BeanPostProcessor，在创建 bean 的过程中创建 Proxy，并且为 Proxy 绑定所有适用于该 bean 的 advisor，最终暴露给容器。

Spring 中 AOP 几个关键的概念 advisor， advice， pointcut

advice = 切面拦截中插入的行为

pointcut = 切面的切入点

advisor = advice + pointcut

BeanFactoryCacheOperationSourceAdvisor内部的切入点实现类是 CacheOperationSourcePointcut，切入的逻辑如下：

abstract class CacheOperationSourcePointcut extends StaticMethodMatcherPointcut implements Serializable { private class CacheOperationSourceClassFilter implements ClassFilter {
private CacheOperationSourceClassFilter() {
} public boolean matches(Class<?> clazz) {
if (CacheManager.class.isAssignableFrom(clazz)) {
return false;
} else {
CacheOperationSource cas = CacheOperationSourcePointcut.this.getCacheOperationSource();
return cas == null || cas.isCandidateClass(clazz);
}
}
}
}


可以看到切入点主要就是判断被切入的方法上是否有注解：CacheOperationSourcePointcut.this.getCacheOperationSource()。

ProxyCachingConfiguration 中还有另一个值得关注的类 - AnnotationCacheOperationSource：

@Bean
@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
public CacheOperationSource cacheOperationSource() {
return new AnnotationCacheOperationSource();
}


CacheOperationSource 持有一个 CacheAnnotationParser 列表。 CacheAnnotationParser 只有一个实现类：SpringCacheAnnotationParser：

public class SpringCacheAnnotationParser implements CacheAnnotationParser, Serializable { private static final Set<Class<? extends Annotation>> CACHE_OPERATION_ANNOTATIONS = new LinkedHashSet<>(8); static {
CACHE_OPERATION_ANNOTATIONS.add(Cacheable.class);
CACHE_OPERATION_ANNOTATIONS.add(CacheEvict.class);
CACHE_OPERATION_ANNOTATIONS.add(CachePut.class);
CACHE_OPERATION_ANNOTATIONS.add(Caching.class);
}
......
@Nullable
private Collection<CacheOperation> parseCacheAnnotations(
DefaultCacheConfig cachingConfig, AnnotatedElement ae, boolean localOnly) {Collection<? extends Annotation> anns = (localOnly ?
AnnotatedElementUtils.getAllMergedAnnotations(ae, CACHE_OPERATION_ANNOTATIONS) :
AnnotatedElementUtils.findAllMergedAnnotations(ae, CACHE_OPERATION_ANNOTATIONS));
if (anns.isEmpty()) {
return null;
}final Collection<CacheOperation> ops = new ArrayList<>(1);
anns.stream().filter(ann -> ann instanceof Cacheable).forEach(
ann -> ops.add(parseCacheableAnnotation(ae, cachingConfig, (Cacheable) ann)));
anns.stream().filter(ann -> ann instanceof CacheEvict).forEach(
ann -> ops.add(parseEvictAnnotation(ae, cachingConfig, (CacheEvict) ann)));
anns.stream().filter(ann -> ann instanceof CachePut).forEach(
ann -> ops.add(parsePutAnnotation(ae, cachingConfig, (CachePut) ann)));
anns.stream().filter(ann -> ann instanceof Caching).forEach(
ann -> parseCachingAnnotation(ae, cachingConfig, (Caching) ann, ops));
return ops;
}
......
}


可以看到 Parser 的作用就是将注解对应的方法解析成 CacheOperation 存起来。

看到这里我们开始有点眉目，开始知道去哪里找拦截了什么和操作了什么。接下来继续对 CacheOperation 和 CacheInterceptor 进行深入。

CacheOperation

CacheOperationSource 接口中只有一个方法：

public interface CacheOperationSource {
default boolean isCandidateClass(Class<?> targetClass) {
return true;
} @Nullable
Collection<CacheOperation> getCacheOperations(Method method, @Nullable Class<?> targetClass);
}


该接口中只有一个方法：通过接口和类名获得对应的 CacheOperation。CacheOperation 是对缓存操作的抽象封装，它的实现类有 3 个：

三个实现类分别对应着 @CacheEvict、@CachePut 和 @Cacheable 注解。

CacheInterceptor

CacheInterceptor 实现的功能就是对 目标方法的实际拦截操作：

public class CacheInterceptor extends CacheAspectSupport implements MethodInterceptor, Serializable { @Override
@Nullable
public Object invoke(final MethodInvocation invocation) throws Throwable {
Method method = invocation.getMethod(); CacheOperationInvoker aopAllianceInvoker = () -> {
try {
return invocation.proceed();
}
catch (Throwable ex) {
throw new CacheOperationInvoker.ThrowableWrapper(ex);
}
}; Object target = invocation.getThis();
Assert.state(target != null, "Target must not be null");
try {
return execute(aopAllianceInvoker, target, method, invocation.getArguments());
}
catch (CacheOperationInvoker.ThrowableWrapper th) {
throw th.getOriginal();
}
}}


CacheInterceptor 代码很简洁，采用函数的形式封装了真正要执行的函数逻辑，最终把此函数传交给父类的 execute()去执行。很显然最终执行目标方法的是 invocation.proceed()。我们直接去父类 CacheAspectSupport 看相关代码逻辑：

public abstract class CacheAspectSupport extends AbstractCacheInvoker
implements BeanFactoryAware, InitializingBean, SmartInitializingSingleton {protected final Log logger = LogFactory.getLog(getClass());private final Map<CacheOperationCacheKey, CacheOperationMetadata> metadataCache = new ConcurrentHashMap<>(1024);private final CacheOperationExpressionEvaluator evaluator = new CacheOperationExpressionEvaluator();@Nullable
private CacheOperationSource cacheOperationSource;private SingletonSupplier<KeyGenerator> keyGenerator = SingletonSupplier.of(SimpleKeyGenerator::new);@Nullable
private SingletonSupplier<CacheResolver> cacheResolver; ......
}


上面摘录出 的一些属性：

Map<CacheOperationCacheKey, CacheOperationMetadata> metadataCache

这个 Map 缓存了所有被注解修饰的类或者方法对应的基本属性信息。

CacheOperationExpressionEvaluator evaluator

解析一些 condition、key、unless 等可以写 el 表达式的处理器。

SingletonSupplier<KeyGenerator> keyGenerator

key 生成器默认使用的 SimpleKeyGenerator，注意 SingletonSupplier 是 Spring5.1 的新类，实现了接口java.util.function.Supplier ，主要是对 null 值进行容错。

接着看相关的方法：

public abstract class CacheAspectSupport extends AbstractCacheInvoker
implements BeanFactoryAware, InitializingBean, SmartInitializingSingleton { // 这个接口来自于 SmartInitializingSingleton 在实例化完所有单例Bean后调用
//可以看到在这里实例化 CacheManager, CacheManager 我们后面会说作用
@Override
public void afterSingletonsInstantiated() {
if (getCacheResolver() == null) {
// Lazily initialize cache resolver via default cache manager...
Assert.state(this.beanFactory != null, "CacheResolver or BeanFactory must be set on cache aspect");
try {
setCacheManager(this.beanFactory.getBean(CacheManager.class));
}
catch (NoUniqueBeanDefinitionException ex) {
throw new IllegalStateException("No CacheResolver specified, and no unique bean of type " +
"CacheManager found. Mark one as primary or declare a specific CacheManager to use.", ex);
}
catch (NoSuchBeanDefinitionException ex) {
throw new IllegalStateException("No CacheResolver specified, and no bean of type CacheManager found. " +
"Register a CacheManager bean or remove the @EnableCaching annotation from your configuration.", ex);
}
}
this.initialized = true;
} //根据CacheOperation 封装CacheOperationMetadata
protected CacheOperationMetadata getCacheOperationMetadata(
CacheOperation operation, Method method, Class<?> targetClass) {CacheOperationCacheKey cacheKey = new CacheOperationCacheKey(operation, method, targetClass);
CacheOperationMetadata metadata = this.metadataCache.get(cacheKey);
if (metadata == null) {
KeyGenerator operationKeyGenerator;
if (StringUtils.hasText(operation.getKeyGenerator())) {
operationKeyGenerator = getBean(operation.getKeyGenerator(), KeyGenerator.class);
}
else {
operationKeyGenerator = getKeyGenerator();
}
CacheResolver operationCacheResolver;
if (StringUtils.hasText(operation.getCacheResolver())) {
operationCacheResolver = getBean(operation.getCacheResolver(), CacheResolver.class);
}
else if (StringUtils.hasText(operation.getCacheManager())) {
CacheManager cacheManager = getBean(operation.getCacheManager(), CacheManager.class);
operationCacheResolver = new SimpleCacheResolver(cacheManager);
}
else {
operationCacheResolver = getCacheResolver();
Assert.state(operationCacheResolver != null, "No CacheResolver/CacheManager set");
}
metadata = new CacheOperationMetadata(operation, method, targetClass,
operationKeyGenerator, operationCacheResolver);
this.metadataCache.put(cacheKey, metadata);
}
return metadata;
} //真正执行目标方法+ 缓存 的实现
@Nullable
protected Object execute(CacheOperationInvoker invoker, Object target, Method method, Object[] args) {
// Check whether aspect is enabled (to cope with cases where the AJ is pulled in automatically)
// 如果已经初始化过(有CacheManager，CacheResolver)，执行这里
if (this.initialized) {
//getTargetClass拿到原始Class 解剖代理
Class<?> targetClass = getTargetClass(target);
//简单的说就是拿到该方法上所有的CacheOperation缓存操作，最终一个一个的执行
CacheOperationSource cacheOperationSource = getCacheOperationSource();
if (cacheOperationSource != null) {
// CacheOperationContexts是非常重要的一个私有内部类
// 注意它是复数!不是CacheOperationContext单数
// 所以它就像持有多个注解上下文一样 一个个执行
Collection<CacheOperation> operations = cacheOperationSource.getCacheOperations(method, targetClass);
if (!CollectionUtils.isEmpty(operations)) {
return execute(invoker, method,
new CacheOperationContexts(operations, method, args, target, targetClass));
}
}
}
// 若还没初始化 直接执行目标方法不执行缓存操作
return invoker.invoke();
} //内部调用的 execute 方法
@Nullable
private Object execute(final CacheOperationInvoker invoker, Method method, CacheOperationContexts contexts) {
// 判断是否同步执行
if (contexts.isSynchronized()) {
CacheOperationContext context = contexts.get(CacheableOperation.class).iterator().next();
if (isConditionPassing(context, CacheOperationExpressionEvaluator.NO_RESULT)) {
Object key = generateKey(context, CacheOperationExpressionEvaluator.NO_RESULT);
Cache cache = context.getCaches().iterator().next();
try {
return wrapCacheValue(method, handleSynchronizedGet(invoker, key, cache));
}
catch (Cache.ValueRetrievalException ex) {
// Directly propagate ThrowableWrapper from the invoker,
// or potentially also an IllegalArgumentException etc.
ReflectionUtils.rethrowRuntimeException(ex.getCause());
}
}
else {
// No caching required, only call the underlying method
return invokeOperation(invoker);
}
}// sync=false的情况，走这里// Process any early evictions beforeInvocation=true的会在此处最先执行~~~// 最先处理@CacheEvict注解~~~真正执行的方法请参见：performCacheEvict
// context.getCaches()拿出所有的caches，看看是执行cache.evict(key);方法还是cache.clear();
// 需要注意的的是context.isConditionPassing(result); condition条件此处生效，并且可以使用#result
// context.generateKey(result)也能使用#result
// @CacheEvict没有unless属性
processCacheEvicts(contexts.get(CacheEvictOperation.class), true,
CacheOperationExpressionEvaluator.NO_RESULT);// 执行@Cacheable 看看缓存是否能够命中
Cache.ValueWrapper cacheHit = findCachedItem(contexts.get(CacheableOperation.class));// 如果缓存没有命中，那就准备一个cachePutRequest
// 因为@Cacheable首次进来肯定命中不了，最终肯定是需要执行一次put操作，这样下次进来就能命中
List<CachePutRequest> cachePutRequests = new ArrayList<>();
if (cacheHit == null) {
collectPutRequests(contexts.get(CacheableOperation.class),
CacheOperationExpressionEvaluator.NO_RESULT, cachePutRequests);
}Object cacheValue;
Object returnValue;
// 如果缓存命中了，并且并且没有@CachePut的话，也就直接返回
if (cacheHit != null && !hasCachePut(contexts)) {
cacheValue = cacheHit.get();
returnValue = wrapCacheValue(method, cacheValue);
}
else {
// 有 cachePut 的情况，先执行目标方法再 put 缓存
returnValue = invokeOperation(invoker);
cacheValue = unwrapReturnValue(returnValue);
}// 封装cacheput对象
collectPutRequests(contexts.get(CachePutOperation.class), cacheValue, cachePutRequests);// 真正统一执行 cacheput 的地方
for (CachePutRequest cachePutRequest : cachePutRequests) {
cachePutRequest.apply(cacheValue);
}// 最后才执行 cacheEvict
processCacheEvicts(contexts.get(CacheEvictOperation.class), false, cacheValue);return returnValue;
}//缓存属性上下文对象
private class CacheOperationContexts {private final MultiValueMap<Class<? extends CacheOperation>, CacheOperationContext> contexts;
//检查注解是否配置同步执行的开关
private final boolean sync;public CacheOperationContexts(Collection<? extends CacheOperation> operations, Method method,
Object[] args, Object target, Class<?> targetClass) { //将当前 method 上所有缓存操作封装到一个map 对象中
this.contexts = new LinkedMultiValueMap<>(operations.size());
for (CacheOperation op : operations) {
this.contexts.add(op.getClass(), getOperationContext(op, method, args, target, targetClass));
}
//同步执行与否取决于这个函数
this.sync = determineSyncFlag(method);
}public Collection<CacheOperationContext> get(Class<? extends CacheOperation> operationClass) {
Collection<CacheOperationContext> result = this.contexts.get(operationClass);
return (result != null ? result : Collections.emptyList());
}public boolean isSynchronized() {
return this.sync;
} //只有@Cacheable有sync属性，所以只需要看CacheableOperation即可
private boolean determineSyncFlag(Method method) {
List<CacheOperationContext> cacheOperationContexts = this.contexts.get(CacheableOperation.class);
if (cacheOperationContexts == null) { // no @Cacheable operation at all
return false;
}
boolean syncEnabled = false;
//只要有一个@Cacheable的sync=true了，那就为true 并且下面还有检查逻辑
for (CacheOperationContext cacheOperationContext : cacheOperationContexts) {
if (((CacheableOperation) cacheOperationContext.getOperation()).isSync()) {
syncEnabled = true;
break;
}
}
// 执行sync=true的检查逻辑
if (syncEnabled) {
// sync=true时候，不能还有其它的缓存操作 也就是说@Cacheable(sync=true)的时候只能单独使用
if (this.contexts.size() > 1) {
throw new IllegalStateException(
"@Cacheable(sync=true) cannot be combined with other cache operations on '" + method + "'");
}
//@Cacheable(sync=true)时，多个@Cacheable也是不允许的
if (cacheOperationContexts.size() > 1) {
throw new IllegalStateException(
"Only one @Cacheable(sync=true) entry is allowed on '" + method + "'");
}
// 拿到唯一的一个@Cacheable
CacheOperationContext cacheOperationContext = cacheOperationContexts.iterator().next();
CacheableOperation operation = (CacheableOperation) cacheOperationContext.getOperation();
//@Cacheable(sync=true)时，cacheName只能使用一个
if (cacheOperationContext.getCaches().size() > 1) {
throw new IllegalStateException(
"@Cacheable(sync=true) only allows a single cache on '" + operation + "'");
}
//sync=true时，unless属性是不支持的,并且是不能写的
if (StringUtils.hasText(operation.getUnless())) {
throw new IllegalStateException(
"@Cacheable(sync=true) does not support unless attribute on '" + operation + "'");
}
return true;
}
return false;
}
}}


execute 相关的代码上面注解写的很清晰，大家可以跟着多看几遍。这里还有一点没有说，最终的 get Cache 或者 put Cache 的操作在哪里呢？刚才在 execute 方法中有一句代码：

Cache.ValueWrapper cacheHit = findCachedItem(contexts.get(CacheableOperation.class));


这里我们看到是先查缓存中是否有该 Cache，进去看有个 findCaches 方法：

@Nullable
private Cache.ValueWrapper findInCaches(CacheOperationContext context, Object key) {
for (Cache cache : context.getCaches()) {
Cache.ValueWrapper wrapper = doGet(cache, key);
if (wrapper != null) {
if (logger.isTraceEnabled()) {
logger.trace("Cache entry for key '" + key + "' found in cache '" + cache.getName() + "'");
}
return wrapper;
}
}
return null;
}


重点关注 doGet 方法，可以看到这个方法是父类 AbstractCacheInvoker 中的，同类里面还有 doPut，doEvict 和 doClear。

小知识

@Cacheable 注解 sync=true 的效果

多线程环境下存在多个操作使用相同的参数同步调用相同的 key，默认情况下缓存不锁定任何资源所以可能导致多次计算。对于这种情况，sync 属性可以将底层锁住，使得只有一个线程进行操作，其他线程堵塞直到更新完缓存返回结果。

小结

至此我们把上面说过的内容总结一下：

BeanFactoryCacheOperationSourceAdvisor

配置 Cache 的切面和拦截实现。拦截的对象即解析出来的 CacheOperation 对象。

每一个 CacheOperation 在执行的时候被封装为 CacheOperationContext 对象（一个方法可能被多个注解修饰），最终通过 CacheResolver 解析出缓存对象 Cache。

CacheOperation

封装了@CachePut、@Cacheable、@CacheEvict的属性信息，以便于拦截的时候能直接操作此对象来执行逻辑。

解析注解对应的代码为 CacheOperation 的工作是 CacheAnnotationParser 来完成的。

CacheInterceptor

CacheInterceptor 执行真正的方法执行和 Cache 操作。最终调用其父类提供的四个 do 方法处理 Cache。

以上整体过程为 Spring 启动对相关注解所在类或者方法的拦截和注入，从而实现 Cache 逻辑。限于篇幅本篇暂讨论这些内容，下一篇我们来看 Spring 如何实现对多缓存底层方案的支持(本地 Cache，Redis，Guava Cache，Caffeine Cache)。