spring的AOP

1、什么是AOP

AOP全称为“Aspect Oriented Programming”，即面向切面编程，是一种编程范式。与传统的面向对象编程（OOP）强调“什么对象做什么事情”的思想不同，AOP强调“在什么地方做什么事情”的思想。

AOP的核心思想是将系统的关注点（Concern）分离出来，通过横向切割技术（Cross-Cutting Concerns）对系统进行模块化，降低系统复杂性。通俗地讲，就是将那些与核心业务逻辑无关但在多个模块中重复出现的代码，抽象成切面（Aspect），然后通过某种技术将其模块化，从而实现对系统关注点的分离和管理。

AOP的实现方式通常是通过动态代理、字节码增强等技术，在程序运行时动态地将切面织入到目标对象中。在Java领域，Spring框架是一个广泛使用AOP技术的框架，它提供了丰富的AOP功能，如基于注解的AOP、基于XML的AOP等等。

AOP的相关术语

• Joinpoint(连接点):

所谓连接点是指那些被拦截到的点。在 spring 中,这些点指的是方法,因为 spring 只支持方法类型的连接点。

• Pointcut(切入点):

所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义。

• Advice(通知/增强):

所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知。通知的类型：前置通知,后置通知,异常通知,最终通知,环绕通知。

• Introduction(引介):

引介是一种特殊的通知在不修改类代码的前提下, Introduction 可以在运行期为类动态地添加一些方法或 Field。

• Target(目标对象):

代理的目标对象。 

• Weaving(织入):  

是指把增强应用到目标对象来创建新的代理对象的过程。spring 采用动态代理织入，而 AspectJ 采用编译期织入和类装载期织入。

• Proxy（代理）:

 一个类被 AOP 织入增强后，就产生一个结果代理类。

• Aspect(切面):

是切入点和通知（引介）的结合。

2、AOP基于XML配置的入门案例：

1、导入所需的jar包

 2、分层结构

3、创建一个类，这个类完成核心功能。

1、创建接口

//定义了一个名为CxkService的接口
package com.liu.service;

public interface CxkService {
    //声明了一个名为chang的抽象方法，该方法有一个String类型的参数ji，返回一个String类型的值
    String chang(String ji);
    
    //声明了一个名为tiao的抽象方法，该方法没有参数，返回一个String类型的值
    String tiao();
    
    //声明了一个名为rap的抽象方法，该方法没有返回值也没有参数
    void rap();
    
    //声明了一个名为basketball的抽象方法，该方法没有返回值也没有参数
    void beskball();
}

此代码定义了一个接口CxkService，其中包含四个方法：chang、tiao、rap和beskball。这些方法都是抽象方法，没有具体实现。

其中，chang方法需要传入一个String类型的参数ji，并且会返回一个String类型的值；tiao方法不需要传入任何参数，但会返回一个String类型的值；rap方法和beskball方法没有任何返回值，也不需要传入任何参数。

这个接口可以被其他类实现，并重写这些抽象方法，以提供具体的实现。

2、创建一个类，实现接口

//定义了一个名为CxkServiceImpl的类，该类实现了CxkService接口
package com.liu.service.impl;

import com.liu.service.CxkService;

public class CxkServiceImpl implements CxkService {
    //重写了接口中的chang方法，传入一个String类型的参数aa，返回null
    @Override
    public String chang(String aa) {
        System.out.println("姬霓太美");
        return null;
    }

    //重写了接口中的tiao方法，不需要传入任何参数，返回null
    @Override
    public String tiao() {
        System.out.println("铁山靠");
        return null;
    }

    //重写了接口中的rap方法，没有返回值也不需要传入任何参数
    @Override
    public void rap() {
        System.out.println("蔡徐坤在rap");
    }

    //重写了接口中的basketball方法，没有返回值也不需要传入任何参数
    @Override
    public void beskball() {
        System.out.println("蔡徐坤在打篮球");
    }
}

这段代码定义了一个名为CxkServiceImpl的类，该类实现了CxkService接口。

在这个类中，重写了接口中的四个抽象方法：chang、tiao、rap和beskball。其中，chang方法会向控制台输出一句话，并返回null；tiao方法也会向控制台输出一句话，并返回null；rap方法和beskball方法则只是向控制台输出了一句话，没有任何返回值。

这个类可以被其他类实例化，并调用实现的方法。

4、创建Loger类，用来做功能的增强。

package com.liu.loger;

public class Loger {
    public void beforePrintLog(){
        System.out.println("前置通知：beforePrintLog执行...");
    }
    public void afterReturningPrintLog(){
        System.out.println("后置通知：afterReturningPrintLog执行...");
    }
    public void afterThrowingPrintLog(){
        System.out.println("异常通知：afterThrowingPrintLog执行...");
    }
    public void afterPrintLog(){
        System.out.println("最终通知：afterPrintLog执行...");
    }
}

这段代码定义了一个名为Loger的类，其中包含四个方法：beforePrintLog、afterReturningPrintLog、afterThrowingPrintLog和afterPrintLog。

这些方法都只是向控制台输出一句话，没有任何其他具体功能。

这个类可以被其他类实例化，并调用其中的方法。通常这些方法会在AOP编程中被调用，用于给程序添加额外的功能或行为。

5、在spring的beans.xml中开始进行AOP的配置：

• 首先把核心类和增强类的bean配置到IOC的容器中
• 使用<aop:config>标签在进行AOP的配置，先通过aop:aspect标签标明谁是增强类。然后在标签中进行aop:before（前置）、aop:after-returning（后置）、aop:after-throwing（异常）、aop:after（最终）的配置，让增强类的某个方法对核心功能类的某一类方法进行功能增强。

<!-- 定义了一个名为spring的XML文件 -->
<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
	http://www.springframework.org/schema/context/spring-context.xsd
	http://www.springframework.org/schema/aop
	http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!-- 定义了一个名为loger的bean，其类为com.liu.loger.Loger -->
    <bean id="loger" class="com.liu.loger.Loger"/>

    <!-- 定义了一个名为cxkService的bean，其类为com.liu.service.impl.CxkServiceImpl -->
    <bean id="cxkSrvice" class="com.liu.service.impl.CxkServiceImpl"/>

    <!-- 定义了一个AOP配置，其中引用了上面定义的loger bean -->
    <aop:config>

        <!-- 定义了一个名为check的切面，引用了上面定义的loger bean -->
        <aop:aspect id="check" ref="loger">

            <!-- 定义了一个名为beforePrintLog的方法，使用了切入点表达式execution(* *..CxkServiceImpl.*(..)) -->
            <aop:before method="beforePrintLog" pointcut="execution(* *..CxkServiceImpl.*(..))"/>

            <!-- 定义了一个名为afterReturningPrintLog的方法，使用了切入点表达式execution(* *..CxkServiceImpl.*(..)) -->
            <aop:after-returning method="afterReturningPrintLog" pointcut="execution(* *..CxkServiceImpl.*(..))"/>

            <!-- 定义了一个名为afterThrowingPrintLog的方法，使用了切入点表达式execution(* *..CxkServiceImpl.*(..)) -->
            <aop:after-throwing method="afterThrowingPrintLog"  pointcut="execution(* *..CxkServiceImpl.*(..))"/>

            <!-- 定义了一个名为afterPrintLog的方法，使用了切入点表达式execution(* *..CxkServiceImpl.*(..)) -->
            <aop:after method="afterPrintLog"  pointcut="execution(* *..CxkServiceImpl.*(..))"/>

        </aop:aspect>

    </aop:config>

</beans>

这段代码是一个Spring配置文件，其中定义了两个bean：loger和bookService。同时，还定义了一个AOP配置，用于给bookService添加额外的功能或行为。

在AOP配置中，定义了一个名为check的切面，引用了上面定义的loger bean。该切面中包含了四个通知方法（before、afterReturning、afterThrowing、after），分别对应AOP编程中的四种通知类型，在执行bookService中的方法时会调用这些通知方法。

除此之外，这个AOP配置还使用了切入点表达式execution(* *..BookServiceImpl.*(..))，该表达式表示对BookServiceImpl中所有方法的执行都将触发这个切面。

6、测试方法是否被增强

// 从 com.liu.service 包中导入 CxkService 类
import com.liu.service.CxkService;
// 从 Spring Framework 中导入 ClassPathXmlApplicationContext 类
import org.springframework.context.support.ClassPathXmlApplicationContext;

// 定义一个 Test01 类
public class Test01 {
    // 定义一个 main 方法
    public static void main(String[] args) {
        // 创建一个 ClassPathXmlApplicationContext 实例，并传入 spring.xml 配置文件的路径
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
        // 从应用程序上下文中检索名为 "cxkService" 的 bean，并将其转换为 CxkService 类型
        CxkService bookService = context.getBean(CxkService.class);
        // 调用 CxkService 对象上的 chang() 方法，并传入字符串 "雞"
        bookService.chang("雞");
        // 将分隔线打印到控制台
        System.out.println("=================");
        // 调用 CxkService 对象上的 tiao() 方法
        bookService.tiao();
        // 将分隔线打印到控制台
        System.out.println("=================");
        // 调用 CxkService 对象上的 rap() 方法
        bookService.rap();
        // 将分隔线打印到控制台
        System.out.println("=================");
        // 调用 CxkService 对象上的 beskball() 方法
        bookService.beskball();
    }
}

测试结果：