Spring基本用法7——AOP的支持(一) 博客分类： Spring SpringAOP架构Web三大框架
前言：AOP，也就是面向切面编程，作为面向切面编程的一种补充，已经比较成熟，如果是OOP是从静态角度考虑程序结构，那么AOP则是从动态角度考虑程序运行。本文旨在介绍Spring对AOP的支持，简述其用法。
本篇文章重点关注以下问题：
- AOP的使用场景
- AOP的基本概念
- Spring对AOP的支持
1. AOP的使用场景
AOP 广泛应用于处理一些具有横切性质的系统级服务，何为横切性质？可以把它理解为各业务流程共有的模块，如下图所示：
日志服务、安全服务就属于横切性质的系统级服务，此服务为各业务流程都需要的服务。常规以OOP方式讲，需要实现上图的功能，各业务流程需要三段完全相似的方法段，如下图所示：
很明显，此方法较low，若果哪天需要切换安全策略，或是修改日志记录细节，就需要维护多处代码(成千上百处)，这是非常令人沮丧的事。AOP就是为弥补OOP处理这些问题而生的，如下图所示：
通过抽象分析出各模块、各方法的交叉关注点，将其抽离出来在一处处理，这种方式无疑非常优雅，维护起来也很方便。
2. AOP基本概念
AOP从程序运行角度考虑程序的流程，提取业务处理过程的切面。Aop面向的是程序运行中的各个步骤，希望以更好的方式来组合业务处理的各个步骤。先来简单介绍下关于面向切面编程的一些术语：
- 切面(Aspect)：切面用于组织多个Advice，Advice放在切面中定义；
- 连接点(Joinpoint)：程序执行过程中明确的点，如方法的调用，或异常的抛出。在SpringAOP中，连接点总是方法的调用；
- 增强处理(Advice)：AOP框架在特定的切入点执行的增强处理。如“around”、“before”等
- 切入点(Pointcut)：可以插入增加处理的连接点。简言之，当某个连接点满足指定要求时，该连接点将被添加增强处理，该连接点也就变成了切入点。
- 引入：将方法或字段添加到被处理的类中。(比如，可以使用一个引入，是任何对象实现isModified接口)
- 目标对象：被AOP框架进行增强处理的对象，也被称为被增强对象。
- AOP代理：AOP框架创建的对象，简单的说，代理就是对目标对象的加强。
- 织入(Weaving)：将增强处理添加到目标对象中，并创建一个被增强的对象(AOP代理)的过程。
3. Spring对AOP的支持
Spring中的AOP代理由Spring的IOC容器负责生成、管理，其依赖关系也由IOC容器负责管理。因此，AOP代理可以直接使用容器中的其他Bean实例作为目标，这种关系可由IOC容器的依赖注入提供。Spring默认使用Java动态代理来创建AOP代理，这样就可以为任何接口实例创建代理了。(也支持cglib)
通过分析上面AOP相关概念，不难发现，如果不深入研究AOP实现原理，只是单纯使用AOP进行开发是件很简单的事情。纵观AOP编程，其中需要程序员参与的只有三部分：
- 定义普通业业务组件
- 定义切入点，一个切入点可能横切多个业务组件
- 定义增强处理，增强处理就是在AOP框架为普通业务组件织入的处理动作。
3.1 准备配置环境
测试项目目录如下图：
3.1.1 首先准备XML配置文件
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.3.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">
<!-- 指定自动搜索Bean组件、自动搜索切面类 -->
<context:component-scan base-package="com.wj.chapter6.aop">
<context:include-filter type="annotation" expression="org.aspectj.lang.annotation.Aspect"/>
</context:component-scan>
<!-- 启动@AspectJ支持 -->
<aop:aspectj-autoproxy/>
</beans>
说明：
- <aop:aspectj-autoproxy/>用来启动Spring对@AspectJ的支持
- 有关<context:component-scan>使用说明可参考http://super-wangj.iteye.com/blog/2387655
3.1.2 准备业务环境
接口+实现，业务相关接口就不上代码了，可以通过附件查看，下面是业务实现类：
AddService：
package com.wj.chapter6.aop.service;
import org.springframework.stereotype.Component;
@Component("addService")
public class AddService implements IAddService {
@Override
public boolean addUser(String name , String pass){
System.out.println("【AddService.addUser】添加用户：" + name);
return true;
}
@Override
public void addProduct(String name) {
System.out.println("【AddService.addProduct】添加商品：" + name);
}
@Override
public void addException() {
throw new NullPointerException();
}
}
DeleteService：
package com.wj.chapter6.aop.service;
import org.springframework.stereotype.Component;
@Component("deleteService")
public class DeleteService implements IDeleteService {
@Override
public void deleteProduct(String name) {
System.out.println("【DeleteService.deleteProduct】删除商品：" + name);
}
@Override
public boolean deleteUser(String name) {
System.out.println("【DeleteService.deleteUser】删除用户：" + name);
return true;
}
}
TxService：
package com.wj.chapter6.aop.service;
import org.springframework.stereotype.Component;
/**
* 测试Around增强, 为当前加法运算添加事物
*/
@Component
public class TxService implements ITxService {
@Override
public int add(int arg1, int arg2) {
int result = arg1 + arg2;
System.out.println("【TxService.add】加法运算结果应该是：" + result);
return result;
}
}
3.2 before增强处理
before增强处理：在目标方法(Target)执行之前织入增强处理(Advice)。在一个切面类里使用@Before来修饰一个方法时，该方法将作为Before增强处理。使用@Before修饰时，通常需要指定一个value属性值，作为切入点表达式，用于指定该增强处理将被织入哪些切入点。下面java类中定义了一个before增强处理：
package com.wj.chapter6.aop.aspect;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
/**
* 定义一个切面，验证before增强
*/
@Aspect
public class AuthAspect {
// 匹配com.wj.chapter6.aop.service包下所有类的、
// 所有方法的执行作为切入点
@Before("execution(* com.wj.chapter6.aop.service.*.*(..))")
public void authority() {
System.out.println("【before增强】模拟执行权限检查");
}
}
@Aspect修饰了AuthAspect类，表面这个类是一个切面类，在切面类中定义了一个AuthAspect方法，这个方法本来并不特殊之处，但因使用了@Before来标注，这就将该方法换成了一个before增强处理。
@Before注解直接指定了切入点表达式，指定匹配wj.chapter6.aop.service包下的所有类的所有方法的执行作为切入点。测试代码最后给出。
3.3 AfterReturning增强处理
AfterReturning增强处理：增强处理将在目标方法正常完成后被织入。其可指定两个参数：
- pointcut/value：指定该切入点表达式(pointcut会覆盖value属性值)
- returning：该属性指定一个形参名，用于表示Advice方法中可定义与此同名的形参，该形参可用于访问目标方法的返回值。同时，在Advice方法中定义该形参时指定类型，会限制目标方法返回指定类型的值或没有返回值。
package com.wj.chapter6.aop.aspect;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
/**
* 定义一个切面，验证@AfterReturning增强
*/
@Aspect
public class LogAspect {
// 匹配com.wj.chapter6.aop.service包下所有类的、
// 所有方法的执行作为切入点
@AfterReturning(returning="rvt" , pointcut="execution(* com.wj.chapter6.aop.service.*.*(..))")
// 声明rvt时指定的类型会限制目标方法必须返回指定类型的值或没有返回值
// 此处将rvt的类型声明为Object，意味着对目标方法的返回值不加限制
public void log(Object rvt) {
System.out.println("【AfterReturning增强】模拟记录日志功能, 获取目标方法返回值:" + rvt);
}
}
使用@AfterReturning注解时，指定了一个returning属性，该属性值为rvt，这表面允许在Advice方法(log())中定义名为rvt的形参，程序可通过rvt形参来访问目标方法的返回值。(虽然可以访问到返回值，但是不能改变返回值)
3.4 After增强处理
After增强处理：与AfterReturning增强处理类似，但也有区别：
- AfterReturning增强处理只有在目标方法成功完成后才会被织入；
- After增强处理不管目标方法如何结束(成功完成或是异常终止)，它都会被织入。
package com.wj.chapter6.aop.aspect;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
/**
* 定义一个切面，验证After增强
*/
@Aspect
public class ReleaseAspect {
@After("execution(* com.wj.chapter6.aop.service.*.*(..))")
public void release() {
System.out.println("【After增强】模拟方法结束后的释放资源...");
}
}
其实，After增强处理的作用非常类似于异常处理中的finally块的作用——无论如何，它总会在方法执行结束之后被织入，因此特别适合用于资源回收。
3.5 Around增强处理
Around增强处理：功能较为强大，近似等于Before增强和AfterReturning增强处理的总和，Around增强处理既可在执行目标方法之前织入增强动作，也可在执行目标方法之后织入增强动作。此外，Around增强处理可以决定目标方法在什么时候执行，如何执行，甚至完全阻止目标方法的执行。Around增强处理也可以改变目标方法的参数值，也可以改变执行目标方法之后的返回值。(功能虽强大，但必须在线程安全的环境下使用)
下面定义一个Around增强处理：
package com.wj.chapter6.aop.aspect;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
/**
* 定义一个切面，验证Around增强
*/
@Aspect
public class TxAspect {
// 匹配com.wj.chapter6.aop.service包下TxService类的所有方法的执行作为切入点
@Around("execution(* com.wj.chapter6.aop.service.TxService.*(..))")
public Object processTx(ProceedingJoinPoint jp) throws java.lang.Throwable {
System.out.println("【Around增强】执行目标方法之前，模拟开始事务...");
Object rvt = jp.proceed(jp.getArgs());
System.out.println("【Around增强】执行目标方法之后，模拟结束事务...");
return rvt;
}
}
与其他增强处理不同的是，该方法的第一个形参必须是ProceedingJoinPoint类型(至少包含一个形参)，在增强处理方法体类，调用ProceedingJoinPoint参数的proceed()方法才会执行目标方法——这就是Around增强处理可以完全控制目标方法的执行时机、如何执行的关键。
调用ProceedingJoinPoint参数的proceed方法时，还可以传入一个Object[]对象作为参数，该数组中的值将被 传入目标方法作为执行方法的参数。
3.6 AfterThrowinf增强处理
AfterThrowing增强处理：主要用于处理程序中未处理的异常。使用@AfterThrowing注解时可置顶如下两个常用属性：
- pointcut/value：指定该切入点表达式(pointcut会覆盖value属性值)
- returning：该属性指定一个形参名，用于表示Advice方法中可定义与此同名的形参，该形参可用于访问目标方法抛出的异常。同时，在Advice方法中定义该形参时指定类型，会限制目标方法必须抛出指定类型的异常。
package com.wj.chapter6.aop.aspect;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect;
/**
* 定义一个切面，验证AfterThrowing增强
*/
@Aspect
public class RepairExAspect {
// 匹配com.wj.chapter6.aop.service包下所有类的、
// 以Exception结尾的方法的作为切入点
@AfterThrowing(throwing="ex" , pointcut="execution(* com.wj.chapter6.aop.service.*.*Exception(..))")
// 声明ex时指定的类型会限制目标方法必须抛出指定类型的异常
// 此处将ex的类型声明为Throwable，意味着对目标方法抛出的异常不加限制
public void doRecoveryActions(Throwable ex) {
System.out.println("【AfterThrowing增强】模拟Advice对异常的修复, 目标方法中抛出的异常:" + ex);
}
}
需要说明的是，AOP的AfterThrowing增强处理虽然可以对目标方法的异常进行处理，但这种异常处理与直接使用catch捕获不同——catch捕捉意味着完全处理该异常，如果catch块中没有重新抛出新异常，则该方法可以正常结束；而AfterThrowing处理虽然处理了该异常，但它不能完全处理该异常，该异常依然会传播到上一级调用者。
3.7 测试代码与结果
package com.wj.chapter6.aop;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.wj.chapter6.aop.service.IAddService;
import com.wj.chapter6.aop.service.IDeleteService;
import com.wj.chapter6.aop.service.ITxService;
public class BeanTest {
// 1.指明xml配置文件位置，便于Spring读取，从而知道Bean的相关信息
private static final String PATH_XML = "com/wj/chapter6/aop/applicationContext.xml";
@SuppressWarnings("resource")
public static void main(String[] args) {
// 2.根据xml配置文件，创建Spring IOC容器的上下文
ApplicationContext ctx = new ClassPathXmlApplicationContext(PATH_XML);
IAddService addService = ctx.getBean("addService" , IAddService.class);
IDeleteService deleteService = ctx.getBean("deleteService" , IDeleteService.class);
ITxService txService = ctx.getBean("txService" , ITxService.class);
addService.addUser("熊燕子", "123456");
System.out.println("---------------------- 方法调用分割线. -------------------- ");
addService.addProduct("小苹果");
System.out.println("---------------------- 方法调用分割线. -------------------- ");
deleteService.deleteUser("熊燕子");
System.out.println("---------------------- 方法调用分割线. -------------------- ");
try {
addService.addException();
} catch (NullPointerException e) {
/* 捕获抛出的空指针异常. */
/* AfterThrowing处理虽然处理了该异常，但它不能完全处理该异常，该异常依然会传播到上一级调用者. */
}
System.out.println("---------------------- 方法调用分割线. -------------------- ");
txService.add(3, 6);
}
}
测试结果为：
除此以外，SpringAOP还可以在切面中访问目标方法的参数，具体实现下一篇博文给出实现。
代码下载地址：链接：http://pan.baidu.com/s/1miNvWy0 密码：w75k
