Spring AOP 使用介绍，从前世到此生

时间 2019-11-17

标签 spring aop 使用介绍前世此生栏目 Spring 繁體版

原文原文链接

前面写过 Spring IOC 的源码分析，不少读者但愿能够出一个 Spring AOP 的源码分析，不过 Spring AOP 的源码仍是比较多的，写出来难免篇幅会大些。java

本文不介绍源码分析，而是介绍 Spring AOP 中的一些概念，以及它的各类配置方法，涵盖了 Spring AOP 发展到如今出现的所有 3 种配置方式。git

因为 Spring 强大的向后兼容性，实际代码中每每会出现不少配置混杂的状况，并且竟然还能工做，本文但愿帮助你们理清楚这些知识。github

本文使用的测试源码已上传到 Github: hongjiev/spring-aop-learning。web

AOP, AspectJ, Spring AOP

咱们先来把它们的概念和关系说说清楚。spring

AOP 要实现的是在咱们原来写的代码的基础上，进行必定的包装，如在方法执行前、方法返回后、方法抛出异常后等地方进行必定的拦截处理或者叫加强处理。express

AOP 的实现并非由于 Java 提供了什么神奇的钩子，能够把方法的几个生命周期告诉咱们，而是咱们要实现一个代理，实际运行的实例实际上是生成的代理类的实例。编程

做为 Java 开发者，咱们都很熟悉 AspectJ 这个词，甚至于咱们提到 AOP 的时候，想到的每每就是 AspectJ，即便你可能不太懂它是怎么工做的。这里，咱们把 AspectJ 和 Spring AOP 作个简单的对比：bash

Spring AOP：app

它基于动态代理来实现。默认地，若是使用接口的，用 JDK 提供的动态代理实现，若是没有接口，使用 CGLIB 实现。你们必定要明白背后的意思，包括何时会不用 JDK 提供的动态代理，而用 CGLIB 实现。eclipse
Spring 3.2 之后，spring-core 直接就把 CGLIB 和 ASM 的源码包括进来了，这也是为何咱们不须要显式引入这两个依赖
Spring 的 IOC 容器和 AOP 都很重要，Spring AOP 须要依赖于 IOC 容器来管理。
若是你是 web 开发者，有些时候，你可能须要的是一个 Filter 或一个 Interceptor，而不必定是 AOP。
Spring AOP 只能做用于 Spring 容器中的 Bean，它是使用纯粹的 Java 代码实现的，只能做用于 bean 的方法。
Spring 提供了 AspectJ 的支持，后面咱们会单独介绍怎么使用，通常来讲咱们用纯的 Spring AOP 就够了。
不少人会对比 Spring AOP 和 AspectJ 的性能，Spring AOP 是基于代理实现的，在容器启动的时候须要生成代理实例，在方法调用上也会增长栈的深度，使得 Spring AOP 的性能不如 AspectJ 那么好。

AspectJ：

AspectJ 出身也是名门，来自于 Eclipse 基金会，link：www.eclipse.org/aspectj

属于静态织入，它是经过修改代码来实现的，它的织入时机能够是：
- Compile-time weaving：编译期织入，如类 A 使用 AspectJ 添加了一个属性，类 B 引用了它，这个场景就须要编译期的时候就进行织入，不然无法编译类 B。
- Post-compile weaving：也就是已经生成了 .class 文件，或已经打成 jar 包了，这种状况咱们须要加强处理的话，就要用到编译后织入。
- Load-time weaving：指的是在加载类的时候进行织入，要实现这个时期的织入，有几种常见的方法。一、自定义类加载器来干这个，这个应该是最容易想到的办法，在被织入类加载到 JVM 前去对它进行加载，这样就能够在加载的时候定义行为了。二、在 JVM 启动的时候指定 AspectJ 提供的 agent：-javaagent:xxx/xxx/aspectjweaver.jar。

AspectJ 能干不少 Spring AOP 干不了的事情，它是 AOP 编程的彻底解决方案。Spring AOP 致力于解决的是企业级开发中最广泛的 AOP 需求（方法织入），而不是力求成为一个像 AspectJ 同样的 AOP 编程彻底解决方案。
由于 AspectJ 在实际代码运行前完成了织入，因此你们会说它生成的类是没有额外运行时开销的。
很快我会专门写一篇文章介绍 AspectJ 的使用，以及怎么在 Spring 应用中使用 AspectJ。

AOP 术语解释

在这里，不许备解释那么多 AOP 编程中的术语了，咱们碰到一个说一个吧。

Advice、Advisor、Pointcut、Aspect、Joinpoint 等等。

Spring AOP

首先要说明的是，这里介绍的 Spring AOP 是纯的 Spring 代码，和 AspectJ 没什么关系，可是 Spring 延用了 AspectJ 中的概念，包括使用了 AspectJ 提供的 jar 包中的注解，可是不依赖于其实现功能。

后面介绍的如 @Aspect、@Pointcut、@Before、@After 等注解都是来自于 AspectJ，可是功能的实现是纯 Spring AOP 本身实现的。

下面咱们来介绍 Spring AOP 的使用方法，先从最简单的配置方式开始提及，这样读者想看源码也会比较容易。

目前 Spring AOP 一共有三种配置方式，Spring 作到了很好地向下兼容，因此你们能够放心使用。

Spring 1.2 基于接口的配置：最先的 Spring AOP 是彻底基于几个接口的，想看源码的同窗能够从这里起步。
Spring 2.0 schema-based 配置：Spring 2.0 之后使用 XML 的方式来配置，使用命名空间 <aop />
Spring 2.0 @AspectJ 配置：使用注解的方式来配置，这种方式感受是最方便的，还有，这里虽然叫作 @AspectJ，可是这个和 AspectJ 其实没啥关系。

Spring 1.2 中的配置

这节咱们将介绍 Spring 1.2 中的配置，这是最古老的配置，可是因为 Spring 提供了很好的向后兼容，以及不少人根本不知道什么配置是什么版本的，以及是否有更新更好的配置方法替代，因此仍是会有不少代码是采用这种古老的配置方式的，这里说的古老并无贬义的意思。

下面用一个简单的例子来演示怎么使用 Spring 1.2 的配置方式。

首先，咱们先定义两个接口 UserService 和 OrderService，以及它们的实现类 UserServiceImpl 和 OrderServiceImpl：

接下来，咱们定义两个 advice，分别用于拦截方法执行前和方法返回后：

advice 是咱们接触的第一个概念，记住它是干什么用的。

上面的两个 Advice 分别用于方法调用前输出参数和方法调用后输出结果。

如今能够开始配置了，咱们配置一个名为 spring_1_2.xml 的文件：

接下来，咱们跑起来看看：

查看输出结果：

准备执行方法: createUser, 参数列表：[Tom, Cruise, 55]
方法返回：User{firstName='Tom', lastName='Cruise', age=55, address='null'}
准备执行方法: queryUser, 参数列表：[]
方法返回：User{firstName='Tom', lastName='Cruise', age=55, address='null'}
复制代码

从结果能够看到，对 UserService 中的两个方法都作了前、后拦截。这个例子理解起来应该很是简单，就是一个代理实现。

代理模式须要一个接口、一个具体实现类，而后就是定义一个代理类，用来包装实现类，添加自定义逻辑，在使用的时候，须要用代理类来生成实例。

此中方法有个致命的问题，若是咱们须要拦截 OrderService 中的方法，那么咱们还须要定义一个 OrderService 的代理。若是还要拦截 PostService，得定义一个 PostService 的代理......

并且，咱们看到，咱们的拦截器的粒度只控制到了类级别，类中全部的方法都进行了拦截。接下来，咱们看看怎么样只拦截特定的方法。

在上面的配置中，配置拦截器的时候，interceptorNames 除了指定为 Advice，是还能够指定为 Interceptor 和 Advisor 的。

这里咱们来理解 Advisor 的概念，它也比较简单，它内部须要指定一个 Advice，Advisor 决定该拦截哪些方法，拦截后须要完成的工做仍是内部的 Advice 来作。

它有好几个实现类，这里咱们使用实现类 NameMatchMethodPointcutAdvisor 来演示，从名字上就能够看出来，它须要咱们给它提供方法名字，这样符合该配置的方法才会作拦截。

咱们能够看到，userServiceProxy 这个 bean 配置了一个 advisor，advisor 内部有一个 advice。advisor 负责匹配方法，内部的 advice 负责实现方法包装。

注意，这里的 mappedNames 配置是能够指定多个的，用逗号分隔，能够是不一样类中的方法。相比直接指定 advice，advisor 实现了更细粒度的控制，由于在这里配置 advice 的话，全部方法都会被拦截。

输出结果以下，只有 createUser 方法被拦截：

准备执行方法: createUser, 参数列表：[Tom, Cruise, 55]
复制代码

到这里，咱们已经了解了 Advice 和 Advisor 了，前面也说了还能够配置 Interceptor。

对于 Java 开发者来讲，对 Interceptor 这个概念确定都很熟悉了，这里就不作演示了，贴一下实现代码：

public class DebugInterceptor implements MethodInterceptor {

    public Object invoke(MethodInvocation invocation) throws Throwable {
        System.out.println("Before: invocation=[" + invocation + "]");
        // 执行 真实实现类 的方法
        Object rval = invocation.proceed();
        System.out.println("Invocation returned");
        return rval;
    }
}
复制代码

上面，咱们介绍完了 Advice、Advisor、Interceptor 三个概念，相信你们应该很容易就看懂它们了。

它们有个共同的问题，那就是咱们得为每一个 bean 都配置一个代理，以后获取 bean 的时候须要获取这个代理类的 bean 实例（如 (UserService) context.getBean("userServiceProxy")），这显然很是不方便，不利于咱们以后要使用的自动根据类型注入。下面介绍 autoproxy 的解决方案。

autoproxy：从名字咱们也能够看出来，它是实现自动代理，也就是说当 Spring 发现一个 bean 须要被切面织入的时候，Spring 会自动生成这个 bean 的一个代理来拦截方法的执行，确保定义的切面能被执行。

这里强调自动，也就是说 Spring 会自动作这件事，而不用像前面介绍的，咱们须要显式地指定代理类的 bean。

咱们去掉原来的 ProxyFactoryBean 的配置，改成使用 BeanNameAutoProxyCreator 来配置：

配置很简单，beanNames 中可使用正则来匹配 bean 的名字。这样配置出来之后，userServiceBeforeAdvice 和 userServiceAfterAdvice 这两个拦截器就不只仅能够做用于 UserServiceImpl 了，也能够做用于 OrderServiceImpl、PostServiceImpl、ArticleServiceImpl......等等，也就是说再也不是配置某个 bean 的代理了。

注意，这里的 InterceptorNames 和前面同样，也是能够配置成 Advisor 和 Interceptor 的。

而后咱们修改下使用的地方：

发现没有，咱们在使用的时候，彻底不须要关心代理了，直接使用原来的类型就能够了，这是很是方便的。

输出结果就是 OrderService 和 UserService 中的每一个方法都获得了拦截：

准备执行方法: createUser, 参数列表：[Tom, Cruise, 55]
方法返回：User{firstName='Tom', lastName='Cruise', age=55, address='null'}
准备执行方法: queryUser, 参数列表：[]
方法返回：User{firstName='Tom', lastName='Cruise', age=55, address='null'}
准备执行方法: createOrder, 参数列表：[Leo, 随便买点什么]
方法返回：Order{username='Leo', product='随便买点什么'}
准备执行方法: queryOrder, 参数列表：[Leo]
方法返回：Order{username='Leo', product='随便买点什么'}
复制代码

到这里，是否是发现 BeanNameAutoProxyCreator 很是好用，它须要指定被拦截类名的模式(如 *ServiceImpl)，它能够配置屡次，这样就能够用来匹配不一样模式的类了。

另外，在 BeanNameAutoProxyCreator 同一个包中，还有一个很是有用的类 DefaultAdvisorAutoProxyCreator，比上面的 BeanNameAutoProxyCreator 还要方便。

以前咱们说过，advisor 内部包装了 advice，advisor 负责决定拦截哪些方法，内部 advice 定义拦截后的逻辑。因此，仔细想一想其实就是只要让咱们的 advisor 全局生效就能实现咱们须要的自定义拦截功能、拦截后的逻辑处理。

BeanNameAutoProxyCreator 是本身匹配方法，而后交由内部配置 advice 来拦截处理；

而 DefaultAdvisorAutoProxyCreator 是让 ioc 容器中的全部 advisor 来匹配方法，advisor 内部都是有 advice 的，让它们内部的 advice 来执行拦截处理。

一、咱们须要再回头看下 Advisor 的配置，上面咱们用了 NameMatchMethodPointcutAdvisor 这个类：

<bean id="logCreateAdvisor" class="org.springframework.aop.support.NameMatchMethodPointcutAdvisor">
    <property name="advice" ref="logArgsAdvice" />
    <property name="mappedNames" value="createUser,createOrder" />
</bean>
复制代码

其实 Advisor 还有一个更加灵活的实现类 RegexpMethodPointcutAdvisor，它能实现正则匹配，如：

<bean id="logArgsAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
    <property name="advice" ref="logArgsAdvice" />
    <property name="pattern" value="com.javadoop.*.service.*.create.*" />
</bean>
复制代码

也就是说，咱们能经过配置 Advisor，精肯定位到须要被拦截的方法，而后使用内部的 Advice 执行逻辑处理。

二、以后，咱们须要配置 DefaultAdvisorAutoProxyCreator，它的配置很是简单，直接使用下面这段配置就能够了，它就会使得全部的 Advisor 自动生效，无须其余配置。

<bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator" />
复制代码

而后咱们运行一下：

输出：

准备执行方法: createUser, 参数列表：[Tom, Cruise, 55]
方法返回：User{firstName='Tom', lastName='Cruise', age=55, address='null'}
准备执行方法: createOrder, 参数列表：[Leo, 随便买点什么]
方法返回：Order{username='Leo', product='随便买点什么'}
复制代码

从结果能够看出，create

方法使用了 logArgsAdvisor 进行传参输出，query

方法使用了 logResultAdvisor 进行了返回结果输出。

到这里，Spring 1.2 的配置就要介绍完了。本文不会介绍得面面俱到，主要是关注最核心的配置，若是读者感兴趣，要学会本身去摸索，好比这里的 Advisor 就不仅有我这里介绍的 NameMatchMethodPointcutAdvisor 和 RegexpMethodPointcutAdvisor，AutoProxyCreator 也不只仅是 BeanNameAutoProxyCreator 和 DefaultAdvisorAutoProxyCreator。

读到这里，我想对于不少人来讲，就知道怎么去阅读 Spring AOP 源码了。

Spring 2.0 @AspectJ 配置

Spring 2.0 之后，引入了 @AspectJ 和 Schema-based 的两种配置方式，咱们先来介绍 @AspectJ 的配置方式，以后咱们再来看使用 xml 的配置方式。

注意了，@AspectJ 和 AspectJ 没多大关系，并非说基于 AspectJ 实现的，而仅仅是使用了 AspectJ 中的概念，包括使用的注解也是直接来自于 AspectJ 的包。

首先，咱们须要依赖 aspectjweaver.jar 这个包，这个包来自于 AspectJ：

<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.8.11</version>
</dependency>
复制代码

若是是使用 Spring Boot 的话，添加如下依赖便可：

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-aop</artifactId>
</dependency>
复制代码

在 @AspectJ 的配置方式中，之因此要引入 aspectjweaver 并非由于咱们须要使用 AspectJ 的处理功能，而是由于 Spring 使用了 AspectJ 提供的一些注解，实际上仍是纯的 Spring AOP 代码。

说了这么多，明确一点，@AspectJ 采用注解的方式来配置使用 Spring AOP。

首先，咱们须要开启 @AspectJ 的注解配置方式，有两种方式：

一、在 xml 中配置：

<aop:aspectj-autoproxy/>
复制代码

使用 @EnableAspectJAutoProxy

@Configuration
@EnableAspectJAutoProxy
public class AppConfig {

}
复制代码

一旦开启了上面的配置，那么全部使用 @Aspect 注解的 bean 都会被 Spring 当作用来实现 AOP 的配置类，咱们称之为一个 Aspect。

注意了，@Aspect 注解要做用在 bean 上面，无论是使用 @Component 等注解方式，仍是在 xml 中配置 bean，首先它须要是一个 bean。

好比下面这个 bean，它的类名上使用了 @Aspect，它就会被当作 Spring AOP 的配置。

<bean id="myAspect" class="org.xyz.NotVeryUsefulAspect">
    <!-- configure properties of aspect here as normal -->
</bean>
复制代码

package org.xyz;
import org.aspectj.lang.annotation.Aspect;

@Aspect
public class NotVeryUsefulAspect {

}
复制代码

接下来，咱们须要关心的是 @Aspect 注解的 bean 中，咱们须要配置哪些内容。

首先，咱们须要配置 Pointcut，Pointcut 在大部分地方被翻译成切点，用于定义哪些方法须要被加强或者说须要被拦截，有点相似于以前介绍的 Advisor 的方法匹配。

Spring AOP 只支持 bean 中的方法（不像 AspectJ 那么强大），因此咱们能够认为 Pointcut 就是用来匹配 Spring 容器中的全部 bean 的方法的。

@Pointcut("execution(* transfer(..))")// the pointcut expression
private void anyOldTransfer() {}// the pointcut signature
复制代码

咱们看到，@Pointcut 中使用了 execution 来正则匹配方法签名，这也是最经常使用的，除了 execution，咱们再看看其余的几个比较经常使用的匹配方式：

within：指定所在类或所在包下面的方法（Spring AOP 独有）

如 @Pointcut("within(com.javadoop.springaoplearning.service..*)")
@annotation：方法上具备特定的注解，如 @Subscribe 用于订阅特定的事件。

如 @Pointcut("execution(

.*(..)) && @annotation(com.javadoop.annotation.Subscribe)")
bean(idOrNameOfBean)：匹配 bean 的名字（Spring AOP 独有）

如 @Pointcut("bean(*Service)")

Tips：上面匹配中，一般 "." 表明一个包名，".." 表明包及其子包，方法参数任意匹配使用两个点 ".."。

对于 web 开发者，Spring 有个很好的建议，就是定义一个 SystemArchitecture：

@Aspect
public class SystemArchitecture {

    // web 层
    @Pointcut("within(com.javadoop.web..*)")
    public void inWebLayer() {}

    // service 层
    @Pointcut("within(com.javadoop.service..*)")
    public void inServiceLayer() {}

    // dao 层
    @Pointcut("within(com.javadoop.dao..*)")
    public void inDataAccessLayer() {}

    // service 实现，注意这里指的是方法实现，其实一般也可使用 bean(*ServiceImpl)
    @Pointcut("execution(* com.javadoop..service.*.*(..))")
    public void businessService() {}

    // dao 实现
    @Pointcut("execution(* com.javadoop.dao.*.*(..))")
    public void dataAccessOperation() {}
}
复制代码

上面这个 SystemArchitecture 很好理解，该 Aspect 定义了一堆的 Pointcut，随后在任何须要 Pointcut 的地方均可以直接引用（如 xml 中的 pointcut-ref=""）。

配置 pointcut 就是配置咱们须要拦截哪些方法，接下来，咱们要配置须要对这些被拦截的方法作什么，也就是前面介绍的 Advice。

接下来，咱们要配置 Advice。

下面这块代码示例了各类经常使用的状况：

注意，实际写代码的时候，不要把全部的切面都揉在一个 class 中。

@Aspect
public class AdviceExample {

    // 这里会用到咱们前面说的 SystemArchitecture
    // 下面方法就是写拦截 "dao层实现"
    @Before("com.javadoop.aop.SystemArchitecture.dataAccessOperation()")
    public void doAccessCheck() {
        // ... 实现代码
    }

    // 固然，咱们也能够直接"内联"Pointcut，直接在这里定义 Pointcut
    // 把 Advice 和 Pointcut 合在一块儿了，可是这两个概念咱们仍是要区分清楚的
    @Before("execution(* com.javadoop.dao.*.*(..))")
    public void doAccessCheck() {
        // ... 实现代码
    }

    @AfterReturning("com.javadoop.aop.SystemArchitecture.dataAccessOperation()")
    public void doAccessCheck() {
        // ...
    }

    @AfterReturning(
        pointcut="com.javadoop.aop.SystemArchitecture.dataAccessOperation()",
        returning="retVal")
    public void doAccessCheck(Object retVal) {
        // 这样，进来这个方法的处理时候，retVal 就是相应方法的返回值，是否是很是方便
        //  ... 实现代码
    }

    // 异常返回
    @AfterThrowing("com.javadoop.aop.SystemArchitecture.dataAccessOperation()")
    public void doRecoveryActions() {
        // ... 实现代码
    }

    @AfterThrowing(
        pointcut="com.javadoop.aop.SystemArchitecture.dataAccessOperation()",
        throwing="ex")
    public void doRecoveryActions(DataAccessException ex) {
        // ... 实现代码
    }

    // 注意理解它和 @AfterReturning 之间的区别，这里会拦截正常返回和异常的状况
    @After("com.javadoop.aop.SystemArchitecture.dataAccessOperation()")
    public void doReleaseLock() {
        // 一般就像 finally 块同样使用，用来释放资源。
        // 不管正常返回仍是异常退出，都会被拦截到
    }

    // 感受这个颇有用吧，既能作 @Before 的事情，也能够作 @AfterReturning 的事情
    @Around("com.javadoop.aop.SystemArchitecture.businessService()")
    public Object doBasicProfiling(ProceedingJoinPoint pjp) throws Throwable {
        // start stopwatch
        Object retVal = pjp.proceed();
        // stop stopwatch
        return retVal;
    }

}
复制代码

细心的读者可能发现了有些 Advice 缺乏方法传参，如在 @Before 场景中参数每每是很是有用的，好比咱们要用日志记录下来被拦截方法的入参状况。

Spring 提供了很是简单的获取入参的方法，使用 org.aspectj.lang.JoinPoint 做为 Advice 的第一个参数便可，如：

@Before("com.javadoop.springaoplearning.aop_spring_2_aspectj.SystemArchitecture.businessService()")
public void logArgs(JoinPoint joinPoint) {
    System.out.println("方法执行前，打印入参：" + Arrays.toString(joinPoint.getArgs()));
}
复制代码

注意：第一，必须放置在第一个参数上；第二，若是是 @Around，咱们一般会使用其子类 ProceedingJoinPoint，由于它有 procceed()/procceed(args[]) 方法。

到这里，咱们介绍完了 @AspectJ 配置方式中的 Pointcut 和 Advice 的配置。对于开发者来讲，其实最重要的就是这两个了，定义 Pointcut 和使用合适的 Advice 在各个 Pointcut 上。

下面，咱们用这一节介绍的 @AspectJ 来实现上一节实现的记录方法传参和记录方法返回值。

xml 的配置很是简单：

这里是示例，因此 bean 的配置仍是使用了 xml 的配置方式。

测试一下：

输出结果：

方法执行前，打印入参：[Tom, Cruise, 55]
User{firstName='Tom', lastName='Cruise', age=55, address='null'}
方法执行前，打印入参：[]
User{firstName='Tom', lastName='Cruise', age=55, address='null'}
复制代码

JoinPoint 除了 getArgs() 外还有一些有用的方法，你们能够进去稍微看一眼。

最后提一点，@Aspect 中的配置不会做用于使用 @Aspect 注解的 bean。

Spring 2.0 schema-based 配置

本节将介绍的是 Spring 2.0 之后提供的基于 <aop /> 命名空间的 XML 配置。这里说的 schema-based 就是指基于 aop这个 schema。

介绍 IOC 的时候也介绍过 Spring 是怎么解析各个命名空间的（各类 *NamespaceHandler），解析 <aop /> 的源码在 org.springframework.aop.config.AopNamespaceHandler 中。

有了前面的 @AspectJ 的配置方式的知识，理解 xml 方式的配置很是简单，因此咱们就能够废话少一点了。

这里先介绍配置 Aspect，便于后续理解：

<aop:config>
    <aop:aspect id="myAspect" ref="aBean">
        ...
    </aop:aspect>
</aop:config>

<bean id="aBean" class="...">
    ...
</bean>
复制代码

全部的配置都在 <aop:config> 下面。

<aop:aspect > 中须要指定一个 bean，和前面介绍的 LogArgsAspect 和 LogResultAspect 同样，咱们知道该 bean 中咱们须要写处理代码。

而后，咱们写好 Aspect 代码后，将其“织入”到合适的 Pointcut 中，这就是面向切面。

而后，咱们须要配置 Pointcut，很是简单，以下：

<aop:config>

    <aop:pointcut id="businessService"
        expression="execution(* com.javadoop.springaoplearning.service.*.*(..))"/>

    <!--也能够像下面这样-->
    <aop:pointcut id="businessService2"
        expression="com.javadoop.SystemArchitecture.businessService()"/>

</aop:config>
复制代码

将 <aop:pointcut> 做为 <aop:config> 的直接子元素，将做为全局 Pointcut。

咱们也能够在 <aop:aspect />内部配置 Pointcut，这样该 Pointcut 仅用于该 Aspect：

<aop:config>
    <aop:aspect ref="logArgsAspect">
        <aop:pointcut id="internalPointcut"
                expression="com.javadoop.SystemArchitecture.businessService()" />
    </aop:aspect>
</aop:config>
复制代码

接下来，咱们应该配置 Advice 了，为了不废话过多，咱们直接上实例吧，很是好理解，将上一节用 @AspectJ 方式配置的搬过来：

上面的例子中，咱们配置了两个 LogArgsAspect 和一个 LogResultAspect。

其实基于 XML 的配置也是很是灵活的，这里没办法给你们演示各类搭配，你们抓住基本的 Pointcut、Advice 和 Aspect 这几个概念，就很容易配置了。

小结

到这里，本文介绍了 Spring AOP 的三种配置方式，咱们要知道的是，到目前为止，咱们使用的都是 Spring AOP，和 AspectJ 没什么关系。

下一篇文章，将会介绍 AspectJ 的使用方式，以及怎样在 Spring 应用中使用 AspectJ。以后差很少就能够出 Spring AOP 源码分析了。

附录

本文使用的测试源码已上传到 Github: hongjiev/spring-aop-learning。

建议读者 clone 下来之后，经过命令行进行测试，而不是依赖于 IDE，由于 IDE 太"智能"了：

mvn clean package
java -jar target/spring-aop-learning-1.0-jar-with-dependencies.jar

pom.xml 中配置了 assembly 插件，打包的时候会将全部 jar 包依赖打到一块儿。
修改 Application.java 中的代码，或者其余代码，而后重复 1 和 2

（全文完）