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(){}
}