SpringBoot AOP - 技术栈

AOP 简述

Aspect Oriented Programming（面向切面编程），对某一种事情的统一处理

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

简单实用

记录代码中每个方法的实行时间

package com.bite.book.aspect;


import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

@Slf4j
@Aspect
@Component
public class TimeAspect {

    @Around("execution(* com.bite.book.controller.*.*(..))")
    public Object timeAspect(ProceedingJoinPoint joinPoint) throws Throwable {
        long start = System.currentTimeMillis();
        Object result = joinPoint.proceed();
        long end = System.currentTimeMillis();
        log.info(joinPoint.getSignature().getName() + "方法执行时间：" + (end - start) + "ms");
        return result;
    }
}

对程序进行简单的讲解:

@Aspect: 标识这是一个切面类
@Around: 环绕通知, 在目标方法的前后都会被执行. 后面的表达式表示对哪些方法进行增强.
ProceedingJoinPoint.proceed() 让原始方法执行

代码执行逻辑

我们通过AOP入门程序完成了业务接口执行耗时的统计.

通过上面的程序, 我们也可以感受到AOP面向切面编程的一些优势：

• 代码无侵入: 不修改原始的业务方法, 就可以对原始的业务方法进行了功能的增强或者是功能的改变

• 减少了重复代码

• 提高开发效率

• 维护方便

Spring AOP

切点(Pointcut)

切点(Pointcut), 也称之为"切入点"，Pointcut 的作用就是提供一组规则 (使用 AspectJ pointcut expression language 来描述), 告诉程序对哪些方法来进行功能增强.

红框中的表达式就是切点表达式

连接点(Join Point)

满足切点表达式规则的方法, 就是连接点. 也就是可以被AOP控制的方法

以入门程序举例, 所有 com.example.demo.controller 路径下的方法, 都是连接点.

package com.bite.book.controller;

import com.bite.book.constant.Constants;
import com.bite.book.enums.ResultCode;
import com.bite.book.model.*;
import com.bite.book.service.BookService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.http.HttpSession;
import java.util.Arrays;
import java.util.List;


@Slf4j
@RequestMapping("/book")
@RestController
public class BookController {

    @Autowired
    private BookService bookService;

    @RequestMapping("/getBookListByPage")
    public Result getBookListByPage(PageRequest pageRequest, HttpSession session){
    }

    @RequestMapping(value = "/addBook", produces = "application/json")
    public String addBook(BookInfo bookInfo){
    }

    @RequestMapping("/queryBookInfoById")
    public BookInfo queryBookInfoById(Integer bookId){

    @RequestMapping(value = "/updateBook",  produces = "application/json")
    public String updateBook(BookInfo bookInfo){
    }

    @RequestMapping(value = "/batchDelete", produces = "application/json")
    public String batchDelete(@RequestParam List<Integer> ids){
    }
}

上述BookController 中的方法都是连接点

切点和连接点的关系

连接点是满足切点表达式的元素. 切点可以看做是保存了众多连接点的一个集合.

比如:

切点表达式: 比特全体教师

连接点就是: 张三,李四等各个老师

通知(Advice)

通知就是具体要做的工作, 指哪些重复的逻辑，也就是共性功能(最终体现为一个方法)比如上述程序中记录业务方法的耗时时间, 就是通知.

在AOP面向切面编程当中, 我们把这部分重复的代码逻辑抽取出来单独定义, 这部分代码就是通知的内容.

切面(Aspect)

切面(Aspect) = 切点(Pointcut) + 通知(Advice)，通过切面就能够描述当前AOP程序需要针对于哪些方法, 在什么时候执行什么样的操作.切面既包含了通知逻辑的定义, 也包括了连接点的定义.

切面所在的类, 我们一般称为切面类(被@Aspect注解标识的类)

通知类型

@Around 就是其中一种通知类型, 表示环绕通知.

Spring中AOP的通知类型有以下几种:

• @Around: 环绕通知, 此注解标注的通知方法在目标方法前, 后都被执行

• @Before: 前置通知, 此注解标注的通知方法在目标方法前被执行

• @After: 后置通知, 此注解标注的通知方法在目标方法后被执行, 无论是否有异常都会执行

• @AfterReturning: 返回后通知, 此注解标注的通知方法在目标方法后被执行, 有异常不会执行

• @AfterThrowing: 异常后通知, 此注解标注的通知方法发生异常后执行

package com.bite.book.aspect;


import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Slf4j
@Aspect
@Component
public class TimeAspect {


    @Before("execution(* com.bite.book.controller.*.*(..))")
    public void doBefore() {
        log.info("方法执行前 --- bofore ");
    }

    @After("execution(* com.bite.book.controller.*.*(..))")
    public void doAfter() {
        log.info("方法执行后 --- After");
    }

    @AfterReturning("execution(* com.bite.book.controller.*.*(..))")
    public void doAfterReturning() {
        log.info("方法执行后，返回结果 --- AfterReturning");
    }

    @AfterThrowing("execution(* com.bite.book.controller.*.*(..))")
    public void doAfterThrowing() {
        log.info("方法执行后，抛出异常 --- AfterThrowing");
    }

    @Around("execution(* com.bite.book.controller.*.*(..))")
    public Object timeAspect(ProceedingJoinPoint joinPoint) throws Throwable {
        log.info("方法执行前 --- Around");
        Object result = joinPoint.proceed();
        log.info("方法执行后，返回结果 --- Around");
        return result;
    }
}

@RequestMapping("/test")
@RestController
public class TestController {
    @RequestMapping("/t1")
    public String t1() {
        return "t1";
    }
    @RequestMapping("/t2")
    public boolean t2() {
        int a = 10 / 0;
        return true;
    }
}

程序正常运行的情况下, @AfterThrowing 标识的通知方法不会执行，从上图也可以看出来, @Around 标识的通知方法包含两部分, 一个"前置逻辑", 一个"后置逻辑".其中"前置逻辑" 会先于@Before 标识的通知方法执行, "后置逻辑" 会晚于@After 标识的通知方法执行

异常时候的情况

程序发生异常的情况下：

• @AfterReturning 标识的通知方法不会执行， @AfterThrowing 标识的通知方法执行了

• @Around 环绕通知中原始方法调用时有异常，通知中的环绕后的代码逻辑也不会在执行了(因为原始方法调用出异常了)

注意事项:

• @Around 环绕通知需要调用 ProceedingJoinPoint.proceed() 来让原始方法执行, 其他通知不需要考虑目标方法执行.

• @Around 环绕通知方法的返回值, 必须指定为Object, 来接收原始方法的返回值, 否则原始方法执行完毕, 是获取不到返回值的.

• 一个切面类可以有多个切点.

@PointCut

上面代码出现了大量重复的切点表达式execution(*com.example.demo.controller.*.*(..)) , Spring提供了@PointCut 注解, 把公共的切点表达式提取出来, 需要用到时引用该切入点表达式即可.

package com.bite.book.aspect;


import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Slf4j
@Aspect
@Component
public class TimeAspect {

    @Pointcut("execution(* com.bite.book.controller.*.*(..))")
    public void pointCut() {}

    @Before("pointCut()")
    public void doBefore() {
        log.info("方法执行前 --- bofore ");
    }

    @After("pointCut()")
    public void doAfter() {
        log.info("方法执行后 --- After");
    }

    @AfterReturning("pointCut()")
    public void doAfterReturning() {
        log.info("方法执行后，返回结果 --- AfterReturning");
    }

    @AfterThrowing("pointCut()")
    public void doAfterThrowing() {
        log.info("方法执行后，抛出异常 --- AfterThrowing");
    }

    @Around("pointCut()")
    public Object timeAspect(ProceedingJoinPoint joinPoint) throws Throwable {
        log.info("方法执行前 --- Around");
        Object result = joinPoint.proceed();
        log.info("方法执行后，返回结果 --- Around");
        return result;
    }
}

切面优先级@Order

当我们在一个项目中, 定义了多个切面类时, 并且这些切面类的多个切入点都匹配到了同一个目标方法.当目标方法运行的时候, 这些切面类中的通知方法都会执行, 那么这几个通知方法的执行顺序是什么样的呢?

@Slf4j
@Component
public class AspectDemo2 {
    @Pointcut("execution(* com.bite.book.controller.*.*(..))")
    private void pt(){}
    //前置通知
    @Before("pt()")
    public void doBefore() {
        log.info("执行 AspectDemo2 -> Before 方法");
    }
    //后置通知
    @After("pt()")
    public void doAfter() {
        log.info("执行 AspectDemo2 -> After 方法");
    }
}

package com.bite.book.aspect;

import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

@Slf4j
@Component
public class AspectDemo3 {
    @Pointcut("execution(* com.bite.book.controller.*.*(..))")
    private void pt(){}
    //前置通知
    @Before("pt()")
    public void doBefore() {
        log.info("执行 AspectDemo3 -> Before 方法");
    }
    //后置通知
    @After("pt()")
    public void doAfter() {
        log.info("执行 AspectDemo3 -> After 方法");
    }
}

package com.bite.book.aspect;

import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

@Slf4j
@Component
public class AspectDemo4 {
    @Pointcut("execution(* com.bite.book.controller.*.*(..))")
    private void pt(){}
    //前置通知
    @Before("pt()")
    public void doBefore() {
        log.info("执行 AspectDemo4 -> Before 方法");
    }
    //后置通知
    @After("pt()")
    public void doAfter() {
        log.info("执行 AspectDemo4 -> After 方法");
    }
}

存在多个切面类时, 默认按照切面类的类名字母排序：

• @Before 通知：字母排名靠前的先执行

• @After 通知：字母排名靠前的后执行

但这种方式不方便管理, 我们的类名更多还是具备一定含义的.Spring 给我们提供了一个新的注解, 来控制这些切面通知的执行顺序: @Order

@Order 注解标识的切面类, 执行顺序如下:

• @Before 通知：数字越小先执行

• @After 通知：数字越大先执行

@Order 控制切面的优先级, 先执行优先级较高的切面, 再执行优先级较低的切面, 最终执行目标方法.

execution表达式

execution() 是最常用的切点表达式, 用来匹配方法, 语法为:

execution(<访问修饰符> <返回类型> <包1 名.类名.方法(方法参数)> <异常>)

切点表达式支持通配符表达:

*：匹配任意字符，只匹配一个元素(返回类型, 包, 类名, 方法或者方法参数)
a. 包名使用 * 表示任意包(一层包使用一个*)
b. 类名使用 * 表示任意类
c. 返回值使用 * 表示任意返回值类型
d. 方法名使用 * 表示任意方法
e. 参数使用 * 表示一个任意类型的参数
.. ：匹配多个连续的任意符号, 可以通配任意层级的包, 或任意类型, 任意个数的参数
a. 使用 .. 配置包名，标识此包以及此包下的所有子包
b. 可以使用 .. 配置参数，任意个任意类型的参数切

@annotation

execution表达式更适用有规则的, 如果我们要匹配多个无规则的方法呢, 比如：TestController中的t1()和UserController中的u1()这两个方法.这个时候我们使用execution这种切点表达式来描述就不是很方便了.我们可以借助自定义注解的方式以及另一种切点表达式@annotation 来描述这一类的切点

@RequestMapping("/user")
@RestController
public class UserController {
    
    @RequestMapping("/u1")
    public String u1(){
        return "u1";        
    }
    
    @RequestMapping("/u2")
    public String u2(){
        return "u2";
    }
}

package com.bite.book.controller;

import com.bite.book.model.BookInfo;
import com.bite.book.model.Result;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;



@RequestMapping("/test")
@RestController
public class TestController {
    @RequestMapping("/t1")
    public String t1() {
        return "t1";
    }
    @RequestMapping("/t2")
    public boolean t2() {
        int a = 10 / 0;
        return true;
    }
}

自定义注解@MyAspect

package com.bite.book.annotation;


import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAspect {
    
}

@Target 标识了Annotation 所修饰的对象范围, 即该注解可以用在什么地方.

1. ElementType.TYPE: 用于描述类、接口(包括注解类型) 或enum声明
2. ElementType.METHOD: 描述方法
3. ElementType.PARAMETER: 描述参数
4. ElementType.TYPE_USE: 可以标注任意类型

@Retention 指Annotation被保留的时间长短, 标明注解的生命周期

1. RetentionPolicy.SOURCE：表示注解仅存在于源代码中, 编译成字节码后会被丢弃. 这意味着在运行时无法获取到该注解的信息, 只能在编译时使用. 比如@SuppressWarnings , 以及lombok提供的注解@Data , @Slf4j
2. RetentionPolicy.CLASS：编译时注解. 表示注解存在于源代码和字节码中, 但在运行时会被丢弃. 这意味着在编译时和字节码中可以通过反射获取到该注解的信息, 但在实际运行时无法获取. 通常用于一些框架和工具的注解.
3. RetentionPolicy.RUNTIME：运行时注解. 表示注解存在于源代码, 字节码和运行时中. 这意味着在编译时, 字节码中和实际运行时都可以通过反射获取到该注解的信息. 通常用于一些需要在运行时处理的注解, 如Spring的 @Controller @ResponseBody

切面类

使用 @annotation 切点表达式定义切点, 只对 @MyAspect 生效

package com.bite.book.aspect;


import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

@Aspect
@Component
@Slf4j
public class MyAspectDemo {
    
    @Pointcut("@annotation(com.bite.book.annotation.MyAspect)")
    public void pt() {}

    @Before("pt()")
    public void before(){
        log.info("MyAspect -> before");
    }
    
    @After("pt()")
    public void after(){
        log.info("MyAspect -> after");
    }
}

添加自定义注解

在TestController中的t1()和UserController中的u1()这两个方法上添加自定义注解 @MyAspect , 其他方法不添加

测试u1和u2

u2不会执行切面中通知部分的代码。

SpringAOP原理

Spring AOP 是基于动态代理来实现AOP的

代理模式

代理模式，也叫委托模式。

定义：为其他对象提供一种代理以控制对这个对象的访问. 它的作用就是通过提供一个代理类, 让我们在调用目标方法的时候, 不再是直接对目标方法进行调用, 而是通过代理类间接调用.

在某些情况下, 一个对象不适合或者不能直接引用另一个对象, 而代理对象可以在客户端和目标对象之间起到中介的作用.

代理模式的主要角色

Subject: 业务接口类. 可以是抽象类或者接口(不一定有)
RealSubject: 业务实现类. 具体的业务执行, 也就是被代理对象.
Proxy: 代理类. RealSubject的代理.

代理模式可以在不修改被代理对象的基础上, 通过扩展代理类, 进行一些功能的附加与增强.根据代理的创建时期, 代理模式分为静态代理和动态代理.

静态代理: 由程序员创建代理类或特定工具自动生成源代码再对其编译, 在程序运行前代理类的.class 文件就已经存在了.

动态代理: 在程序运行时, 运用反射机制动态创建而成.

静态代理

静态代理: 在程序运行前, 代理类的 .class文件就已经存在了.

定义接口

package com.bite.book.test;

public interface HouseSubject {
void rentHouse();
}

实现接口

package com.bite.book.test;

public class RealHouseSubject implements HouseSubject {

 @Override
 public void  rentHouse() {
     System.out.println("我是房东, 我出租房子");
 }

}

代理

package com.bite.book.test;

public class HouseProxy implements HouseSubject{

 private HouseSubject houseSubject;
 public HouseProxy(HouseSubject houseSubject) {
     this.houseSubject = houseSubject;
 }

 @Override
 public void rentHouse() {
     //开始代理
     System.out.println("我是中介, 开始代理");
     //代理房东出租房子
     houseSubject.rentHouse();
     //代理结束
     System.out.println("我是中介, 代理结束");
 }

}

使用

package com.bite.book.test;

public class StaticMain {
public static void main(String[] args) {
HouseSubject subject = new RealHouseSubject();
HouseProxy proxy = new HouseProxy(subject);
```
     proxy.rentHouse();
 }
```
}

上面这个代理实现方式就是静态代理

动态代理

我们不需要针对每个目标对象都单独创建一个代理对象, 而是把这个创建代理对象的工作推迟到程序运行时由JVM来实现. 也就是说动态代理在程序运行时, 根据需要动态创建生成.比如房屋中介, 我不需要提前预测都有哪些业务,而是业务来了我再根据情况创建.

Java也对动态代理进行了实现, 并给我们提供了一些API, 常见的实现方式有两种:

JDK动态代理
CGLIB动态代理

JDK动态代理

JDK 动态代理类实现步骤

定义一个接口及其实现类(静态代理中的HouseSubject 和 RealHouseSubject )
自定义 InvocationHandler 并重写invoke 方法，在 invoke 方法中我们会调用目标方法(被代理类的方法)并自定义一些处理逻辑
通过 Proxy.newProxyInstance(ClassLoader loader,Class<?>[ ]interfaces,InvocationHandler h) 方法创建代理对象

定义动态代理类

实现InvocationHandler接口

package com.bite.book.test;

import org.springframework.cglib.proxy.InvocationHandler;

import java.lang.reflect.Method;

public class JDKInvocationHandler implements InvocationHandler {

    private Object target;

    public JDKInvocationHandler(Object object) {
        this.target = object;
    }

    @Override
    public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
        System.out.println("before");

        Object ret = method.invoke(target, objects);

        System.out.println("after");
        return ret;
    }
}

创建一个代理对象并使用

public class DynamicMain {
    public static void main(String[] args) {
        HouseSubject target = new RealHouseSubject();

        InvocationHandler handler = new JDKInvocationHandler(target);

        // JDKInvocationHandler 实例化时不需要强制类型转换
        HouseSubject proxy = (HouseSubject) Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                new Class<?>[] {HouseSubject.class},
               handler
        );

        proxy.rentHouse();
    }
}

InvocationHandler：接口时Java动态代理的关键接口之一，它定义了一个单一方法 invoke() , 用于处理被代理对象的方法调用.

public interface InvocationHandler {
    /**
* 参数说明
* proxy：代理对象
* method：代理对象需要实现的方法，即其中需要重写的方法
* args：method所对应方法的参数
*/
    public Object invoke(Object proxy, Method method, Object[] args)
    throws Throwable;
}

通过实现InvocationHandler 接口, 可以对被代理对象的方法进行功能增强.

Proxy

Proxy 类中使用频率最高的方法是： newProxyInstance() , 这个方法主要用来生成一个代理对象、

public static Object newProxyInstance(ClassLoader loader,
                                      Class<?>[] interfaces,
                                      InvocationHandler h)
throws IllegalArgumentException
{
    //...代码省略
}

这个方法一共有 3 个参数：

Loader: 类加载器, 用于加载代理对象.

interfaces : 被代理类实现的一些接口(这个参数的定义, 也决定了JDK动态代理只能代理实现了接口的一些类)

h : 实现了 InvocationHandler 接口的对象

CGLIB动态代理

有些场景下, 我们的业务代码是直接实现的, 并没有接口定义. 为了解决这个问题, 我们可以用 CGLIB 动态代理机制来解决.

CGLIB(Code Generation Library)是一个基于ASM的字节码生成库，它允许我们在运行时对字节码进行修改和动态生成. CGLIB 通过继承方式实现代理, 很多知名的开源框架都使用到了CGLIB. 例如 Spring中的 AOP 模块中: 如果目标对象实现了接口，则默认采用 JDK 动态代理, 否则采用 CGLIB 动态代理.

定义一个类(被代理类)
自定义 MethodInterceptor 并重写 intercept 方法， intercept 用于增强目标方法，和 JDK 动态代理中的 invoke 方法类似
通过 Enhancer 类的 create()创建代理类

依赖

<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>3.3.0</version>
</dependency>

自定义MethodInteerceptor(方法拦截器)

实现MethodInterceptor

package com.bite.book.test2;

import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

public class GCLIBInterceptor implements MethodInterceptor {

    private Object target;

    public GCLIBInterceptor(Object target) {
        this.target = target;
    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects,
                            MethodProxy methodProxy) throws Throwable {
        // 代理增强内容
        System.out.println("我是中介, 开始代理");
        //通过反射调用被代理类的方法
        Object retVal = methodProxy.invoke(target, objects);
        //代理增强内容
        System.out.println("我是中介, 代理结束");
        return retVal;
    }
}

创建代理类，并使用

package com.bite.book.test2;

import com.bite.book.test.HouseSubject;
import com.bite.book.test.RealHouseSubject;
import org.springframework.cglib.proxy.Enhancer;


public class DynamicMain {
    public static void main(String[] args) {
        HouseSubject target= new RealHouseSubject();
        HouseSubject proxy= (HouseSubject) Enhancer.create(target.getClass(), new CGLIBInterceptor(target));
        proxy.rentHouse();
    }
}

MethodInterceptor

MethodInterceptor 和 JDK动态代理中的InvocationHandler 类似, 它只定义了一个方法 intercept() , 用于增强目标方法.

public interface MethodInterceptor extends Callback {
    /**
* 参数说明:
* o: 被代理的对象
* method: 目标方法(被拦截的方法, 也就是需要增强的方法)
* objects: 方法入参
* methodProxy: 用于调用原始方法
*/
    Object intercept(Object o, Method method, Object[] objects, MethodProxy
                     methodProxy) throws Throwable;
}

Enhancer.create()

Enhancer.create() 用来生成一个代理对象

public static Object create(Class type, Callback callback) {
    //...代码省略
}

参数说明:

type: 被代理类的类型(类或接口)

callback: 自定义方法拦截器 MethodInterceptor