【Spring】AOP底层原理(动态代理)-》 AOP概念及术语 -》 AOP实现

最新推荐文章于 2024-01-28 14:55:05 发布
最新推荐文章于 2024-01-28 14:55:05 发布
阅读量1.4k 收藏 21
点赞数 17
分类专栏： Spring 文章标签： spring java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ebb29bbe/article/details/128813234
版权

在这里插入图片描述

个人简介：Java领域新星创作者；阿里云技术博主、星级博主、专家博主；正在Java学习的路上摸爬滚打，记录学习的过程~
个人主页：.29.的博客
学习社区：进去逛一逛~

在这里插入图片描述

AOP - 面向切面编程



一、简述AOP

AOP —— 面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。

是Spring框架中的一个重要内容。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

AOP的作用：

  • 简化代码：把方法中固定位置的重复的代码抽取出来，让被抽取的方法更专注于自己的核心功能，提高内聚性。

  • 代码增强：把特定的功能封装到切面类中，看哪里有需要，就往上套，被套用了切面逻辑的方法就被切面给增强了。



二、AOP底层原理

AOP面向切面编程，在底层使用动态代理实现，其中分为两种情况：

  • 有接口时，使用JDK动态代理
  • 无接口时，使用CGLIB动态代理

JDK动态代理：创建接口实现类代理对象，增强类的方法；
CGLIB动态代理：创建子类的代理对象，增强类的方法；



三、实现动态代理（案例）

使用的相关Maven依赖：

<dependencies>
        <!--spring context依赖-->
        <!--当你引入Spring Context依赖之后，表示将Spring的基础依赖引入了-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.6.RELEASE</version>
        </dependency>

        <!--spring aop依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>5.2.6.RELEASE</version>
        </dependency>
        <!--spring aspects依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>5.2.6.RELEASE</version>
        </dependency>

        <!--junit5测试-->
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-api</artifactId>
            <version>5.3.1</version>
        </dependency>
    </dependencies>

① 声明计算器接口Calculator，包含加减乘除的抽象方法：

/**
 * @author .29.
 * @create 2023-02-04 15:01
 */
public interface Calculator {
    int add(int i, int j);

    int sub(int i, int j);

    int mul(int i, int j);

    int div(int i, int j);
}

② 创建接口实现类，实现加减乘除等方法：

import org.springframework.stereotype.Component;

/**
 * @author .29.
 * @create 2023-02-04 15:02
 */

//简单功能的实现类
@Component
public class CalculatorImpl implements Calculator {
    @Override
    public int add(int i, int j) {

        int result = i + j;

        System.out.println("方法内部 result = " + result);

        return result;
    }

    @Override
    public int sub(int i, int j) {

        int result = i - j;

        System.out.println("方法内部 result = " + result);

        return result;
    }

    @Override
    public int mul(int i, int j) {

        int result = i * j;

        System.out.println("方法内部 result = " + result);

        return result;
    }

    @Override
    public int div(int i, int j) {

        int result = i / j;

        System.out.println("方法内部 result = " + result);

        return result;
    }
}

③ 编写被代理对象的工厂类：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;

/**
 * @author .29.
 * @create 2023-02-04 22:05
 */
public class ProxyFactory {
    //目标对象
    private Object target;

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

    //返回代理对象
    public Object getProxy(){
        //动态代理返回对象
        //调用Proxy类中的newProxyInstance(),获取动态代理对象
        /*
        * newProxyInstance()中需要传入三个参数
        * ① ClassLoader：加载动态生成代理类的 类加载器
        * ② Class[] interfaces： 目标对象实现的所有接口
        * ③ InvocationHandler: 设置代理对象实现目标对象方法的过程
        * */
        ClassLoader classLoader = target.getClass().getClassLoader();

        Class<?>[] interfaces = target.getClass().getInterfaces();

        InvocationHandler invocationHandler = new InvocationHandler(){
            //参数一：代理对象
            //参数二：需要重写目标对象的方法
            //参数三：method方法（参数二）中的参数
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                //方法调用前输出的日志
                System.out.println("[动态代理][日志]"+method.getName()+",参数："+ Arrays.toString(args));

                //调用目标方法
                Object result = method.invoke(target, args);

                //方法调用后输出的日志
                System.out.println("[动态代理][日志]"+method.getName()+",结果："+ result);
                return result;
            }
        };
        //调用Proxy类中的newProxyInstance(),获取动态代理对象
         return Proxy.newProxyInstance(classLoader,interfaces,invocationHandler);
    }
}

④ 测试：

/**
 * @author .29.
 * @create 2023-02-04 22:24
 */
public class TestCalculator {
    public static void main(String[] args) {
        //创建代理对象
        ProxyFactory proxyFactory = new ProxyFactory(new CalculatorImpl());
        //通过代理对象获取目标对象
        Calculator proxy = (Calculator) proxyFactory.getProxy();
        //调用目标对象方法
        proxy.add(1,1);
        System.out.println();

        proxy.div(1,1);
        System.out.println();

        proxy.mul(1,1);
        System.out.println();

        proxy.sub(1,1);
        System.out.println();
    }
}

在这里插入图片描述



四、AOP术语

1.横切关注点：
分散在每个各个模块中解决同一样的问题，如用户验证、日志管理、事务处理、数据缓存都属于横切关注点。

从每个方法中抽取出来的同一类非核心业务。在同一个项目中，我们可以使用多个横切关注点对相关方法进行多个不同方面的增强。

这个概念不是语法层面的，而是根据附加功能的逻辑上的需要：有十个附加功能，就有十个横切关注点。

2.通知：
每一个横切关注点上要做的事情都需要写一个方法来实现，这样的方法就叫通知方法。

  • 前置通知：使用@Before注解标识，在被代理的目标方法前执行
  • 返回通知：使用@AfterReturning注解标识，在被代理的目标方法成功结束后执行（寿终正寝）
  • 异常通知：使用@AfterThrowing注解标识，在被代理的目标方法异常结束后执行（死于非命）
  • 后置通知：使用@After注解标识，在被代理的目标方法最终结束后执行（盖棺定论）
  • 环绕通知：使用@Around注解标识，使用try…catch…finally结构围绕整个被代理的目标方法，包括上面四种通知对应的所有位置

各种通知的执行顺序：

  • Spring版本5.3.x以前：
    • 前置通知
    • 目标操作
    • 后置通知
    • 返回通知或异常通知
  • Spring版本5.3.x以后：
    • 前置通知
    • 目标操作
    • 返回通知或异常通知
    • 后置通知

3.切面：
即：封装通知方法的类。

4.目标：
即：被代理的目标对象。

5.代理：
向目标对象应用通知之后创建的代理对象。

6.连接点：
这也是一个纯逻辑概念，不是语法定义的。

把方法排成一排，每一个横切位置看成x轴方向，把方法从上到下执行的顺序看成y轴，x轴和y轴的交叉点就是连接点。通俗说，就是spring允许你使用通知的地方

7.切入点：
定位连接点的方式。

每个类的方法中都包含多个连接点，所以连接点是类中客观存在的事物（从逻辑上来说）。

如果把连接点看作数据库中的记录，那么切入点就是查询记录的 SQL 语句。

Spring 的 AOP 技术可以通过切入点定位到特定的连接点。通俗说，要实际去增强的方法

切点通过 org.springframework.aop.Pointcut 接口进行描述，它使用类和方法作为连接点的查询条件。



五、AOP的注解方式实现

须知：
切入点表达式语法：
execution(权限修饰符 增强方法返回类型 增强方法所在类全路径.方法名称(方法参数))

在这里插入图片描述


1.导入Maven依赖：

<dependencies>
        <!--spring context依赖-->
        <!--当你引入Spring Context依赖之后，表示将Spring的基础依赖引入了-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.6.RELEASE</version>
        </dependency>

        <!--spring aop依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>5.2.6.RELEASE</version>
        </dependency>
        <!--spring aspects依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>5.2.6.RELEASE</version>
        </dependency>

        <!--junit5测试-->
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-api</artifactId>
            <version>5.3.1</version>
        </dependency>
    </dependencies>

2.准备被代理的 接口+实现类：

/**
 * @author .29.
 * @create 2023-02-04 15:01
 */

public interface Calculator {
    int add(int i, int j);

    int sub(int i, int j);

    int mul(int i, int j);

    int div(int i, int j);
}


import org.springframework.stereotype.Component;

/**
 * @author .29.
 * @create 2023-02-04 15:02
 */

//简单功能的实现类
@Component
public class CalculatorImpl implements Calculator {
    @Override
    public int add(int i, int j) {

        int result = i + j;

        System.out.println("方法内部 result = " + result);

        return result;
    }

    @Override
    public int sub(int i, int j) {

        int result = i - j;

        System.out.println("方法内部 result = " + result);

        return result;
    }

    @Override
    public int mul(int i, int j) {

        int result = i * j;

        System.out.println("方法内部 result = " + result);

        return result;
    }

    @Override
    public int div(int i, int j) {

        int result = i / j;

        System.out.println("方法内部 result = " + result);

        return result;
    }
}

※ 3.创建并配置切面类：

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

import java.util.Arrays;

/**
 * @author .29.
 * @create 2023-02-04 22:47
 */
//切面类
//@Aspect代表这是一个切面类
//@Component代表将此类交给Spring处理，能够放入IOC容器中去
@Aspect
@Component
public class LogAspect {
    //设置切入点 和 通知类型
    //切入点表达式：execution(权限修饰符 增强方法返回类型 增强方法所在类全路径.方法名称(方法参数))

    //重用切入点表达式：使用@Pointcut注解，设置需要重复使用的切入点表达式
    @Pointcut(value = "execution(public int com.haojin.spring.aop.annoaop.CalculatorImpl.*(..))")
    public void pointCut(){}
    //之后，在使用通知时，将切入点表达式用 方法名 替换，即pointCut()（同一个切面）
    //若在不同的切面，需要加上重用切入点表达式方法的全类名：com.haojin.spring.aop.annoaop.LogAspect.pointCut()（不同的切面）

    //通知类型：
    // @Before("切入点表达式配置切入点") 前置
    @Before(value = "pointCut()")   //重用切入点表达式，使用方法名替换
    public void beforeMethod(JoinPoint joinPoint){
        String name = joinPoint.getSignature().getName();//获取增强方法的名字
        Object[] args = joinPoint.getArgs();             //获取增强方法的参数数组
        System.out.println("Logger-->前置通知，增强方法为："+name+",参数："+ Arrays.toString(args));
    }

    // @AfterReturning() 返回
    //返回通知 可以获取到返回值，在切入表达式中增加返回值属性:returning = ""
    @AfterReturning(value = "pointCut()",returning = "result")
    //增强方法中需要添加 返回值参数result，参数名与切入点表达式保持一致（result）
    public void afterReturningMethod(JoinPoint joinPoint,Object result){//可以存在参数JoinPoint，以此来获取信息
        String name = joinPoint.getSignature().getName();//获取增强方法的名字
        System.out.println("Logger-->返回通知，增强方法为："+name+"，返回结果："+result);

    }

    // @AfterThrowing() 异常
    //目标方法出现异常时，此通知会执行，在切入表达式中增加属性：
    @AfterThrowing(value = "pointCut()",throwing = "exception")
    //增加 Throwable类型参数，参数名必须与切入点表达式保持一致（exception）
    public void aAfterThrowingMethod(JoinPoint joinPoint,Throwable exception){//可以存在参数JoinPoint，以此来获取信息
        String name = joinPoint.getSignature().getName();//获取增强方法的名字
        System.out.println("Logger-->异常通知，增强方法为："+name+"异常信息："+exception);

    }

    // @After() 后置
    @After(value = "execution(* com.haojin.spring.aop.annoaop.CalculatorImpl.*(..))")
    public void afterMethod(JoinPoint joinPoint){//可以存在参数JoinPoint，以此来获取信息
        String name = joinPoint.getSignature().getName();//获取增强方法的名字
        System.out.println("Logger-->后置通知，增强方法为："+name);

    }
    // @Around() 环绕通知，可以通过try-catch-finally,使得增强方法在所有阶段执行（增强方法可设置返回值）
    @Around("execution(public int com.haojin.spring.aop.annoaop.CalculatorImpl.*(..))")
    //可设置 ProceedingJoinPoint属性参数,以此调用增强方法(JoinPoint的子接口，JoinPoint没有调用目标方法的功能)
    public Object aroundMethod(ProceedingJoinPoint joinPoint){
        String name = joinPoint.getSignature().getName();//通过ProceedingJoinPoint参数获取增强方法名
        Object[] args = joinPoint.getArgs();             //获取增强方法参数数组
        String argStr = Arrays.toString(args);           //参数数组转字符串
        Object result = null;

        try{
            System.out.println("环绕通知 == 增强方法执行前执行");

            //通过ProceedingJoinPoint类型参数调用增强方法
            result = joinPoint.proceed();

            System.out.println("环绕通知 = 增强方法返回值之后执行");

        }catch(Throwable throwable){//捕捉Throwable类型异常
            throwable.printStackTrace();
            System.out.println("环绕通知 = 增强方法异常时执行");

        }finally {
            System.out.println("环绕方法 = 增强方法执行完毕执行");

        }

        return result;
    }

切面优先级：

切面的优先级控制切面的 内外嵌套 顺序
外层切面：优先级高
内层切面：优先级低

…
可使用@Order()注解设置优先级
@Order(较小的数) 优先级较高
@Order(较大的数) 优先级较低


4.配置Spring配置文件（这里命名为 bean.xml）：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--
        基于注解的AOP的实现：
        1、将目标对象和切面交给IOC容器管理（注解+扫描）
        2、开启AspectJ的自动代理，为目标对象自动生成代理
        3、将切面类通过注解@Aspect标识
    -->
    <context:component-scan base-package="com.haojin.spring.aop.annoaop"></context:component-scan>

    <!--开启AspectJ的自动代理-->
    <aop:aspectj-autoproxy />

</beans>

5.测试：

import com.haojin.spring.aop.annoaop.Calculator;
import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @author .29.
 * @create 2023-02-06 9:34
 */
public class TestAop {
    //以实现类中的加法功能为例
    @Test
    public void testAdd(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        Calculator bean = context.getBean(Calculator.class);
        bean.add(3,13);
    }
}

在这里插入图片描述

.29.
关注
  • 17
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 23
    评论
专栏目录
AOP底层实现.eddx
05-07
AOP底层实现原理图
Spring AOP实验
06-05
一、 实验目的 1、了解AOP的概念和作用； 2、理解AOP中的相关术语； 3、了解Spring中两种动态代理方式的区别； 4、掌握基于XML和注解的AspectJ开发。 二、 实验内容 1、按图所示的类图结构，设计接口及其实现类，并完成另外两附加要求：（1）日志功能：在程序执行期间追踪正在发生的活动（打印出调用的方法，以及参数的参数值）；（2）验证功能：希望计算器只能处理正数的运算，当有负数参与运算时，给出提示说明。 分别使用基于XML和注解的AspectJ实现上述功能(创建两个项目)。 （图就是int加减乘除）
Spring框架-AOP底层实现原理
最新发布
qq_44715376的博客
01-28 1087
Spring框架-AOP底层实现原理
Spring5_AOP.pdf
01-02
从Spring5-AOP的概念->底层原理->相关术语->AOP操作(AspectJ注解)->AOP操作（AspectJ配置文件）说明AOP的相关笔记
SpringBoot下的SpringAOP-day04-源代码
03-09
SpringBoot下的Spring——DAY04——动态代理总结、AOP、自定义注解进行拦截、动态获取注解参数、通知方法 1.动态代理总结 1.1 JDK动态代理特点 1.2 CGlib动态代理 1.2.1 CGLib特点说明 1.3 动态代理的作用 2 Spring中的AOP 2.1 AOP介绍 2.2 AOP中专业术语(难点) 2.3 AOP 入门案例 2.3.1 创建一个SpringBoot的module 2.3.1 导入jar包 2.3.2 项目工程结构 2.3.3 配置类 2.3.4 Service层 2.3.4.1 接口 2.3.4.2 实现类 2.3.5 切入点表达式 2.3.6 定义切面类 2.3.7 让AOP生效 2.3.8 编辑测试类 2.4 AOP形象化的比喻 2.5 关于切入点表达式解析 2.5.1 bean标签写法 2.5.2 within表达式 2.5.3 execution表达式 2.6 按照自定义注解进行拦截 2.6.1 自定义注解 2.6.2 切入点表达式写法 2.6.3 在service层实现类UserServiceImpl的addUser()方法
Spring AOP 原理剖析，这一篇就够
12-22
Spring AOP 学习记录 AOP（面向切面编程）方面的知识又是看了忘忘了看，今天有空记录下AOP的知识点。主要分为以下几方面： ​ 1、AOP相关术语 ​ 2、基础知识及示例 ​ 3、增强分类 1、AOP相关术语 连接点（Joinpoint） 一个类拥有一些边界性质的特定点，如一个类的各个方法就可称为连接点。 切点（Pointcut） 切点就是在众多连接点中选择自己感兴趣的连接点，如果将连接点比作一个数据库中的所有记录，那么切点就是一个查询语句的查询条件。 增强（Advice） 增强是置入目标连接点的一段代码，增强本身携带方位信息，如方法调用前、调用后、调用前后、异常抛出使等。 切
AOP-底层原理
cy364328541的博客
04-16 4627
AOP底层原理讲解及代码实现
aop的底层原理
weixin_42596214的博客
01-05 806
AOP(面向切面编程)是一种程序设计思想，旨在将一些跨越多个对象的功能(即切面)模块化。这样可以有效地将与一般业务逻辑无关的功能从核心业务逻辑中分离出来，这样就可以在不修改核心业务逻辑的情况下在不同的地方重用这些功能，也可以更灵活地对这些功能进行配置和管理。 AOP的底层原理是动态代理。动态代理是在运行时动态地创建代理类的一种机制，它可以在不修改源码的情况下，为一个对象提供额外的功能。在 AOP ...
springAop看这篇就够了-- Spring AOP是什么？你都拿它做什么？
大碍桃花开
01-13 904
为什么会有面向切面编程（AOP）？我们知道Java是一个面向对象（OOP）的语言，但它有一些弊端，比如当我们需要为多个不具有继承关系的对象引入一个公共行为，例如日志、权限验证、事务等功能时，只能在在每个对象里引用公共行为。这样做不便于维护，而且有大量重复代码。AOP的出现弥补了OOP的这点不足。 为了阐述清楚Spring AOP，我们从将以下方面进行讨论： 代理模式 静态代理原理及实践 动态代理原...
AOP的底层原理：动态代理
admin3335的博客
10-16 1040
AOP的底层原理：动态代理
Spring AOP底层实现原理（动态代理）
weixin_33717117的博客
09-04 512
2019独角兽企业重金招聘Python工程师标准>>> ...
SpringAOP的实现机制（底层原理）、应用场景等详解，模拟过程的实例
09-09
简介： 本资源将深入探讨Spring框架中使用的两种关键的动态代理方式：JDK动态代理和CGLib动态代理。这两种代理方式在Spring AOP中起到关键作用，用于实现横切关注点的切面编程。通过学习它们的原理和实际应用，您将能够更好地理解和利用Spring AOP来提高您的应用程序的可维护性和可扩展性。 内容亮点： JDK动态代理： 我们将详细介绍JDK动态代理的概念和工作原理。您将了解如何使用Java的反射机制来创建代理对象，以及如何将横切逻辑注入到目标方法中。我们还提供了实际示例，演示如何在Spring AOP中使用JDK动态代理。 CGLib动态代理： 我们将深入研究CGLib动态代理，它允许您在不需要接口的情况下创建代理对象。您将了解CGLib的工作原理，以及如何生成子类来实现代理。我们还提供了示例，展示如何在Spring AOP中使用CGLib动态代理。 JDK动态代理与CGLib的比较： 我们将比较这两种动态代理方式的优劣势，以帮助您选择适合您项目需求的代理方式。您将了解它们在性能、可用性和适用场景方面的差异。
Spring AOP 底层实现原理
欢迎来到三十七度的博客
08-12 3027
AOP(Aspect-Oriented Programming), 即 面向切面编程, 它与 OOP( Object-Oriented Programming, 面向对象编程) 相辅相成, 提供了与 OOP 不同的抽象软件结构的视角在 OOP 中, 我们以类(class)作为我们的基本单元, 而 AOP 中的基本单元是 Aspect(切面)以上就是我对Java开发大型互联网架构Spring AOP实现原理之Spring AOP底层实现 问题及其优化总结。......
spring的AOP底层原理
weixin_42514547的博客
08-14 126
在这里，我们看到第二次，走增强方法的时候，走到返回通知的方法，在Aop里面，返回通知里面的增强方法，是不管目标方法是否报错，都会执行的方法，在这里，我们可以看到返回通知里的方法确实也是这样，不管mi.proceed（）主干流程方法是否会报错，到最后，都会执行finally中的方法，然后继续回到proceed()方法(注意，在这几次走增强方法时，每个增强方法都没执行完，然后就继续调用了proceed方法，这就是springAop执行增强方法的巧妙之处，感兴趣的读者可以下来自行了解)
面试常问的Spring AOP底层原理
热门推荐
loss_rose777的博客
01-25 2万+
AOP底层原理可以划分成四个阶段：创建代理对象阶段、拦截目标对象阶段、调用代理对象阶段、调用目标对象阶段。
Spring AOP底层原理
qq_54876312的博客
05-21 2730
什么是AOP AOP：Aspect Oriented Programing(面向切面编程) 采用横向抽取机制，取代传统继承体系重复性代码（性能监视、事务管理、安全检查、缓存）即代理机制 使用纯JAVA实现，不需要专门的编写过程和类加载器，在运行期通过代理方式向目标织入增强代码 AOP相关术语 Joinpoint(连接点）：所谓连接点是指那些可以被拦截到的点。在Spring中，这些点指的是方法，因为spring只支持方法类型的连接点。 Pointcut(切入点）:所谓切入点是指我们要对哪些Joinpoi
AOP的动态代理
xh_yj的博客
01-13 569
一、什么是AOP 1、面向切面编程（方面），利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重复性，同时提高了开发的效率。 2、通俗描述：不通过修改源代码方式，在主干功能里面添加新功能。 3、列：实现登录权限功能中用到了AOP 二、AOP底层原理 1、Aop底层使用动态代理 （1）有两种情况动态代理   第一种 有接口情况，使用JDK动态代理   第二种没有接口情况，使用CGLIB动态代理 ...
什么是AOP，AOP的底层实现原理
ToBeWhatYouWant
07-11 8879
什么是AOP?AOP的底层实现 1.什么是AOP AOP（Aspect Oritented Programing） 面向切面编程。 AOP采取横向抽取机制，取代了传统的继承纵向继承体系的重复性代码（性能监视，事务管理，安全检查，缓存）。 Spring的AOP采用了纯java实现，不需要专门的编译过程和类加载器，在运行期间通过动态代理的方式向目标类注入增强代码。 2.AOP应用场景说明 对程序进行增...
Spring AOP 底层原理
06-10
Spring AOP 的底层原理是基于动态代理技术和字节码生成技术实现的。 在 Spring AOP 中，通常使用 JDK 动态代理或者 CGLIB 字节码生成技术来生成代理对象。当目标对象被代理时，Spring AOP 将对切面所提供的通知进行拦截，并在目标对象的方法执行前、执行后或者发生异常时执行这些通知。 具体来说，当使用 JDK 动态代理时，Spring AOP 将为目标对象创建一个实现了目标对象所实现接口的代理对象。当方法被调用时，代理对象将拦截这个方法调用，并将请求转发给切面所提供的通知。当使用 CGLIB 字节码生成技术时，Spring AOP 将为目标对象创建一个继承自目标对象的子类，并重写其中的方法。当方法被调用时，子类将拦截这个方法调用，并将请求转发给切面所提供的通知。 总之，Spring AOP 的底层原理是基于动态代理技术和字节码生成技术实现的，通过拦截目标对象的方法调用，来实现对切面所提供的通知的执行。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 23
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

.29.

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值