AOP的基本使用

AOP简介

• AOP（Aspect Oriented Programming）面向切面编程，一种编程范式，指导开发者如何组织程序结构。
  • OOP（Object Oriented Programming）面向对象编程
• 作用：在不惊动原始设计的基础上为其进行功能增强
• Spring理念：无侵入式/无入侵式

在spring boot中使用导入依赖

<dependency>
	<groupId>org.aspectj</groupId>
	<artifactId>aspectjweaver</artifactId>
	<version>${aspectj}</version>
 </dependency>

核心概念

• 连接点（JoinPoint）：程序执行过程中的任意位置，粒度为执行方法，抛出异常，设置变量等
  • 在Spring中，理解为方法的执行
• 切入点（Pointcut）：匹配连接点的式子
  • 在spring中，一个切入点可以描述一个具体的方法，可以匹配多个方法
    • 一个具体的方法，com.xxx.dao包下的Dao接口中的某个方法
    • 匹配多个方法：如所有的save方法，所有的get开头的方法，所有带一个参数的方法等
• 通知（Advice）：在切入点出执行的操作，一般是共性功能
  • 在SpringAop中，功能最终以方法的形式呈现
• 通知类：定义通知的类
• 切面（Aspect）：描述通知与切入点的对应关系

代码演示

//定义接口
package com.xxx.dao
public interface BookDao{
	public void save();
}

//定义实现类
package com.xxx.impl
@Repository //定义Bean
public class BookDaoImpl implements BookDao{
	public void save() {}
}

//定义通知类
package com.xxx.advice
@Compenent  //定义Bean
@Aspect  //该注解表示该类是通知类
public call MyAdvice{
	//定义切入点
	//指定com.xxx.dao包下的 返回值为void无参的save()方法为切入点
	@Pointcut("execution(void com.xxx.dao.BookDao.save())")
	private void pointCut() {}

	//定义通知
	@Before("pointCut()") //指定切入点，在切入点之前执行下述通知
	public void advice(){
		//待执行代码
	}
}

//@EnableAspectJAutoProxy，在spring配置类中打开

上述代码会在执行dao包下的save()方法之前，先执行advice包下的advice()方法

AOP的工作流程

1. Spring容器启动
2. 读取所有切面配置中的切入点
3. 初始化Bean，判断bean对应的类中的方法是否匹配到任意的切入点
   • 匹配失败：创建对象
   • 匹配失败：创建原始对象（目标对象)的代理对象
4. 获取bean执行方法
   • 获取bean，调用方法并执行，完成操作
   • 获取的bean是代理对象，根据代理对象的运行模式运行原始方法与增强的内容，完成操作

• 目标对象（Target）：原始功能去掉通知功能对应的类产生的对象，这种对象是无法直接完成最终工作的
• 代理（Proxy）：目标对象无法直接直接完成工作，需要对其进行功能回填，通过原始对象的代理对象实现
• SpringAOP的本质：代理模式

AOP切入点表达式

• 语法格式
• 通配符
• 书写技巧

语法格式

• 切入点：要进行增强的方法
• 切入点表达式：要进行增强方法的描述方法

//定义接口
package com.xxx.dao
public interface BookDao{
	public void save();
}

//定义实现类
package com.xxx.impl
@Repository //定义Bean
public class BookDaoImpl implements BookDao{
	public void save() {}
}

//在通知类中
//描述方法一：执行com.xxx.dao包下BookDao接口中的无参无返回值save()方法
execution(void com.xxx.dao.BookDao.save())

//描述方法二：执行com.xxx.impl包下BookDaoPiml接口中的无参无返回值save()方法
execution(void com.xxx.impl.BookDaoImpl.save())

• 切入点表达式标准格式：动作关键字（访问修饰符 返回值 包名.类/接口名.方法名(参数) 异常名）
  execution（public void com.xxx.bao.BookDao.save()）

@Pointcut("execution(public * com.sky.mapper.*.*(..)) && @annotation(com.sky.annotation.AutoFill)")

• • 动作关键字：描述切入点的行为动作，例如 execution,@annotation 表示执行到指定切入点
  • 访问修饰符：public，private等，可以省略
  • 返回值
  • 包名
  • 类/接口
  • 方法名
  • 参数
  • 异常名：方法定义中抛出的指定异常，可以省略

通配符

可以使用通配符描述切入点，快速描述

• *：单个独立的任意符号，可以独立出现，也可以作为前缀或者后缀的匹配符出现

  • execute（public * com.xxx..BookDao.get(*)）
    • 返回值任意
    • com.xxx包下的所有一层包中
    • 所有包的BookDao接口中的所有以find 为前缀的方法
    • 前缀find的方法的参数为：一个任意类型的参数

• ..：多个连续的任意符号，可以独立出现，常用于简化包名与参数名的书写

  • execution（public User com…UserService.findById(…)）
    • com包下的所有包中
    • 所有包中的UserService接口中的findById()方法
    • findById方法的参数为：多个任意类型的参数
      *+：用于匹配子类类型
  • execution（* * . . * Service + . *(. .)）

书写技巧

• 所有代码按照规范开发，否则以下技巧全部失效
• 描述切入点通常描述接口,而不描述实现类
• 访问控制修饰符针对接口开发均采用public描述（**可以省略访问修饰符的描述）
• 返回值类型对于增删改类使用精准类型加速匹配，对于查询类使用*通配快速匹配
• 包名书写尽量不使用..匹配，效率过低，常采用单个*匹配
• 接口名/类名书写名称与模块相关的采用*匹配，如UserService书写为*service

AOP通知类型

• AOP的通知，在运行代码时可放入合理的位置
• AOP通知共分为5中类型
  • 前置通知，@Before
  • 后置通知，@After
  • 环绕通知，@Around
  • 返回后通知，@AfterReturning
  • 抛出异常后通知，@AfterThrowing

@Around注意事项

1. 环绕通知必须依赖形参ProceedingJoinPoint才能实现对原始方法的调用，进而实现原始方法调用前后同时添加通知
2. 通知中如果未使用ProceedingJoinPoint对原始方法进行调用，将跳过原始方法的执行
3. 都原始方法的调用可以不接收返回值，通知方法设置成void即可，如果接收返回值，通知返回值必须设定为Object类型
4. 原始方法的返回值如果是void类型，通知方法的返回值类型可以设置成void，也可以设置成Object
5. 由于无法预知原始方法运行后是否会抛出异常，因此环绕通知方法必循抛出Throwable对象

@Around("pt()")
public Object around(ProceddingJoinPoint pjp) throes Thrownble {
	//在切入点之前执行
	
	//调用proceed方法来执行切入点方法(原始方法)
	Object ret = pjp.proceed();
	
	//在切入点之后执行

	return ret
}

AOP通知获取数据

• 获取参数
• 获取返回值
• 获取异常

1. 获取切入点方法的参数
   • JoinPoint：适用于前置，后置，返回后，抛出异常后通知
   • ProceedJoinPoin：适用于环绕通知
2. 获取切入点方法返回值
   • 返回后通知
   • 环绕通知
3. 获取切入点方法运行异常信息
   • 抛出异常后通知
   • 环绕通知

获取参数

调用getArgs()方法，
如：joinPoin.getArgs();
proceedJoinPoint.getArgs();

@Before("pt()")
public void before(JoinPoint jp) {
	Object args = jp.getArgs();
}

@Around("pt()")
public Object around(ProceedingJoinPoint pjp) throws Throwable{
	Object args = pjp.getArgs();
}

获取返回值

• 返回后通知：获取原始方法的返回值需要给@AfterReturning设置returning属性，且通知需携带一个形参，形参名与returning属性值一致

@AfterReturning(value = "pt()", returning = "ret")
pbulic void afterReturning(Object ret){
	//ret即为原始方法的返回值
	//通知内容
}

• 环绕通知获取原始方法的返回值

@Around("pt()")
public Object around(ProceedingJoinPoint pjp) throws Throwable{
	//调用原始方法，获取器返回值
	Object ret = pjp.proceed();
	return ret;
}

对于环绕通知调用proceed()方法（即：调用原始方法）的返回值就是原始方法的返回值

获取异常

• 抛出异常后通知：在原始方法抛出异常后，通知可以获取原始方法的异常对象，使用形参可以接收异常对象，且在@AfterThrowing注解中添加throwing属性

@AfterThrowing(value = "pt()", throwing = "throw")
public void afterThrowing(Throwable throw) {
	//throw即为原始方法抛出的异常对象
}

• 环绕通知获取异常

@Around("pt()")
public Object around(ProceedingJoinPoint pjp) throws Throwable{
	Object ret = null;
	try {
		ret = pjp.proceed();
	} catch (Throwable throw) {
		//throw即为原始方法的异常对象
		throw.printStackTrace();
	}
	return ret;
}

扩展

• 当返回值和参数都要获取时，获取参数的形参在前，获取返回值的形参在后，否则将报错 ,用于获取返回后通知和环绕通知

@AfterReturning(value = "pt()", returning = "ret")
public void faterReturning(JoinPoint jp, Object ret){
	//jp获取形参 在 ret获取返回值 之前
}

• 对于 proceed() 调用原始方法的调用
  • 调用无参方法，即调用原始对象
  • 可以给proceed()方法传递一个数组对象，该数组对象保存的是原始对象的参数，可以修改原始方法的参数

@Around
public Object around(ProceedingJoinPoint pjp)throw Throwable {
	//获取原始方法的参数
	Object args = pjp.getArgs();
	//对参数进行修改
	args[0] = 111;
	//调用proceed()方法访问原始方法，并将参数args返回
	Object ret = pjp.proceed(args);  //此时，原始方法的参数已被修改
	return ret；
}

• ProceedingJoinPoint是JoinPoint的子类
  • 常用方法

返回值	方法名	描述
Object[ ]	pjp.getArgs()	获取原始方法的参数
Object	pjp.proceed()	调用原始方法
Signature	pjp.getSignature()	获取执行签名信息
String	signature. getDeclaringTypeName()	通过签名获取执行类型，即：获取接口名(包括包名)
String	signature.getName()	获取方法名

JoinPoint 简介

joinPoint连接点：用于获取目标类/目标方法的相关信息

常用方法：

• getTarget()：
  描述：该方法用于获取Join Point所关联的目标对象。在方法调用的Join Point中，这通常是被调用的方法所属的对象实例。
  用途：通过获取目标对象，我们可以在切面逻辑中访问该对象的属性和方法，或者根据对象类型执行不同的逻辑。

• getSignature()：
  描述：该方法用于获取Join Point的签名。签名通常包括方法名、参数类型和返回类型等信息。
  Signature有一个子接口 MethodSignature ，MethodSignature中有一个 getMethod() 方法可获取将要执行方法的Method对象（就像反射一样），因为在springboot中切入点一般都是指某个方法，所以我们在获取 Singnature 时可直接转 MethodSignature，利用反射方便获取方法的Method对象，从而获取方法的信息，常用的 Method 方法由 invoke() 方法，

  //通过反射获取目标对象
   MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
   Method method = methodSignature.getMethod();
  

  用途：通过获取签名，我们可以知道在Join Point上执行的具体是哪个方法，以及该方法的参数和返回类型。这对于日志记录、权限检查等场景非常有用。

• getArgs()：
  描述：该方法用于获取Join Point的参数列表。在方法调用的Join Point中，这通常是传递给被调用方法的参数值。
  用途：通过获取参数列表，我们可以在切面逻辑中检查参数的值，或者根据参数执行不同的逻辑。这对于参数验证、日志记录等场景非常有用。