Spring之CGLIB和JDK动态代理底层实现

已于 2024-04-18 23:38:40 修改
阅读量1k 收藏 22
点赞数 20
分类专栏： Spring 文章标签： java 开发语言
于 2024-04-17 23:50:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/changyinling520/article/details/137893727
版权
本文详细介绍了CGLIB和JDK动态代理的使用方法，以及Spring框架如何自动在两者间切换，重点展示了如何在CGLIB和JDK代理中设置代理逻辑，以及ProxyFactory在不同场景下的行为。
摘要由CSDN通过智能技术生成

目录

CGLIB

使用示例-支持创建代理对象，执行代理逻辑

使用示例-多个方法，走不同的代理逻辑

JDK动态代理

使用示例-支持创建代理对象，执行代理逻辑

ProxyFactory

如何自动在CGLIB和JDK动态代理转换

使用示例-使用CGLIB代理方式

使用示例-使用JDK动态代理方式

Spring会自动在JDK动态代理和CGLIB之间转换:

1、如果目标对象实现了接口，默认情况下会采用JDK的动态代理实现AOP

2、如果目标对象实现了接口，可以强制使用CGLIB实现AOP

3、如果目标对象没有实现了接口，必须采用CGLIB库

本文主要讲解CGLIB和JDK动态代理的使用和底层原理，以及Spring如何自动在JDK动态代理和CGLIB之间转换

CGLIB

CGLIB动态代理是利用ASM开源包，对代理对象类的class文件加载进来，通过修改其字节码生成子类来处理。

使用示例-支持创建代理对象，执行代理逻辑

新建一个UserService类，这个类是目标类，后续会被代理

public class UserService {
	public void test() {
		System.out.println("userService execute test....");
	}
}

使用Enhancer类设置代理类UserService，设置代理逻辑，创建代理对象

public class CylTest {
	public static void main(String[] args) {
		UserService target = new UserService();

		Enhancer enhancer = new Enhancer();
		enhancer.setSuperclass(UserService.class);

		//设置代理逻辑
		enhancer.setCallbacks(new Callback[]{new MethodInterceptor() {
			@Override
			public Object intercept(/*目标对象*/Object o,
                                    /*目标对象方法*/Method method,
                                    /*参数*/Object[] args,
                                    /*代理对象方法*/MethodProxy methodProxy) 
            throws Throwable {
				System.out.println("before");
				Object result = method.invoke(target, args);
				System.out.println("after");
				return result;
			}
		}});

        //创建代理对象=>类型是UserService，但却是代理对象
		UserService userService = (UserService) enhancer.create();
		userService.test();
	}
}

这个阶段会产生三个对象：

1.目标对象-targetUserService

2.负责创建代理对象的工厂对象enhancer

3.代理对象-proxyUserService

最终执行效果：

before

userService execute test....

after

使用示例-多个方法，走不同的代理逻辑

新建一个UserService类，设置两个方法

public void test() {
		System.out.println("userService execute test....");
	}

	public void a() {
		System.out.println("userService execute a....");
	}

在enhancer对象中设置两个代理逻辑，test方法走代理逻辑1，a方法走代理逻辑2

public static void main(String[] args) {
		UserService targetUserService = new UserService();

		Enhancer enhancer = new Enhancer();
		enhancer.setSuperclass(UserService.class);

		//代理逻辑:1
		MethodInterceptor firstCallback = new MethodInterceptor() {
			@Override
			public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
				System.out.println("before");
				Object result = method.invoke(targetUserService, args);
				System.out.println("after");
				return result;
			}
		};
		//代理逻辑:2
		NoOp secondCallback = NoOp.INSTANCE;

		enhancer.setCallbacks(new Callback[]{firstCallback, secondCallback});

		enhancer.setCallbackFilter(new CallbackFilter() {
			@Override
			public int accept(Method method) {
				//方法test执行=》firstCallback代理逻辑:1
				if (method.getName().equals("test")) {
					return 0;
				}
				//其他执行=》secondCallback代理逻辑:2
				return 1;
			}
		});

		UserService proxyUserService = (UserService) enhancer.create();
		System.out.println("执行proxyUserService.test:");
		proxyUserService.test();
		System.out.println("--------------------------------------------------------");
		System.out.println("执行proxyUserService.a:");
		proxyUserService.a();
	}

最终执行效果：

执行proxyUserService.test:

before

userService execute test....

after

--------------------------------------------------------

执行proxyUserService.a:

userService execute a....

JDK动态代理

JDK动态代理是利用反射机制生成一个实现代理接口的匿名类，在调用具体方法前调用InvokeHandler来处理。

使用示例-支持创建代理对象，执行代理逻辑

//接口
public interface UserInterface {
	void test();
	void a();
}
//实现类
public class UserService implements UserInterface {
	@Override
	public void test() {
		System.out.println("userService execute test....");
	}
	@Override
	public void a() {
		System.out.println("userService execute a....");
	}
}

使用Proxy.newProxyInstance创建一个代理接口，InvocationHandler制定代理逻辑

public class CylTest {
	public static void main(String[] args) {
		UserService targetUserService = new UserService();

		UserInterface proxyUserInterface = (UserInterface) Proxy.newProxyInstance(
				UserInterface.class.getClassLoader(),
				new Class[]{UserInterface.class},
				new InvocationHandler() {
					@Override
					public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
						System.out.println("before");
						Object result = method.invoke(targetUserService, args);
						System.out.println("after");
						return result;
					}
				});

		proxyUserInterface.test();
	}
}

最终执行效果：

before

userService execute test....

after

ProxyFactory

如何自动在CGLIB和JDK动态代理转换

ProxyFactory是Spring封装的代理工厂，对目标对象使用CGLIB或者JDK动态代理有处理逻辑。

代理方式
CGLIBisProxyTargetClass属性=true
只实现了SpringProxy接口
被代理对象没有实现接口
JDK动态代理被代理类只实现了接口，且实现了非SpringProxy接口

org.springframework.aop.framework.DefaultAopProxyFactory#createAopProxy

@Override
	public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
		// 如果ProxyFactory的isOptimize为true，Spring认为cglib比jdk动态代理要快
		// 或者isProxyTargetClass为true，
		// 或者被代理对象没有实现接口，
		// 或者只实现了SpringProxy这个接口
		// 那么则利用Cglib进行动态代理，但如果被代理类是接口，或者被代理类已经是进行过JDK动态代理而生成的代理类了则只能进行JDK动态代理

		// 其他情况都会进行JDK动态代理，比如被代理类实现了除SpringProxy接口之外的其他接口

		// 是不是在GraalVM虚拟机上运行
		if (!NativeDetector.inNativeImage() &&
				(config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config))) {

			Class<?> targetClass = config.getTargetClass();
			if (targetClass == null) {
				throw new AopConfigException("TargetSource cannot determine target class: " +
						"Either an interface or a target is required for proxy creation.");
			}
			if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
				return new JdkDynamicAopProxy(config);
			}
			return new ObjenesisCglibAopProxy(config);
		}
		else {
			return new JdkDynamicAopProxy(config);
		}
	}

使用示例-使用CGLIB代理方式

设置目标类 

public class UserService {

	public void test() {
		System.out.println("test...");
	}

}
public static void main(String[] args) {
    UserService userService = new UserService();
    ProxyFactory proxyFactory = new ProxyFactory();
    //
    proxyFactory.setTarget(userService);
    
    
    //代理逻辑1
    MethodBeforeAdvice methodBeforeAdvice = new MethodBeforeAdvice() {
        @Override
        public void before(Method method, Object[] args, Object target) throws Throwable {
            System.out.println("begin");
        }
    };
    
     //代理逻辑2
    AfterReturningAdvice afterReturningAdvice = new AfterReturningAdvice() {
    
        @Override
        public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
            System.out.println("end");
        }
    };
    
    //添加多个代理逻辑
    proxyFactory.addAdvice(0, methodBeforeAdvice);
    proxyFactory.addAdvice(1, afterReturningAdvice);
    
    UserService proxyUserService = (UserService) proxyFactory.getProxy();
    proxyUserService.test();
	}

使用示例-使用JDK动态代理方式

设置目标接口

//UserInterface
public interface UserInterface {
	void test();
}

//UserService
public class UserService implements UserInterface {

	@Override
	public void test() {
		System.out.println("test...");
	}
}
public static void main(String[] args) {
    UserService userService = new UserService();
    ProxyFactory proxyFactory = new ProxyFactory();
    proxyFactory.setTarget(userService);
    proxyFactory.setInterfaces(UserInterface.class);
    
    
    //代理逻辑1
    MethodBeforeAdvice methodBeforeAdvice = new MethodBeforeAdvice() {
        @Override
        public void before(Method method, Object[] args, Object target) throws Throwable {
            System.out.println("begin");
        }
    };
    
     //代理逻辑2
    AfterReturningAdvice afterReturningAdvice = new AfterReturningAdvice() {
    
        @Override
        public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
            System.out.println("end");
        }
    };
    
    //添加多个代理逻辑
    proxyFactory.addAdvice(0, methodBeforeAdvice);
    proxyFactory.addAdvice(1, afterReturningAdvice);
    
    UserInterface proxyUserService = (UserInterface) proxyFactory.getProxy();
    proxyUserService.test();
}

菜腿1994
关注
  • 20
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Spring系列七：JDK 动态代理和 CGLIB 代理，从三流java外包到秒杀阿里P7
jixuczy的博客
04-02 404
什么是ActiveMQ?ActiveMQ服务器宕机怎么办？丢消息怎么办？持久化消息非常慢怎么办？消息的不均匀消费怎么办？死信队列怎么办？ActiveMQ中的消息重发时间间隔和重发次数吗？
Spring AOP的设计与实现——JDK动态代理、CGLIB动态代理
mashaokang1314的博客
01-13 727
概念了解： Spring AOP面向切面编程、动态代理的理解 深入理解SpringAOP中的动态代理 JVM的动态代理特性 在Spring AOP实现中，使用的核心技术是动态代理，这种动态代理实际上是JDK的一个特性。通过JDK的动态代理特性，可以为任意Java对象创建代理对象，通过Java Reflection API来完成。 在代理模式的的设计中，会设计一个接口和目标对象一直的对象Proxy，它们都实现了同一个接口的方法。对目标对象方法的调用，往往就被代理对象给拦截了，通过这种拦截，为目标对象方法操
【Spring】Spring AOP底层原理：JDK动态代理和CGLIB动态代理
最新发布
m0_65277261的博客
05-27 1292
Spring AOP 的实现原理是基于动态代理和字节码操作的。而动态代理是基于反射机制的。 在编译时， Spring 会使用 AspectJ 编译器将切面代码编译成字节码文件。在运行时， Spring 会使用 Java 动态代理或 CGLIB 代理生成代理类，这些代理类会在目标对象方法执行前后插入切面代码，从而实现AOP的功能。
【spring】jdk动态代理和cglib动态代理的区别
王佑辉的博客
03-19 3566
6.性能上：在老版的jdk，jdk代理生成的类速度快，通过反射调用慢，cglib是jdk代理速度的10倍左右，jdk在版本每次升级都会有很大的性能提升，cglib停滞不前，jdk7 8的动态代理性能在1万次实验中比cglib要快20%左右。5.jdk动态代理如果目标类未实现接口则无法代理，cglib是通过继承的方式来动态代理，若目标类被final关键字修饰，则无法使用cglib做动态代理。1.jdk动态代理只提供实现接口的目标类代理，不支持没有实现接口的目标类的代理。3.从限制角度讨论区别。
CGLIB动态代理的使用
qq_61267719的博客
06-14 469
CGLIB动态代理是通过继承被代理类来实现代理的，所以被代理类不用实现接口。使用动态代理能够把代理的方法都集成在一个方法invoke中，即使新增方法，也不用修改代理类，扩展性好。在很多地方都用到了代理，比如spring的aop就是通过代理实现的。鉴权也是通过代理。关于CJLib的具体解释可查看这篇文章CGLIB动态代理之intercept函数刨析_cglib intercept_一个默默努力的人的博客-CSDN博客。
CGLIB动态代理--实例/原理
IT利刃出鞘的博客
02-13 2214
本文用示例介绍CGLIB动态代理的用法。
jdk与cglib动态代理与底层实现
12-21
JDK和CGLIB是Java中实现动态代理的两种主要方式，它们在Spring框架中扮演着关键角色，尤其是在AOP（面向切面编程）中。 1. **JDK动态代理**： JDK动态代理基于Java的接口机制实现，因此，要使用JDK动态代理，被...
Jdk动态代理 底层
01-20
前言 java动态代理主要有2种，Jdk动态代理、Cglib动态...需要注意的是，Jdk动态代理相比起cglib动态代理，Jdk动态代理的对象必须实现接口，否则将报错。我们也将带着这个问题在源码分析中寻找答案 当@Cacheable注解在方
AOP之JDK动态代理和CGLib动态代理
05-19
Spring框架是AOP实现的一个典范，它提供了两种主要的动态代理方式：JDK动态代理和CGLib动态代理。 **JDK动态代理**： JDK动态代理基于Java的反射API实现，适用于接口代理。当目标对象实现了至少一个接口时，Spring...
输出JDK和CGLib动态代理产生的class文件.zip
06-17
- target/classes：编译后的class文件，包括目标接口和实现类的class文件，以及由Proxy生成的代理类class文件 - 测试代码：展示如何使用Proxy创建代理对象并调用方法 2. CGLib代理项目： - src/main/java：包含...
SpringAOP的实现机制（底层原理）、应用场景等详解，模拟过程的实例
09-09
本资源将深入探讨Spring框架中使用的两种关键的动态代理方式：JDK动态代理和CGLib动态代理。这两种代理方式在Spring AOP中起到关键作用，用于实现横切关注点的切面编程。通过学习它们的原理和实际应用，您将能够更好...
jdk动态代理模式的分析与底层实现
03-18
基于java的jdk动态代理, 比较了静态代理与动态代理的区别，以及动态代理的底层实现，反编译class文件 jdk动态代理和cglib的区别
Spring框架中JDK动态代理和cglib动态代理
11-06
Spring框架的AOP中重要的一个知识点，动态代理，springAOP框架会根绝实际情况选择使用jdk的动态代理还是cglib的动态代理
Spring-AOP简介与底层实现机制——动态代理
2401_84152797的博客
05-04 560
三个工作日收到了offer，头条面试体验还是很棒的，这次的头条面试好像每面技术都问了我算法，然后就是中间件、MySQL、Redis、Kafka、网络等等。第一个是算法关于算法，我觉得最好的是刷题，作死的刷的，多做多练习，加上自己的理解，还是比较容易拿下的。而且，我貌似是将《算法刷题LeetCode中文版》、《算法的乐趣》大概都过了一遍，尤其是这本。
cglib动态代理
热门推荐
NCS123456的博客
06-13 1万+
CGLIB（Code Generation Library），是一个强大的，高性能，高质量的 Code 生成类库，它可以在运行期扩展 Java 类与实现 Java 接口。
Spring AOP实现原理详解之Cglib代理实现
JavaMonsterr的博客
07-06 1086
我们在前文中已经介绍了SpringAOP的切面实现和创建动态代理的过程，那么动态代理是如何工作的呢？本文主要介绍Cglib动态代理的案例和SpringAOP实现的原理。要了解动态代理是如何工作的，首先需要了解什么是代理？代理模式(Proxy pattern): 为另一个对象提供一个替身或占位符以控制对这个对象的访问举个简单的例子：我(client)如果要买(doOperation)房，可以找中介(proxy)买房，中介直接和卖方(target)买房。中介和卖方都实现买卖(doOperation)的操作。中介
Spring事务与JDK/CGLIB动态代理
liyifan687的博客
05-29 3600
近日面试问及AOP和动态代理，再之后的事务方面有所生疏，感谢面试官特意给我介绍了下，一个之前的知识盲区。 首先Spring事务在开发过程中是通过@Transactional注解来控制。 1. Transactional注解的原理 对于使用了Transactional注解的方法的类，Spring AOP代理会在运行时生成这个类的代理对象。 当这个对象运行这个注解方法时，会读取@Transa...
SpringAOP的两种动态代理：JDK动态代理和cglib动态代理
chuyuyin的博客
07-01 2231
AOP（Aspect-Oriented Programming，面向切面的编程），它是可以通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加功能的一种技术。它是一种新的方法论，它是对传统OOP编程的一种补充。　　OOP是关注将需求功能划分为不同的并且相对独立，封装良好的类，并让它们有着属于自己的行为，依靠继承和多态等来定义彼此的关系；AOP是希望能够将通用需求功能从不相关的...
spring之cglib代理的妙用
buzhidaolvtu的博客
11-27 1513
例子: @Bean public Service1 service1(){ return new Service1Impl(); } @Bean public Service2 service2(){ Service1 service1 = service1(); return new Service2Im
springaop的底层实现原理
06-07
Spring AOP 的底层实现原理是基于动态代理和字节码生成技术。在 Spring AOP 中，当一个 Bean 被 Spring 容器创建时，Spring 会检查这个 Bean 是否有 AOP 相关的注解或配置，如果有，Spring 会为这个 Bean 创建一个代理对象。当调用这个 Bean 的方法时，实际上是调用代理对象的方法，代理对象会在方法执行前后执行一些额外的逻辑，例如记录日志、检查权限等。 Spring AOP 通过 JDK 动态代理和 CGLIB 字节码生成两种方式来创建代理对象。当目标对象实现了接口时，Spring 会使用 JDK 动态代理；当目标对象没有实现接口时，Spring 会使用 CGLIB 字节码生成来创建代理对象。具体来说，JDK 动态代理是通过反射机制在运行时创建代理类，而 CGLIB 字节码生成则是在编译时生成代理类的子类。 在 Spring AOP 的实现中，切面（Aspect）是一组横切关注点的集合。在 AOP 中，切面可以通过注解或 XML 配置来定义。Spring AOP 支持五种通知（Advice）类型：前置通知（Before）、后置通知（After）、返回通知（AfterReturning）、异常通知（AfterThrowing）和环绕通知（Around）。这些通知可以在切面中定义，并与切点（Pointcut）一起组成一个完整的切面。切点用于指定哪些方法需要被代理，可以通过注解或表达式来定义。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值