Spring AOP高级——源码实现（2）Spring AOP中通知器（Advisor）与切面（Aspect）

本文例子完整源码地址：https://github.com/yu-linfeng/BlogRepositories/tree/master/repositories/Spring%20AOP%E9%AB%98%E7%BA%A7%E2%80%94%E2%80%94%E6%BA%90%E7%A0%81%E5%AE%9E%E7%8E%B0%EF%BC%882%EF%BC%89Spring%20AOP%E4%B8%AD%E9%80%9A%E7%9F%A5%E5%99%A8%EF%BC%88Advisor%EF%BC%89%E4%B8%8E%E5%88%87%E9%9D%A2%EF%BC%88Aspect%EF%BC%89

 

　　之所以还未正式进入Spring AOP的源码，是因为我在阅读Spring AOP生成代理对象时遇到了一点小麻烦让我不得不暂时停止，转而理清有关Spring AOP中的两个概念性问题。

　　前面的博客里都没有提到过“通知器”这个概念，在《Spring实战》书中也只是简单地说明了在xml中<aop:advisor>用于定义一个通知器，此后便没再说明，而是使用<aop:aspect>定义一个切面。而在《Spring技术内幕》中有关Spring AOP章节中则是介绍了AOP中三个概念：通知、切点、通知器。在这时，我对“通知器”产生了很大的疑惑，查阅了相关资料并没有满意的答案，于是决定自己一探究竟。

　　首先来讨论定义通知器相关的使用方法。 定义一个通知类，其中包含前置通知和后置通知，注意如果是使用<aop:advisor>定义通知器的方式实现AOP则需要通知类实现Advice接口，前置通知方法对应的是MethodBeforeAdvice，后置通知方法对应的是AfterReturningAdvice。

package com.demo;

import org.springframework.aop.AfterReturningAdvice;
import org.springframework.aop.MethodBeforeAdvice;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

/**
 * Created by Kevin on 2017/11/15.
 */
@Component("advisorTest")
public class AdvisorTest implements MethodBeforeAdvice, AfterReturningAdvice{

    /**
     * 前置通知
     * @param method
     * @param args
     * @param target
     * @throws Throwable
     */
    @Override
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println("前置通知");
    }

    /**
     * 后置通知
     * @param returnValue
     * @param method
     * @param args
     * @param target
     * @throws Throwable
     */
    @Override
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("后置通知");
    }
}

　　定义一个需要被代理的目标对象。

package com.demo;

import org.springframework.stereotype.Component;

/**
 * 目标对象，需要被代理的类及方法
 * Created by Kevin on 2017/11/15.
 */
@Component("testPoint")
public class TestPoint {

    public void test() {
        System.out.println("方法调用");
    }
}

　　我们要达到的目的就是在test方法调用前和调用后分别打印“前置通知”和“后置通知”。

　　applicationContext.xml中定义通知器如下：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">

    <context:component-scan base-package="com.demo"/>

    <aop:config>
        <aop:pointcut id="test" expression="execution(* com.demo.TestPoint.test())"/>
        <aop:advisor advice-ref="advisorTest" pointcut-ref="test"/>
    </aop:config>

</beans>

　　最后的运行结果符合预期。那么问题来了，如果我们只想在定义的这个切点 <aop:pointcut id="test" expression="execution(* com.demo.TestPoint.test())"/>里只配置前置通知，这个时候怎么办呢？答案是，通过以上方式是不可以的。也就是说如果通过定义Advisor的方式，在有的地方比较局限，狭隘来讲通过定义Advisor通知器的方式，只能定义只有一个通知和一个切入点的切面。当然一个通知不准确，因为上面可以看到只要实现不同的通知接口即可代理，但如果实现了多个通知接口，而只想使用一个时就不可以了。通知器是一个特殊的切面。

　　接着来讨论定义切面相关的使用方法。 如果使用<aop:aspect>定义切面的方式，通知类是可以不用实现任何通知接口的，这是很大一个便利。同样要实现上面例子的功能，定义一个通知类，包括前置通知和后置通知。

package com.demo;

import org.springframework.stereotype.Component;

/**
 * Created by Kevin on 2017/11/15.
 */
@Component("aspectTest")
public class AspectTest {

    /**
     * 前置通知
     */
    public void doBefore() {
        System.out.println("前置通知");
    }

    /**
     * 后置通知
     */
    public void doAfter() {
        System.out.println("后置通知");
    }
}

　　目标对象和上面的例子一致，紧接着是applicationContext.xml中切面的配置。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">

    <context:component-scan base-package="com.demo"/>

    <aop:config>
        <aop:aspect ref="aspectTest">
            <aop:pointcut id="test" expression="execution(* com.demo.TestPoint.test())"/>
            <aop:before method="doBefore" pointcut-ref="test"/>
            <aop:after-returning method="doAfter" pointcut-ref="test"/>
        </aop:aspect>
    </aop:config>
</beans>

　　可以看到我们通过<aop:aspect>定义了一个切面，如果只需要前置通知，则只定义<aop:before>就可以了，这和<aop:advisor>是很大的不同，由此可知通过<aop:aspect>定义切面的方式可以在其中灵活地定义通知，而不必像通知器那样约束。

　　实际上可以这么说，通知器是一个特殊的切面。而在最开始那两篇博客中没有提到是因为那两个例子中使用的是AspectJ注解，而在AspectJ注解中并没有与此对应的概念。

　　在实际中用到的<aop:advisor>场景最多的莫过于在Spring中配置事务。除此之外，很少用到，也不建议使用。因为最大的一个问题就是定义通知时需要实现通知接口，这违背了一点Spring“非侵入式”编程的初衷。

　　这篇博客穿插在源码的其中是为了更好的理清Spring AOP中各种概念问题，缘由我在开头已经说过，接下来就正式开始Spring AOP源码的解读。

 

 

这是一个能给程序员加buff的公众号