AOP 简介

AOP 即 Aspect Oriented Program 面向切面编程,在面向切面编程的思想里面,核心业务功能和切面功能分别独立进行开发,然后把切面功能和核心业务功能“编织”在一起,这就叫AOP。面向切面编程就是 Spring 最为重要的功能之一了,在数据库事务中切面编程被广泛使用。

AOP 的作用和优势

作用: 在程序运行期间,不修改源码的情况下对方法进行功能增强。

优势: 减少重复代码,提高开发效率,并且便于维护。

AOP 实现原理

基于 JDK 的动态代理

TargetInterface proxy = (TargetInterface) Proxy.newProxyInstance(
target.getClass().getClassLoader(), // 目标对象类加载器
target.getClass().getInterfaces(), // 目标对象相同的接口字节码对象数组
new InvocationHandler() {
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
advice.before(); // 前置增强
Object result = method.invoke(target, args); //执行目标方法
advice.afterReturning(); //后置增强
return result;
}
}
);

基于 cglib 的动态代理

// 1. 创建增强器
Enhancer enhancer = new Enhancer();
// 2. 设置父类(目标)
enhancer.setSuperclass(Target.class);
// 3. 设置回调
enhancer.setCallback(new MethodInterceptor() {
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
advice.before(); // 执行前置
Object result = method.invoke(target, objects); // 执行目标
advice.afterRuturning(); // 执行后置
return result;
}
});
Target proxy = enhancer.create();

AOP 相关概念

Spring 的 AOP 底层实现原理就是对上面的动态代理的代码进行了封装,封装后我们只需要对需要关注的部分进行代码编写,并通过配置的方式完成指定目标的方法增强。

  • Target(目标对象):代理的目标对象。
  • Proxy(代理): 一个类被 AOP 织入增强后,就产生一个结果代理类。
  • Joinpoint(连接点):所谓连接点是指那些被拦截到的点,在 Spring 中,这些点指的是方法,因为 Spring 只支持方法类型的连接点。
  • Pointcut(切入点):所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义。
  • Advice (通知/增强):所谓通知是指拦截到 Joinpoint 之后要做的事情。
  • Aspect(切面):是切入点和通知的结合。
  • Weaving(织入):是指把增强应用到目标对象来创建新的代理对象的过程。Spring 采用动态代理织入,而 Aspect J 采用编译期织入和类装载期织入。

AOP 的简单使用

  1. 首先导入 aspectjweaver 的坐标。
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.6</version>
</dependency>
  1. 创建目标类
public class Target {
public void save(){
System.out.println("save running...");
}
}
  1. 创建增强类
public class MyAspect {
public void before(){
System.out.println("前置增强");
}
public void afterReturning(){
System.out.println("后置增强");
}
// ProceedingJoinPoint: 执行中的连接点(切点)
public Object around(ProceedingJoinPoint pjp) throws Throwable {
System.out.println("环绕增强 前");
Object proceed = pjp.proceed(); //调用切点方法
System.out.println("环绕增强 后");
return proceed;
}
public void afterThrowing(){
System.out.println("抛出异常增强");
}
public void after(){
System.out.println("最终增强");
}
}
  1. 配置切面(需要引入 aop 包)
<?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: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.xsd">

<bean id="myAspect" class="com.vsneko.aop.MyAspect"></bean>
<bean id="target" class="com.vsneko.aop.Target"></bean>

<!-- 配置织入,告诉 Spring 哪些方法(切点)需要进行哪些增强(前置后置)-->
<aop:config>
<!-- 声明切面类-->
<aop:aspect ref="myAspect">

<aop:before method="before" pointcut="execution(void com.vsneko.aop.Target.*(..))"></aop:before>

<aop:after-returning method="afterReturning" pointcut="execution(void com.vsneko.aop.Target.*(..))"></aop:after-returning>

<aop:around method="around" pointcut="execution(void com.vsneko.aop.Target.*(..))"></aop:around>

<aop:after-throwing method="afterThrowing" pointcut="execution(void com.vsneko.aop.Target.*(..))"></aop:after-throwing>

<aop:after method="after" pointcut="execution(void com.vsneko.aop.Target.*(..))"></aop:after>

</aop:aspect>
</aop:config>
</beans>

切点表达式的写法

execution([修饰符] 返回值类型 包名.类名.方法名(参数))
  • 访问修饰符可以省略
  • 返回值类型、包名、类名、方法名可以使用星号 (*) 代表任意。
  • 包名与类名之间一个点 (.) 代表当前包下的类,两个点 (..) 代表当前包及其子包下的类。
  • 参数列表可以使用两个点 (..) 表示任意个数、任意类型的参数。

例如:

execution(public void com.vsneko.aop.Target.save())
execution(void com.vsneko.aop.Target.*(..))
execution(* com.vsneko.aop.*.*(..)) // 常用
execution(* com.vsneko.aop..*.*(..))
execution(* *..*.*(..))

通知的类型

名称 标签 说明
前置通知 <aop:before> 指定增强的方法在切入点之前执行
后置通知 <aop:after-returning> 指定增强的方法在切入点之后执行
环绕通知 <aop:around> 指定增强的方法在切入点之前和之后都执行
异常抛出通知 <aop:after-throwing> 指定增强的方法在出现异常时执行
最终通知 <aop:after> 无论增强方法执行是否有异常都会执行

切入点表达式提取

<aop:config>
<!-- 声明切面类-->
<aop:aspect ref="myAspect">
<aop:pointcut id="myPointcut" expression="execution(void com.vsneko.aop.Target.*(..))"/>

<aop:before method="before" pointcut-ref="myPointcut"></aop:before>
</aop:aspect>
</aop:config>

Spring 的 AOP 注解

步骤

  1. 将目标类和切面类配置 @Component 注解。
  2. 将切面类配置 @Aspect 注解,告诉 Spring 容器这是一个切面类。
  3. 将增强方法配置 @Before、@afterReturning 或其他注解,并传入切点表达式。
@Component
@Aspect
public class MyAspect {

@Before("execution(void com.vsneko.aop.Target.*(..))")
public void before(){
System.out.println("前置增强");
}
}
  1. applicationContext.xml 中配置 组件扫描 和 AOP 自动注入。
<?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:aop="http://www.springframework.org/schema/aop"
xmlns:context="http://www.springframework.org/schema/context"
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.vsneko.aop"></context:component-scan>

<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

注解的切入点表达式提取

@Component()
@Aspect
public class MyAspect {

@Before("pointcut()")
public void before(){
System.out.println("前置增强");
}
@AfterReturning("MyAspect.pointcut()")
public void afterReturning(){
System.out.println("后置增强");
}
@Pointcut("execution(void com.vsneko.aop.Target.*(..))")
public void pointcut(){}
}