1.准备工作，创建maven项目
1. pom.xml 加入依赖
<dependencies><!--spring核心坐标--><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>6.0.6</version></dependency> <!--测试--> <dependency><groupId>org.springframework</groupId><artifactId>spring-test</artifactId><version>6.0.6</version></dependency><!--注解--><dependency><groupId>jakarta.annotation</groupId><artifactId>jakarta.annotation-api</artifactId><version>2.1.1</version></dependency><!--junit5--><dependency><groupId>org.junit.jupiter</groupId><artifactId>junit-jupiter-api</artifactId><version>5.3.1</version><scope>test</scope></dependency></dependencies> |
2. 创建配置类
@Configuration@ComponentScan(basePackages = {"com.bdqn"})public class SpringConfig {} |
3. 准备计算器接口
package com.bdqn.proxy; public interface Calculator {int add(int i, int j);int sub(int i, int j);int mul(int i, int j);int div(int i, int j);} |
4.准备纯净计算器的实现类
package com.bdqn.proxy; /*** 实现计算接口,单纯添加 + - * / 实现! 掺杂其他功能!*/@Componentpublic class CalculatorImpl implements Calculator {@Overridepublic int add(int i, int j) {int result=i+j;System.out.println("结果："+result);return result;}@Overridepublic int sub(int i, int j) {int result=i-j;System.out.println("结果："+result);return result;}@Overridepublic int mul(int i, int j) {int result=i*j;System.out.println("结果："+result);return result;}@Overridepublic int div(int i, int j) {int result=i/j;System.out.println("结果："+result);return result;}} |
5.测试效果
@SpringJUnitConfig(classes = {SpringConfig.class})public class TestAop {@AutowiredCalculator c;@Testpublic void testCalculator(){c.add(10,2);System.out.println("----------");c.sub(10,2); System.out.println("----------");c.mul(10,2);System.out.println("----------");c.div(10,2);}} |
2.AOP 面向切面编程思想
| AOP：Aspect Oriented Programming面向切面编程 中文：面向切面编程 定义：在程序原有的纵向执行流程中，针对某一个或某一些方法添加通知形成横向切面过程，称为面向切面编程。  |
3.AOP思想主要的应用场景
| AOP（面向切面编程）是一种编程范式，它通过将通用的横切关注点（如日志、事务、权限控制等）与业务逻辑分离，使得代码更加清晰、简洁、易于维护。AOP可以应用于各种场景，以下是一些常见的AOP应用场景： 1. 日志记录：在系统中记录日志是非常重要的，可以使用AOP来实现日志记录的功能，可以在方法执行前、执行后或异常抛出时记录日志。 2. 事务处理：在数据库操作中使用事务可以保证数据的一致性，可以使用AOP来实现事务处理的功能，可以在方法开始前开启事务，在方法执行完毕后提交或回滚事务。 3. 安全控制：在系统中包含某些需要安全控制的操作，如登录、修改密码、授权等，可以使用AOP来实现安全控制的功能。可以在方法执行前进行权限判断，如果用户没有权限，则抛出异常或转向到错误页面，以防止未经授权的访问。 4. 性能监控：在系统运行过程中，有时需要对某些方法的性能进行监控，以找到系统的瓶颈并进行优化。可以使用AOP来实现性能监控的功能，可以在方法执行前记录时间戳，在方法执行完毕后计算方法执行时间并输出到日志中。 5. 异常处理：系统中可能出现各种异常情况，如空指针异常、数据库连接异常等，可以使用AOP来实现异常处理的功能，在方法执行过程中，如果出现异常，则进行异常处理（如记录日志、发送邮件等）。 6. 缓存控制：在系统中有些数据可以缓存起来以提高访问速度，可以使用AOP来实现缓存控制的功能，可以在方法执行前查询缓存中是否有数据，如果有则返回，否则执行方法并将方法返回值存入缓存中。 7. 动态代理：AOP的实现方式之一是通过动态代理，可以代理某个类的所有方法，用于实现各种功能。 综上所述，AOP可以应用于各种场景，它的作用是将通用的横切关注点与业务逻辑分离，使得代码更加清晰、简洁、易于维护。 |
4.AOP术语名词介绍
| 切点： 原有功能。 Pointcut 如：sub()方法 通知： 在切点前后执行。 Advice --前置通知：在切点前执行 --正常返回后置通知：在切点成功结束后执行（**寿终正寝**） --异常后置通知：在切点出现异常后执行（**死于非命**） --后置通知：在切点最终结束后执行（**盖棺定论**） --环绕通知：使用try...catch...finally结构围绕整个被代理的目标方法，包括上面四种通知对应的所有位置] 切面： 所有功能统称。 织入： 将通知切面嵌入到切点生成代理对象的过程。 |
5.Spring Aop基于注解方式实现
1.Spring Aop 底层技术组成
 动态代理（InvocationHandler）：JDK原生的实现方式，需要被代理的目标类必须实现接口。因为这个技术要求代理对象和目标对象实现同样的接口（兄弟两个拜把子模式）。 cglib：通过继承被代理的目标类（认干爹模式）实现代理，所以不需要目标类实现接口 AspectJ：早期的AOP实现的框架，SpringAOP借用了AspectJ中的AOP注解。 |
2. 实现步骤
1. pom.xml 加入AOP相关的依赖
<!--spring核心坐标，引入AOP坐标--><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>6.0.6</version></dependency><!--spring-aop依赖的aspectjweaver--><dependency><groupId>org.springframework</groupId><artifactId>spring-aspects</artifactId><version>6.0.6</version></dependency> |
2. 声明切面类
package com.bdqn.advice;import org.aspectj.lang.annotation.*;import org.springframework.stereotype.Component;//@Aspect表示这个类是一个切面类@Aspect//@Component注解保证这个切面类能够放入IOC容器@Componentpublic class LogAdvice {/*** 前置通知* @Before注解：声明当前方法是前置通知方法* value属性：指定切入点表达式，由切入点表达式控制当前通知方法要作用在哪一个目标方法上*/@Before(value = "execution(* com.bdqn.proxy.CalculatorImpl.*(..))")public void logBefore() {System.out.println("[AOP前置通知] 方法开始了");}/*** 正常后置通知：只有切点正常返回，才会执行*/@AfterReturning(value = "execution(* com.bdqn.proxy.CalculatorImpl.*(..))")public void logAfterSuccess() {System.out.println("[AOP返回通知] 方法成功返回了");}/*** 异常通知：只有切点出现异常，才会执行*/@AfterThrowing(value = "execution(* com.bdqn.proxy.CalculatorImpl.*(..))")public void logAfterException() {System.out.println("[AOP异常通知] 方法抛异常了");}/*** finally后置通知：不管是否出现异常，都会执行*/@After(value = "execution(* com.bdqn.proxy.CalculatorImpl.*(..))")public void logFinally() {System.out.println("[AOP后置通知] 方法最终结束了");} } |
3. 配置类方式,开启aspectj注解支持
@Configuration@ComponentScan(basePackages = {"com.bdqn"})//作用等于 <aop:aspectj-autoproxy /> 配置类上开启 Aspectj注解支持!@EnableAspectJAutoProxypublic class SpringConfig{} |
4.测试效果
@SpringJUnitConfig(classes = {SpringConfig.class})public class TestAop {@AutowiredCalculator c;@Testpublic void testCalculator(){c.add(10,20);System.out.println("----------");c.div(10,5);System.out.println("----------");c.div(10,0);}} |
5. 输出结果
 |
6.获取通知细节信息
1.JointPoint接口
需要获取方法签名、传入的实参等信息时，可以在通知方法声明JoinPoint类型的形参。
要点1：JoinPoint 接口通过 getSignature() 方法获取目标方法的签名（方法声明时的完整信息）
要点2：通过目标方法签名对象获取方法名
要点3：通过 JoinPoint 对象获取外界调用目标方法时传入的实参列表组成的数组
/*** 前置通知* @Before注解：声明当前方法是前置通知方法* value属性：指定切入点表达式，由切入点表达式控制当前通知方法要作用在哪一个目标方法上* 在方法形参位置声明一个JoinPoint类型的参数，Spring就会将这个对象传入根据JoinPoint对象就可以获取目标方法名称、实际参数列表*/@Before(value = "execution(* com.bdqn.proxy.CalculatorImpl.*(..))")public void logBefore(JoinPoint joinPoint) {// 1.通过JoinPoint对象获取目标方法签名对象// 方法的签名：一个方法的全部声明信息Signature signature = joinPoint.getSignature();// 2.通过方法的签名对象获取目标方法的详细信息//获取目标方法名String methodName = signature.getName();System.out.println("methodName = " + methodName);//获取目标方法修饰符int modifiers = signature.getModifiers();System.out.println("modifiers = " + modifiers);//获取目标获取带修饰符的类路径String declaringTypeName = signature.getDeclaringTypeName();System.out.println("declaringTypeName = " + declaringTypeName);// 3.通过JoinPoint对象获取外界调用目标方法时传入的实参列表Object[] args = joinPoint.getArgs();System.out.println("[AOP前置通知] " + methodName + "方法开始了，参数列表：" + Arrays.toString(args));} |
2.方法返回值
在返回通知中，通过@AfterReturning注解的returning属性获取目标方法的返回值！
/*** 正常后置通知：只有切点正常返回，才会执行* 在返回通知中获取目标方法返回值分两步：* 第一步：在@AfterReturning注解中通过returning属性设置一个名称* 第二步：使用returning属性设置的名称在通知方法中声明一个对应的形参*/@AfterReturning(value = "execution(* com.bdqn.proxy.CalculatorImpl.*(..))",returning = "targetMethodReturnValue")public void logAfterSuccess(JoinPoint joinPoint, Object targetMethodReturnValue) {String methodName = joinPoint.getSignature().getName();System.out.println("[AOP返回通知] "+methodName+"方法成功结束了，返回值是：" + targetMethodReturnValue);} |
3.异常对象捕捉
在异常通知中，通过@AfterThrowing注解的throwing属性获取目标方法抛出的异常对象
/*** 异常通知：只有切点出现异常，才会执行* 在异常通知中获取目标方法抛出的异常分两步：* 第一步：在@AfterThrowing注解中声明一个throwing属性设定形参名称* 第二步：使用throwing属性指定的名称在通知方法声明形参，Spring会将目标方法抛出的异常对象从这里传给我们*/@AfterThrowing(value = "execution(* com.bdqn.proxy.CalculatorImpl.*(..))",throwing = "e")public void logAfterException(JoinPoint joinPoint,Throwable e) {String methodName = joinPoint.getSignature().getName();System.out.println("[AOP异常通知] "+methodName+"方法抛异常了，异常类型是：" + e.getClass().getName());} |
4.切点表达式语法
1.切点表达式作用
AOP切点表达式（Pointcut Expression）是一种用于指定切点的语言，它可以通过定义匹配规则，来选择需要被切入的目标对象。
 |
2. 切点表达式语法
 |
5.重用(提取)切点表达式
1. 重用切点表达式优点
@Before(value = "execution(* com.bdqn.proxy.CalculatorImpl.*(..))")public void logBefore() {System.out.println("[AOP前置通知] 方法开始了");}/*** 正常后置通知：只有切点正常返回，才会执行*/@AfterReturning(value = "execution(* com.bdqn.proxy.CalculatorImpl.*(..))")public void logAfterSuccess() {System.out.println("[AOP返回通知] 方法成功返回了");}/*** 异常通知：只有切点出现异常，才会执行*/@AfterThrowing(value = "execution(* com.bdqn.proxy.CalculatorImpl.*(..))")public void logAfterException() {System.out.println("[AOP异常通知] 方法抛异常了");}/*** finally后置通知：不管是否出现异常，都会执行*/@After(value = "execution(* com.bdqn.proxy.CalculatorImpl.*(..))")public void logFinally() {System.out.println("[AOP后置通知] 方法最终结束了");} |
上面案例，是我们之前编写切点表达式的方式，发现， 所有增强方法的切点表达式相同！
出现了冗余，如果需要切换也不方便统一维护！
我们可以将切点提取，在增强上进行引用即可！
2.内部引用
2.1 提取
/*** 提取切点:切入点表达式重用*/@Pointcut("execution(* com.bdqn.proxy.CalculatorImpl.*(..))")public void pointcut() {} |
2.2 同一类引用
@Before(value = "pointcut()")public void logBefore(JoinPoint joinPoint) { |
2.3 不同类中引用
@Before(value = "com.bdqn.advice.LogAdvice.pointcut()")public void logBefore(JoinPoint joinPoint) { |
3.切点统一管理
| @Component public class AtguiguPointCut {
@Pointcut(value = "execution(public int *..Calculator.sub(int,int))") public void atguiguGlobalPointCut(){}
@Pointcut(value = "execution(public int *..Calculator.add(int,int))") public void atguiguSecondPointCut(){}
@Pointcut(value = "execution(* *..*Service.*(..))") public void transactionPointCut(){} } |
6. 环绕通知
环绕通知对应整个 try...catch...finally 结构，包括前面四种通知的所有功能。
/*** 环绕通知=前置+后置通知+异常通知* 通过在通知方法形参位置声明ProceedingJoinPoint类型的形参，Spring会将这个类型的对象传给我们*/@Around(value = "pointcut()")public Object txArroud(ProceedingJoinPoint joinPoint) {// 通过ProceedingJoinPoint对象获取外界调用目标方法时传入的实参数组Object[] args = joinPoint.getArgs();// 通过ProceedingJoinPoint对象获取目标方法的签名对象Signature signature = joinPoint.getSignature();// 通过签名对象获取目标方法的方法名String methodName = signature.getName();// 声明变量用来存储目标方法的返回值Object result = null;try {// 在目标方法执行前：开启事务（模拟）System.out.println("[AOP 环绕通知] 开启事务，方法名：" + methodName + "，参数列表：" + Arrays.asList(args));// 过ProceedingJoinPoint对象调用目标方法目标方法的返回值一定要返回给外界调用者result = joinPoint.proceed(args);// 在目标方法成功返回后：提交事务（模拟）System.out.println("[AOP 环绕通知] 提交事务，方法名：" + methodName + "，方法返回值：" + result);}catch (Throwable e){// 在目标方法抛异常后：回滚事务（模拟）System.out.println("[AOP 环绕通知] 回滚事务，方法名：" + methodName + "，异常：" + e.getClass().getName());}finally {// 在目标方法最终结束后：释放数据库连接System.out.println("[AOP 环绕通知] 释放数据库连接，方法名：" + methodName);}return result;} |
7. Spring AOP的jdk 和Cglib动态代理生效
在目标类没有实现任何接口的情况下，Spring会自动使用cglib技术实现代理。
总结：
| a. 如果目标类有接口,选择使用jdk动态代理 b. 如果目标类没有接口,选择cglib动态代理 c. 如果有接口,接口接值 d. 如果没有接口,类进行接值 |
8. 注解实现总结
 |
9.Spring Aop基于XML方式实现 (了解)
1. 准备工作
| 加入依赖：和基于注解的 AOP 时一样 准备代码:把测试基于注解功能时的Java类复制到新module中，去除所有注解。 |
2. 配置Spring配置文件
<?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"><!-- 开启aspectj框架注解支持--><aop:aspectj-autoproxy></aop:aspectj-autoproxy><!-- 配置目标类的bean --><bean id="calculator" class="com.bdqn.proxy.CalculatorImpl"/><!-- 配置切面类的bean --><bean id="logAdvice" class="com.bdqn.advice.LogAdvice"/><!-- 配置AOP --><aop:config><!-- 配置切入点表达式 --><aop:pointcut id="logPointCut" expression="execution(* com.bdqn.proxy.CalculatorImpl.*(..))"/><!-- aop:aspect标签：配置切面 ref属性：关联切面类的bean --><aop:aspect ref="logAdvice"><!-- aop:before标签：配置前置通知 --><!-- method属性：指定前置通知的方法名 --><!-- pointcut-ref属性：引用切入点表达式 --><aop:before method="logBefore" pointcut-ref="logPointCut"/><!-- aop:after-returning标签：配置返回通知 --><!-- returning属性：指定通知方法中用来接收目标方法返回值的参数名 --><aop:after-returning method="logAfterSuccess" pointcut-ref="logPointCut" returning="targetMethodReturnValue"/><!-- aop:after-throwing标签：配置异常通知 --><!-- throwing属性：指定通知方法中用来接收目标方法抛出异常的异常对象的参数名 --><aop:after-throwing method="logAfterException" pointcut-ref="logPointCut" throwing="e"/><!-- aop:after标签：配置后置通知 --><aop:after method="logFinally" pointcut-ref="logPointCut"/><!-- aop:around标签：配置环绕通知 --><aop:around method="logArroud" pointcut-ref="logPointCut"/></aop:aspect></aop:config></beans> |
3. 测试
@SpringJUnitConfig(locations = "classpath:applicationContext.xml")public class TestAop {@AutowiredCalculator c;@Testpublic void testCalculator(){c.add(10,20);System.out.println("----------");c.div(10,0);}} |
