spring之AOP(面向切面编程)之详结

AOP面向切面编程，一种编程范式，指导开发者如何组织程序结构

作用：

在不惊动原始设计的基础上为其进行功能增强

核心概念

代理：SpringAOP的核心本质是采用代理模式实现的
连接点：程序执行过程中的任意位置，粒度为执行方法、抛出异常、设置变量等
- 在springAOP中，理解为方法的执行
切入点：匹配连接点的式子
- 在springAOP中，一个切入点可以只描述一个具体方法，也可以匹配多个方法
通知：在切入点出执行的操作，也就是共性功能，在AOP中，功能最终以方法的形式呈现
通知类：定义通知的类
切面：描述通知与切入点的对应关系

如果不理解的话可以看这一段话帮助理解：连接点（所有英雄）、切入点（增强的英雄）、通知类（buff库）、通知（各种buff）、切面（可以理解为设计师，从buff库里面拿出具体的buff加强给英雄）

现给一个入门案例：

注解配置类：

@Configuration
@ComponentScan("com.example")
@EnableAspectJAutoProxy  //切面相关注解
public class SpringConfig {
}

切面：

@Component  //交给spring来管理
@Aspect //声明这个类是切面
public class MyAdvice {//定义一个私有的切入点@Pointcut("execution(void com.example.dao.BookDao.update())")private void pt(){}//通知在方法前执行@Before("pt()")public void method(){System.out.println(System.currentTimeMillis());}
}

连接点及实现类：

public interface BookDao {public void save();public void update();
}

@Repository
public class BookDaoImpl implements BookDao {@Overridepublic void save() {System.out.println("book dao save...");}@Overridepublic void update() {System.out.println("book dao update...");}
}

测试：

public class Aop {public static void main(String[] args) {ApplicationContext ctx= new AnnotationConfigApplicationContext(SpringConfig.class);BookDao bookDao = ctx.getBean(BookDao.class);bookDao.update();}
}
//输出
1712407510166
book dao update...

工作流程

Spring容器启动
读取所有切面配置中的切入点

初始化bean，判定bean对应的类中的方法是否匹配到任意切入点

匹配失败，创建对象

public static void main(String[] args) {ApplicationContext ctx= new AnnotationConfigApplicationContext(SpringConfig.class);BookDao bookDao = ctx.getBean(BookDao.class);//bookDao.update();System.out.println(bookDao);System.out.println(bookDao.getClass());}//输出
com.example.dao.impl.BookDaoImpl@b3ca52e
class com.example.dao.impl.BookDaoImpl

匹配成功，创建原始对象(目标对象)的代理对象。目标对象：原始功能去掉共性功能对应的类产生的对象，这种对象是无法直接完成最终工作的。代理：目标对象无法直接完成工作，需要对其进行功能回调，通过原始对象的代理对象实现

public static void main(String[] args) {ApplicationContext ctx= new AnnotationConfigApplicationContext(SpringConfig.class);BookDao bookDao = ctx.getBean(BookDao.class);//bookDao.update();System.out.println(bookDao);System.out.println(bookDao.getClass());}//输出
com.example.dao.impl.BookDaoImpl@7530ad9c
class com.sun.proxy.$Proxy19

获取bean的执行方法
1. 获取bean，调用方法并执行，完成操作
2. 获取的bean是代理对象时，根据代理对象的运行模式运行原始方法与增强的内容，完成操作

切入点表达式

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

1. 描述方式

方式1：执行com.example.dao包下的BookDao接口中的无参数update方法：execution(void com.example.dao.BookDao.update())
方式2：执行com.example.dao.impl包下的BookDaoImpl类中的无参数update方法：execution(void com.example.dao.impl.BookDaoImpl.update())

2. 切入点表达式的标准格式

格式：动作关键字(访问修饰符返回值包名.类/接口名.方法名（参数）异常名)

execution(public void com.example.dao.impl.BookDaoImpl.update(int))

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

通配符描述切入点：

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

//匹配com.example包下任意包中的BookDao类或接口中所有update开头的带有一个参数的方法
execution(public * com.example.*.BookDao.update*(*))

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

//匹配com包下任意包中的BookDao类或接口中所有名称为update的方法
execution(public Book com..BookDao.update(..))

+ ：专用于匹配子类型
```
execution(* *..*Dao+.*(..))
```

通知类型

AOP通知描述了抽取的共性功能，根据共性功能抽取的位置不同，最终运行代码时要将其加入到合理的位置

AOP通知共分为5种类型：

前置通知：@Before

@Component  //交给spring来管理
@Aspect //声明这个类是切面
public class MyAdvice {//定义一个私有的切入点@Pointcut("execution(void com.example.dao.BookDao.update())")private void pt(){}//通知在方法前执行@Before("pt()")public void method(){System.out.println(System.currentTimeMillis());}
}
//输出
1712407510166
book dao update...

后置通知：@After。如果方法异常也会执行

@Component  //交给spring来管理
@Aspect //声明这个类是切面
public class MyAdvice {//定义一个私有的切入点@Pointcut("execution(void com.example.dao.BookDao.update())")private void pt(){}@After("pt()")public void method(){System.out.println(System.currentTimeMillis());}
}//输出
book dao update...
1712407576367

环绕通知：@Around
```
@Component  //交给spring来管理
@Aspect //声明这个类是切面
public class MyAdvice {//定义一个私有的切入点@Pointcut("execution(void com.example.dao.BookDao.update())")private void pt(){}@Around("pt()")public void method(ProceedingJoinPoint pjp) throws Throwable {System.out.println("around before advice...");//表示对原始操作的调用pjp.proceed();//如果方法有返回值的话用以下//Object proceed = pjp.proceed();System.out.println("around after advice...");}
}//输出
around before advice...
book dao update...
around after advice...
```
- 注意事项：
  - 环绕通知必须依赖形参ProceedingJoinPoint才能实现对原始方法的调用，进而实现原始方法调用前后同时添加通知
  - 通知中如果未使用ProceedingJoinPoint对原始方法进行调用将跳过原始方法的执行
  - 对原始方法的调用可以不接收返回值，通知方法设置成void即可，如果接收返回值，必须设定为Object类型
  - 原始方法的返回值如果是void类型，通知方法的返回值类型可以设置成void，也可以设置成Object类型
  - 由于无法预知原始方法运行后是否会抛出异常，因此环绕通知方法必须抛出Throwable对象
返回后通知：@AfterRunning。方法执行完后执行，如果方法异常不会执行
抛出异常后通知：@AfterThrowing。方法异常会执行，无异常则不执行

通知获取数据

获取切入点方法的参数

JoinPoint：适用于前置、后置、返回后、抛出异常后通知，必须是第一个参数。现以前置为例：

//接口实现类的方法
@Override
public String findName(int id) {System.out.println("id:"+id);return "test";
}//前置通知
//定义一个私有的切入点@Pointcut("execution(* com.example.dao.BookDao.findName(..))")private void pt(){}@Before("pt()")public void before(JoinPoint joinPoint){//获取方法的参数Object[] args = joinPoint.getArgs();System.out.println(Arrays.toString(args));System.out.println("before advice...");}//测试public static void main(String[] args) {ApplicationContext ctx= new AnnotationConfigApplicationContext(SpringConfig.class);BookDao bookDao = ctx.getBean(BookDao.class);String name = bookDao.findName(100);System.out.println(name);}//输出
[100]
before advice...
id:100
test

ProceedingJoinPoint：适用于环绕通知

 @Around("pt()")public Object around(ProceedingJoinPoint pjp) throws Throwable {//获取方法的参数Object[] args = pjp.getArgs();System.out.println(Arrays.toString(args));//可以对原始操作的参数进行修改args[0]=666;Object proceed = pjp.proceed(args);//args可加可不加，默认是方法的参数，修改后传递的是修改的数据return proceed;
}
//测试public static void main(String[] args) {ApplicationContext ctx= new AnnotationConfigApplicationContext(SpringConfig.class);BookDao bookDao = ctx.getBean(BookDao.class);String name = bookDao.findName(100);System.out.println(name);}//输出
[100]
id:666
test

获取切入点方法返回值

返回后通知

@AfterReturning(value = "pt()",returning = "ret")public void afterReturning(Object ret){System.out.println("方法的返回值是："+ret);System.out.println("afterReturning advice...");}

环绕通知。

 @Around("pt()")public Object around(ProceedingJoinPoint pjp) throws Throwable {//获取方法的参数Object[] args = pjp.getArgs();System.out.println(Arrays.toString(args));//可以对原始操作的参数进行修改args[0]=666;Object proceed = pjp.proceed(args);//args可加可不加，默认是方法的参数，修改后传递的是修改的数据return proceed;//proceed就是方法的返回值
}

获取切入点方法运行异常信息

抛出异常后通知

@AfterThrowing(value = "pt()",throwing = "t")public void afterThrowing(Throwable t){System.out.println("afterThrowing advice...");}

环绕通知。

@Around("pt()")public Object around(ProceedingJoinPoint pjp) throws Throwable {Object ret=null;try {ret= pjp.proceed();} catch (Throwable e) {e.printStackTrace();}return ret;}