Spring AOP 详解

文章目录

  • 1.什么是 Spring AOP
  • 2.为什要用 AOP
  • 3.AOP 组成
    • 3.1 切面(Aspect)
    • 3.2 连接点(Join Point)
    • 3.3 切点(Pointcut)
    • 3.5 通知(Advice)
  • 4.Spring AOP 实现
    • 4.1 添加 AOP 框架支持
    • 4.2 定义切面和切点
    • 4.3 定义通知
  • 5.Spring AOP 实现原理

1.什么是 Spring AOP

AOP(Aspect Oriented Programming)面向切面编程,它是一种思想,它是对某一类事情的集中处理。比如用户登录权限的效验,没学 AOP 之前,我们所有需要判断用户登录的页面(中的方法),都要各自实现或调用用户验证的方法,然而有了 AOP 之后,我们只需要在某一处配置一下,所有需要判断用户登录页面(中的方法)就全部可以实现用户登录验证了,不再需要每个方法中都写相同的用户登录验证了。

Spring AOP 是⼀个框架,提供了⼀种对 AOP 思想的实现,它们的关系和 IoC 与 DI 类似。

2.为什要用 AOP

AOP 能够将那些与业务无关,却为业务模块所共同调用的逻辑或责任(例如事务处理、日志管理、权限控制等)封装起来,便于减少系统的重复代码,降低模块间的耦合度,并有利于未来的可拓展性和可维护性

AOP可以实现的功能

  • 用户登录判断
  • 统一日志记录
  • 统一方法执行时间统计
  • 统一的返回格式设置
  • 统一的异常处理
  • 事务的开启和提交等

3.AOP 组成

AOP 整个组成部分的概念如下图所示,以多个页面都要访问用户登录权限为例:
Spring AOP 详解_第1张图片

3.1 切面(Aspect)

切面(Aspect)由切点(Pointcut)和通知(Advice)组成,它既包含了横切逻辑的定义,也包括了连接点的定义。

切面是包含了 通知、切点 和 切面 的类,相当于 AOP 实现的某个功能的集合。

3.2 连接点(Join Point)

应用执行过程中能够插入切⾯的一个点,这个点可以是方法调用时,抛出异常时,甚至修改字段时。切面代码可以利⽤这些点插入到应用的正常流程之中,并添加新的行为。

连接点相当于需要被增强的某个 AOP 功能的所有方法。

3.3 切点(Pointcut)

Pointcut 的作用就是提供一组规则(使用 AspectJ pointcut expression language 来描述)来匹配 Join Point,给满足规则的 Join Point 添加 Advice。

切点相当于保存了众多连接点的一个集合(如果把切点看成一个表,而连接点就是表中一条一条的数据)。

3.5 通知(Advice)

切面的工作被称之为通知。通知 定义了切面是什么,何时使用,其描述了切面要完成的工作,解决何时执行这个工作的问题。
Spring 切面类中,可以在方法上使用以下注解,会设置方法为通知方法,在满足条件后会通知本方法进行调⽤:

  • 前置通知 @Before:通知方法会在目标方法调用之前执行。
  • 后置通知 @After:通知方法会在目标方法返回或者抛出异常后调用。
  • 返回之后通知 @AfterReturning:通知方法会在目标方法返回后调用。
  • 抛异常后通知 @AfterThrowing:通知方法会在目标方法抛出异常后调用。
  • 环绕通知 @Around:通知包裹了被通知的方法,在被通知的方法通知之前和调用之后执行⾃定义的行为。

4.Spring AOP 实现

使用 Spring AOP 来实现一下 AOP 的功能,完成的目标是拦截所有 UserController 里面的方法,每次调用 UserController 中任意一个方法时,都执行相应的通知事件。

Spring AOP 的实现步骤如下

  1. 添加 Spring AOP 框架支持。
  2. 定义切面和切点。
  3. 定义通知。

4.1 添加 AOP 框架支持

在 pom.xml 中添加如下配置:


<dependency>
	<groupId>org.springframework.bootgroupId>
	<artifactId>spring-boot-starter-aopartifactId> 
dependency>

4.2 定义切面和切点

Spring AOP 切点的定义如下,在切点中我们要定义拦截的规则,具体实现如下:

@Aspect // 表明此类为⼀个切⾯ 
@Component
public class UserAspect {
	// 定义切点,这⾥使⽤ AspectJ 表达式语法
	@Pointcut("execution(* com.example.demo.controller.UserController.* (..))")
	public void pointcut(){ } 
}

其中 pointcut 方法为空方法,它不需要有方法体,此方法名就是起到一个“标识”的作用,标识下面的通知方法具体指的是哪个切点(因为切点可能有很多个)。

切点表达式说明

AspectJ 支持三种通配符

  • * :匹配任意字符,只匹配一个元素(包,类,或⽅法,方法参数)
  • .. :匹配任意字符,可以匹配多个元素 ,在表示类时,必须和 * 联合使⽤。
  • + :表示按照类型匹配指定类的所有类,必须跟在类名后面,如 com.cad.Car+ ,表示继承该类的 所有子类包括本身

切点表达式 由切点函数组成,其中 execution() 是最常⽤的切点函数,用来匹配方法,语法为:

execution(<修饰符><返回类型><..⽅法(参数)><异常>)

修饰符和异常可以省略。

表达式示例:

  • execution(* com.cad.demo.User.*(..)) :匹配 User 类里的所有方法。
  • execution(* com.cad.demo.User+.*(..)) :匹配该类的子类包括该类的所有方法。
  • execution(* com.cad.*.*(..)) :匹配 com.cad 包下的所有类的所有方法。
  • execution(* com.cad..*.*(..)) :匹配 com.cad 包下、子孙包下所有类的所有方法。
  • execution(* addUser(String, int)) :匹配 addUser 方法,且第一个参数类型是 String,第⼆个参数类型是 int。

4.3 定义通知

通知定义的是被拦截的方法具体要执行的业务,比如用户登录权限验证方法就是具体要执行的业务。
Spring AOP 中,可以在方法上使用以下注解,会设置方法为通知方法,在满足条件后会通知本方法进行调用,具体实现如下:

@Aspect     // 当前面是一个切面
@Component
@Slf4j
public class UserAspect {
    // 切点(定义规则:拦截UserController下的所有方法)
    @Pointcut("execution(* com.example.springaop.controller.UserController.*(..))")
    public void pointCut() {}

    // 1.定义前置通知(AOP拦截之后具体的业务执行)
    @Before("pointCut()")
    public void doBefore() {
        log.info("执行了前置通知方法");
    }

    // 2.定义后置通知方法
    @After("pointCut()")
    public void doAfter() {
        log.info("执行了后置通知方法");
    }

    // 3.定义返回后通知
    @AfterReturning("pointCut()")
    public void doReturn() {
        log.info("执行了返回后通知");
    }

    // 4.定义异常后通知
    @AfterThrowing("pointCut()")
    public void doAfterThrowing() {
        log.info("执行了异常之后的通知");
    }

    // 5.环绕通知
    @Around("pointCut()")
    public Object doAround(ProceedingJoinPoint joinPoint) {
        Object obj;
        long start = System.currentTimeMillis();
        log.info("环绕通知的前置方法");
        try {
            obj = joinPoint.proceed();  // 执行了拦截方法
        } catch (Throwable e) {
            throw new RuntimeException(e);
        }
        log.info("环绕通知的后置方法");
        long end = System.currentTimeMillis();
        log.info("方法执行共花费了:" + (end - start) + "ms");
        return obj;
    }
}

实现UserController:

@RestController
@Slf4j
@RequestMapping("/user")
public class UserController {
    @RequestMapping("sayhi")
    public String sayHi(String name) {
        log.info("执行了sayhi方法");
        return "你好" + name;
    }
}

通过浏览器访问 sayhi 调用 sayHi方法:

Spring AOP 详解_第2张图片

5.Spring AOP 实现原理

Spring AOP 是构建在动态代理基础上,因此 Spring 对 AOP 的支持局限于方法级别的拦截

Spring AOP 支持 JDK Proxy 和 CGLIB 方式实现动态代理。默认情况下,实现了接口的类,使用AOP 会基于 JDK 生成代理类,没有实现接口的类,会基于 CGLIB 生成代理类。
Spring AOP 详解_第3张图片
织入(Weaving):代理的生成时机

织入是把切面应用到目标对象并创建新的代理对象的过程,切⾯在指定的连接点被织入到目标对象中。在目标对象的生命周期里有多个点可以进行织入:

  • 编译期:切面在目标类编译时被织入。这种方式需要特殊的编译器。AspectJ的织入编译器就是以这种方式织入切面的。
  • 类加载期:切面在目标类加载到JVM时被织入。这种方式需要特殊的类加载器(ClassLoader),它可以在目标类被引入应用之前增强该目标类的字节码。AspectJ5的加载时织入(load-timeweaving. LTW)就支持以这种方式织入切面。
  • 运行期:切面在应用运行的某一时刻被织入。一般情况下,在织入切面时,AOP容器会为目标对象动态创建一个代理对象。SpringAOP就是以这种方式织入切面的。

动态代理

此种实现在设计模式上称为动态代理模式,在实现的技术⼿段上,都是在 class 代码运行期,动态的织入字节码。
Spring 框架中的AOP,主要基于两种饭式:JDKCGLIB 的方式。这两种方式的代理目标都是被代理类中的方法,在运行期,动态的织入字节码生成代理类。

  • CGLIB是Java中的动态代理框架,主要作用就是根据目标类和方法,动态生成代理类。
  • Java中的动态代理框架,几乎都是依赖字节码框架(如 ASM,Javassist 等)实现的。
  • 字节码框架是直接操作 class 字节码的框架。可以加载已有的class字节码文件信息,修改部分信息,或动态生成一个 class。

JDK 动态代理实现

JDK 实现时,先通过实现 InvocationHandler 接⼝创建方法调用处理器,再通过 Proxy 来创建代理类。

//动态代理:使⽤JDK提供的api(InvocationHandler、Proxy实现),此种⽅式实现,要求被代理类必须实现接⼝
public class PayServiceJDKInvocationHandler implements InvocationHandler {
    //⽬标对象即就是被代理对象
    private Object target;

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

    //proxy代理对象
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        //1.安全检查
        System.out.println("安全检查");
        //2.记录⽇志
        System.out.println("记录⽇志");
        //3.时间统计开始
        System.out.println("记录开始时间");
        //通过反射调⽤被代理类的⽅法
        Object retVal = method.invoke(target, args);
        //4.时间统计结束
        System.out.println("记录结束时间");
        return retVal;
    }

    public static void main(String[] args) {
        PayService target = new AliPayService();
        //⽅法调⽤处理器
        InvocationHandler handler =
                new PayServiceJDKInvocationHandler(target);
        //创建⼀个代理类:通过被代理类、被代理实现的接⼝、⽅法调⽤处理器来创建
        PayService proxy = (PayService) Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                new Class[]{PayService.class},
                handler
        );
        proxy.pay();
    }
}

CGLIB 动态代理实现

public class PayServiceCGLIBInterceptor implements MethodInterceptor {
    //被代理对象
    private Object target;

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

    @Override
    public Object intercept(Object o, Method method, Object[] args,
                            MethodProxy methodProxy) throws Throwable {
        //1.安全检查
        System.out.println("安全检查");
        //2.记录⽇志
        System.out.println("记录⽇志");
        //3.时间统计开始
        System.out.println("记录开始时间");
        //通过cglib的代理⽅法调⽤
        Object retVal = methodProxy.invoke(target, args);
        //4.时间统计结束
        System.out.println("记录结束时间");
        return retVal;
    }

    public static void main(String[] args) {
        PayService target = new AliPayService();
        PayService proxy = (PayService)
                Enhancer.create(target.getClass(), new
                        PayServiceCGLIBInterceptor(target));
        proxy.pay();
    }
}

JDK 和 CGLIB 实现的区别

  1. JDK 实现,要求被代理类必须实现接口,之后是通过 InvocationHandler 及 Proxy,在运行时动态的在内存中⽣成了代理类对象,该代理对象是通过实现同样的接口实现(类似静态代理接口实现的方式),只是该代理类是在运行期时,动态的织入统一的业务逻辑字节码来完成。
  2. CGLIB 实现,被代理类可以不实现接口,是通过继承被代理类,在运行时动态的生成代理类对象。

你可能感兴趣的:(JavaEE进阶,spring,java,后端,aop,spring,boot)