一、开始学习
1、新建项目，结构如下
2、添加 spring 依赖
<!-- spring 的核心依赖 -->
<dependencies>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.3.23</version>
</dependency>
<dependency>
<groupId>ch.qos.logback</groupId>
<artifactId>logback-classic</artifactId>
<version>1.4.5</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.8</version>
</dependency>
</dependencies>AspectJ 是 eclipse 开源组织编写的一套强大的 AOP 框架， 它拥有特殊的编译器和类加载器，因此可以在编译时创建 代理和类加载时创建代理，但由于 spring 本身对 AOP 的实现是基于运行时创建代理的，所以只能使用 jdk 和 cglib 来创建代理，但 spring 却使用了 AspectJ 的切入点表达式 以及相关的注解，使用起来更加的简单和方便 。
使用AspectJ，你可以通过定义切面来在不修改原始代码的情况下，将通用功能织入到应用程序中。
3、在 service 包下新建一个 UserService 类
@Slf4j
public class UserService {
public void add(){
log.info("添加用户...");
}
}
4、在 aspect 包下新建一个 ServiceAspect 切面类
/**
* @Date 2023-10-12
* @Author qiu
* 这是一个切面类
*/
@Slf4j
public class ServiceAspect implements MethodBeforeAdvice, AfterReturningAdvice, MethodInterceptor, ThrowsAdvice {
/**
* 环绕通知
*
* @param invocation 回调处理器，用于调用目标对象的方法
* @return
* @throws Throwable
*/
@Override
public Object invoke(MethodInvocation invocation) throws Throwable {
log.info("环绕通知前...");
// 调用目标对象方法
Object proceed = invocation.proceed();
log.info("环绕通知后....");
return proceed;
}
/**
* 后置通知
*
* @param returnValue 目标方法的返回值
* @param method 目标对象的方法
* @param args 目标方法所需要的参数
* @param target 目标对象
* @throws Throwable
*/
@Override
public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
log.info("后置通知...");
}
/**
* 前置通知
*
* @param method 准备调用的目标对象
* @param args 目标方法的所需要的参数
* @param target 目标对象（被代理的对象）
* @throws Throwable 有可能抛出的异常
*/
@Override
public void before(Method method, Object[] args, Object target) throws Throwable {
log.info("前置通知...");
}
/**
* 异常通知，根据官方文档说明
* 该方法名必须叫做 afterThrowing
* 并且必须包含一个 Exception 参数
*
* @param e
*/
public void afterThrowing(Exception e) {
log.info("异常通知...." + e.getMessage());
}
}
这是一个使用AspectJ实现的切面类示例。该切面类实现了
MethodBeforeAdvice、AfterReturningAdvice、MethodInterceptor和ThrowsAdvice这几个接口。其中：
invoke()方法是环绕通知，在目标方法执行前后进行拦截，并在前后打印日志。afterReturning()方法是后置通知，在目标方法正常返回后执行，并打印日志。before()方法是前置通知，在目标方法执行前执行，并打印日志。afterThrowing()方法是异常通知，在目标方法抛出异常时执行，并打印异常信息。通过使用这些切面通知，你可以在应用程序中将这些关注点逻辑切入到目标方法的执行过程中，实现更灵活和可维护的代码结构。
5、在 resources 包下新建一个 beans.xml 文件
<?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 https://www.springframework.org/schema/aop/spring-aop.xsd">
<!-- 装配 UserService（目标对象） -->
<bean id="userService" class="edu.nf.ch19.service.UserService"/>
<!-- 装切面，将切面纳入 spring 容器中管理 -->
<bean id="serviceAspect" class="edu.nf.ch19.aspect.ServiceAspect"/>
<!-- Aop 配置 proxy-target-class="true" 属性设置为 true
表示强制使用 cglib 生成代理，无论目标对象有没有实现接口
-->
<aop:config proxy-target-class="true">
<!-- 配置切入点，spring 使用了 AspectJ 的切入点表达式
来实现了 AOP 中切入点的概念,通过切入点表达式
可以找到需要增强的目标方法。而找到的这些目标方法就称之为
连接点。id 属性指定一个切入点的唯一标识，
expression 用于声明切入点表达式。
切入点表达式的语法：
execution(访问修饰符 包名.类名.方法名(参数类型))
也可以使用通配符来扩大切入点的范围
execution(访问修饰符 包名.*.*(..))
-->
<aop:pointcut id="myPointcut" expression="execution(* edu.nf.ch19.service.UserService.*(..))"/>
<!-- 配置通知器（也就是切面），使用 advice-ref 属性引用上面装配的切面
pointcut-ref 引用切入点的 id
-->
<aop:advisor advice-ref="serviceAspect" pointcut-ref="myPointcut"/>
</aop:config>
</beans> 这是一个使用Spring AOP配置的XML示例。该配置文件定义了一个userService的目标对象和一个serviceAspect的切面对象，并通过AOP将切面应用到目标对象的方法上。
解析该配置文件的主要内容如下：
配置了
userService的目标对象。通过指定class属性为edu.nf.ch19.service.UserService，将该类装配为 Spring 容器中的一个 bean。配置了
serviceAspect的切面对象。通过指定class属性为edu.nf.ch19.aspect.ServiceAspect，将该类装配为 Spring 容器中的一个 bean。在
<aop:config>标签内配置了 AOP 相关的内容。通过设置proxy-target-class属性为true，启用了基于类的代理。定义了
myPointcut切点，使用表达式execution(* edu.nf.ch19.service.UserService.*(..))来匹配edu.nf.ch19.service.UserService类中的所有方法。定义了
advisor，将serviceAspect作为通知（advice-ref）应用到myPointcut切点（pointcut-ref）。
通过这样的配置，你可以实现在edu.nf.ch19.service.UserService类的所有方法上应用serviceAspect切面对象中定义的通知逻辑。
6、测试
public class Main {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
UserService service = context.getBean(UserService.class);
service.add();
}
}运行结果
7、看图分析
1）什么是连接点？
目标对象的方法（被切入的方法）就称之为连接点，一个切入点可以对应目标对象的的多个连接点。AOP是对一个类的方法在不进行任何修改的前提下进行增强，那么UserService 里的 add（）方法，就是连接点。
2）什么是通知？
通知（也叫增强）就是对目标行为植入额外的逻辑代码，从而增强原有的功能。切面类（通知类）里面的所有方法都是增强方法。
3）什么是切入点？
执行 add（） 方法的时候本来是只有添加用户，但是执行后输出了环绕通知、前置通知、后置通知，也就是说，add()方法已经被增强了，被增强的方法就叫做切入点。
4）什么是切面？
切面是用于编写切面逻辑的一个类，这个类很类似于JDK动态代理中的回调处理器或者cglib中的方法拦截器，主要就是将需要增强目标对象的功能代码编写在这个类中，而这些功能增强的代码就是切面逻辑。 通知是增强的方法，会有多个，切入点是需要增强的方法，也会有多个，哪个切入点需要添加哪个通知，它们之间的关系就叫做切面。
5）什么是切面类（通知类）？
通知（增强）是一个方法，方法不能独立存在需要写在类中，这个类就叫切面类（通知类）。
6）什么是代理？
AOP 是在不改变原有设计 ( 代码 ) 的前提下对其进行增强的，它的底层采用的是代理模式实现的，所以要对原始对象进行增强，就需要对原始对象创建代理对象，在代理对象中的方法把通知[ 如 :UserService 中的 add 方法 ] 内容加进去，就实现了增强 , 这就是我们所说的代理 (Proxy) 。在运行时动态创建的对象，称之为代理对象，负责调用目标对象的方法，并执行增强功能。
7) 什么是目标？
被代理的对象就是目标对象。
目标对象就是要被增强的类（UserService）。
8）什么是织入？
将切面中的增强逻辑应用到目标具体的连接点上并产生代理的过程称之为织入。
切面类中的增强方法应用到 UserService 的 add（） 方法中的这个过程就是织入。
因此通常描述为“将通知织入到具体的目标”。
织入的时机可以分为以下几种：
类加载时织入，需要特殊的类加载器（LTW）
编译时织入，需要特殊的编译器（CTW）
运行时织入，通常使用JDK或者CGLIB在程序运行创建代理对象，
spring就是基于运行时织入的。（注意：spring仅仅只是用到了AspectJ的切入点表达式和注解，但并没有使用AspectJ的类加载和编译时织入功能，而是使用JDK和CGLIB在运行时生成代理对象。）
二、使用 AspectJ 的好处？
使用 AspectJ 有以下几个好处：
更强大的切面编程能力：AspectJ 提供了更丰富、更灵活的切面编程功能，可以针对更细粒度的 Join Point（连接点）进行切面编程。它支持更多的切点表达式，可以在方法的入参、返回值、异常等多个层面进行切面逻辑的定义，使得切面的编写更加灵活和精确。
更高效的性能：AspectJ 不依赖动态代理机制，使用字节码增强技术，生成修改后的目标类字节码，将切面逻辑直接插入到目标类的指定位置。这种静态织入方式比运行时的动态代理织入更高效，减少了额外的代理调用开销，提升了系统的运行性能。
更广泛的应用场景：AspectJ 可以与 Spring AOP 进行无缝集成，可以作为 Spring 框架的一部分使用。除了在 Spring 应用中使用外，AspectJ 还可以用于 JavaEE 应用、独立的 Java 应用，甚至能够修改第三方类库的字节码，具备更广泛的应用场景。
更丰富的功能扩展：AspectJ 提供了一些特殊的切面类型，例如
percflow、pertarget等，可以实现更复杂的切面逻辑。此外，AspectJ 还提供了一些高级功能，如异常处理、事务管理等，可以扩展切面的应用范围，使得切面编程更加强大和灵活。
总的来说，使用 AspectJ 可以提供更强大、更灵活的切面编程能力，同时具备更高的性能效率和更广泛的应用场景，是一个优秀的切面编程框架。
三、总结
本章节多了很多个理论知识点，连接点、通知、切入点、切面、代理、目标、织入，这本个理论很重要，也是 AOP 切面编程的最重要的知识，要想学好 AOP 就要理解它的思想，把这八个理解了就差不多了。
四、gitee 案例
案例完整地址：https://gitee.com/qiu-feng1/spring-framework.git
