【Spring】2. AOP
1. AOP 概述
在软件开发领域，有一个非常重要规则就是 DRY（Don’t Repeat Yourself），意思就是不要写重复的代码。
传统的 OOP（面向对象编程）是纵向方向的思考方式，比如父类、子类、接口。而有的时候需要横向编程的思考方式。比如我们有一个系统，分为好多个模块，每个模块都负责处理一项重要的功能。但是每个模块都需要一些相似的辅助功能如安全、日志输出等等。这就是一种交叉业务，而这种“交叉”非常适合用AOP来解决。
AOP（Aspect Oriented Programming）：面向切面编程。它通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
2. AOP 底层原理
AOP底层采用的反射和动态代理机制。Spring 内部使用了两种代理机制：基于 JDK 的动态代理和基于 Cglib 的动态代理。
-
基于 JDK 的动态代理
要求被代理的类必须是接口的实现类
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class UserDaoProxy implements InvocationHandler{
private UserDao userDao; //被代理对象
private Enhancement em; //增强对象
public UserDaoProxy(UserDao userDao, Enhancement em) {
this.userDao = userDao;
this.em = em;
}
/**
* 代理
* @return
*/
public UserDao proxy() {
Object obj = Proxy.newProxyInstance(
getClass().getClassLoader(), //类加载器
userDao.getClass().getInterfaces(), //被代理对象所实现的接口
this //InvocationHandler对象
);
return (UserDao) obj;
}
/**
* 功能增强
*
* @param proxy 增强后对象
* @param method 被代理对象的方法
* @param args 被代理方法的参数
* @return Object 返回增强后对象
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//假设需求对delete方法增强
if (method.getName().equals("delete")) {
//前置增强
em.before();
//调用原始方法
method.invoke(userDao, args);
//后置增强
em.after();
} else {
//调用原始方法
method.invoke(userDao, args);
}
return proxy;
}
}
-
基于 Cglib 的动态代理
被代理的类可以不是接口的实现类。
import java.lang.reflect.Method;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
public class UserDaoProxy implements MethodInterceptor{
private UserDao userDao; //被代理对象
private Enhancement em; //增强对象
public UserDaoProxy(UserDao userDao, Enhancement em) {
this.userDao = userDao;
this.em = em;
}
/**
* 代理
* @return
*/
public UserDao proxy() {
//创建Cglib核心类对象
Enhancer enhancer = new Enhancer();
//设置父类（即被代理类）
enhancer.setSuperclass(userDao.getClass());
//设置回调,回调需要实现InvocationHandler接口
enhancer.setCallback(this);
//创建被代理对象
UserDao userDapProxy = (UserDao) enhancer.create();
return userDapProxy;
}
/**
*
* Object proxy 被代理对象
* Method method 被代理方法
* Object[] args 被代理方法参数
* MethodProxy methodProxy 代理后的方法
* @return Object 返回增强后对象
*/
@Override
public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
if (method.getName().equals("delete")) {
em.before(); //前置增强
Object ivs = methodProxy.invokeSuper(proxy, args);
em.after(); //后置增强
return ivs;
}
return methodProxy.invokeSuper(proxy, args);
}
}
3. 相关术语
-
Target(目标对象)：是指代理的目标对象
-
Joinpoint(连接点)：是指可以被拦截到的点。在 Spring 中指的是方法，Spring 只支持方法类型的连接点。
-
Pointcut(切入点)：是指实际被拦截的连接点
-
Aspect(切面)：是指增强功能的总和
-
Advice(通知/增强)：增强的具体功能
-
Weaving(织入)：是指把增强应用到目标对象来创建新的代理对象的过程。
4. AOP 的 xml 实现
4.1 导入 jar 包
AspectJ是一个面向切面的框架，它扩展了Java语言，AspectJ定义了AOP语法。Spring2.0以后增加了对AspectJ的支持。
4.2 在配置文件中引入aop约束
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
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/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">
beans>
4.3 创建 bean 对象并配置
<bean id="userdao" class="com.bodhixu.web.UserDaoImpl"/>
<bean id="asp" class="com.bodhixu.web.CustomAspect"/>
4.4 配置aop
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
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/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">
<bean id="userdao" class="com.bodhixu.web.UserDaoImpl"/>
<bean id="asp" class="com.bodhixu.web.CustomAspect"/>
<aop:config>
<aop:pointcut expression="execution(* com.bodhixu.web.UserDaoImpl.*(..))" id="userdaoPointcut"/>
<aop:aspect ref="asp">
<aop:before method="customBefore" pointcut-ref="userdaoPointcut"/>
aop:aspect>
aop:config>
beans>
5. 通知类型
-
Before Advice（前置通知）：在一个切入点之前执行的通知
-
After Advice（后置通知）：在一个切入点正常完成后执行的通知，无论是否发生异常都会执行
-
After Return Advice（返回后通知）：在一个切入点正常完成后执行返回后的通知。和后置通知的区别在于，增强的方法可以通过参数接收切入点方法的返回值。
-
After throwing advice（异常抛出后通知）：在一个切入点抛出异常时执行的通知
-
Around advice（环绕通知）：包围一个切入点的通知，就像方法调用。这是最强大的一种通知类型。环绕通知可以在方法调用前后完成自定义的行为
public class UserDao {
public void insert() {
System.out.println("插入数据");
}
public void delete() {
System.out.println("删除数据");
}
public String query() {
System.out.println("查询数据");
return "学生abc";
}
public void update() throws Exception{
System.out.println("更新数据");
int x = 1/0;
}
public String deleteCopy() {
System.out.println("删除数据并记录...");
return "删除数据abc";
}
}
public class Enhancement {
public void before() {
System.out.println("前置通知...");
}
public void after() {
System.out.println("后置通知...");
}
//返回后通知，可以通过参数接收方法的返回值，参数名必须和xml配置文件中的returning属性值一致
public void afterReturn(String result) {
System.out.println("返回后通知..." + result);
}
//异常抛出后通知，可以通过参数接收异常对象，参数名必须和xml配置文件中的throwing属性名一致
public void afterThrow(Exception e) {
System.out.println("异常抛出通知..." + e.getMessage());
}
//参数：切入点
public void arround(ProceedingJoinPoint joinPoint) {
System.out.println("环绕通知前...");
try {
Object result = joinPoint.proceed();
System.out.println("result = " + result);
} catch (Throwable e) {
e.printStackTrace();
}
System.out.println("环绕通知后...");
}
}
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
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/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">
<bean id="usreDao" class="com.bodhixu.ssm.UserDao"/>
<bean id="em" class="com.bodhixu.ssm.Enhancement"/>
<aop:config>
<aop:pointcut expression="execution(* com.bodhixu.ssm.UserDao.insert(..))" id="insert"/>
<aop:pointcut expression="execution(* com.bodhixu.ssm.UserDao.delete(..))" id="delete"/>
<aop:pointcut expression="execution(* com.bodhixu.ssm.UserDao.query(..))" id="query"/>
<aop:pointcut expression="execution(* com.bodhixu.ssm.UserDao.update(..))" id="update"/>
<aop:pointcut expression="execution(* com.bodhixu.ssm.UserDao.deleteCopy(..))" id="deleteCopy"/>
<aop:aspect ref="em">
<aop:before method="before" pointcut-ref="insert"/>
<aop:after method="after" pointcut-ref="delete"/>
<aop:after-returning method="afterReturn" pointcut-ref="query" returning="result"/>
<aop:after-throwing method="afterThrow" pointcut-ref="update" throwing="e"/>
<aop:around method="arround" pointcut-ref="deleteCopy"/>
aop:aspect>
aop:config>
beans>
6. AOP 的注解实现
6.1 开启 AOP 注解扫描
<aop:aspectj-autoproxy/>
6.2 切面注解
@Aspect
@Component
public class Enhancement {}
6.3 通知注解
@Aspect
@Component
public class Enhancement {
@Before(value="execution(* com.bodhixu.ssm.UserDao.insert(..))")
public void before() {
System.out.println("前置通知...");
}
@After("execution(* com.bodhixu.ssm.UserDao.delete(..))")
public void after() {
System.out.println("后置通知...");
}
//返回后通知，可以通过参数接收方法的返回值，参数名必须和xml配置文件中的returning属性值一致
@AfterReturning(value="execution(* com.bodhixu.ssm.UserDao.query(..))", returning="result")
public void afterReturn(String result) {
System.out.println("返回后通知..." + result);
}
//异常抛出后通知，可以通过参数接收异常对象，参数名必须和xml配置文件中的throwing属性名一致
@AfterThrowing(value="execution(* com.bodhixu.ssm.UserDao.update(..))", throwing="e")
public void afterThrow(Exception e) {
System.out.println("异常抛出通知..." + e.getMessage());
}
//环绕通知
@Around(value="execution(* com.bodhixu.ssm.UserDao.deleteCopy(..))")
public void arround(ProceedingJoinPoint joinPoint) {
System.out.println("环绕通知前...");
try {
Object result = joinPoint.proceed();
System.out.println("result = " + result);
} catch (Throwable e) {
e.printStackTrace();
}
System.out.println("环绕通知后...");
}
}
