Spring中AOP相关源码解析

前言

在Spring中AOP是咱们使用的很是频繁的一个特性。经过AOP咱们能够补足一些面向对象编程中不足或难以实现的部分。

AOP

前置理论

首先在学习源码以前咱们须要了解关于AOP的相关概念如切点切面等，以及如何使用AOP，这里能够看我以前的文章：Spring系列之AOP的原理及手动实现

建立AOP相关对象

对于Java这种面向对象语言来讲任何功能的实现都是依赖于对象，AOP也不例外。

首先咱们先来准备好在配置文件中配置好AOP相关的属性。

spring.xml

<bean id="aspect" class="cn.javass.spring.chapter6.aop.HelloWorldAspect"/>

   <bean id="beforeAdvice" class="cn.javass.spring.chapter6.aop.BeforeAdviceImpl"/>
    <aop:aspectj-autoproxy/>
    <aop:config>
        <aop:pointcut id="pointcutA" expression="execution(* cn.javass..*.sayAfterReturning(..))"></aop:pointcut>
        <aop:advisor id="advisor" pointcut="execution(* cn.javass..*.sayAdvisorBefore(..))"
                     advice-ref="beforeAdvice"/>
        <aop:aspect id="aspects" ref="aspect">
             <aop:before pointcut="execution(* cn.javass..*.sayBefore(..)) and args(param)" method="beforeAdvice(java.lang.String)" arg-names="param"/>

             <aop:after-returning pointcut-ref="pointcutA" method="afterReturningAdvice" arg-names="retVal" returning="retVal"/>

             <aop:after-throwing pointcut="execution(* cn.javass..*.sayAfterThrowing(..))" method="afterThrowingAdvice" arg-names="exception" throwing="exception"/>

             <aop:after pointcut="execution(* cn.javass..*.sayAfterFinally(..))" method="afterFinallyAdvice"/>

             <aop:around pointcut="execution(* cn.javass..*.sayAround(..))" method="aroundAdvice"/>
        </aop:aspect>
    </aop:config>

在上面的配置中建立了几种不一样的advice。这些配置在spring启动时会被相应的建立为对象。

AopNamespaceHandler

在前面IOC文章中咱们有提到在Spring中经过spi的机制来肯定解析配置文件中不一样标签的解析类。

在aop包中找到spring.handlers文件：

http\://www.springframework.org/schema/aop=org.springframework.aop.config.AopNamespaceHandler

能够肯定的是处理aop相关标签的就是AopNamespaceHandler这个类。

public void init() {
        this.registerBeanDefinitionParser("config", new ConfigBeanDefinitionParser());
        this.registerBeanDefinitionParser("aspectj-autoproxy", new AspectJAutoProxyBeanDefinitionParser());
        this.registerBeanDefinitionDecorator("scoped-proxy", new ScopedProxyBeanDefinitionDecorator());
        this.registerBeanDefinitionParser("spring-configured", new SpringConfiguredBeanDefinitionParser());
    }

在AopNamespaceHandler中除了构造函数就只有上面的init方法，上面代码就是注册解析不一样标签的解析器的BeanDefinition。咱们须要关注的是aspectj-autoproxy标签的解析器类AspectJAutoProxyBeanDefinitionParser。

#### AopConfigUtils#registerOrEscalateApcAsRequired

跟踪```AspectJAutoProxyBeanDefinitionParser```的parse方法最终会进入到```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;
    }
    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;
}

这里的常量```AUTO_PROXY_CREATOR_BEAN_NAME = "org.springframework.aop.config.internalAutoProxyCreator";```

首先要明白的是internalAutoProxyCreator并非spring中的一个实际的类，AUTO_PROXY_CREATOR_BEAN_NAME是一个用于建立aop类的Beandefinition的名字。

在上面的代码逻辑中若是AUTO_PROXY_CREATOR_BEAN_NAME表示的Beandefinition已经存在则判断新须要注册的类其优先级和已经存在的类定义进行比较，若是新须要注册的优先级较高则进行替换。

若是不存在已经注册的Beandefinition则将其进行注册。被注册的Beandefinition表示的类为```AspectJAwareAdvisorAutoProxyCreator```。

#### 完成aop功能须要建立的对象

在前面IOC文章中分析过了在解析完配置文件后须要建立的对象都会将其BeanDefinition注册到IOC容器中，因此咱们能够将断点设置在配置文件解析完成以后就能够看到须要建立那些对象了。

![须要建立的对象](https://user-gold-cdn.xitu.io/2019/7/5/16bc0e4a57f8a819?w=789&h=405&f=png&s=22442)

如上图```helloWorldService```就是须要被加强的类。

public interface IHelloWorldService {

void sayHello();
void sayBefore(String param);
boolean sayAfterReturning();
void sayAfterThrowing();
boolean sayAfterFinally();
void sayAround(String param);
void sayAdvisorBefore(String param);

}

而```aspect,beforeAdvice,pointcutA,advisor```都是咱们在配置文件中配置过的，是切点，切面和处理方法的实现类。```org.springframework.aop.config.internalAutoProxyCreator```是上面分析过的用于建立aop代理的实现类。

然后面的以```org.springframework.aop.aspectj.AspectJPointcutAdvisor```开头的几个类实际上就是包含了切点和通知的一个切面的实现类，也就是它来决定哪些类须要被加强。

![加强实现类](https://user-gold-cdn.xitu.io/2019/7/5/16bc0e4a582a62c7?w=785&h=223&f=png&s=15964)

### 功能加强
#### 加强时机
若是看过前面手写aop文章的同窗应该知道当时咱们分析aop加强时机时有说过aop的加强功能其实是依赖于动态代理实现的。而动态代理若是要对一个对象进行加强那么首先须要持有该对象才行。

因此咱们在对对象进行加强的前提是该对象已经被建立完成以后。并且咱们要清楚的是一个类对象被加强后咱们全部须要使用该对象的地方都应该使用该对象，这样就肯定了类加强的时机必定是在类对象建立以后而且在完成注入以前。

#### AspectJAwareAdvisorAutoProxyCreator
前面有说过建立代理对象其实是经过```AspectJAwareAdvisorAutoProxyCreator```来完成，先来了解一下该类，查看该类的继承体系。

![继承体系](https://user-gold-cdn.xitu.io/2019/7/5/16bc0e4a5a031b8b?w=639&h=215&f=png&s=21661)

能够看到实际上该类自己仍是一个BeanPostProcessor，那么能够确定的是咱们只要找到执行BeanPostProcessor的地方而且是在实例化后执行的地方便可。通过调试后定位到```AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsAfterInitialization```方法。

public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName) throws BeansException {

    Object result = existingBean;
    for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
        result = beanProcessor.postProcessAfterInitialization(result, beanName);
        if (result == null) {
            return result;
        }
    }
    return result;
}

这里是对后置处理器进行遍历，对于aop咱们须要关注的是```AspectJAwareAdvisorAutoProxyCreator```这一个处理器。

##### wrapIfNecessary

protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
    //more code
    // Create proxy if we have advice.
    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;
}

这里去掉了前面一些代码，getAdvicesAndAdvisorsForBean方法是用来获取和当前对象匹配的切面。这里获取相匹配的切面类是经过```AbstractAdvisorAutoProxyCreator```来实现。

protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
    List<Advisor> candidateAdvisors = findCandidateAdvisors();
    List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
    extendAdvisors(eligibleAdvisors);
    if (!eligibleAdvisors.isEmpty()) {
        //根据在配置文件中配置的order属性或者注解@order()进行从小到大的排序
        //order的值越小其优先级越高
        eligibleAdvisors = sortAdvisors(eligibleAdvisors);
    }
    return eligibleAdvisors;
}

首先获取到全部的切面类，而后经过```AopUtils.findAdvisorsThatCanApply```方法来肯定哪些类可以匹配。

##### AopUtils.findAdvisorsThatCanApply

public static List<Advisor> findAdvisorsThatCanApply(List<Advisor> candidateAdvisors, Class<?> clazz) {
    if (candidateAdvisors.isEmpty()) {
        return candidateAdvisors;
    }
    List<Advisor> eligibleAdvisors = new LinkedList<Advisor>();
    for (Advisor candidate : candidateAdvisors) {
        if (candidate instanceof IntroductionAdvisor && canApply(candidate, clazz)) {
            eligibleAdvisors.add(candidate);
        }
    }
    boolean hasIntroductions = !eligibleAdvisors.isEmpty();
    for (Advisor candidate : candidateAdvisors) {
        if (candidate instanceof IntroductionAdvisor) {
            // already processed
            continue;
        }
        if (canApply(candidate, clazz, hasIntroductions)) {
            eligibleAdvisors.add(candidate);
        }
    }
    return eligibleAdvisors;
}

public static boolean canApply(Advisor advisor, Class<?> targetClass, boolean hasIntroductions) {
    if (advisor instanceof IntroductionAdvisor) {
        return ((IntroductionAdvisor) advisor).getClassFilter().matches(targetClass);
    }
    else if (advisor instanceof PointcutAdvisor) {
        PointcutAdvisor pca = (PointcutAdvisor) advisor;
        return canApply(pca.getPointcut(), targetClass, hasIntroductions);
    }
    else {
        // It doesn't have a pointcut so we assume it applies.
        return true;
    }
}

实现逻辑很简单，遍历全部的advisor调用canApply肯定是否匹配。

切面是有切入点和通知组成，切入点用来肯定哪些对象须要被加强，而通知决定如何进行加强。因此很明显这里肯定类对象是否匹配是由切入点(pointCut)决定的。

咱们先来看一下切入点是什么。

public interface Pointcut {
//类过滤器 用于肯定类对象是否匹配 只有当类对象匹配后才进行方法的匹配
ClassFilter getClassFilter();

//方法匹配器 用于肯定具体哪一些方法须要被加强。
MethodMatcher getMethodMatcher();
//生成一个pointcut对象实例
Pointcut TRUE = TruePointcut.INSTANCE;

}

上面咱们能够看到实际上就是经过ClassFilter和MethodMatcher相互配合来实现的，具体的实现过程会由于实现方式大同小异。其中实现方式包括好比正则匹配，AspectJ匹配等，在咱们以前的手写系列中就是经过正则来进行匹配的，这里匹配的实现不深刻探讨。

经过上面的逻辑即可以肯定好加强该类会用到哪些advisor。

#### createProxy
当肯定好须要用到的advisor和其顺序后就开始进行建立代理对象了。建立代理对象的方法由前面提到的```wrapIfNecessary```来调用```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());
}

建立实际上市代理经过代理工厂类(ProxyFactory)实现的。

##### JDK代理仍是cglib
在建立代理对象时须要肯定使用JDK代理仍是cglib代理，前面有提到过若是在配置文件中配置了```proxy-target-class="true"```的话那么就只会使用cglib进行代理。可是若是没有配置的话则须要经过实际状况来决定是JDK代理仍是cglib。

而除了```proxy-target-class```外，咱们实际上还能够配置一个属性```optimize```，该属性默认值为false，若是咱们将其置为true那么就表示容许spring对代理生成策略进行优化，意思就是若是该类有接口，就代理接口（使用JDK代理）；若是没有接口，就代理类（使用CGLIB代理）。而不是像若是只配置proxyTargetClass=true时强制代理类，而不去考虑代理接口的方式。

综上在spring中使用代理方式的策略以下：
- 若是没有配置```optimize```和```proxy-target-class```而且该类实现了接口，那么使用JDK动态代理。
- 若是没有配置```optimize```和```proxy-target-class```而且该类没有实现接口，那么使用cglib动态代理。
- 若是配置了```optimize```和```proxy-target-class```而且该类实现了接口，那么使用JDK动态代理。
- 若是配置了```optimize```和```proxy-target-class```而且该类没有实现接口，那么使用cglib动态代理。

实现代码以下：

public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
    if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
        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.");
        }
        if (targetClass.isInterface()) {
            return new JdkDynamicAopProxy(config);
        }
        return new ObjenesisCglibAopProxy(config);
    }
    else {
        return new JdkDynamicAopProxy(config);
    }
}

如今已经取到了建立代理对象的策略和目标对象，就能够直接建立代理对象了。若是对这放面有兴趣的能够自行搜索。

建立好代理对象以后使用代理对象替代以前建立好的对象，那么在使用的时候就会调用加强后的方法完成功能。

#### 多个advisor如何肯定顺序

在实际开发过程当中，可能会存在一个方法被多个advisor加强，可能有的在方法执行前加强有的在方法执行后进行加强。那么在spring中如何肯定每个加强方法的调用时机保证不会出问题的呢？

在手写aop系列中有讲过这个问题，当时咱们是经过[责任链模式](https://www.runoob.com/design-pattern/chain-of-responsibility-pattern.html)来解决这个问题。实际上spring中就是经过责任链模式来解决该问题的。

在```JdkDynamicAopProxy```的```invoke```方法中，会经过getInterceptorsAndDynamicInterceptionAdvice方法来获取加强当前调用方法的全部advisor的chain，可是须要注意的是这个chain并非根据实际应该的执行顺序排列的。仅仅只是全部会被执行的加强方法的集合。

List