Spring源码学习笔记(9)——AOP

Spring源码学习笔记(9)——AOP

一. 基于注解的AOP开发

AOP的定义及一些术语相信大家已经很熟悉了，这里不再赘述。下面演示基于注解的Spring AOP开发。

1. 编写业务逻辑类

   @Component
   public class SimpleCalculator {
       int divide(int x,int y){
           return x / y;
       }
   }
   

   编写了一个简单的计算器类，计算整数的除法。

2. 编写切面类，并指定通知类型和切入点

   @Aspect
   @Component
   public class CalculatorAspect {
       //声明切入点
       @Pointcut("execution(public * william.annotation.component.SimpleCalculator.*(..))")
       public void pointcut(){}
   
       //前置通知
       @Before("pointcut()")
       public void before(JoinPoint joinPoint){
           System.err.println("前置通知-->方法名: " + joinPoint.getSignature().getName() +
                              ",参数列表: " + Arrays.asList(joinPoint.getArgs()));
       }
   
       //后置通知
       @AfterReturning(value = "pointcut()",returning = "retVal")
       public void after(JoinPoint joinPoint,Object retVal){
           System.err.println("后置通知-->方法名: " + joinPoint.getSignature().getName() +
                              ",返回值: " + retVal);
       }
   
       //环绕通知
       @Around("pointcut()")
       public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
           System.err.println("环绕通知前-->方法名: " + joinPoint.getSignature().getName());
           Object retVal = joinPoint.proceed();
           System.err.println("环绕通知后-->返回值: " + retVal);
           return retVal;
       }
   
   }
   

   使用@Aspect注解声明一个切面。切面包含切入点和通知方法。使用@Pointcut注解可以以方法的方式声明切入点，切入点表达式的相关内容这里不做过多介绍。使用@Before、@After、@Around等注解可以声明前置、后置、增强通知等。

3. 开启基于注解的AOP功能

   @Configuration
   @ComponentScan
   @EnableAspectJAutoProxy
   public class MainConfig {
   }
   

   在配置类上使用@EnableAspectJAutoProxy注解开启AOP自动代理，Spring就可以根据上述注解自动实现AOP的功能。

   执行测试代码，观察控制台打印：

   public class AnnotationMain {
       public static void main(String[] args) {
           AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig.class);
           SimpleCalculator simpleCalculator = applicationContext.getBean(SimpleCalculator.class);
           simpleCalculator.divide(1,1);
       }
   }
   

   环绕通知前-->方法名: divide
   前置通知-->方法名: divide,参数列表: [1, 1]
   环绕通知后-->返回值: 1
   后置通知-->方法名: divide,返回值: 1
   

   使用Spring的注解开发AOP功能是十分简单的。下面结合源码，分析Spring AOP的原理。

二. AOP源码分析

在上面的实例中，使用@EnableAspectJAutoProxy注解就可以开启自动代理功能，那么该功能是如何实现的呢？首先看@EnableAspectJAutoProxy源码：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(AspectJAutoProxyRegistrar.class)
public @interface EnableAspectJAutoProxy {

	//是否强制使用CGLib进行动态代理
	boolean proxyTargetClass() default false;

}

可以看到，@EnableAspectJAutoProxy注解使用@Import导入了一个AspectJAutoProxyRegistrar类，@Import的功能在前面有过详细介绍，下面看AspectJAutoProxyRegistrar：

class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar {
	@Override
	public void registerBeanDefinitions(
			AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {

		AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);

		AnnotationAttributes enableAJAutoProxy =
				AnnotationConfigUtils.attributesFor(importingClassMetadata, EnableAspectJAutoProxy.class);
		if (enableAJAutoProxy.getBoolean("proxyTargetClass")) {
			AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
		}
	}

}

核心逻辑在AopConfigUtils.registerOrEscalateApcAsRequired()方法中：

private static BeanDefinition registerOrEscalateApcAsRequired(Class<?> cls, BeanDefinitionRegistry registry, Object source) {
    Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
    if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
        BeanDefinition apcDefinition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
        if (!cls.getName().equals(apcDefinition.getBeanClassName())) {
            int currentPriority = findPriorityForClass(apcDefinition.getBeanClassName());
            int requiredPriority = findPriorityForClass(cls);
            if (currentPriority < requiredPriority) {
                apcDefinition.setBeanClassName(cls.getName());
            }
        }
        return null;
    }
    
    //向容器中注册一个beanName为org.springframework.aop.config.internalAutoProxyCreator的Bean:AnnotationAwareAspectJAutoProxyCreator
    RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
    beanDefinition.setSource(source);
    beanDefinition.getPropertyValues().add("order", Ordered.HIGHEST_PRECEDENCE);
    beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
    registry.registerBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME, beanDefinition);
    return beanDefinition;
}

该方法首先检查容器中是否已经存在beanName为org.springframework.aop.config.internalAutoProxyCreator的Bean，如果没有，则以该beanName注册一个Bean：AnnotationAwareAspectJAutoProxyCreator。AnnotationAwareAspectJAutoProxyCreator是Spring AOP的一个重要组件，下面对其进行分析：

先简单看一下AnnotationAwareAspectJAutoProxyCreator的继承路径：

AnnotationAwareAspectJAutoProxyCreator—>AspectJAwareAdvisorAutoProxyCreator—>AbstractAdvisorAutoProxyCreator—>AbstractAutoProxyCreator，而AbstractAutoProxyCreator实现了SmartInstantiationAwareBeanPostProcessor和BeanFactoryAware接口，这也就意味着AnnotationAwareAspectJAutoProxyCreator具有后处理器和BeanFactoryAware接口的功能，这也是Spring处理AOP动态代理的地方。

首先看AbstractAutoProxyCreator的后处理方法：

SmartInstantiationAwareBeanPostProcessor是一种特殊的后处理器，可以它不是在Bean的属性赋值前后进行拦截，而是在Bean实例化前后进行拦截，由此可以将一个Bean转换成代理的Bean。

public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
    if (bean != null) {
        Object cacheKey = getCacheKey(bean.getClass(), beanName);
        if (!this.earlyProxyReferences.contains(cacheKey)) {
            return wrapIfNecessary(bean, beanName, cacheKey);
        }
    }
    return bean;
}

首先在代理缓存池中查看当前beanName是否已经创建了代理对象，如果已经创建，则直接返回代理对象，否则执行创建代理对象的逻辑，即wrapIfNecessary()方法：

protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
    if (beanName != null && this.targetSourcedBeans.contains(beanName)) {
        return bean;
    }
    if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
        return bean;
    }
    if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
        this.advisedBeans.put(cacheKey, Boolean.FALSE);
        return bean;
    }
	
    //获取基于bean的所有拦截器，组成一个拦截器链，并根据拦截器链创建代理对象
    Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
    if (specificInterceptors != DO_NOT_PROXY) {
        this.advisedBeans.put(cacheKey, Boolean.TRUE);
        Object proxy = createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
        this.proxyTypes.put(cacheKey, proxy.getClass());
        return proxy;
    }

    this.advisedBeans.put(cacheKey, Boolean.FALSE);
    return bean;
}

创建代理对象的处理在createProxy()方法中：

protected Object createProxy(
    Class<?> beanClass, String beanName, Object[] specificInterceptors, TargetSource targetSource) {

    ProxyFactory proxyFactory = new ProxyFactory();
    proxyFactory.copyFrom(this);

    if (!proxyFactory.isProxyTargetClass()) {
        if (shouldProxyTargetClass(beanClass, beanName)) {
            proxyFactory.setProxyTargetClass(true);
        }
        else {
            evaluateProxyInterfaces(beanClass, proxyFactory);
        }
    }

    Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
    for (Advisor advisor : advisors) {
        proxyFactory.addAdvisor(advisor);
    }

    proxyFactory.setTargetSource(targetSource);
    customizeProxyFactory(proxyFactory);

    proxyFactory.setFrozen(this.freezeProxy);
    if (advisorsPreFiltered()) {
        proxyFactory.setPreFiltered(true);
    }

    return proxyFactory.getProxy(getProxyClassLoader());
}