Spring之AOP

AOP简介

• AOP(Aspect Oriented Programing)面向切面编程，是一种编程思想，一种编程范式，指导开发者如何组织程序结构。
  • Java的编程特点就是OOP(Object Oriented Programing)面向对象编程
• 作用：在不惊动原始设计的基础上进行功能增强。总而言之就是进行功能增强
• SpringAOP本质：代理模式

AOP核心概念

• 连接点(JoinPoint)：方法的执行
• 切入点(Pointcut)：用来描述一个具体方法，也可以匹配多个具体方法。
• 通知(advice)：在切入点执行的功能，也就是共性功能。
• 通知类：定义通知的类
• 切面(Aspect)：描述通知与切入点的对应关系

AOP入门案例（快速上手）

1.导入AOP相关坐标

<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>x.x.x</version>
</dependency>

由于spring-context坐标中已经依赖了spring-aop坐标，所以不需要再导入：

2.定义通知类，并制作通知

举例：

public class Myadvice(){ //定义通知类
     
    //定义通知
    public void before(){
    }
}

3.定义切入点

切入点定义依托在一个不具有实际意义的方法进行，即无参数、无返回值，方法体无实际逻辑

举例：

@Pointcut("execution(* *..*Service.*(..))")
private void pt(){}

4.绑定切入点与通知的关系，并指定通知添加到原始连接点的具体执行位置

举例：

@Component
@Aspect
public class Myadvice{  //通知类
    @Pointcut("execution(* *..*Service.*(..))") //切入点
    private void pt(){}

    @Before("pt()")  //使用AOP通知注解形式，指定要添加的位置
    public void before(){  //通知
    }
}

5.定义通知类受Spring容器管理，并定义当前类为切面类

举例：

@Component //受spring容器管理
@Aspect //定义为切面类
public class Myadvice{  //通知类
    @Pointcut("execution(* *..*Service.*(..))") //切入点
    private void pt(){}

    @Before("pt()")  //使用AOP通知注解形式，指定要添加的位置
    public void before(){  //通知
    }
}

6.开启Spring对AOP注解驱动支持

举例：

@Configuration
@ComponentScan("com.maoge")
@EnableAspectJAutoProxy //开启AOP切面注解功能
public class SpringConfig {

}

AOP工作流程

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

AOP核心概念：

• 目标对象(Target)：原始功能去掉共性功能对应的类产生的对象，这种对象是无法直接完成工作的
• 代理(Proxy)：目标对象无法直接完成工作，需要对其进行功能回填，通过原始对象的代理对象实现

AOP切入点表达式

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

1.语法格式

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

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

举例说明：

//对com.maoge.service包下BookService类下的login的方法的描述
execution(boolean com.maoge.service.BookService.login())

2.通配符

• *：单个独立的任意符号，可以独立出现，也可以作为前缀或者后缀的匹配符出现
• …：多个连续的任意符号，可以独立出现，常用于简化包名与参数的书写
• +：专用于匹配子类类型

举例说明：

//匹配com.maoge.service包下BookService类下的任意返回值类型的所有无参方法
execution(* com.maoge.service.BookService.*()))

//匹配com包下的任意包下的BookService类中的任意返回值类型的所有名为login的方法
execution(* com..BookService.login(..)

//匹配任意包下的以Service结尾的类名下的及其子类下的所有方法
execution(*  *..*Service+.*(..))

AOP通知

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

1.AOP通知类型

AOP通知共分为5种类型：

• 前置通知
• 后置通知
• 环绕通知
• 返回后通知
• 抛出异常后通知

举例说明:

• 首先定义一个切入点，使用 @Pointcut 注解，参数为切入点表达式

  @Pointcut("[切入点表达式]")
  private void pt(){}
  

• 前置通知使用 @Before 注解，参数value为切入点的方法名

  @Before("pt()")
  public void before(){
      System.out.println("这是前置通知");
  }
  

• 后置通知使用 @After 注解，参数value为切入点的方法名

  @After("pt()")
  public void after(){
  	 System.out.println("这是后置通知");
  }
  

• 环绕通知使用 @aRound 注解，参数value为切入点的方法名

  @Around("pt()")
  public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
       System.out.println("前面的通知");
       Object proceed = joinPoint.proceed();
       System.out.println("后面的通知");
       return proceed;
  }
  

• 返回后通知使用 @AfterReturning 注解，参数value为切入点的方法名

  @AfterReturning("pt()")
  public void afterReturning(){
      System.out.println("这是返回后通知");
  }
  

• 抛出异常后通知使用 @AfterThrowing 注解，参数value为切入点的方法名

  @AfterThrowing("pt()")
  public void afterThrowing(){
      System.out.println("这是抛出异常后通知");
  }
  

2.AOP通知获取数据

1.获取参数

获取参数：获取切入点方法的参数

• JoinPoint：JoinPoint对象描述了连接点方法的运行状态，可以获取到原始方法的调用参数。适用于前置、后置、返回后、抛出异常后通知
• ProceedJointPoint：是JoinPoint的子类。适用于环绕通知

举例说明：

//前置通知获取切入点方法参数
@Before("pt()")
public void before(JoinPoint joinPoint){
   //获取切入点方法参数数组
   Object[] args = joinPoint.getArgs();
   //进行打印
   System.out.println(Arrays.toString(args));
}
//后置、返回后、抛出异常通知与前置通知雷同

//环绕通知获取切入点方法参数
@Around("pt()")
public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
    Object proceed = joinPoint.proceed();
    //获取切入点方法参数数组
    Object[] args = joinPoint.getArgs();
    //进行打印
    System.out.println(Arrays.toString(args));
    return proceed;
}                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        

2.获取返回值

获取返回值：获取切入点方法的返回值
获取返回值的AOP通知只有两种：返回后通知(afterReturning)、环绕通知(aRound)：

• 返回后通知可以通过 @AfterReturning 注解中returning 的参数获取切入点方法的返回值，returning的值与方法的形参名一致

  @AfterReturning(value = "pt()",returning = "ret")
  public void afterReturning(Object ret){
       System.out.println(ret);
  }
  

• 环绕通知中可以手工书写对原始方法的调用，得到的结果即为原始方法的返回值

  @Around("pt()")
  public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
       //获取切入点方法返回值
       Object proceed = joinPoint.proceed();
       return proceed;
  }
  

3.获取异常

获取异常：获取切入点方法运行异常信息
获取异常的AOP通知只有两种：抛出异常后通知(afterThrowing)、环绕通知(aRound)：

• 抛出异常后通知可以获取切入点方法中出现的异常信息，使用形参可以接收对应的异常对象

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

• 环绕通知可以获取切入点方法运行的异常信息，使用形参可以接收运行时抛出的异常对象

  @Around("pt()")
  public Object around(ProceedingJoinPoint joinPoint){
          //获取切入点方法返回值
          Object proceed = null;
          try {
              proceed = joinPoint.proceed();
          } catch (Throwable t) {
              System.out.println(t);
              t.printStackTrace();
          }
          return proceed;
  }