Spring AOP框架

什么是Spring AOP?

在介绍Spring AOP之前,先来了解一下 AOP是什么?

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

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

为什么要用AOP?

想象⼀个场景,我们在做后台系统时,除了登录和注册等⼏个功能不需要做⽤户登录验证之外,其他⼏ 乎所有⻚⾯调⽤的前端控制器( Controller)都需要先验证⽤户登录的状态,那这个时候我们要怎么处 理呢?

我们之前的处理⽅式是每个 Controller 都要写⼀遍⽤户登录验证,然⽽当你的功能越来越多,那么你要 写的登录验证也越来越多,⽽这些⽅法⼜是相同的,这么多的⽅法就会代码修改和维护的成本。那有没 有简单的处理⽅案呢?答案是有的,对于这种功能统⼀,且使⽤的地⽅较多的功能,就可以考虑 AOP 来统⼀处理了

除了统一的用户登录功能验证的实现,AOP还可以去实现哪些功能?

  • 统⼀⽇志记录
  • 统⼀⽅法执⾏时间统计
  • 统⼀的返回格式设置
  • 统⼀的异常处理
  • 事务的开启和提交等
    也就是说使⽤ AOP 可以扩充多个对象的某个能⼒,所以 AOP 可以说是 OOP(Object Oriented Programming,⾯向对象编程)的补充和完善

使用了AOP之后,我们的业务代码就可以专心去处理本身业务,不需要去分心还要去进行别的一些功能…比如判空等等

Spring AOP的学习部分

  1. 学习 AOP 是如何组成的?也就是学习 AOP 组成的相关概念。
  2. 学习 Spring AOP 使⽤
  3. 学习 Spring AOP 实现原理。

AOP的组成

切面(Aspect)

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

切⾯(Aspect)由切点(Pointcut)和通知(Advice)组成,它既包含了横切逻辑的定义,也包 括了连接点的定义。
白话解释:切⾯是包含了:通知、切点和切⾯的类,相当于 AOP 实现的某个功能的集合

连接点(Join Point)

应⽤执⾏过程中能够插⼊切⾯的⼀个点,这个点可以是⽅法调⽤时,抛出异常时,甚⾄修改字段 时。切⾯代码可以利⽤这些点插⼊到应⽤的正常流程之中,并添加新的⾏为

白话解释:连接点相当于需要被增强的某个 AOP 功能的所有⽅法

切点(Poincut)

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

白话解释:切点相当于保存了众多连接点的⼀个集合(如果把切点看成⼀个表,⽽连接点就是表中⼀条⼀条 的数据)

通知(advice)

切⾯也是有⽬标的 ——它必须完成的⼯作。在 AOP 术语中,切⾯的⼯作被称之为通知。 通知:定义了切⾯是什么,何时使⽤,其描述了切⾯要完成的⼯作,还解决何时执⾏这个⼯作的 问题。

就拿统一实现用户登录功能的验证来说,切面本身就是一个集合,他是包含切点和通知的
切点就是来定义AOP拦截规则的,假设在查看问文章列表的时候,是需要先去进行用户验证的,这个时候请求就会被中途拦截(未进入文章列表)
然后通过验证登录这个AOP来进行拦截并且通过里面的方法去验证,用户验证登录的这个切点就是去拦截那些需要进行用户登录的请求,他就是去定义规则,来通过程序这个请求是否需要去被拦截
而连接点不属于切面,它的概念就是那些会被拦截的请求的集合,所有可能触发AOP拦截的点(集合)
而通知就是在切点判断需要拦截之后,具体的实施,如何去验证用户信息正确就是通知需要做的
Spring AOP框架_第1张图片

本身通知又分好几种类型

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

Spring AOP框架_第2张图片
接下来的代码看懂了,这张图的一些概念就能懂

Spring AOP的实现

接下来我们使⽤ Spring AOP 来实现⼀下 AOP 的功能,完成的⽬标是拦截所有 UserController ⾥⾯的 ⽅法,每次调⽤ UserController 中任意⼀个⽅法时,都执⾏相应的通知事件。
Spring AOP 的实现步骤如下:

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

添加Spring AOP的框架支持

由于在创建Spring Boot项目的时候,添加框架都是经常使用的,所以在那里是搜索不到AOP的框架的,需要我们在网上找到对应版本的aop依赖手动添加进到pom.xml中
Spring AOP框架_第3张图片

定义切面和切点

切点指的是具体要处理的某⼀类问题,⽐如⽤户登录权限验证就是⼀个具体的问题,记录所有⽅法的执 ⾏⽇志就是⼀个具体的问题,切点定义的是某⼀类问题。 Spring AOP 切点的定义如下,在切点中我们要定义拦截的规则,具体实现如下:

Spring AOP框架_第4张图片
其中 pointcut ⽅法为空⽅法,它不需要有⽅法体,此⽅法名就是起到⼀个“标识”的作⽤,标识下⾯的通 知⽅法具体指的是哪个切点(因为切点可能有很多个)。

Spring AOP框架_第5张图片
Spring AOP框架_第6张图片

切点表达式说明

Sping AOP 的切点的拦截规则就是参照了AspectJ的语法来实现的

Spring AOP框架_第7张图片
Spring AOP框架_第8张图片
Spring AOP框架_第9张图片
Spring AOP框架_第10张图片

定义相关通知:

Spring AOP框架_第11张图片
代码示例:
切面类:

package com.example.demo.aop;

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 //注入
public class UserAspect {

    //定义一个切点 ,设置拦截规则
    @Pointcut("execution(* com.example.demo.controller.UserController.*(..))")
    public void pointcut(){

    }
     /**
     * 定义pointCut切点的前置通知
     * 在执行目标方法之前去执行的方法就叫做前置通知
      * **/

    @Before("pointcut()")
    public void deBefore(){
        System.out.println("前置通知被执行了");
    }
    @After("pointcut()")
    public void doAfter(){
        System.out.println("后置通知被执行了");
    }

}

Spring AOP框架_第12张图片在这里插入图片描述
在游览器输入url之后,访问到了sayhi方法的时候,被切点拦截了,先去执行前置通知,再去执行sayhi方法,最后执行后置通知
Spring AOP框架_第13张图片
加上了抛出异常通知之后,再仔细观察一下
Spring AOP框架_第14张图片
Spring AOP框架_第15张图片

Spring AOP框架_第16张图片
然后就会报错,抛出异常之后,返回通知没有被执行,因为返回通知是在目标方法返回后才去执行的,但是因为有异常最后肯定返回不了,所以返回通知没有执行,会执行后置通知
Spring AOP框架_第17张图片

使用环绕通知实现每个方法的执行时间

Spring AOP框架_第18张图片
准确来说,环绕通知的写法格式是固定的,记住即可

Spring AOP实现原理

Spring AOP 是构建在动态代理基础上,因此 Spring 对 AOP 的⽀持局限于⽅法级别的拦截。 Spring AOP ⽀持 JDK Proxy 和 CGLIB ⽅式实现动态代理。默认情况下,实现了接⼝的类,使⽤ AOP 会基于 JDK ⽣成代理类,没有实现接⼝的类,会基于 CGLIB ⽣成代理类
Spring AOP框架_第19张图片

织⼊(Weaving):代理的⽣成时机

织⼊是把切⾯应⽤到⽬标对象并创建新的代理对象的过程,切⾯在指定的连接点被织⼊到⽬标对 象中
在⽬标对象的⽣命周期⾥有多个点可以进⾏织⼊

  • 编译期:切⾯在⽬标类编译时被织⼊。这种⽅式需要特殊的编译器。AspectJ的织⼊编译器就 是以这种⽅式织⼊切⾯的。
  • 类加载器:切⾯在⽬标类加载到JVM时被织⼊。这种⽅式需要特殊的类加载器 (ClassLoader),它可以在⽬标类被引⼊应⽤之前增强该⽬标类的字节码。AspectJ5的加载 时织⼊(load-time weaving. LTW)就⽀持以这种⽅式织⼊切⾯。
  • 运⾏期:切⾯在应⽤运⾏的某⼀时刻被织⼊。⼀般情况下,在织⼊切⾯时,AOP容器会为⽬标对象动态创建⼀个代理对象。SpringAOP就是以这种⽅式织⼊切⾯的。

动态代理:

此种实现在设计模式上称为动态代理模式,在实现的技术⼿段上,都是在 class 代码运⾏期,动 态的织⼊字节码。 我们学习 Spring 框架中的AOP,主要基于两种⽅式:JDK 及 CGLIB 的⽅式。这两种⽅式的代理 ⽬标都是被代理类中的⽅法,在运⾏期,动态的织⼊字节码⽣成代理类

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

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

import org.example.demo.service.AliPayService;
import org.example.demo.service.PayService;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.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);
        //创建⼀个代理类:通过被代理类、被代理实现的接⼝、⽅法调⽤处理器来创建

CGLIB 动态代理实现
   import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
import org.example.demo.service.AliPayService;
import org.example.demo.service.PayService;
import java.lang.reflect.Method;
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();
   }
}

Spring AOP框架_第20张图片
Spring AOP框架_第21张图片

你可能感兴趣的:(笔记,spring,java,spring,boot)