Spring往期精彩文章

• Spring源码搭建
• Spring源码阅读一

前言

我们都知道Java是一门面向对象(OOP)的语言，所谓万物皆对象。但是它也存在着一些个弊端：当你需要给多个不具有继承关系的对象引入同一个公共的行为的时候，例如日志，安全检测等等，我们只能在每个对象中去引入这个公共行为，这样就产生了大量的重复代码，并且耦合度也会很高，不利于维护。正因如此就产生了面向切面(AOP)编程。可以说有了AOP使得面向对象更加完善，是对其的一个补充，AOP所关注的方式是横向的，不同于OOP的纵向，接下来我们详细讲解一下spring中的AOP。

AOP的使用

我们先从动态AOP开始

• 首先引入Aspect

  org.aspectj aspectjweaver 1.9.7

• 创建用于拦截的测试Bean

  package com.vipbbo.selfdemo.spring.aop.test;

  public class TestBean {
  private String message = "Test Message";

  public String getMessage() {
      return message;
  }
  
  public void setMessage(String message) {
      this.message = message;
  }
  
  public void test(){
      System.out.println(this.message);
  }

  }

• 创建Advisor

spring中一改以往摒弃了它最原始的繁杂的配置方式，目前采用@AspectJ注解的方式对POJO进行标注，使得AOP的工作大大简化。例如在AspectJTest类中，我们要做的就是在所有类的test方法执行前在控制台输出beforeTest，在所有类的test方法执行后打印afterTest，同时又使用环绕通知的方式在所有类的方法执行前后在此分别打印around……before和around……after

AspectJTest代码

@Aspect
public class AspectJTest {
    @Pointcut("execution(* *.test(..))")
    public void test(){

    }

    @Before("test()")
    public void beforeTest(){
        System.out.println("beforeTest");
    }

    @Around("test()")
    public Object aroundTest(ProceedingJoinPoint joinPoint){
        System.out.println("around.........before");
        Object proceed = null;
        try {
            proceed = joinPoint.proceed();
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
        System.out.println("around.........after");
        return proceed;
    }

    @After("test()")
    public void afterTest(){
        System.out.println("afterTest");
    }
}

• 创建配置文件

  
  http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd" >

  <!--开启AOP 自动配置-->
  <aop:aspectj-autoproxy/>
  <bean id="testBean" class="com.vipbbo.selfdemo.spring.aop.test.TestBean">
      <property name="message" value="一个苦逼的程序员"/>
  </bean>
  <bean id="aspect" class="com.vipbbo.selfdemo.spring.aop.test.AspectJTest"/>

在编写配置文件中要注意图中的声明、命名空间：

• 测试类

  public class Test {
  public static void main(String[] args) {
  ApplicationContext ac = new ClassPathXmlApplicationContext("spring-aop.xml");
  TestBean testBean = (TestBean) ac.getBean("testBean");
  testBean.test();
  }
  }

运行结果如下：

通过上述代码可以看出，Spring实现了对所有类的test方法进行了增强，使得辅助功能(日志等)可以独立出来，也做到了解耦和对程序的扩展。那么Spring是如何实现AOP的呢？实现我们知道，Spring是由一个配置文件控制是否支持注解的AOP，也就是<aop:aspectj-autoproxy/>，当配置文件有了这句声明的时候，Spring就会支持注解的AOP，那么分析从这里开始。

AOP自定义注解源码解读

我们知道Spring中的自定义注解，如果声明了自定义注解，那么在Spring中的一个地方一定注册了对应的解析器，我们从aspectj-autoProxy入手：

在Spring源码中全局搜索，我们发现了在包`org.springframework.aop.config`下的`AopNamespaceHandler`,然后我们打开这个类

在AopNamespaceHandler类中我们发现了这个init函数

public class AopNamespaceHandler extends NamespaceHandlerSupport {

    /**
     * Register the {@link BeanDefinitionParser BeanDefinitionParsers} for the
     * '{@code config}', '{@code spring-configured}', '{@code aspectj-autoproxy}'
     * and '{@code scoped-proxy}' tags.
     */
    @Override
    public void init() {
        // In 2.0 XSD as well as in 2.5+ XSDs
        registerBeanDefinitionParser("config", new ConfigBeanDefinitionParser());
        registerBeanDefinitionParser("aspectj-autoproxy", new AspectJAutoProxyBeanDefinitionParser());
        registerBeanDefinitionDecorator("scoped-proxy", new ScopedProxyBeanDefinitionDecorator());

        // Only in 2.0 XSD: moved to context namespace in 2.5+
        registerBeanDefinitionParser("spring-configured", new SpringConfiguredBeanDefinitionParser());
    }

}

从上述代码可以看出，在解析配置文件的时候，一旦遇到aspectj-autoproxy就会使用AspectJAutoProxyBeanDefinitionParser解析器进行解析，接下来我们该函数的具体实现：

注册AnnotationAwareAspectJAutoProxyCreator

所有的解析器都是对接口BeanDefinitionParser的实现，入口都是从parse函数开始的，AnnotationAwareAspectJAutoProxyCreator的parse函数如下：

• 看源码(具体实现在AspectJAutoProxyBeanDefinitionParser.class)

  @Override
  @Nullable
  public BeanDefinition parse(Element element, ParserContext parserContext) {
  // 注册AnnotationAwareAspectJAutoProxyCreator
  AopNamespaceUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(parserContext, element);
  // 对于注解中的子类进行处理
  extendBeanDefinition(element, parserContext);
  return null;
  }

从上述代码我们又看出具体实现逻辑是在registerAspectJAnnotationAutoProxyCreatorIfNecessary方法中实现的，继续进入到函数方法体内：

• 看源码(具体实现在AopNamespaceUtils.class)

  /**
  * 注册AnnotationAwareAspectJAutoProxyCreator
  * @param parserContext
  * @param sourceElement
  */
  public static void registerAspectJAnnotationAutoProxyCreatorIfNecessary(
  ParserContext parserContext, Element sourceElement) {

      // 注册或升级 AutoProxyCreator定义beanName为org.springframework.aop.config.internalAutoProxyCreator的BeanDefinition
      BeanDefinition beanDefinition = AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(
              parserContext.getRegistry(), parserContext.extractSource(sourceElement));
      // 对于proxy-target-class以及expose-proxy属性的处理
      useClassProxyingIfNecessary(parserContext.getRegistry(), sourceElement);
      // 注册组件并通知，便于监听器作进一步处理
    registerComponentIfNecessary(beanDefinition, parserContext);

  }

看上述源码可知在函数registerAspectJAnnotationAutoProxyCreatorIfNecessary中主要做了三件事，基本是每行代码做了一件。接下来我们一一解析：

函数体内的registerAspectJAnnotationAutoProxyCreatorIfNecessary 方法

注册或升级AnnotationAwareAspectJAutoProxyCreator

对于AOP的实现基本都是靠AnnotationAwareAspectJAutoProxyCreator来完成的，它可以根据@Pointcut注解定义的节点来自动代理相匹配的bean，但是为了配置简单，Spring使用了自动配置来帮我们自动注册AnnotationAwareAspectJAutoProxyCreator，其过程就是在这里实现的。我们继续跟进方法内部：

• 看源码(具体实现在AopConfigUtils.class)

  @Nullable
  public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(
  BeanDefinitionRegistry registry, @Nullable Object source) {

      return registerOrEscalateApcAsRequired(AnnotationAwareAspectJAutoProxyCreator.class, registry, source);
  }

在上面代码中我们看到了函数registerOrEscalateApcAsRequired继续跟进：

• 看源码(具体实现在AopConfigUtils.class)

  @Nullable
  private static BeanDefinition registerOrEscalateApcAsRequired(
  Class cls, BeanDefinitionRegistry registry, @Nullable 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) {
              // 改变bean最重要的就是改变bean所对应的className属性
              apcDefinition.setBeanClassName(cls.getName());
          }
      }
      return null;
  }
  
  // 注册BeanDefinition，Class为AnnotationAwareAspectJAutoProxyCreator.class,beanName为internalAutoProxyCreator
  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;</code></pre>
  }

    /**
     * The bean name of the internally managed auto-proxy creator.
     */
public static final String AUTO_PROXY_CREATOR_BEAN_NAME =
            "org.springframework.aop.config.internalAutoProxyCreator";

<aop:aspectj-autoproxy proxy-target-class="true"/>