什么是AOP

AOP（Aspect-OrientedProgramming，面向切面编程），可以说是OOP（Object-Oriented Programing，面向对象编程）的补充和完善。OOP引入封装、继承和多态性等概念来建立一种对象层次结构，用以模拟公共行为的一个集合。当我们需要为分散的对象引入公共行为的时候，OOP则显得无能为力。也就是说，OOP允许你定义从上到下的关系，但并不适合定义从左到右的关系。例如日志功能。日志代码往往水平地散布在所有对象层次中，而与它所散布到的对象的核心功能毫无关系。对于其他类型的代码，如安全性、异常处理和透明的持续性也是如此。这种散布在各处的无关的代码被称为横切（cross-cutting）代码，在OOP设计中，它导致了大量代码的重复，而不利于各个模块的重用。
而AOP技术则恰恰相反，它利用一种称为“横切”的技术，剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，并将其名为“Aspect”，即方面。所谓“方面”，简单地说，就是将那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可操作性和可维护性。AOP代表的是一个横向的关系，如果说“对象”是一个空心的圆柱体，其中封装的是对象的属性和行为；那么面向方面编程的方法，就仿佛一把利刃，将这些空心圆柱体剖开，以获得其内部的消息。而剖开的切面，也就是所谓的“方面”了。然后它又以巧夺天功的妙手将这些剖开的切面复原，不留痕迹。

一 AOP的基本概念

Aspect(切面):指横切性关注点的抽象即为切面,它与类相似,只是两者的关注点不一样,类是对物体特征的抽象,而切面是对横切性关注点的抽象.
joinpoint(连接点):所谓连接点是指那些被拦截到的点。在spring中,这些点指的是方法,因为spring只支持方法类型的连接点,实际上joinpoint还可以是field或类构造器)
Pointcut(切入点):所谓切入点是指我们要对哪些joinpoint进行拦截的定义.
Advice(通知):所谓通知是指拦截到joinpoint之后所要做的事情就是通知.通知分为前置通知（before）,后置通知（afterReturning）,异常通知（afterThrowing）,最终通知（after）,环绕通知（around）
Target(目标对象):代理的目标对象
Weave(织入):指将aspects应用到target对象并导致proxy对象创建的过程称为织入.
Introduction(引入):在不修改类代码的前提下, Introduction可以在运行期为类动态地添加一些方法或Field.
AOP代理：AOP框架创建的对象，代理就是目标对象的加强。Spring中的AOP代理可以使JDK动态代理，也可以是CGLIB代理，前者基于接口，后者基于子类

通知方法:

前置通知:在我们执行目标方法之前运行(@Before)
后置通知:在我们目标方法运行结束之后 ,不管有没有异常(@After)
返回通知:在我们的目标方法正常返回值后运行(@AfterReturning)
异常通知:在我们的目标方法出现异常后运行(@AfterThrowing)
环绕通知:动态代理, 需要手动执行joinPoint.procced()(其实就是执行我们的目标方法执行之前相当于前置通知, 执行之后就相当于我们后置通知(@Around)

二基于XML的执行先后顺序:

前置通知(@Before) → 环绕通知(@Around) → 后置通知(@AfterRunning)/异常通知(@AfterThrowing) → 最终通知(@After)

三 advice（通知）注解的执行先后顺序

情况一: 一个方法只被一个Aspect类拦截

当一个方法只被一个Aspect拦截时，这个Aspect中的不同advice是按照怎样的顺序进行执行的呢？请看:

添加Aspect类

package com.neuedu.spring.interceptor;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

@Aspect//此功能扩展类就是一个切面类
@Component
public class ServiceInterceptor {
    
    @Pointcut("execution(* com.neuedu.spring.service..*.*(..))")
    public void allMethod() {}
    /**
     * 声明切入点的方法，不能声明参数，否则会报错
     * 
     * 默认该方法也不要有返回值，方法体中也不要有任何内容，虽然写了不会报错。
     */
    // 只有环绕通知可以接收ProceedingJoinPoint，而其他通知只能接收JoinPoint
    
    //调用目标对象方法后写日志
    @After("allMethod()")
    public void log(JoinPoint joinPoint)
    {
        System.out.println("After：写日志");
    }
    @AfterReturning("allMethod()")
    public void log(JoinPoint joinPoint)
    {
        System.out.println("[Aspect1] afterReturning advise");
    }
    @AfterThrowing("allMethod()")
    public void log()
    {
        System.out.println("[Aspect1] afterThrowing advise");
    }
    //调用目标对象方法前权限校验
    @Before("allMethod()")
    public void checkUser()
    {
        System.out.println("Before：权限校验");
    }
    //计时方法要对目标对象方法执行的时间进行统计，所以如何在本方法中调用到目标对象是个技术点
    @Around("allMethod()")
    public Object time(ProceedingJoinPoint joinPoint)
    {
        System.out.println("开始计时...");
        Long startTime=System.currentTimeMillis();
        Object result=null;
        try {
            result=joinPoint.proceed();//执行目标对象的方法
        } catch (Throwable e) {
            e.printStackTrace();
        }
        
        Long endTime=System.currentTimeMillis();
        System.out.println("结束计时：一共执行了"+(endTime-startTime)+"毫秒");
        return result;
    }
    
    /**
     <aop:config>
     
      <aop:aspectj>
        <aop:pointcut>
        <aop:before>
     */
    
}

目标类

package com.neuedu.spring.service;

import org.springframework.stereotype.Service;

@Service
public class ProductService {
    
    public void up()
    {
        System.out.println("商品 上架");
    }
    
    public void down()
    {
        System.out.println("商品 下架");
    }

}

测试代码

package test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.neuedu.spring.service.ProductService;

public class Test {

    public static void main(String[] args) {
        
        ApplicationContext act=new ClassPathXmlApplicationContext("beans.xml");
        
        ProductService productService=(ProductService) act.getBean("productService");

        productService.down();
    }

}

测试正常情况

开始计时...
Before：权限校验
商品 下架
结束计时：一共执行了126毫秒
After：写日志
[Aspect1] afterReturning advise

测试异常情况

开始计时...
Before：权限校验
throw an exception
After：写日志
[Aspect1] afterThrowing advise

总结：

针对一个方法只被一个aspect类拦截时，aspect类内部的 advice 将按照以下的顺序进行执行情况如下：

正常情况.png

异常情况.png

解释：执行到核心业务方法或者类时，会先执行AOP。在aop的逻辑内，先走@Around注解的方法。然后是@Before注解的方法，然后这两个都通过了，走核心代码，核心代码走完，无论核心有没有返回值，都会走@After方法。然后如果程序无异常，正常返回就走@AfterReturn,有异常就走@AfterThrowing。

情况二: 同一个方法被多个Aspect类拦截

此处举例为被两个aspect类拦截。
有些情况下，对于两个不同的aspect类，不管它们的advice使用的是同一个pointcut，还是不同的pointcut，都有可能导致同一个方法被多个aspect类拦截。那么，在这种情况下，这多个Aspect类中的advice又是按照怎样的顺序进行执行的呢？请看:
分别新建两个aspect类

package test;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Component
@Aspect
public class Aspect1 {
    @Pointcut("execution(* com.neuedu.spring.service..*.*(..))")
    public void allMethod1() {}

    @Before(value = "allMethod1")
    public void before(JoinPoint joinPoint) {
        System.out.println("[Aspect1] before advise");
    }

    @Around(value = "allMethod1()")
    public void around(ProceedingJoinPoint pjp) throws  Throwable{
        System.out.println("[Aspect1] around advise 1");
        pjp.proceed();
        System.out.println("[Aspect1] around advise2");
    }

    @AfterReturning(value = "allMethod1()")
    public void afterReturning(JoinPoint joinPoint) {
        System.out.println("[Aspect1] afterReturning advise");
    }

    @AfterThrowing(value = "allMethod1()")
    public void afterThrowing(JoinPoint joinPoint) {
        System.out.println("[Aspect1] afterThrowing advise");
    }

    @After(value = "allMethod1()")
    public void after(JoinPoint joinPoint) {
        System.out.println("[Aspect1] after advise");
    }
}

package test;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Component
@Aspect
public class Aspect2 {
    @Pointcut("execution(* com.neuedu.spring.service..*.*(..))")
    public void allMethod2() {}

    @Before(value = "allMethod2()")
    public void before(JoinPoint joinPoint) {
        System.out.println("[Aspect2] before advise");
    }

    @Around(value = "allMethod2()")
    public void around(ProceedingJoinPoint pjp) throws Throwable{
        System.out.println("[Aspect2] around advise 1");
        pjp.proceed();
        System.out.println("[Aspect2] around advise2");
    }

    @AfterReturning(value = "allMethod2()")
    public void afterReturning(JoinPoint joinPoint) {
        System.out.println("[Aspect2] afterReturning advise");
    }

    @AfterThrowing(value = "allMethod2()")
    public void afterThrowing(JoinPoint joinPoint) {
        System.out.println("[Aspect2] afterThrowing advise");
    }

    @After(value = "allMethod2()")
    public void after(JoinPoint joinPoint) {
        System.out.println("[Aspect2] after advise");
    }
}

测试用代码也不变

还是使用上面的那个。但是现在 aspect1 和 aspect2 都会拦截该测试中的方法。
下面继续进行测试！

测试正常情况

我们会看到输出的结果是：

[Aspect2] around advise 1
[Aspect2] before advise
[Aspect1] around advise 1
[Aspect1] before advise
test OK
[Aspect1] around advise2
[Aspect1] after advise
[Aspect1] afterReturning advise
[Aspect2] around advise2
[Aspect2] after advise
[Aspect2] afterReturning advise

但是这个时候，我不能下定论说 aspect2 肯定就比 aspect1 先执行。
不信？你把服务务器重新启动一下，再试试，说不定你就会看到如下的执行结果：

[Aspect1] around advise 1
[Aspect1] before advise
[Aspect2] around advise 1
[Aspect2] before advise
test OK
[Aspect2] around advise2
[Aspect2] after advise
[Aspect2] afterReturning advise
[Aspect1] around advise2
[Aspect1] after advise
[Aspect1] afterReturning advise

也就是说，这种情况下， aspect1 和 aspect2 的执行顺序是未知的。那怎么解决呢？不急，下面会给出解决方案。

测试异常情况

我们会看到输出的结果是：

[Aspect2] around advise 1
[Aspect2] before advise
[Aspect1] around advise 1
[Aspect1] before advise
throw an exception
[Aspect1] after advise
[Aspect1] afterThrowing advise
[Aspect2] after advise
[Aspect2] afterThrowing advise

同样地，如果把服务器重启，然后再测试的话，就可能会看到如下的结果：

[Aspect1] around advise 1
[Aspect1] before advise
[Aspect2] around advise 1
[Aspect2] before advise
throw an exception
[Aspect2] after advise
[Aspect2] afterThrowing advise
[Aspect1] after advise
[Aspect1] afterThrowing advise

也就是说，同样地，异常情况下， aspect1 和 aspect2 的执行顺序也是未定的。
那么在情况二下，如何指定每个 aspect 的执行顺序呢？
方法有两种：

实现org.springframework.core.Ordered接口，实现它的getOrder()方法
给aspect添加@Order注解，该注解全称为：org.springframework.core.annotation.Order
不管采用上面的哪种方法，都是值越小的 aspect 越先执行。
比如，我们为 apsect1 和 aspect2 分别添加 @Order 注解，如下：

@Order(5)
@Component
@Aspect
public class Aspect1 {
    // ...
}

@Order(6)
@Component
@Aspect
public class Aspect2 {
    // ...
}

这样修改之后，可保证不管在任何情况下， aspect1 中的 advice 总是比 aspect2 中的 advice 先执行。如下图所示：

image.png

注意点

如果在同一个 aspect 类中，针对同一个 pointcut，定义了两个相同的 advice(比如，定义了两个 @Before)，那么这两个 advice 的执行顺序是无法确定的，哪怕你给这两个 advice 添加了 @Order 这个注解，也不行。这点切记。
对于@Around这个advice，不管它有没有返回值，但是必须要方法内部，调用一下 pjp.proceed();否则，Controller 中的接口将没有机会被执行，从而也导致了 @Before这个advice不会被触发。比如，我们假设正常情况下，执行顺序为”aspect2 -> apsect1 -> controller”，如果，我们把 aspect1中的@Around中的 pjp.proceed();给删掉，那么，我们看到的输出结果将是：

[Aspect2] around advise 1
[Aspect2] before advise
[Aspect1] around advise 1
[Aspect1] around advise2
[Aspect1] after advise
[Aspect1] afterReturning advise
[Aspect2] around advise2
[Aspect2] after advise
[Aspect2] afterReturning advise

从结果可以发现， Controller 中的接口未被执行，aspect1 中的 @Before advice 也未被执行。

4 在aop中校验不通过如何不让程序进入核心代码？

通过aop中注解的执行的先后顺序我们知道，校验发生在核心代码前面的只剩下两个——@Before,@Around。
@Before : 这个注解只有在异常时才不会走核心方法——连接点。正常@Before无法阻止当前线程进入连接点。
@Around : 这个注解在连接点前后执行。并且注解的方法传入的ProceedingJionPoint 类中封装的代理方法proceed()可以让当前线程从aop方法转到连接点——核心代码方法。所以一般我们用这个注解，如果aop的安全校验不通过，则不调用proceed()方法，就永远不会进入连接点。
除此外，要注意除了Around注解的方法可以传ProceedingJionPoint 外，别的几个都不能传这个类。但是普通的数据类型是不限制的。注解的方法的返回值也不限制，可以自由限制。

Spring AOP详细介绍

Spring AOP详细介绍

什么是AOP

一 AOP的基本概念

通知方法:

二基于XML的执行先后顺序:

三 advice（通知）注解的执行先后顺序

情况一: 一个方法只被一个Aspect类拦截

添加Aspect类

目标类

测试代码

测试正常情况

测试异常情况

总结：

情况二: 同一个方法被多个Aspect类拦截

测试用代码也不变

测试正常情况

测试异常情况

注意点

4 在aop中校验不通过如何不让程序进入核心代码？

推荐阅读更多精彩内容

Spring AOP详细介绍

什么是AOP

一 AOP的基本概念

通知方法:

二 基于XML的执行先后顺序:

三 advice（通知）注解的执行先后顺序

情况一: 一个方法只被一个Aspect类拦截

添加Aspect类

目标类

测试代码

测试正常情况

测试异常情况

总结：

情况二: 同一个方法被多个Aspect类拦截

测试用代码也不变

测试正常情况

测试异常情况

注意点

4 在aop中校验不通过如何不让程序进入核心代码？

推荐阅读更多精彩内容

二基于XML的执行先后顺序: