SpringCache框架加载/拦截原理详解

//dao  @Pointcut("@annotation(com.kaola.cs.data.common.aspect.DataSourceSelect)")  public void dao() {  }

@EnableCaching@Configurationpublic class CacheConfigure extends CachingConfigurerSupport {  @Override  @Bean  public CacheManager cacheManager() {    SimpleCacheManager result = new SimpleCacheManager();    List<Cache> caches = new ArrayList<>();    caches.add(new ConcurrentMapCache("testCache"));    result.setCaches(caches);    return result;  }  @Override  @Bean  public CacheErrorHandler errorHandler() {    return new SimpleCacheErrorHandler();  }}

@Configuration@Role(BeanDefinition.ROLE_INFRASTRUCTURE)public class ProxyCachingConfiguration extends AbstractCachingConfiguration { @Bean(name = CacheManagementConfigUtils.CACHE_ADVISOR_BEAN_NAME) @Role(BeanDefinition.ROLE_INFRASTRUCTURE) public BeanFactoryCacheOperationSourceAdvisor cacheAdvisor() { BeanFactoryCacheOperationSourceAdvisor advisor = new BeanFactoryCacheOperationSourceAdvisor(); advisor.setCacheOperationSource(cacheOperationSource()); advisor.setAdvice(cacheInterceptor()); if (this.enableCaching != null) {  advisor.setOrder(this.enableCaching.<Integer>getNumber("order")); } return advisor; } @Bean @Role(BeanDefinition.ROLE_INFRASTRUCTURE) public CacheOperationSource cacheOperationSource() { return new AnnotationCacheOperationSource(); } @Bean @Role(BeanDefinition.ROLE_INFRASTRUCTURE) public CacheInterceptor cacheInterceptor() { CacheInterceptor interceptor = new CacheInterceptor(); interceptor.configure(this.errorHandler, this.keyGenerator, this.cacheResolver, this.cacheManager); interceptor.setCacheOperationSource(cacheOperationSource()); return interceptor; }}

/* BeanFactoryCacheOperationSourceAdvisor 继承了 AbstractBeanFactoryPointcutAdvisor 在spring 中的效果就是，在每个bean的初始化时 (每个bean都会被加载成 advised 对象 -> 有 targetSource 和 Advisor[] 数组) 每个bean被调用方法的时候都是先遍历advisor的方法，然后在调用原生bean(也就是targetSource)的方法，实现了aop的效果 bean 加载的时候 BeanFactoryCacheOperationSourceAdvisor 的 getPointcut()-> 也就是 CacheOperationSourcePointcut 就会被获取，然后调用  CacheOperationSourcePointcut.matches()方法, 用来匹配对应的bean  假设bean 在 BeanFactoryCacheOperationSourceAdvisor 的扫描中 matchs() 方法返回了true 结果就是   在每个bean的方法被调用的时候 CacheInterceptor 中的 invoke() 方法就会被调用  总结：  spring-cache 也完成了aop一样的实现(spring-aop也是这样做的) 重点就是在 CacheOperationSourcePointcut.matchs() 方法中，怎么匹配接口的了 这里先不说后面具体介绍！！！！*/public class BeanFactoryCacheOperationSourceAdvisor extends AbstractBeanFactoryPointcutAdvisor { @Nullable private CacheOperationSource cacheOperationSource; private final CacheOperationSourcePointcut pointcut = new CacheOperationSourcePointcut() { @Override @Nullable protected CacheOperationSource getCacheOperationSource() {  return cacheOperationSource; } }; /** * Set the cache operation attribute source which is used to find cache * attributes. This should usually be identical to the source reference * set on the cache interceptor itself. */ public void setCacheOperationSource(CacheOperationSource cacheOperationSource) { this.cacheOperationSource = cacheOperationSource; } /** * Set the {@link ClassFilter} to use for this pointcut. * Default is {@link ClassFilter#TRUE}. */ public void setClassFilter(ClassFilter classFilter) { this.pointcut.setClassFilter(classFilter); } @Override public Pointcut getPointcut() { return this.pointcut; }}

public abstract class AbstractFallbackCacheOperationSource implements CacheOperationSource { /** * Canonical value held in cache to indicate no caching attribute was * found for this method and we don't need to look again. */ private static final Collection<CacheOperation> NULL_CACHING_ATTRIBUTE = Collections.emptyList(); /** * Logger available to subclasses. * <p>As this base class is not marked Serializable, the logger will be recreated * after serialization - provided that the concrete subclass is Serializable. */ protected final Log logger = LogFactory.getLog(getClass()); /** * Cache of CacheOperations, keyed by method on a specific target class. * <p>As this base class is not marked Serializable, the cache will be recreated * after serialization - provided that the concrete subclass is Serializable. */ private final Map<Object, Collection<CacheOperation>> attributeCache = new ConcurrentHashMap<>(1024); /** * Determine the caching attribute for this method invocation. * <p>Defaults to the class's caching attribute if no method attribute is found. * @param method the method for the current invocation (never {@code null}) * @param targetClass the target class for this invocation (may be {@code null}) * @return {@link CacheOperation} for this method, or {@code null} if the method * is not cacheable */ @Override @Nullable public Collection<CacheOperation> getCacheOperations(Method method, @Nullable Class<?> targetClass) { if (method.getDeclaringClass() == Object.class) {  return null; } Object cacheKey = getCacheKey(method, targetClass); Collection<CacheOperation> cached = this.attributeCache.get(cacheKey); if (cached != null) {  return (cached != NULL_CACHING_ATTRIBUTE ? cached : null); } else {  Collection<CacheOperation> cacheOps = computeCacheOperations(method, targetClass);  if (cacheOps != null) {  if (logger.isTraceEnabled()) {   logger.trace("Adding cacheable method '" + method.getName() + "' with attribute: " + cacheOps);  }  this.attributeCache.put(cacheKey, cacheOps);  }  else {  this.attributeCache.put(cacheKey, NULL_CACHING_ATTRIBUTE);  }  return cacheOps; } } /** * Determine a cache key for the given method and target class. * <p>Must not produce same key for overloaded methods. * Must produce same key for different instances of the same method. * @param method the method (never {@code null}) * @param targetClass the target class (may be {@code null}) * @return the cache key (never {@code null}) */ protected Object getCacheKey(Method method, @Nullable Class<?> targetClass) { return new MethodClassKey(method, targetClass); } @Nullable private Collection<CacheOperation> computeCacheOperations(Method method, @Nullable Class<?> targetClass) { // Don't allow no-public methods as required. if (allowPublicMethodsOnly() && !Modifier.isPublic(method.getModifiers())) {  return null; } // The method may be on an interface, but we need attributes from the target class. // If the target class is null, the method will be unchanged. Method specificMethod = AopUtils.getMostSpecificMethod(method, targetClass); // First try is the method in the target class. Collection<CacheOperation> opDef = findCacheOperations(specificMethod); if (opDef != null) {  return opDef; } // Second try is the caching operation on the target class. opDef = findCacheOperations(specificMethod.getDeclaringClass()); if (opDef != null && ClassUtils.isUserLevelMethod(method)) {  return opDef; } if (specificMethod != method) {  // Fallback is to look at the original method.  opDef = findCacheOperations(method);  if (opDef != null) {  return opDef;  }  // Last fallback is the class of the original method.  opDef = findCacheOperations(method.getDeclaringClass());  if (opDef != null && ClassUtils.isUserLevelMethod(method)) {  return opDef;  } } return null; } /** * Subclasses need to implement this to return the caching attribute for the * given class, if any. * @param clazz the class to retrieve the attribute for * @return all caching attribute associated with this class, or {@code null} if none */ @Nullable protected abstract Collection<CacheOperation> findCacheOperations(Class<?> clazz); /** * Subclasses need to implement this to return the caching attribute for the * given method, if any. * @param method the method to retrieve the attribute for * @return all caching attribute associated with this method, or {@code null} if none */ @Nullable protected abstract Collection<CacheOperation> findCacheOperations(Method method); /** * Should only public methods be allowed to have caching semantics? * <p>The default implementation returns {@code false}. */ protected boolean allowPublicMethodsOnly() { return false; }}

public class AnnotationCacheOperationSource extends AbstractFallbackCacheOperationSource implements Serializable { private final Set<CacheAnnotationParser> annotationParsers; @Override @Nullable protected Collection<CacheOperation> findCacheOperations(Class<?> clazz) { return determineCacheOperations(parser -> parser.parseCacheAnnotations(clazz)); } @Override @Nullable protected Collection<CacheOperation> findCacheOperations(Method method) { return determineCacheOperations(parser -> parser.parseCacheAnnotations(method)); } /** * Determine the cache operation(s) for the given {@link CacheOperationProvider}. * <p>This implementation delegates to configured * {@link CacheAnnotationParser CacheAnnotationParsers} * for parsing known annotations into Spring's metadata attribute class. * <p>Can be overridden to support custom annotations that carry caching metadata. * @param provider the cache operation provider to use * @return the configured caching operations, or {@code null} if none found */ @Nullable protected Collection<CacheOperation> determineCacheOperations(CacheOperationProvider provider) { Collection<CacheOperation> ops = null; for (CacheAnnotationParser annotationParser : this.annotationParsers) {  Collection<CacheOperation> annOps = provider.getCacheOperations(annotationParser);  if (annOps != null) {  if (ops == null) {   ops = annOps;  }  else {   Collection<CacheOperation> combined = new ArrayList<>(ops.size() + annOps.size());   combined.addAll(ops);   combined.addAll(annOps);   ops = combined;  }  } } return ops; }}

@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; } 

// 代码自己看吧。也很简单 -> 结果就是spring-cache 也可以拦截到mybatis的dao层接口，进行缓存 @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) if (this.initialized) {  Class<?> targetClass = getTargetClass(target);  CacheOperationSource cacheOperationSource = getCacheOperationSource();  if (cacheOperationSource != null) {  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(); }