【Spring】Spring AOP 初识及实现原理解析

这篇具有很好参考价值的文章主要介绍了【Spring】Spring AOP 初识及实现原理解析。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

【Spring】Spring AOP 初识及实现原理解析,JavaEE进阶,spring,java,后端,java-ee

  • 博主简介:想进大厂的打工人
  • 博主主页:@xyk:
  • 所属专栏: JavaEE进阶 

目录

文章目录

一、初识AOP

1.1 什么是AOP?

1.2 AOP的组成

1.2.1 切面(Aspect)

1.2.2 切点(Pointcut)

1.2.3 连接点(Join Point)

1.2.4 通知(Advice)

1.3 AOP的使用场景

二、Srping AOP 实现

2.1 添加Spring AOP 依赖

2.2 定义切面和切点

2.3 定义通知

三、Spring AOP 实现原理

3.1 什么是动态代理?

3.2 JDK 动态代理实现

3.3 CGLIB 动态代理实现

3.4 JDK 和 CGLIB 实现的区别


一、初识AOP

1.1 什么是AOP?

AOP(Aspect Oriented Programming):面向切面编程,它是⼀种思想,它是对某⼀类事情的
集中处理。
在我们想要对某一件事情进行集中处理,就可以使用到AOP,它提供一种将程序中的横切关注点模块化的方式。在 AOP 中,我们将这些横切关注点称为“切面”,它们独立于业务逻辑模块,但是可以在程序运行的不同阶段被织入到业务逻辑中。

简单来说,AOP 就是对某一件事进行集中处理的思想方式~

1.2 AOP的组成

1.2.1 切面(Aspect)

切⾯(Aspect)由切点(Pointcut)和通知(Advice)组成,它既包含了横切逻辑的定义,也包
括了连接点的定义。相当于处理某方面具体问题的一个类,包含多个方法,而这些方法就是切点和通知。

1.2.2 切点(Pointcut)

Pointcut 的作⽤就是提供⼀组规则来匹配连接点(Join Point),给满足规则的连接点添加通知(Advice),可以理解为用来进行主动拦截的规则(配置)

1.2.3 连接点(Join Point)

应⽤执⾏过程中能够插⼊切⾯的⼀个点,连接点可以理解为可能会触发AOP规则的所有点。(所有请求)

1.2.4 通知(Advice)

在AOP术语中,切面的工作被称之为通知。通知是切面在连接点上执行的动作。它定义了在何时(例如在方法调用之前或之后)以及如何(例如打印日志或进行性能监控)应用切面的行为。即,程序中被拦截请求触发的具体动作。

Spring 切⾯类中,可以在方法上使⽤以下注解,会设置⽅法为通知方法,在满⾜条件后会通知本
⽅法进⾏调⽤:

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

1.3 AOP的使用场景

在做任何一个系统都需要登录功能,那么几乎想要使用这个系统都需要我们进行验证用户登录状态,我们之前的处理⽅式是每个 Controller 都要写⼀遍⽤户登录验证,然⽽当你的功能越来越多,那么你要写的登录验证也越来越多,⽽这些⽅法⼜是相同的,这么多的⽅法就会代码修改和维护的成本。对于这种功能统⼀,且使⽤的地⽅较多的功能,就可以考虑 AOP来统⼀处理了。

【Spring】Spring AOP 初识及实现原理解析,JavaEE进阶,spring,java,后端,java-ee

【Spring】Spring AOP 初识及实现原理解析,JavaEE进阶,spring,java,后端,java-ee 

除了统一登录判断外,使用AOP还可以实现:

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

二、Srping AOP 实现

Spring AOP 的实现步骤如下:

  1. 添加 Spring AOP 框架⽀持
  2. 定义切⾯和切点:(1)创建切面类(2)配置拦截规则
  3. 定义通知

2.1 添加Spring AOP 依赖

<!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-bo
ot-starter-aop -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>

2.2 定义切面和切点

使用 @Aspect 注解表明当前类为一个切面,而在切点中,我们要定义拦截的规则,具体实现如下:

@Component // 随着框架的启动而启动
@Aspect // 告诉框架我是一个切面类
public class UserAspect {

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

    }
}

在上述实现代码中,pointcut 为一个空方法,只是起到一个“标识”的作用,标识下面的通知方法具体指的是哪个切点,切点可以有多个。

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

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

常见的切点表达式的示例:

  • 匹配特定类的所有方法:
  • execution(* com.example.MyClass.*(..)):匹配 com.example.MyClass 类中的所有方法。
  • 匹配特定包下的所有方法:
  • execution(* com.example.*.*(..)):匹配 com.example 包及其子包下的所有方法。
  • 匹配特定方法名的方法:
  • execution(* com.example.MyClass.myMethod(..)):匹配 com.example.MyClass 类中名为 myMethod 的方法。
  • 匹配特定方法参数类型的方法:
  • execution(* com.example.MyClass.myMethod(String, int)):匹配 com.example.MyClass 类中具有一个 String 参数和一个 int 参数的 myMethod 方法。
  • 匹配特定返回类型的方法:
  • execution(String com.example.MyClass.myMethod(..)):匹配 com.example.MyClass 类中返回类型为 String 的 myMethod 方法。
package com.example.demo.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/user")
public class UserController {

    @RequestMapping("/hi")
    public String sayHi(String name){
        System.out.println("执行了Hi");
        return "Hi," + name;
    }

    @RequestMapping("/hello")
    public String sayHello(){
        System.out.println("执行了Hello");
        return "Hello,world";
    }
}

2.3 定义通知

通知定义的是被拦截方法具体要执行的业务。我们上面列出了可以使用哪些通知~这里举出例子

package com.example.demo.aop;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Component // 随着框架的启动而启动
@Aspect // 告诉框架我是一个切面类
public class UserAspect {


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

    }

    @Before("pointcut()")
    public void beforeAdvice(){
        System.out.println("执行了前置通知~");
    }

    @After("pointcut()")
    public void AfterAdvice(){
        System.out.println("执行了后置通知~");
    }

    /**
     * 环绕通知
     * @param joinPoint
     * @return
     */
    @Around("pointcut()")
    public Object aroundAdvice(ProceedingJoinPoint joinPoint){
        System.out.println("进入了环绕通知~");
        Object obj = null;
        try {
        // 执⾏拦截⽅法
            obj = joinPoint.proceed();
        } catch (Throwable e) {
            e.printStackTrace();
        }
        System.out.println("退出了环绕通知~");
        return obj;
    }

}

环绕通知是在前置通知之前和后置通知之后运行的~

【Spring】Spring AOP 初识及实现原理解析,JavaEE进阶,spring,java,后端,java-ee   

三、Spring AOP 实现原理

Spring AOP 是通过动态代理的⽅式,在运⾏期将 AOP 代码织⼊到程序中的,它的实现⽅式有两种:JDK Proxy 和 CGLIB因此,Spring 对 AOP 的支持局限于方法级别的拦截。

  1. 默认情况下,实现了接⼝的类,使⽤ AOP 会基于 JDK ⽣成代理类
  2. 没有实现接⼝的类,会基于 CGLIB ⽣成代理类
     

3.1 什么是动态代理?

动态代理(Dynamic Proxy)是一种设计模式,它允许 在运行时创建代理对象,并将方法调用转发给实际的对象。 动态代理可以用于实现横切关注点(如日志记录、性能监控、事务管理等)的功能,而无需修改原始对象的代码。

在Java中,动态代理通常使用 java.lang.reflect.Proxy 类和 java.lang.reflect.InvocationHandler 接口来实现。

调用者在调用方法时,会先转发给代理类创建的代理对象,随后再由代理对象转发给目标对象。

【Spring】Spring AOP 初识及实现原理解析,JavaEE进阶,spring,java,后端,java-ee

以下是使用动态代理的一般步骤:

  1. 创建一个实现InvocationHandler接口的类,该类将作为代理对象的调用处理程序。在InvocationHandler接口的invoke方法中,可以定义在方法调用前后执行的逻辑。
  2. 使用Proxy类的newProxyInstance方法创建代理对象。该方法接受三个参数:类加载器、代理接口数组和调用处理程序。它将返回一个实现指定接口的代理对象。
  3. 使用代理对象调用方法。当调用代理对象的方法时,实际上会调用调用处理程序的invoke方法,并将方法调用转发给实际的对象。
     

3.2 JDK 动态代理实现

先通过实现 InvocationHandler 接⼝创建⽅法调⽤处理器,再通过 Proxy 来创建代理类。文章来源地址https://www.toymoban.com/news/detail-639029.html

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

3.3 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, Method
            Proxy 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(),n
                ew PayServiceCGLIBInterceptor(target));
        proxy.pay();
    }
}

3.4 JDK 和 CGLIB 实现的区别

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

到了这里,关于【Spring】Spring AOP 初识及实现原理解析的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 【微服务】Spring Aop原理深入解析

    目录 一、前言 二、aop概述 2.1 什么是AOP 2.2 AOP中的一些概念 2.2.1 aop通知类型

    2024年02月04日
    浏览(50)
  • Spring AOP(AOP概念、组成、Spring AOP实现及实现原理)

    学习 Spring AOP 之前,先要了解 AOP 是什么 AOP(Aspect Oriented Programming):面向切面编程,它和 OOP(面向对象编程)类似。 它是一种思想, 是对某一类事情的集中处理。 比如用户登录权限的效验,在学习 AOP 之前,在需要判断用户登录的页面,都要各自实现或调用用户验证的方

    2024年02月02日
    浏览(41)
  • 【Spring】Spring AOP入门及实现原理剖析

    AOP (Aspect-Oriented Programming) 是一种编程范式,它提供一种将程序中的横切关注点模块化的方式。横切关注点可以是日志、事务、安全等,它们不属于业务逻辑,但是又必须要与业务逻辑紧密耦合在一起。在 AOP 中,我们将这些横切关注点称为“切面”,它们独立于业务逻辑模块

    2024年02月17日
    浏览(46)
  • Spring AOP实现原理

    从入口  org.springframework.context.support.AbstractApplicationContext#refresh  开始看 找到Bean的创建方法进入: 再进入详细方法:  找到getBean(beanName): 找到doGetBean(xxx,xxx,xxx,xxx);   找到实际的Bean创建方法createBean(beanName, mdb, args);可以非常明显的看到,Bean就是通过Proxy的方式获取的。   继续

    2023年04月25日
    浏览(41)
  • Spring AOP(AOP概念,组成成分,实现,原理)

    目录 1. 什么是Spring AOP? 2. 为什么要用AOP? 3. AOP该怎么学习? 3.1 AOP的组成 (1)切面(Aspect) (2)连接点(join point) (3)切点(Pointcut) (4)通知(Advice)  4. Spring AOP实现 4.1 添加 AOP 框架支持 ​编辑  4.2 定义切面 4.3 定义切点 4.4 定义通知 4.5 切点表达式说明 AspectJ

    2024年02月13日
    浏览(45)
  • Spring AOP的原理与实现

    前言: 博主在最近的几次面试中,大中小厂都问到了Spring的AOP思想相关问题,这块知识确实是面试中的重点内容,因此结合所看的书籍,在这篇文章中总结下。该专栏比较适合刚入坑Java的小白以及准备秋招的大佬阅读,感谢大佬的关注。 如果文章有什么需要改进的地方欢迎

    2024年02月13日
    浏览(38)
  • javaee spring 测试aop 切面

    spring配置文件

    2024年02月09日
    浏览(39)
  • Spring AOP 实现原理和使用场景

    Spring AOP 是通过在目标方法执行前、执行后、抛出异常时等切入点执行切面代码的一种机制。其实现原理是使用动态代理技术,在方法运行时动态生成代理对象,然后插入切面代码。当执行目标方法时,由动态代理对象拦截方法并在适当的时间点执行切面代码,然后再调用实

    2024年02月05日
    浏览(56)
  • 【Spring AOP学习】AOP的组成 && SpringAOP的实现和实现原理

    目录 一、认识SpringAOP 1、AOP是什么? 2、AOP的功能 3、AOP的组成(重要) 二、SpringAOP的实现 🌷1、添加Spring AOP框架支持 🌷2、定义切面和切点 🌷 3、定义通知 3.1 完成代码实现 3.2 具体通知分析 🌷4、小练习:使用AOP统计UserController每个方法的执行时间。  三、SpringAOP的实现

    2024年02月15日
    浏览(32)
  • 【JavaEE进阶】 利用Spring简单实现加法计算器和用户登录

    本篇博客主要内容: 理解前后端交互过程 接⼝传参,数据返回,以及⻚⾯展⽰ 需求:输⼊两个整数,点击\\\"点击相加\\\"按钮,显⽰计算结果 效果展示如下: 具体实现步骤,博主大致分为以下几步: 准备工作 约定前后端交互接⼝ 后端服务器代码的书写 创建SpringBoot项⽬: 引⼊Spring Web依

    2024年01月17日
    浏览(53)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包