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)。

巴特西

Spring Cache 带你飞(一)

开启 Spring Cache

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

CacheOperation

CacheInterceptor

小结

最新文章

热门文章