【期末向】一个例子带你搞定Spring AOP

写在前面：本文旨在帮助身边的小伙伴应对即将到来的考试（封面那本书），有些东西没写出来只代表考试没涉及到，我知道你很急，但你先别急，以后有你急的。

1.什么是Spring AOP

AOP（Aspect Oriented Programming，面向切面编程），一种编程范式，指导开发者如何组织程序结构。

AOP 采取横向抽取机制（动态代理），即将分散在各个方法中的重复代码提取出来，然后在程序编译或者运行阶段，再将这些抽取出来的代码应用到需要执行的地方。这种横向抽取机制采用传统的OOP是无法办到的，因为OOP实现的是父子关系的纵向重用。但是AOP不是OOP的替代品，而是OOP的补充。

AOP目的在于分离功能性需求和非功能性需求，使开发人员可以集中处理某一个关注点或者横切逻辑，减少对业务代码的侵入，增强代码的可读性和可维护性。其应用主要体现在事务处理、日志管理、权限控制、异常处理等方面。在不修改源代码的前提下，为系统中的业务组件添加某种功能。

2.AOP核心概念

连接点（Joinpoint）：程序执行过程中的任意位置，粒度为执行方法、抛出异常、设置变量等，在Spring AOP中指可以被动态代理拦截目标类的方法。

切入点（Poincut）：由一个切入点表达式定义，表达式描述要对哪些连接点进行拦截。

通知（Advice）：切面的具体实现，指拦截到连接点后要做的事情，即对切入点增强的内容 ，在Spring AOP中以方法的形式体现。

切面（Aspect）：切入点和通知的结合，指封装横切到系统功能的一个类

目标（Target）：被通知的目标对象

代理（Proxy）：向目标对象应用通知之后创建的代理对象

织入（Weave）：指把通知应用到目标上，生成代理对象的过程。

3.通知类型

AOP通知描述了需要抽取的共性功能，根据共性功能抽取的位置不同，最终运行代码时要将其加入到合理的位置。在基于注解的AOP开发中，AspectJ提供了5个注解分别对应5种通知类型：

名称	描述
@Before	用于定义前置通知，作用于方法执行前。
@AfterReturning	用于定于后置返回通知，作用于方法执行后，只有方法正常执行结束后才进行
@Around	用于定义环绕通知，可作用于方法执行的前后
@AfterThrowing	用于定义抛出异常后通知，作用于方法抛出异常后，只有方法执行出异常才进行
@After	用于定义后置通知，作用于方法执行后,不管方法执行的过程中有没有抛出异常都会执行

4.Spring整合AspectJ基于注解开发AOP

Spring对AOP的实现包括以下三种方式：

1. Spring框架结合AspectJ框架实现的AOP，基于注解的方式
2. Spring框架结合AspectJ框架实现的AOP，基于XML的方式
3. Spring框架自己实现的AOP，基于XML的方式

简单了解一下什么是AspectJ？

AspectJ是Eclipse组织的一个使用Java语言开发的支持AOP的框架。AspectJ是独立于Spring框架之外的一个框架，Spring框架使用了AspectJ。

（1）创建Maven工程，导入相关依赖

  <dependencies>
    <!-- Spring依赖，包含aop相关依赖-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>6.0.6</version>
    </dependency>

     <!-- Spring整合AspectJ所需依赖包-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aspects</artifactId>
      <version>6.0.6</version>
    </dependency>


<!--    <dependency>-->
<!--      <groupId>org.aspectj</groupId>-->
<!--      <artifactId>aspectjweaver</artifactId>-->
<!--      <version>1.9.4</version>-->
<!--    </dependency>-->

  </dependencies>

（2）在spring配置文件中开启包扫描和基于注解的AspectJ支持

值得注意的是：Idea比较智能，在你开启包扫描和基于注解的AspectJ支持的时候会自动帮你填补上context和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:context="http://www.springframework.org/schema/context"
       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/context
                           https://www.springframework.org/schema/context/spring-context.xsd
                           http://www.springframework.org/schema/aop
                           https://www.springframework.org/schema/aop/spring-aop.xsd">
    
    <!-- 开启spring的包扫描-->
    <context:component-scan base-package="com.example"/>
    <!-- 启动基于注解的AspectJ支持-->
    <aop:aspectj-autoproxy/>
</beans>

 （3）编写需要增强的功能

@Component
public class MyService {

    public void save(){
        System.out.println("原方法在此处执行");
        //模拟异常抛出
        for (;true;){
            int a = 1;
            int b = 0;
            int c = a / b;
            break;
        }
    }
}

 （4）使用@Aspect注解定义一个切面类，并在类中定义通知

@Aspect//声明一个切面
@Component
public class MyAspect {

    //定义切入点，描述需要增强的方法
    //括号内是一个切入点表达式，这里不细说，*表示所有返回值，后边表示需要切入的方法
    @Pointcut("execution(* com.example.service.MyService.save())")
    private void pt(){ }

    @Before("pt()")
    public void before() {
        System.out.println("我是前置通知，作用于方法前");
    }

    @After("pt()")
    public void after() {
        System.out.println("我是后置通知，作用于方法执行后，无论方法执行过程中有没有异常");
    }

    @Around("pt()")
    public void around(ProceedingJoinPoint pjp) throws Throwable{
        System.out.println("我是环绕通知前置部分");
        //表示逻辑上原方法在此时调用
        pjp.proceed();
        System.out.println("我是环绕通知后置部分");
    }

    @AfterReturning("pt()")
    public void afterReturning() {
        System.out.println("我是后置返回通知，只作用于方法正常执行完成后");
    }

    @AfterThrowing("pt()")
    public void afterThrowing() {
        System.out.println("我是抛出异常后通知，作用于方法抛出异常后");
    }

}

 （5）测试

public class App {

    public static void main( String[] args ) {
        //获取IoC容器
        ApplicationContext ctx = new ClassPathXmlApplicationContext("spring.xml");
        //获取bean
        MyService myService = ctx.getBean(MyService.class);
        //调用方法
        myService.save();
    }
}

（6）分析结果

可以看到，由于方法执行过程中出现了异常，afterThrowing通知执行了；相反的，由于方法没有正常结束返回，afterReturning通知和Around通知中逻辑方法调用后的输出语句也没有执行

 我们把模拟异常的代码注释掉，再次观察结果，可以看到，除了afterThrowing通知没有执行，其他通知都正常执行了。

@Component
public class MyService {

    public void save(){
        System.out.println("原方法在此处执行");
        //模拟异常抛出
//        for (;true;){
//            int a = 1;
//            int b = 0;
//            int c = a / b;
//            break;
//        }
    }
}

 ​​​​