JDK动态代理和CGLIB动态代理

最新推荐文章于 2025-04-19 20:28:14 发布
原创 最新推荐文章于 2025-04-19 20:28:14 发布 · 178 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文深入探讨Java动态代理机制，包括JDK动态代理和CGLIB代理的实现方式，对比两种代理的优缺点，及其实现过程中的关键步骤。通过具体代码示例，详细解析动态代理在实际开发中的应用。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

JDK动态代理：

概述：
代理是一种常用的设计模式，其目的就是为其他对象提供一个代理以控制对某个对象的访问。代理类负责为委托类预处理消息，过滤消息并转发消息，以及进行消息被委托类执行后的后续处理。详细介绍请参考：java设计模式之代理模式。为了保持行为的一致性，代理类和委托类通常会实现相同的接口，所以在访问者看来两者没有丝毫的区别。通过代理类这中间一层，能有效控制对委托类对象的直接访问，也可以很好地隐藏和保护委托类对象，同时也为实施不同控制策略预留了空间，从而在设计上获得了更大的灵活性。Java 动态代理机制以巧妙的方式近乎完美地实践了代理模式的设计理念。

  • 在java的动态代理机制中一个是 InvocationHandler(Interface)、另一个则是 Proxy(Class).

文章参考引用自：https://blog.youkuaiyun.com/xiaokang123456kao/article/details/77679848

    1. 声明接口
package com.feifan.jdk;

import java.util.List;

/**
 * 需要动态代理的接口
 * @author Donald
 * 2018-11-27 22:23:34
 */
public interface ProxyInterface {
	public String sayHello();
	public List<String> listShow();
	public void sayNothing(String ... strings);
	public String arrayReturn(Object[] args);
}
    1. 声明实现类
package com.feifan.jdk;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * 具体的实现类
 * @author Donald
 * 2018-11-27 22:27:03
 */
public class ProxyInterfaceImpl implements ProxyInterface {

	@Override
	public String sayHello() {
		return "sayHello ====NoParmater";
	}

	@Override
	public List<String> listShow() {
		List<String> list= new ArrayList<>();
		list.add("wang");
		list.add("ming");
		list.add("huhu");
		return list;
	}

	@Override
	public String arrayReturn(Object[] args) {
		String string=Arrays.toString(args);
		return string;
	}

	@Override
	public void sayNothing(String... strings) {
		System.out.println(Arrays.toString(strings));
	}
	
}
    1. 声明InvokeHandler 实现类
package com.feifan.jdk;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;


/**
 *每次生成动态代理类对象都需要指定一个实现InvocationHandler接口的调用处理器对象
 * @author Donald
 * 2018-11-27 22:37:43
 */
public class InvokHandler implements InvocationHandler{

	//这个就是我们需要代理的真实对象。
	private Object subject;
	
	
	public InvokHandler(Object subject) {
		this.subject = subject;
	}


	/**
	 * 一个动态代理类都必须要实现InvocationHandler这个接口，
	 * 并且每个代理类的实例都关联了一个handler，当我们通过代理对象调用一个方法的时候，
	 * 这个方法的调用就会被转发为由InvocationHandler这个接口的 invoke 方法来进行调用。
	 * 我们来看看InvocationHandler这个接口的唯一一个方法 invoke 方法：
	 * @param proxy 指代JDK动态生成的最终代理对象
	 * @param method 指代的是我们所要调用真实对象的某个方法的Method对象
	 * @param args 指代的是调用真实对象某个方法时接受的参数
	 * @return method对应的方法 的返回值
	 */
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		Object result=null;
		try {
			System.out.println("前置通知:当前调用的方法是："+method.getName());
			//当代理对象调用真实对象的方法时，其会自动的跳转到代理对象
			//关联的handler对象 的invoke方法进行调用。
			result=method.invoke(subject, args);//指定被代理的对象和参数
			System.out.println("后置通知:程序正常执行之后result...."+result);
		} catch (Exception e) {
			System.out.println("方法执行异常通知Exception："+e.getMessage());
		}
		System.out.println("方法执行了通知");
		return result;
	}

}
  • 测试
  • //loader:一个ClassLoader对象，定义了由哪个ClassLoader对象来生成代理对象进行加载
    //interfaces:一个Interface对象的数组，表示的是我将要给我需要代理的对象提供一组什么接口，如果我提供了一组接口给它，那么这个代理对象就宣称实现了该接口(多态)，这样我就能调用这组接口中的方法了
    //h:一个InvocationHandler对象，表示的是当我这个动态代理对象在调用方法的时候，会关联到哪一个InvocationHandler对象上，间接通过invoke来执行
package com.feifan.jdk;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.List;

import org.junit.jupiter.api.Test;

public class TestJDKProxy {
	
	@Test
	public void JDKTest() {
		//1.被代理对象
		ProxyInterface proxyInterface= new ProxyInterfaceImpl();
		//2.InvocationHandler 的实现类
		InvokHandler invokHandler=new InvokHandler(proxyInterface);
		
		//3.调用Proxy的静态方法
		/**
		 * public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
		 * ClassLoader loader,类加载器
		 * Class<?>[] interfaces,目标对象实现的接口
         * InvocationHandler h:InvocationHandler 的实现类
        
		 */
		ProxyInterface newProxy = (ProxyInterface)Proxy.newProxyInstance(proxyInterface.getClass().getClassLoader()
								, proxyInterface.getClass().getInterfaces()
								, invokHandler);
		//此处会调用newProxy的toString 方法
		System.out.println("newProxy动态代理对象内存地址："+newProxy+"\t>>newProxyname:"+newProxy.getClass().getSimpleName());
		
	
		List<String> listShow = newProxy.listShow();
		System.out.println("listShow"+listShow);
		System.out.println("-------------------");
		
		newProxy.sayNothing("sss","sds","ssK");
		System.out.println("-------------------");
		
		Object [] kObjects={"ddd","dd","ff"};
		String arrayReturn = newProxy.arrayReturn(kObjects);
		System.out.println(arrayReturn);
		
	}

}
  • 结果：
    在这里插入图片描述
    JDK内置的Proxy动态代理可以在运行时动态生成字节码，而没必要针对每个类编写代理类。中间主要使用到了一个接口InvocationHandler与Proxy.newProxyInstance静态方法，参数说明如下：

使用内置的Proxy实现动态代理有一个问题：被代理的类必须实现接口，未实现接口则没办法完成动态代理。

CGLIB 代理实现：

CGLIB是针对类来实现代理的，原理是对指定的业务类生成一个子类，并覆盖其中业务方法实现代理。因为采用的是继承，所以不能对final修饰的类进行代理.
CGLIB(Code Generation Library)是一个开源项目,是一个强大的，高性能，高质量的Code生成类库，它可以在运行期扩展Java类与实现Java接口，通俗说cglib可以在运行时动态生成字节码。

  • 实体类
package com.feifan.cglib;

public class CglibEntity {
		public void cg() {
			System.out.println("CGLIB 代理类 无参");
		}
		
		public void cg1(String name)
		{
			System.out.println("CGLIB 代理测试：name"+name);
		}
		
		public void cg2() {
			int k=1/0;
		}
}
  • 动态代理类
package com.feifan.cglib;

import static org.hamcrest.CoreMatchers.nullValue;

import java.lang.reflect.Method;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

/**
 * 动态代理类、实现一个方法拦截器接口
 * @author Donald
 * 2018-11-28 20:57:11
 */
public class CglibDynamic implements MethodInterceptor{

	//被代理的对象
	Object targetObject;
	
	//动态生成一个新的类，使用父类的无参构造方法创建一个指定了特定回调的代理实例。
	public Object getCglibObject(Object object)
	{
		targetObject=object;
		//增强器，动态代码生成器
		Enhancer enhancer= new Enhancer();
		//回调方法
		enhancer.setCallback(this);
		//设置生成类的父类类型
		enhancer.setSuperclass(targetObject.getClass());
		//动态生成字节码并返回代理对象
		Object object2 = enhancer.create();
		//System.out.println(object2+">>>>");
		return object2;
	}
	
	//拦截方法
	/**
	 * Object为由CGLib动态生成的代理类实例，
	 * Method为上文中实体类所调用的被代理的方法引用，
	 * Object[]为参数值列表，
	 * MethodProxy为生成的代理类对方法的代理引用。
	 * 返回：从代理实例的方法调用返回的值。
	 */
	@Override
	public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
		Object result =null;
		// 被织入的横切内容，开始时间Before
		System.out.println("cglib方法执行之前");
		//调用方法
		try {
			result = proxy.invoke(targetObject, args);
			System.out.println("CGLIB目标方法正常执行了"+proxy.getSignature().getName());
		} catch (Exception e) {
			e.printStackTrace();
			System.out.println("cglib方法执行异常");
		}
		System.out.println("cglib目标方法执行了");
		return result;
	}

}
  • 测试方法
package com.feifan.cglib;

import org.junit.Test;

public class CglibTest {
	
	@Test
	public void cglibTest() {
		CglibEntity cglibEntity= new CglibEntity();
		CglibDynamic cglibDynamic=new CglibDynamic();
		System.out.println("------");
		CglibEntity cglibTarget = (CglibEntity)cglibDynamic.getCglibObject(cglibEntity);
		System.out.println(cglibTarget+"------");
		cglibTarget.cg1("HIJI");
		cglibTarget.cg2();
	}

}
  • 测试结果
    在这里插入图片描述
    代码参考：

链接：https://pan.baidu.com/s/10wC0L53eVsc6EeIs2JiQDA
提取码：lwnd

JDK动态代理和CGLIB动态代理有什么区别？
水w的博客
09-15 7124
JDK动态代理和CGLIB动态代理有什么区别？
手写实现JDK动态代理
YvesHe的专栏
10-23 333
前言 在Java领域，动态代理应用非常广泛，特别是流行的Spring/MyBatis等框架。JDK本身是有实现动态代理技术的，不过要求被代理的类必须实现接口，不过cglib对这一不足进行了有效补充。本篇博客将涉及2个话题：第一，JDK动态代理的实现原理，带你探索动态代理的实质面目；第二，自己动手写代码去实现JDK动态代理，去创造世界！ JDK动态代理 先写一个例子，感性认识下动态代理~ 业务接口： interface 业务实现类： interface impl 业务处理类：.
Java Proxy 和 CGLIB 动态代理原理
程序员小乐
04-18 361
点击上方 "程序员小乐"关注,星标或置顶一起成长每天凌晨00点00分,第一时间与你相约每日英文Leave all your unhappiness to yester...
JDK动态代理和Cglib动态代理
xingze的博客
10-30 191
JDK动态代理 JDK动态代理的条件是被代理对象必须实现接口。 需要创建代理类需要实现InvocationHandler接口。 public interface Animal { void eat(); } CGLIB动态代理 CGLIB动态代理可以不实现接口，直接对Java类进行代理。 CGLIB动态代理需要实现MethodInterceptor接口，重写intercept(...
动态代理两种实现方式：jdk动态代理和cglib动态代理
相由心生的博客
10-31 374
废话不多说，直接上代码! 1、首先是接口及其实现方法： package proxy.test; public interface UserService { public String getName(int id); public Integer getAge(int id); } package proxy.test; public class UserServiceImpl...
Java动态代理：基于JDK的动态代理和基于CGLIB的动态代理
weixin_42155491的博客
06-28 221
前言 学习Spring aop的时候，一直都知道是基于动态代理实现的，那么到底什么是动态代理，又该如何自己实现一个动态代理呢，对此做一个记录。 所谓动态代理，一般是为了给需要实现的方法添加预处理或者添加后续操作，但是不干预实现类的正常业务，把一些基本业务和主要的业务逻辑分离。 基于JDK的动态代理 两个核心的类Proxy、InvocationHandler（接口）；基于JDK的动态代理是需要被代理的类实现某个接口。下面贴一下代码应用： 首先要有一个接口和实现类，实现类就是需要被代理的类；业务很简单，就是打印
jdk动态代理和cglib动态代理对比
zfj321的博客
12-28 1266
JDK 动态代理：只代理接口（interface），无法代理类。它使用java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口来实现动态代理。 CGLIB 动态代理：可以代理类和接口。它通过生成目标类的子类来创建代理对象，因此可以代理没有实现接口的类。
JDK动态代理和CGLIB动态代理的区别
最新发布
m0_75236543的博客
04-19 837
在 Spring AOP 中，和是两种核心的代理实现方式，它们的区别可以从多个维度进行对比。finalfinal：Spring 5.x 后 CGLIB 性能优化明显，差距缩小。final// 必须实现 UserService 接口System.out.println("[JDK代理]前置处理");System.out.println("[JDK代理]后置处理");});// 直接代理普通类System.out.println("[CGLIB代理]前置处理");// 调用父类方法。
JDK动态代理和Cglib动态代理实例源码
01-04
- **灵活性**：JDK代理要求目标类实现接口，而Cglib无此限制。 - **使用场景**：如果目标类已经实现了接口，且不关心性能，优先选择JDK代理；否则，Cglib是更好的选择。 在`DynamicProxyTest`源码中，我们可以看到...
JAVA动态代理实现Demo（JDK动态代理和CGLIB动态代理）
12-19
Java提供了两种主要的动态代理实现方式：JDK动态代理和CGLIB动态代理。 **JDK动态代理**： JDK动态代理基于接口实现，也就是说，被代理的对象必须实现至少一个接口。代理机制的核心是`java.lang.reflect.Proxy`类和...
Ajax短轮询，长轮询，SSE(Server Sent Event)轮询 和 websocket轮询
qq_16183731的博客
03-09 1224
AJAX轮询方式 客服端以用户定义的时间间隔去服务器上查询最新的数据。太短的时间间隔客服端会对服务器在短时间内发送出多个请求。 长轮询或者COMET。服务器与客服端需要保持一条长时间的请求，它使得服务器在有数据时可以返回消息给客户端。 HTTP协议 http 协议是请求/响应范式的，每个 http 响应都对应一个 http 请求，http 协议是无状态的，多个 http 请求之间相互隔...
DockerMaven 插件 ＜version＞1.4.10＜/version＞
qq_16183731的博客
11-15 914
通过maven 插件自动部署 Maven 插件 自动部署步骤 1.1 修改宿主机的Docker 配置，让其可以远程访问 vi /lib/systemd/system/docker.service # 2. 其中 ExecStart= 后添加配置 -H tcp://0.0.0.0:2375 -H unix:///var/run/docker.sock 1.2 刷新配置重启服务 systemctl daemon-reload systemctl restart docker docker start
IDEA Java性能分析插件VisualVM Launcher 配置
qq_16183731的博客
12-04 839
IDEA 加载插件 VisualVM Launcher 2. 从本地jdk中选择visualvm.exe，进行配置。 3. 启动实时观测 4. 实时监控
手写可重入锁（Lock）
qq_16183731的博客
03-14 519
可重入锁 用 lock 来保证原子性。 什么是原子性，就是不可分，从头执行到尾，不能被其他线程同时执行。 可通过CAS来实现原子操作 CAS(Compare and Swap): CAS操作需要输入两个数值，一个旧值（期望操作前的值）和一个新值，在操作期间先比较下旧值有没有发生变化，如果没有发生变化，才交换成新值，发生了变化则不交换。 CAS主要通过compareAndSwapXXX()方法来实...
数组的反射
qq_16183731的博客
12-19 425
数组的反射 具有相同维数和元素类型的数组属于同一个类型，即相同的Class对象 代表数组的Class实例对象的getSuperClass()方法返回的父类为object类对应的Class 基本类型的一维数组可以被当作object类型使用，不能当作Object[]类型使用，非基本类型的一维数组，既可以当Object类型使用，又可以当Object[]类型使用。 //JDK1.6 Arrays pu...
HttpClient工具类编写
qq_16183731的博客
03-06 395
什么是HttpClient HTTP 协议可能是现在 Internet 上使用得最多、最重要的协议了，越来越多的 Java 应用程序需要直接通过 HTTP 协议来访问网络资源。虽然在 JDK 的 java net包中已经提供了访问 HTTP 协议的基本功能，但是对于大部分应用程序来说，JDK 库本身提供的功能还不够丰富和灵活。HttpClient 是Apache HttpComponents 下的...
ThreadLocal 基本使用
qq_16183731的博客
03-13 368
ThreadLocal 很多地方叫做线程本地变量，也有些地方叫做线程本地存储，ThreadLocal为变量在每个线程中都创建了一个副本，那么每个线程可以访问自己内部的副本变量。 它本身是为线程安全和某些特定场景的问题而设计的。 先了解一下ThreadLocal类提供的几个方法： public T get() { } public void set(T value) { } publi...
JDK8 lambda 表达式的使用
qq_16183731的博客
03-05 293
JDK8的重要新特性之一——Lambda表达式 JDK 8 之前，java不支持函数式编程的。函数编程，即可理解是将一个函数（也称为“行为”）作为一个参数进行传递。通常我们提及得更多的是面向对象编程，面向对象编程是对数据的抽象（各种各样的POJO类），而函数式编程则是对行为的抽象（将行为作为一个参数进行传递）。在JavaScript中这是很常见的一个语法特性，但在Java中将一个函数作为参数传递...
ActiveMQ 安装及使用套装
qq_16183731的博客
11-17 260
下载ActiveMQ 安装包 下载地址：http://activemq.apache.org/components/classic/download/ 2. 解压 tar -zxvf apache-activemq-5.15.10-bin.tar.gz 启动/stop(./activemq stop) cd apache-activemq-5.15.10/bin ./activemq ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值