【Spring】Spring AOP底层原理：JDK动态代理和CGLIB动态代理

2024-05-28 08:36
文章标签 java 动态 jdk spring 原理 代理 底层 aop cglib

本文主要是介绍【Spring】Spring AOP底层原理：JDK动态代理和CGLIB动态代理，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

目录

1、代理模式

1.1、静态代理

1.2、动态代理 

2、JDK 动态代理

2.1、jdk动态代理简介

2.2、使用JDK动态代理机制步骤

3、CGLIB 动态代理

3.1、CGLIB 动态代理的特性

3.2、CGLIB的核心类

3.3、CGLIB 动态代理步骤

4、JDK 和 CGLIB 创建代理对象的区别

​编辑

1、代理模式

        代理模式(Proxy Pattern)是一种结构性模式。代理模式为一个对象提供了一个替身，以控制对这个对象的访问。即通过代理对象访问目标目标对象，可以在目标对象实现的基础上，增强额外的功能操作，即扩展目标对象的功能。

        代理模式主要有三种形式，分别是静态代理、动态代理（也称JDK代理、接口代理）和cglib代理（在内存动态创建对象而不需要实现接口，也可属于动态代理得范畴）

1.1、静态代理

 静态代理在前一章中已经说过了：【Spring】Spring AOP底层原理前置知识：代理模式中的静态代理-CSDN博客

1.2、动态代理 

        Spring AOP 的实现原理是基于动态代理和字节码操作的。而动态代理是基于反射机制的。

        在编译时， Spring 会使用 AspectJ 编译器将切面代码编译成字节码文件。在运行时， Spring 会使用 Java 动态代理或 CGLIB 代理生成代理类，这些代理类会在目标对象方法执行前后插入切面代码，从而实现AOP的功能。

        相比于静态代理来说，动态代理更加灵活。我们不需要针对每个目标类都单独创建一个代理类，并且也不需要我们必须实现接口，我们可以直接代理实现类(CGLIB 动态代理机制)。从 JVM 角度来说，动态代理是在运行时动态生成类字节码，并加载到JVM 中的。说到动态代理，Spring AOP、RPC框架是两个不得不的提的，它们的实现都依赖了动态代理。动态代理在日常开发中使用的相对较小，但是在框架中的几乎是必用的一门技术。学会了动态代理之后对于理解和学习各种框架的原理也非常有帮助。

Spring AOP 可以使用两种代理方式：JDK动态代理和 CGLIB 代理。如果目标对象实现了至少一个接口，则使用JDK动态代理；否则，使用 CGLIB 代理。下面分别介绍这两种代理方式的实现原理。

2、JDK 动态代理

2.1、jdk动态代理简介

jdk动态代理：使用java反射包中的类和接口实现动态代理的功能。

反射包 java.lang.reflect , 里面有三个类 ： InvocationHandler , Method, Proxy

在 Java 动态代理机制中InvocationHandler 接囗和 Proxy 类是核心。

Proxy 类中使用频率最高的方法是: newProxyInstance()，Proxy,这个方法主要用来生成一个代理对象,。

public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)
throws IllegalArgumentException
{
......
}

这个方法一共有 3 个参数:

（1）loader：类加载器，用于加载代理对象,传入被代理类的类加载器

（2）interfaces：被代理类实现的一些接口；被代理的类必须要实现这个接口

（3）h：实现了 InvocationHandler 接囗的对象，我们自己写的，代理类要完成的功能。

要实现动态代理的话，还必须需要实现 InvocationHandler 来自定义处理逻辑。当我们的动态代理对象调用一个方法时候，这个方法的调用就会被转发到实现了 InvocationHandler 接口的实现类中重写了的 invoke 方法来调用。

示例：

还没使用JDK动态代理机制时，创建的对象就是被代理类自己

//被代理类要实现的接口IUserService
public interface IUserService {void add();
}//被代理类UserService
public class UserService implements IUserService{@Overridepublic void add(){System.out.println("增加用户");}
}//测试类TestJDKProxy
public class TestJDKProxy {@Testpublic void test(){IUserService userService = new UserService();System.out.println(userService.getClass());}}

这时候还没有使用动态代理来获取代理类，所以这里IUserService userService = new UserService();创建的对象不是动态生成的代理对象

2.2、使用JDK动态代理机制步骤

（1）创建接口，定义目标类要完成的功能

（2）创建目标类实现接口

（3）创建InvocationHandler接口的实现类，在invoke方法中完成代理类的功能
        1.调用目标方法
        2.增强功能

（4）使用Proxy类的静态方法，创建代理对象。 并把返回值转为接口类型。

第一步和第二步我们前面还没使用JDK动态代理机制时已经完成了，现在只需要完成第三步和第四步

第三步：创建InvocationHandler接口的实现类MyHandler

public class MyHandler implements InvocationHandler {Object target; //target代表被代理类的实例对象//通过这个方法可以把被代理类的实例对象，也就是目标对象传递进来赋值给target，//后面调用被代理类里面的方法要用到public MyHandler(Object target){this.target = target;}@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {//实现增强代码的地方，这里就用一个简单的打印语句代替一下了System.out.println("增强的代码：前置通知");//执行目标方法，这里是基于反射机制来实现的Object returnValue = method.invoke(target, args);System.out.println("增强的代码：后置通知");//返回目标方法的返回值return returnValue;}
}

第四步：使用Proxy类的静态方法，创建代理对象

//测试类TestJDKProxy
public class TestJDKProxy {@Testpublic void test(){IUserService userService = (IUserService) Proxy.newProxyInstance(UserService.class.getClassLoader(),//目标对象(UserService)的类加载器，负责向内存中加载对象的，这里使用反射机制来获取UserService.class.getInterfaces(),//接口，目标对象(UserService)实现的接口，也是反射获取的new MyHandler(new UserService())//自己写的实现了 InvocationHandler 接口的实现类，在里面写代理类要完成的功能，// 我只在里面简单写了打印语句打印“前置通知”和“后置通知”);//生成出来的代理实现了IUserService接口，这就是为什么上面的方法一定要传入目标对象(UserService)实现的接口IUserServiceSystem.out.println(userService.getClass()); //打印看看现在拿到的对象是不是动态创建的代理对象userService.add(); //执行这个代理对象的方法，他会执行代理类中的增强方法和被代理类中的add方法}}

运行结果：

        所以在Spring AOP底层原理中，Spring AOP就是帮我们做了上面的第三步和第四步，以此来实现JDK动态代理机制为我们创建代理类对象，然后把这个代理类对象放入到IOC容器当中。我们去IOC容器中拿被代理类（就相当于上面例子中的UserService类）的Bean时，实际上拿的是他的代理类（相当于上面例子中的class jdk.proxy2.$Proxy8）的Bean，这就是为什么可以把增强的代码以切面编程的方式加到目标对象中去运行的原因

        总之，JDK 动态代理是 Java 自带的动态代理实现方式。使用JDK动态代理时，需要目标对象实现至少一个接口。JDK 动态代理会在运行时生成一个实现了目标对象接口的代理类，该代理类会在目标对象方法执行前后插入切面代码。

3、CGLIB 动态代理

3.1、CGLIB 动态代理的特性

        （1）cglib动态代理是针对类来实现代理的，它的原理是对指定的目标类（被代理类）生成一个子类，并覆盖其中方法实现增强。而JDK的动态代理机制只能代理实现了接口的类，而没有实现接口的类就不能实现JDK的动态代理。所以使用cglib实现动态代理，完全不受代理类必须实现接口的限制。

        （2）cglib底层采用ASM字节码生成框架，使用字节码技术生成代理类，比使用Java反射效率要高。

        （3）因为cglib动态代理采用的是继承，所以不能对final修饰的类进行代理。

        （4）由于cglib是一个第三方的框架，不是JDK自带的，所以要引入maven依赖。但是在的Spring3版本之后cglib就被整合进Spring中了，就不再需要引入cglib的maven依赖了

引入cglib的maven依赖

//引入cglib的maven依赖
<dependency><groupId>cglib</groupId><artifactId>cglib</artifactId><version>3.2.6</version>
</dependency>

3.2、CGLIB的核心类

        （1）net.sf.cglib.proxy.Enhancer： Enhancer（代理工厂类，也可以叫做增强类）是CGLIB中的主要类之一，用于创建代理对象。通过Enhancer可以指定被代理类、回调方法和拦截器等信息，然后生成代理对象的字节码。

        （2）net.sf.cglib.proxy.MethodInterceptor： MethodInterceptor（拦截类）是CGLIB中的一个接口，用于实现代理对象的拦截逻辑。当代理对象的方法被调用时，MethodInterceptor中的intercept方法会被调用，开发者可以在该方法中添加额外的逻辑。类似于JDK动态代理中的InvocationHandler接口

        （3）net.sf.cglib.proxy.Callback： Callback是一个接口，它定义了代理对象的回调方法。MethodInterceptor就是继承了Callback接口的一个更成熟的接口，用于拦截方法调用。CGLIB还提供了其他类型的Callback，如NoOp、LazyLoader等，用于实现不同的代理逻辑。

MethodInterceptor继承了Callback接口在源码中如下图：

3.3、CGLIB 动态代理步骤

（1）引入 CGLIB 依赖（好像Spring3版本之后cglib就被整合进Spring中了，就不需要引入依赖了）

（2）定义一个被代理类（这个被代理类可以实现接口，也可以不实现接口）

（3）定义一个拦截类并实现接口 MethodInterceptor

（4）创建代理工厂类实例

（5）生成代理类对象，并通过代理对象调用方法

示例：

//定义一个没有实现任何接口的被代理类UserService
public class UserService{public void add(){System.out.println("增加用户");}
}//定义一个拦截类MyMethodInterceptor并实现接口 MethodInterceptor
public class MyMethodInterceptor implements MethodInterceptor {Object target; //target代表被代理类的实例对象//通过这个方法可以把被代理类的实例对象，也就是目标对象传递进来赋值给target，//后面调用被代理类里面的方法要用到public MyMethodInterceptor(Object target){this.target = target;}@Overridepublic Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {//实现增强代码的地方，这里就用一个简单的打印语句代替一下了System.out.println("增强的代码：前置通知");//执行目标方法，这里是直接调用父类方法(就是直接调用被代理类的方法)，相当于执行super.方法()Object returnValue = proxy.invoke(target, args);System.out.println("增强的代码：后置通知");//返回目标方法的返回值return returnValue;}
}//创建代理工厂类的对象，然后通过代理对象调用方法
public class TestCGLIBProxy {@Testpublic void test(){//创建代理工厂类实例Enhancer enhancer = new Enhancer();//设置被代理的类enhancer.setSuperclass(UserService.class);//设置处理类enhancer.setCallback(new MyMethodInterceptor(new UserService()));//生成的代理类，这个代理类是继承自UserService的UserService userService = (UserService) enhancer.create();System.out.println(userService.getClass()); //打印结果为：class com.lt.autoProxy.cglib.UserService$$EnhancerByCGLIB$$beeda0dcuserService.add(); //通过代理对象调用方法}}

运行结果：

4、JDK 和 CGLIB 创建代理对象的区别

        （1）JDK 动态代理只能代理实现了接口的类，因为他生成出来的代理类是采用实现目标类的接口的方式，比如目标类UserService实现了接口lUserService，代理类的生成方式就是 public proxy$0 implements lUserService{} ，proxy$0就是JDK 动态代理生成出来的代理类（当然这只是一个例子，proxy$0是我为了好理解而取的代理类类名）

        （2）而 CGLIB 可以代理未实现任何接口的类。因为他生成出来的代理类是采用继承目标类的方式，比如目标类为UserService，代理类的生成方式就是 public $xxxxCqlib$ extends UserServcef} ，另外CGLIB 动态代理是通过生成一个被代理类的子类来拦截被代理类的方法调用，因此不能代理声明为final 类型的类和方法。

        （平常的业务是用不到动态代理的，一般都是框架的底层才会用到） 

补充：

        所以可以根据是否有实现接口来选择JDK动态代理或CGLIB，但是用Spring AOP来实现的话，无需关心，因为底层会自动根据被代理目标类是否实现接口自动选择JDK或CGLIB

        在Spring中默认用JDK动态代理 判断目标类是否实现接口，如果实现了接口就用JDK动态代理，否则就使用CGLIB动态代理

可以通过配置来改变Spring使用哪一种动态代理机制：

@EnableAspectAutoProxy(proxyTargetClass=false) = jdk动态代理 （默认） @EnableAspectJAutoProxy(proxyTargetClass=true)= cglib

在SpringBoot2.x版本后默认是使用CgLib作为默认的动态代理实现

@EnableAspectAutoProxy注解在SpringBoot的默认启动类上有一个，默认启动类上的这个注解设置的是proxyTargetClass=true，也就说默认是使用cglib动态代理的。如果想把他改成使用jdk动态代理，就可以在SpringBoot的配置文件application.properties里配置：spring.aop.proxy-target-class=false

推荐：

【Spring】Spring AOP底层原理前置知识：代理模式中的静态代理-CSDN博客icon-default.png?t=N7T8https://blog.csdn.net/m0_65277261/article/details/139106845?spm=1001.2014.3001.5501

【Spring】AOP中的核心概念：通知(Advice)和切点(Pointcut)_advice 切面-CSDN博客icon-default.png?t=N7T8https://blog.csdn.net/m0_65277261/article/details/138890487?spm=1001.2014.3001.5501

【Spring】初识 Spring AOP（面向切面编程）-CSDN博客icon-default.png?t=N7T8https://blog.csdn.net/m0_65277261/article/details/138724937?spm=1001.2014.3001.5501

这篇关于【Spring】Spring AOP底层原理：JDK动态代理和CGLIB动态代理的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1010062。

相关文章

JVM 的类初始化机制

JVM 的类初始化机制

前言 当你在 Java 程序中new对象时，有没有考虑过 JVM 是如何把静态的字节码（byte code）转化为运行时对象的呢，这个问题看似简单，但清楚的同学相信也不会太多，这篇文章首先介绍 JVM 类初始化的机制，然后给出几个易出错的实例来分析，帮助大家更好理解这个知识点。 JVM 将字节码转化为运行时对象分为三个阶段，分别是：loading 、Linking、initialization
阅读更多...
Spring Security 基于表达式的权限控制

Spring Security 基于表达式的权限控制

前言 spring security 3.0已经可以使用spring el表达式来控制授权，允许在表达式中使用复杂的布尔逻辑来控制访问的权限。 常见的表达式 Spring Security可用表达式对象的基类是SecurityExpressionRoot。 表达式描述hasRole([role])用户拥有制定的角色时返回true （Spring security默认会带有ROLE_前缀）,去
阅读更多...
浅析Spring Security认证过程

浅析Spring Security认证过程

类图 为了方便理解Spring Security认证流程，特意画了如下的类图，包含相关的核心认证类 概述 核心验证器 AuthenticationManager 该对象提供了认证方法的入口，接收一个Authentiaton对象作为参数; public interface AuthenticationManager {Authentication authenticate(Authenti
阅读更多...
Spring Security--Architecture Overview

Spring Security--Architecture Overview

1 核心组件 这一节主要介绍一些在Spring Security中常见且核心的Java类，它们之间的依赖，构建起了整个框架。想要理解整个架构，最起码得对这些类眼熟。 1.1 SecurityContextHolder SecurityContextHolder用于存储安全上下文（security context）的信息。当前操作的用户是谁，该用户是否已经被认证，他拥有哪些角色权限…这些都被保
阅读更多...
Spring Security基于数据库验证流程详解

Spring Security基于数据库验证流程详解

Spring Security 校验流程图 相关解释说明（认真看哦） AbstractAuthenticationProcessingFilter 抽象类 /*** 调用 #requiresAuthentication(HttpServletRequest, HttpServletResponse) 决定是否需要进行验证操作。* 如果需要验证，则会调用 #attemptAuthentica
阅读更多...
Spring Security 从入门到进阶系列教程

Spring Security 从入门到进阶系列教程

Spring Security 入门系列 《保护 Web 应用的安全》 《Spring-Security-入门（一）：登录与退出》 《Spring-Security-入门（二）：基于数据库验证》 《Spring-Security-入门（三）：密码加密》 《Spring-Security-入门（四）：自定义-Filter》 《Spring-Security-入门（五）：在 Sprin
阅读更多...
Java架构师知识体认识

Java架构师知识体认识

源码分析 常用设计模式 Proxy代理模式Factory工厂模式Singleton单例模式Delegate委派模式Strategy策略模式Prototype原型模式Template模板模式 Spring5 beans 接口实例化代理Bean操作 Context Ioc容器设计原理及高级特性Aop设计原理Factorybean与Beanfactory Transaction 声明式事物
阅读更多...
Java进阶13讲__第12讲_1/2

Java进阶13讲__第12讲_1/2

多线程、线程池 1.  线程概念 1.1  什么是线程 1.2  线程的好处 2.   创建线程的三种方式 注意事项 2.1  继承Thread类 2.1.1 认识  2.1.2  编码实现  package cn.hdc.oop10.Thread;import org.slf4j.Logger;import org.slf4j.LoggerFactory
阅读更多...
第10章 中断和动态时钟显示

第10章 中断和动态时钟显示

第10章 中断和动态时钟显示 从本章开始，按照书籍的划分，第10章开始就进入保护模式（Protected Mode）部分了，感觉从这里开始难度突然就增加了。 书中介绍了为什么有中断（Interrupt）的设计，中断的几种方式：外部硬件中断、内部中断和软中断。通过中断做了一个会走的时钟和屏幕上输入字符的程序。 我自己理解中断的一些作用： 为了更好的利用处理器的性能。协同快速和慢速设备一起工作
阅读更多...
深入探索协同过滤：从原理到推荐模块案例

深入探索协同过滤：从原理到推荐模块案例

文章目录 前言一、协同过滤1. 基于用户的协同过滤（UserCF）2. 基于物品的协同过滤（ItemCF）3. 相似度计算方法 二、相似度计算方法1. 欧氏距离2. 皮尔逊相关系数3. 杰卡德相似系数4. 余弦相似度 三、推荐模块案例1.基于文章的协同过滤推荐功能2.基于用户的协同过滤推荐功能 前言     在信息过载的时代，推荐系统成为连接用户与内容的桥梁。本文聚焦于
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2