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

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

作用：

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

核心概念

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

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

现给一个入门案例：

注解配置类：

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

切面：

java 复制代码

@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());
    }
}

连接点及实现类：

java 复制代码

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

java 复制代码

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

    @Override
    public void update() {
        System.out.println("book dao update...");
    }
}

测试：

java 复制代码

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对应的类中的方法是否匹配到任意切入点

匹配失败，创建对象

java 复制代码

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

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

java 复制代码

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. 切入点表达式的标准格式

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

java 复制代码

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

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

通配符描述切入点：

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

java 复制代码

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

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

java 复制代码

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

+ ： 专用于匹配子类型
java 复制代码
```
execution(* *..*Dao+.*(..))
```

通知类型

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

AOP通知共分为5种类型：

前置通知：@Before

java 复制代码

@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。如果方法异常也会执行

java 复制代码

@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
java 复制代码
```
@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：适用于前置、后置、返回后、抛出异常后通知，必须是第一个参数。现以前置为例：

java 复制代码

//接口实现类的方法
@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：适用于环绕通知

java 复制代码

 @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

获取切入点方法返回值

返回后通知

java 复制代码

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

环绕通知。

java 复制代码

 @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就是方法的返回值
}

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

抛出异常后通知

java 复制代码

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

环绕通知。

java 复制代码

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