Spring AOP与代理模式

阿里云国际，腾讯云国际，AWS 免费开户实名账号 代冲值 优惠多多 微信号：monov8 飞机：@monov8

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

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

为什要⽤ AOP

想象⼀个场景我们在做后台系统时除了登录和注册等⼏个功能不需要做⽤户登录验证之外其他⼏乎所有⻚⾯调⽤的前端控制器 Controller都需要先验证⽤户登录的状态那这个时候我们要怎么处理呢
我们的处理⽅式是每个 Controller 都要写⼀遍⽤户登录验证然⽽当你的功能越来越多那么你要写的登录验证也越来越多⽽这些⽅法⼜是相同的这么多的⽅法就会代码修改和维护的成本。那有没有简单的处理⽅案呢答案是有的对于这种功能统⼀且使⽤的地⽅较多的功能就可以考虑 AOP来统⼀处理了。
除了统⼀的⽤户登录判断之外AOP 还可以实现

  • 统⼀⽇志记录
  • 统⼀⽅法执⾏时间统计
  • 统⼀的返回格式设置
  • 统⼀的异常处理
  • 事务的开启和提交等

也就是说使⽤ AOP 可以扩充多个对象的某个能⼒所以 AOP 可以说是 OOPObject Oriented Programming⾯向对象编程的补充和完善。

Spring AOP 学习主要分为以下 3 个部分

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

AOP 组成

切⾯Aspect

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

连接点Join Point

应⽤执⾏过程中能够插⼊切⾯的⼀个点这个点可以是⽅法调⽤时抛出异常时甚⾄修改字段时。切⾯代码可以利⽤这些点插⼊到应⽤的正常流程之中并添加新的⾏为。
连接点相当于需要被增强的某个 AOP 功能的所有⽅法

切点Pointcut

Pointcut 是匹配 Join Point 的谓词。
Pointcut 的作⽤就是提供⼀组规则使⽤ AspectJ pointcut expression language 来描述来匹配 Join Point给满⾜规则的 Join Point 添加 Advice。
切点相当于保存了众多连接点的⼀个集合如果把切点看成⼀个表⽽连接点就是表中⼀条⼀条的数据

通知Advice

切⾯也是有⽬标的 ——它必须完成的⼯作。在 AOP 术语中切⾯的⼯作被称之为通知。
通知定义了切⾯是什么何时使⽤其描述了切⾯要完成的⼯作还解决何时执⾏这个⼯作的问题。
Spring 切⾯类中可以在⽅法上使⽤以下注解会设置⽅法为通知⽅法在满⾜条件后会通知本⽅法进⾏调⽤

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

1690531676440.png

Spring AOP 实现

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

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

添加 AOP 框架⽀持 ,在 pom.xml 中添加如下配置

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

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

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

@Slf4j
//@Component  //演示统一功能, 暂时先去掉
@Aspect //定义了一个切面
public class LoginAspect {
@Pointcut("execution(* com.example.demo.controller.UserController.*(..))")
    public void pointcut(){ }
}

其中 pointcut ⽅法为空⽅法它不需要有⽅法体此⽅法名就是起到⼀个“标识”的作⽤标识下⾯的通知⽅法具体指的是哪个切点因为切点可能有很多个

切点表达式说明

AspectJ ⽀持三种通配符

  • 匹配任意字符只匹配⼀个元素包类或⽅法⽅法参数
    … 匹配任意字符可以匹配多个元素 在表示类时必须和 * 联合使⽤。
  • 表示按照类型匹配指定类的所有类必须跟在类名后⾯如 com.cad.Car+ ,表示继承该类的所有⼦类包括本身
    切点表达式由切点函数组成其中 execution() 是最常⽤的切点函数⽤来匹配⽅法语法为

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

1690534978948.png
表达式示例

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。

3. 定义通知

@Slf4j
//@Component  //演示统一功能, 暂时先去掉
@Aspect //定义了一个切面
public class LoginAspect {
    @Pointcut("execution(* com.example.demo.controller.UserController.*(..))")
    public void pointcut(){ }

    @Before("pointcut()")
    public void doBefore(){
        log.info("do before....");
    }
    @After("pointcut()")
    public void doAfter(){
        log.info("do after...");
    }
    @AfterReturning("pointcut()")
    public void doAfterReturning(){
        log.info("do after returning...");
    }
    @AfterThrowing("pointcut()")
    public void doAfterThrowing(){
        log.info("do after throwing");
    }

//    @Around("pointcut()")
//    public Object doAround(ProceedingJoinPoint joinPoint){
//        Object oj = null;
//        log.info("环绕通知执行之前...");
//        log.info(joinPoint.getSignature().toLongString());
//        try {
//            oj = joinPoint.proceed();//调用目标方法
//        } catch (Throwable e) {
//            throw new RuntimeException(e);
//        }
//        log.info("环绕通知执行之后....");
//        return oj;
//    }

    /**
     * 使用 AOP 统计 UserController 每个方法的执行时间。
     * @param joinPoint 连接点
     * @return
     */
    @Around("pointcut()")
    public Object doAround(ProceedingJoinPoint joinPoint){
        Object oj = null;
        long start = System.currentTimeMillis();
        try {
            oj = joinPoint.proceed();//调用目标方法
        } catch (Throwable e) {
            throw new RuntimeException(e);
        }
        log.info(joinPoint.getSignature().toString()+"耗时:"+(System.currentTimeMillis()-start));
        return oj;
    }

    @Before("execution(* com.example.demo.controller.TestController.*(..))")
    public void before2(){
        log.info("before2....");
    }
}

Spring AOP 实现原理

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

织⼊Weaving代理的⽣成时机
织⼊是把切⾯应⽤到⽬标对象并创建新的代理对象的过程切⾯在指定的连接点被织⼊到⽬标对象中.
在⽬标对象的⽣命周期⾥有多个点可以进⾏织⼊
编译期切⾯在⽬标类编译时被织⼊。这种⽅式需要特殊的编译器。AspectJ的织⼊编译器就是以这种⽅式织⼊切⾯的。
类加载期切⾯在⽬标类加载到JVM时被织⼊。这种⽅式需要特殊的类加载器
ClassLoader,它可以在⽬标类被引⼊应⽤之前增强该⽬标类的字节码。AspectJ5的加载时织⼊load-time weaving. LTW就⽀持以这种⽅式织⼊切⾯。
运⾏期切⾯在应⽤运⾏的某⼀时刻被织⼊。⼀般情况下在织⼊切⾯时AOP容器会为⽬标对象动态创建⼀个代理对象。SpringAOP就是以这种⽅式织⼊切⾯的。
此种实现在设计模式上称为动态代理模式在实现的技术⼿段上都是在 class 代码运⾏期动态的织⼊字节码。
我们学习 Spring 框架中的AOP主要基于两种⽅式JDK 及 CGLIB 的⽅式。这两种⽅式的代理⽬标都是被代理类中的⽅法在运⾏期动态的织⼊字节码⽣成代理类。

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

代理模式

定义为其他对象提供⼀种代理以控制对这个对象的访问。在某些情况下⼀个对 象不适合或者不能直接引⽤另⼀个对象⽽代理对象可以在客户端和⽬标对象之间起到中介的作⽤。
代理模式分为静态代理和动态代理

静态代理

静态代理中我们对⽬标对象的每个⽅法的增强都是⼿动完成的⾮常不灵活⽐如接⼝⼀旦新增加⽅法⽬标对象和代理对象都要进⾏修改且麻烦(需要对每个⽬标类都单独写⼀个代理类。 实际应⽤场景⾮常⾮常少⽇常开发⼏乎看不到使⽤静态代理的场景。
上⾯我们是从实现和应⽤⻆度来说的静态代理从 JVM 层⾯来说 静态代理在编译时就将接⼝、实现类、代理类这些都变成了⼀个个实际的 class ⽂件。
静态代理实现步骤:

  1. 定义⼀个接⼝及其实现类
  2. 创建⼀个代理类同样实现这个接⼝
  3. 将⽬标对象注⼊进代理类然后在代理类的对应⽅法调⽤⽬标类中的对应⽅法。
    这样的话我们就可以通过代理类屏蔽对⽬标对象的访问并且可以在⽬标⽅法执⾏前后做⼀些⾃⼰想做的事情。
public interface PayService {
    void pay();
}

public class AliPayService implements PayService{
    @Override
    public void pay() {
        System.out.println("ali pay....");
    }
}

public class StaticProxy implements PayService{
    private final PayService payService;

    public StaticProxy(PayService payService) {
        this.payService = payService;
    }

    @Override
    public void pay() {
        System.out.println("before...");
        payService.pay();
        System.out.println("after...");
    }
}

    public static void main(String[] args) {
        PayService service = new AliPayService();
        PayService proxy = new StaticProxy(service);
        proxy.pay();
    }

动态代理

相⽐于静态代理来说动态代理更加灵活。我们不需要针对每个⽬标类都单独创建⼀个代理类并且也不需要我们必须实现接⼝我们可以直接代理实现类( CGLIB 动态代理机制)。
从 JVM ⻆度来说动态代理是在运⾏时动态⽣成类字节码并加载到 JVM 中的。
说到动态代理不得不提的是Spring AOP它的实现依赖了动态代理。动态代理在我们⽇常开发中使⽤的相对较少但是在框架中的⼏乎是必⽤的⼀⻔技术。学会了动态代理之后对于我们理解和学习各种框架的原理也⾮常有帮助。
就 Java 来说动态代理的实现⽅式有很多种⽐如 JDK 动态代理、CGLIB 动态代理等等。

JDK 动态代理实现

public class JDKInvocationHandler implements InvocationHandler {

    //目标对象即就是被代理对象
    private Object target;

    public JDKInvocationHandler(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();
        //创建一个代理类通过被代理类、被代理实现的接口、方法调用处理器来创建
        PayService proxy = (PayService) Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                new Class[]{PayService.class},
                new JDKInvocationHandler(target)
        );
        proxy.pay();
    }

CGLIB 动态代理实现

public class CGLIBInterceptor implements MethodInterceptor {

    //被代理对象
    private Object target;

    public CGLIBInterceptor(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 CGLIBInterceptor(target));//创建代理对象
        proxy.pay();
    }

JDK 和 CGLIB 实现的区别

  1. JDK 实现要求被代理类必须实现接⼝之后是通过 InvocationHandler 及 Proxy在运⾏时动态的在内存中⽣成了代理类对象该代理对象是通过实现同样的接⼝实现类似静态代理接⼝实现的⽅式只是该代理类是在运⾏期时动态的织⼊统⼀的业务逻辑字节码来完成。
  2. CGLIB 实现被代理类可以不实现接⼝是通过继承被代理类在运⾏时动态的⽣成代理类对象。
阿里云国际，腾讯云国际，AWS 免费开户实名账号 代冲值 优惠多多 微信号：monov8 飞机：@monov8
标签: Spring
返回列表

上一篇：【探索Linux】—— 步步学习强大的命令行工具 P.1（Linux简介）

下一篇：Java中String方法魔性学习

“Spring AOP与代理模式” 的相关文章

Spring常用设计模式--抽象工厂模式10个月前 (02-02)
Spring AOP 企业级应用 - 统一功能处理10个月前 (02-02)
SpringBoot原理-自动配置-Condition10个月前 (02-02)
【RabbitMQ】SpringBoot整合RabbitMQ10个月前 (02-02)
IDEA远程快速部署SpringBoot项目到Docker环境10个月前 (02-02)
Spring入门-IOC/DI注解管理与整合mybatis及Junit(2)10个月前 (02-02)
SpringCache之@CachePut注解的使用说明10个月前 (02-02)
springMVC的学习拦截器之验证用户登录案例10个月前 (02-02)
SpringCloud Alibaba10个月前 (02-02)
【Spring6源码・IOC】Bean的实例化10个月前 (02-02)

Powered By Z-BlogPHP. Theme by TOYEAN.