（二）Spring源码解析--AOP

AOP为我们提供无侵入的切面编程能力，在Spring中通过切面可以完成事务控制等功能，下面我们一起来分析Spring中AOP的实现原理。

我们以注解版的切面配置为例，若想实现AOP功能，首先我们需要定义一个如下的切面类：我们通过注解@Aspect标注切面，通过@Component将此切面作为Spring容器组件

@Aspect
@Component
public class Audience {

	@Pointcut("execution(* aop.Performance.perform(..))")
	public void performance(){}

	@Before("performance()")
	public void beforePerform(){
		System.out.println("在表演开始之前，请领导讲话!");
	}

	@After("performance()")
	public void afterPerform(){
		System.out.println("表演完成后，大家鼓掌感谢!");
	}

}

若想使用AOP注解功能，还需要开启注解代理如下所示：通过注解@EnableAspectJAutoProxy启用AOP功能

@Configurable
@ComponentScan(basePackages = {"aop"},excludeFilters = {
		@ComponentScan.Filter(type = FilterType.ANNOTATION,classes = {Controller.class,Service.class})
})
@EnableAspectJAutoProxy
public class SpringConfig {

}

 查看注解@EnableAspectJAutoProxy发现其引入了组件类AspectJAutoProxyRegistrar.class

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import({AspectJAutoProxyRegistrar.class})
public @interface EnableAspectJAutoProxy {
    boolean proxyTargetClass() default false;

    boolean exposeProxy() default false;
}

进入AspectJAutoProxyRegistrar.class发现器主要是向容器中注册了一个创建器，那么是什么创建器?继续跟进查看发现其实际是向容器中注册了一个AnnotationAwareAspectJAutoProxyCreator创建其

public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        //重点:向注册中心注册一个创建器
        AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);
        AnnotationAttributes enableAspectJAutoProxy = AnnotationConfigUtils.attributesFor(importingClassMetadata, EnableAspectJAutoProxy.class);
        if (enableAspectJAutoProxy.getBoolean("proxyTargetClass")) {
            AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
        }

        if (enableAspectJAutoProxy.getBoolean("exposeProxy")) {
            AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
        }

    }

public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry, Object source) {
        // 重点：注册AnnotationAwareAspectJAutoProxyCreator
        return registerOrEscalateApcAsRequired(AnnotationAwareAspectJAutoProxyCreator.class, registry, source);
    }

AnnotationAwareAspectJAutoProxyCreator是一个什么东西呢，让我们点进去继续查看 发先其继承关系如下

发现它有一个顶层接口InstantiationAwareBeanPostProcessor,这个接口我们在第一节IOC容器初始时就已经非常熟悉了，它会在bean实例化前后和初始化前后执行，在AbstractAutoProxyCreator中对接口方法进行了实现，最终代理类生成是在postProcessAfterInitialization中的this.wrapIfNecessary()中

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

        return bean;
    }

wrapIfNecessary()会调用createProxy()方法生成代理对象

 Object proxy = this.createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));

createProxy()方法，如下源码所示如果有接口会选择JDK动态代理，没有接口会选择CGLIB生成动态代理

// 通过AopProxy创建代理
 public Object getProxy(ClassLoader classLoader) {
        return this.createAopProxy().getProxy(classLoader);
    }

// 1. 有接口选择JDK动态代理 没有接口选择cglib生成动态代理

public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
        if (!config.isOptimize() && !config.isProxyTargetClass() && !this.hasNoUserSuppliedProxyInterfaces(config)) {
            return new JdkDynamicAopProxy(config);
        } else {
            Class targetClass = config.getTargetClass();
            if (targetClass == null) {
                throw new AopConfigException("TargetSource cannot determine target class: Either an interface or a target is required for proxy creation.");
            } else {
                return (AopProxy)(!targetClass.isInterface() && !Proxy.isProxyClass(targetClass) ? new ObjenesisCglibAopProxy(config) : new JdkDynamicAopProxy(config));
            }
        }
    }

//2. JDK动态代理生成
 public Object getProxy(ClassLoader classLoader) {
        if (logger.isDebugEnabled()) {
            logger.debug("Creating JDK dynamic proxy: target source is " + this.advised.getTargetSource());
        }

        Class[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true);
        this.findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
        return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
    }

 通过getProxy就得到了我们的代理对象了，下面我们将分析如代理对象方法调用流程：

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object oldProxy = null;
        boolean setProxyContext = false;
        TargetSource targetSource = this.advised.targetSource;
        Class targetClass = null;
        try {
                
               ...............................................
                // 得到方法通知链
                List