Spring Cache 系列 & 0x02 组件

Spring Cache 系列 & 0x01 开篇
Spring Cache 系列 & 0x02 组件
Spring Cache 系列 & 0x03 注解

这一篇试着讲解 Spring Cache 如何加载缓存实例的。
Spring Cache 是使用动态代理完成的，下面一步一步剖析Spring 如何加载管理 Cache Bean 的。

0x01 需要的代码

import org.springframework.cache.annotation.CacheConfig;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

@Service
@CacheConfig(cacheNames = {"CacheService"})
public class CacheService {

    @Cacheable(key = "#root.targetClass.getName() + '_' + #root.args[0]")
    public String get(Long value) {

        return "-1";
    }

    @CachePut(key = "#root.targetClass.getName() + '_' + #p0")
    public String update(Long value) {
        return "0";
    }

    @CacheEvict(key = "#root.targetClass.getName() + '_' + #a0")
    public void delete(Long value) {

    }
}

import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurer;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.concurrent.ConcurrentMapCacheManager;
import org.springframework.cache.interceptor.CacheErrorHandler;
import org.springframework.cache.interceptor.CacheResolver;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.cache.interceptor.SimpleCacheErrorHandler;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@EnableCaching
public class CacheConfiguration {


    @Bean
    public CachingConfigurer cachingConfigurer() {
        return new CachingConfigurer() {
            @Override
            public CacheManager cacheManager() {
                return new ConcurrentMapCacheManager();
            }

            @Override
            public CacheResolver cacheResolver() {
                return null;
            }

            @Override
            public KeyGenerator keyGenerator() {
                return null;
            }

            @Override
            public CacheErrorHandler errorHandler() {
                return new SimpleCacheErrorHandler();
            }
        };
    }

    @Bean
    public CacheService cacheService() {
        return new CacheService();
    }


    public static void main(String[] args) {
        Long id = 10L;
        AnnotationConfigApplicationContext app = new AnnotationConfigApplicationContext(CacheConfiguration.class);
        CacheService cacheService = app.getBean(CacheService.class);
        String s = cacheService.get(id);
        System.out.println("get: " + s);

        String update = cacheService.update(id);
        System.out.println("update: " + update);

        String s1 = cacheService.get(id);
        System.out.println("get: " + s1);
        
        cacheService.delete(id);

        String s2 = cacheService.get(id);
        System.out.println("get: " + s2);
    }

}

上面两个类是演示如何使用 Spring Cache 的；接下来对最要的类做进一步分析；

0x02 Cache 入口

0x021 EnableCaching

这个注解的表面意思是开启缓存；也就是加载、管理缓存实例的入口；

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
// 这里会交由 Spring 加载、实例化 Import 里的类 CachingConfigurationSelector； 可以去网上搜索有关 Import 的用途说明；
@Import(CachingConfigurationSelector.class)
public @interface EnableCaching {
    boolean proxyTargetClass() default false;
    AdviceMode mode() default AdviceMode.PROXY;

    int order() default Ordered.LOWEST_PRECEDENCE;
}

0x022 CachingConfigurationSelector

public class CachingConfigurationSelector extends AdviceModeImportSelector<EnableCaching> {

    private static final String PROXY_JCACHE_CONFIGURATION_CLASS =
            "org.springframework.cache.jcache.config.ProxyJCacheConfiguration";

    private static final String CACHE_ASPECT_CONFIGURATION_CLASS_NAME =
            "org.springframework.cache.aspectj.AspectJCachingConfiguration";

    private static final String JCACHE_ASPECT_CONFIGURATION_CLASS_NAME =
            "org.springframework.cache.aspectj.AspectJJCacheConfiguration";


    private static final boolean jsr107Present;

    private static final boolean jcacheImplPresent;

    static {
        ClassLoader classLoader = CachingConfigurationSelector.class.getClassLoader();
        jsr107Present = ClassUtils.isPresent("javax.cache.Cache", classLoader);
        jcacheImplPresent = ClassUtils.isPresent(PROXY_JCACHE_CONFIGURATION_CLASS, classLoader);
    }

   // 重写父类方法
    @Override
    public String[] selectImports(AdviceMode adviceMode) {
            // EnableCaching#mode() 的配置，这里默认是 PROXY(JDK PROXY)
        switch (adviceMode) {
            case PROXY:
                            // 我们主要介绍的是 JDK PROXY
                return getProxyImports();
            case ASPECTJ:
                return getAspectJImports();
            default:
                return null;
        }
    }
     
    private String[] getProxyImports() {
// 默认加载两个类AutoProxyRegistrar、ProxyCachingConfiguration
        List<String> result = new ArrayList<>(3);
        result.add(AutoProxyRegistrar.class.getName());
        result.add(ProxyCachingConfiguration.class.getName());
// 这里我们不介绍 JCACHE；因为他不影响我们使用 Spring Cache
        if (jsr107Present && jcacheImplPresent) {
            result.add(PROXY_JCACHE_CONFIGURATION_CLASS);
        }
        return StringUtils.toStringArray(result);
    }

    private String[] getAspectJImports() {
        List<String> result = new ArrayList<>(2);
        result.add(CACHE_ASPECT_CONFIGURATION_CLASS_NAME);
        if (jsr107Present && jcacheImplPresent) {
            result.add(JCACHE_ASPECT_CONFIGURATION_CLASS_NAME);
        }
        return StringUtils.toStringArray(result);
    }

}

// 父类
public abstract class AdviceModeImportSelector<A extends Annotation> implements ImportSelector {

     // 这个常量对应的 是 EnableCaching#mode() 方法
    public static final String DEFAULT_ADVICE_MODE_ATTRIBUTE_NAME = "mode";

    protected String getAdviceModeAttributeName() {
        return DEFAULT_ADVICE_MODE_ATTRIBUTE_NAME;
    }

    @Override
    public final String[] selectImports(AnnotationMetadata importingClassMetadata) {
        Class<?> annType = GenericTypeResolver.resolveTypeArgument(getClass(), AdviceModeImportSelector.class);
        Assert.state(annType != null, "Unresolvable type argument for AdviceModeImportSelector");

        AnnotationAttributes attributes = AnnotationConfigUtils.attributesFor(importingClassMetadata, annType);
        if (attributes == null) {
            throw new IllegalArgumentException(String.format(
                    "@%s is not present on importing class '%s' as expected",
                    annType.getSimpleName(), importingClassMetadata.getClassName()));
        }
       // 获取 EnableCaching#mode() 的配置
        AdviceMode adviceMode = attributes.getEnum(getAdviceModeAttributeName());
        String[] imports = selectImports(adviceMode);
        if (imports == null) {
            throw new IllegalArgumentException("Unknown AdviceMode: " + adviceMode);
        }
        return imports;
    }

    
         // @see CachingConfigurationSelector#selectImports(AdviceMode)
    @Nullable
    protected abstract String[] selectImports(AdviceMode adviceMode);

}

0x023 AutoProxyRegistrar

// ImportBeanDefinitionRegistrar 支持 Spring 动态加载 Bean 的重要接口；
public class AutoProxyRegistrar implements ImportBeanDefinitionRegistrar {

    private final Log logger = LogFactory.getLog(getClass());
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        boolean candidateFound = false;
   // importingClassMetadata 表示的是当前加载的 Bean；也就是 CacheConfiguration 实例；
   // 类 AutoProxyRegistrar 是通过 EnableCaching 注解加载的；而 EnableCaching 是在 CacheConfiguration 类上的；
  // 所有 annTypes 获取的 CacheConfiguration 类型上的 注解；也就是 @Configuration、@EnableCaching
        Set<String> annTypes = importingClassMetadata.getAnnotationTypes();
        for (String annType : annTypes) {
            AnnotationAttributes candidate = AnnotationConfigUtils.attributesFor(importingClassMetadata, annType);
            if (candidate == null) {
                continue;
            }
                // 这里获取 EnableCaching 注解的属性；
                // 通过这里我们可以自定义注解实现我们自己的业务；配置 mode、proxyTargetClass 两个属性，开通 AOP 的支持
            Object mode = candidate.get("mode");
            Object proxyTargetClass = candidate.get("proxyTargetClass");
            if (mode != null && proxyTargetClass != null && AdviceMode.class == mode.getClass() &&
                    Boolean.class == proxyTargetClass.getClass()) {
                candidateFound = true;
                if (mode == AdviceMode.PROXY) {
                    // 这里加载一个重要的类 InfrastructureAdvisorAutoProxyCreator ；
                    // 而这个类有一个重要的接口 InstantiationAwareBeanPostProcessor，这个接口的有一个方法 postProcessBeforeInstantiation 是在 Spring 初始化完 Bean 实例化之前调的接口；
                   // AOP 就是在这里对符合条件(下面会介绍怎么符合条件)的 Bean 进行动态代理控制
                   // @see org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#postProcessBeforeInstantiation 这是 InfrastructureAdvisorAutoProxyCreator 类的子类；
                    AopConfigUtils.registerAutoProxyCreatorIfNecessary(registry);
                    if ((Boolean) proxyTargetClass) {
                        // @see org.springframework.aop.framework.DefaultAopProxyFactory#createAopProxy
                        // 如果没有这个，Spring 默认使用 JDK 动态代理
                        AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
                        return;
                    }
                }
            }
        }
}

0x024 ProxyCachingConfiguration

@Configuration
@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
public class ProxyCachingConfiguration extends AbstractCachingConfiguration {
     // 实例化 AOP 缓存 切面
     // 如果不了解切面可以去网上搜索一下 AOP 介绍；
    @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();
    }

    // 实例化 AOP 拦截器
    @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;
    }

}

上面介绍了如何使用Spring Cache，以及加载一个类似CacheService用到了那些Spring 组件；如果你熟悉了上面 EnableCaching 注解模式(Spring 4.x、Spring Boot 大量使用)、@Import 注解、ImportBeanDefinitionRegistrar 动态加载 Bean 接口、AOP(切面、切点、连接点、通知)、BeanPostProcessor 组件、以及了解Spring 的加载过程；学习 Spring Cache 不会有任何压力。

如果你已经看过 Spring Cache 系列 & 0x01 开篇 这篇文章；你可以试着Debug InfrastructureAdvisorAutoProxyCreator#postProcessBeforeInstantiation(Class<?>, String) 方法，你就会知道如何创建代理类；