动态代理的两种方式以及优缺点

本文介绍了动态代理技术,它能在运行期创建指定接口或类的子类及实例,可无侵入增强代码。重点讲解了JDK和CGLIB两种动态代理方式的实现,包括重要成员、原理图和代码示例,并对比了二者优缺点,JDK只能基于接口代理,CGLIB无法处理final方法。

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

前言

动态代理应用非常的广泛,在各种开源的框架中都能看到他们的身影,比如spring中的aop使用动态代理增强,mybatis中使用动态代理生成mapper,动态代理主要有JDK和CGLIB两种方式,今天来学习下这两种方式的实现,以及它们的优缺点

动态代理:是使用反射和字节码的技术,在运行期创建指定接口或类的子类,以及其实例对象的技术,通过这个技术可以无侵入的为代码进行增强

一、JDK实现的动态代理

1、解析

jdk实现的动态代理由两个重要的成员组成,分别是Proxy、InvocationHandler

Proxy:是所有动态代理的父类,它提供了一个静态方法来创建动态代理的class对象和实例

InvocationHandler:每个动态代理实例都有一个关联的InvocationHandler,在代理实例上调用方法是,方法调用将被转发到InvocationHandler的invoke方法

2、简单看下jdk的动态代理的原理图

 3、代码实现

现在模拟一个用户注册的功能,动态代理对用户的注册功能进行增强,会判断用户名和密码的长度,如果用户名<=1和密码<6则会抛出异常

User.java

package com.taolong;

public class User {

	private String name;
	
	private Integer age;
	
	private String password;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}


	public Integer getAge() {
		return age;
	}

	public void setAge(Integer age) {
		this.age = age;
	}

	public String getPassword() {
		return password;
	}

	public void setPassword(String password) {
		this.password = password;
	}

	@Override
	public String toString() {
		return "User [name=" + name + ", age=" + age + ", password=" + password + "]";
	}
	
	
}

 UserService.java

package com.taolong.jdk;

import com.taolong.User;

public interface UserService {
	
	void addUser(User user);
}

 UserServiceImpl.java

package com.taolong.jdk;

import com.taolong.User;

public class UserServiceImpl implements UserService {

	@Override
	public void addUser(User user) {
		System.out.println("jdk...正在注册用户,用户信息为:"+user);
	}

}

 UserServiceInterceptor.java

package com.taolong.jdk;

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

import com.taolong.User;

public class UserServiceInterceptor implements InvocationHandler {

	private Object realObj;
	
	public UserServiceInterceptor(Object realObject) {
		super();
		this.realObj = realObject;
	}
	
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		if (args!=null && args.length > 0 && args[0] instanceof User) {
			User user = (User)args[0];
			//进行增强判断
			if (user.getName().length() <= 1) {
				throw new RuntimeException("用户名长度必须大于1");
			}
			if (user.getPassword().length() <= 6) {
				throw new RuntimeException("密码长度必须大于6");
			}
		}
		Object result = method.invoke(realObj, args);
		System.out.println("用户注册成功...");
		return result;
	}

	public Object getRealObj() {
		return realObj;
	}

	public void setRealObj(Object realObj) {
		this.realObj = realObj;
	}
	
}

 ClientTest.java

package com.taolong.jdk;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;

import com.taolong.User;

public class ClientTest {

	public static void main(String[] args) {
		User user = new User();
		user.setName("hongtaolong");
		user.setPassword("hong");
		user.setAge(23);
		//被代理类
		UserService delegate = new UserServiceImpl();
		InvocationHandler userServiceInterceptor = new UserServiceInterceptor(delegate);
		//动态代理类
		UserService userServiceProxy = (UserService)Proxy.newProxyInstance(delegate.getClass().getClassLoader(),
				delegate.getClass().getInterfaces(), userServiceInterceptor);
		System.out.println("动态代理类:"+userServiceProxy.getClass());
		userServiceProxy.addUser(user);
	}
}

 运行结果:当密码的长度小于6时

这里就起到了动态增强的作用,mybatis的使用中我们知道不需要创建dao中的mapper接口的子类,也能调用到相应的方法,其实就是生成的实现了mapper接口的动态的代理类,我们可以去看看它的这个方法

 

 接下来我们看下cglib的使用

二、CGLIB动态代理

1、解析

CGLIB(Code Generation Library)是一个基于ASM的字节码生成库,它允许我们在运行时对字节码进行修改和动态生成。CGLIB通过继承的方式实现代理(最后这部分我们深思一下,它可能有哪些局限,final方法是不能够被重写,所以它不能增强被final修饰的方法,这个等下我们来验证)

CGLIB的实现也有两个重要的成员组成,Enhancer、MethodInterceptor,其实这两个的使用和jdk实现的动态代理的Proxy、InvocationHandler非常相似

Enhancer:来指定要代理的目标对象,实际处理代理逻辑的对象,最终通过调用create()方法得到代理对象、对这个对象所有的非final方法的调用都会转发给MethodInterceptor

MethodInterceptor:动态代理对象的方法调用都会转发到intercept方法进行增强

2、图解

3、代码的实现

还是上面的场景,注册用户进行拦截增强,部分代码如下

UserServiceCglibInterceptor.java

package com.taolong.cglib;

import java.lang.reflect.Method;

import com.taolong.User;

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

public class UserServiceCglibInterceptor implements MethodInterceptor {

	private Object realObject;
	
	public UserServiceCglibInterceptor(Object realObject) {
		super();
		this.realObject = realObject;
	}
	
	@Override
	public Object intercept(Object object, Method method, Object[] args, MethodProxy proxy) throws Throwable {
		if (args!=null && args.length > 0 && args[0] instanceof User) {
			User user = (User)args[0];
			//进行增强判断
			if (user.getName().length() <= 1) {
				throw new RuntimeException("用户名长度必须大于1");
			}
			if (user.getPassword().length() <= 6) {
				throw new RuntimeException("密码长度必须大于6");
			}
		}
		Object result = method.invoke(realObject, args);
		System.out.println("用户注册成功...");
		return result;
	}

}

 ClientTest.java

package com.taolong.cglib;

import com.taolong.User;

import net.sf.cglib.proxy.Enhancer;

public class ClientTest {

	public static void main(String[] args) {
		User user = new User();
		user.setName("hongtaolong");
		user.setPassword("hong");
		user.setAge(23);
		//被代理的对象
		UserServiceImplCglib delegate = new UserServiceImplCglib();
		UserServiceCglibInterceptor serviceInterceptor = new UserServiceCglibInterceptor(delegate);
		Enhancer enhancer = new Enhancer();
		enhancer.setSuperclass(delegate.getClass());
		enhancer.setCallback(serviceInterceptor);
		//动态代理类
		UserServiceImplCglib cglibProxy = (UserServiceImplCglib)enhancer.create();
		System.out.println("动态代理类父类:"+cglibProxy.getClass().getSuperclass());
		cglibProxy.addUser(user);
	}
}

运行结果:

 这里顺便打印了动态代理类的父类,接下来我们将它的父类UserServiceImplCglib的addUser方法用final修饰,看看是否会被增强

UserServiceImplCglib.java

package com.taolong.cglib;

import com.taolong.User;

public class UserServiceImplCglib {

	final void addUser(User  user) {
		System.out.println("cglib...正在注册用户,用户信息为:"+user);
	}
}

 运行结果:

 

总结一下

1、JDK原声动态代理时java原声支持的、不需要任何外部依赖、但是它只能基于接口进行代理(因为它已经继承了proxy了,java不支持多继承)

2、CGLIB通过继承的方式进行代理、无论目标对象没有没实现接口都可以代理,但是无法处理final的情况(final修饰的方法不能被覆写)

好了,就暂时先写到这里了,感兴趣的朋友可以具体看一下实现的源码,如有错误欢迎指正,谢谢!

 

 

<think>好的,用户现在问的是静态代理和动态代理的区别,以及动态代理两种方式的差异。我需要先理清楚这些概念,然后以通俗易懂的方式解释,尤其是考虑到用户是初学者,可能对AOP已经有了一些基础了解,但需要更深入的代理机制的解释。 首先,用户之前已经了解过AOP的核心概念和应用,现在转向代理的实现机制,这是AOP背后的重要技术。所以需要从代理的基本概念入手,对比静态和动态代理的不同。 静态代理和动态代理的主要区别在于代理类的创建时机和方式。静态代理是手动编写代理类,每个目标类都需要一个对应的代理类,这样在目标类多的时候会非常麻烦,代码冗余。而动态代理是在运行时动态生成代理类,不需要为每个目标类单独编写代理,提高了灵活性和可维护性。 接下来,动态代理两种方式:JDK动态代理和CGLIB动态代理。需要解释它们的实现原理、优缺点以及适用场景。JDK动态代理基于接口,通过反射机制生成代理类,要求目标类必须实现接口。而CGLIB通过继承目标类,使用字节码技术生成子类作为代理,因此可以代理没有接口的类。但需要注意final方法的问题,因为CGLIB无法代理final方法。 用户作为初学者,可能需要更具体的示例和对比表格来帮助理解。因此,我应该给出代码示例,说明静态代理和两种动态代理的实现方式,并通过表格总结它们的差异。同时,要指出Spring AOP是如何选择使用哪种动态代理的,这样用户能结合实际框架应用来理解。 还要注意用户可能存在的疑问点,比如为什么JDK动态代理必须基于接口,CGLIB如何生成字节码,以及性能上的差异。虽然现在CGLIB和JDK动态代理在性能上差距不大,但了解历史背景也很重要。 最后,确保回答结构清晰,分点明确,使用生活化的类比帮助理解。例如,静态代理就像手工制作每个产品的模具,而动态代理则是3D打印,按需生成。这样的类比有助于用户形成直观印象。</think>### 一、静态代理 vs 动态代理(快递代收点类比📦) #### 1. **静态代理** → **手工定制快递柜** - **特点**: - 需要**手动编写代理类** - 每个被代理类都要有对应的代理类 - 编译时确定代理关系 - **代码示例**: ```java // 接口:快递服务 interface ExpressService { void deliver(String packageId); } // 目标类:顺丰快递 class SFExpress implements ExpressService { public void deliver(String packageId) { System.out.println("顺丰正在派送包裹:" + packageId); } } // 静态代理类:快递代收点 class StaticProxy implements ExpressService { private SFExpress target = new SFExpress(); public void deliver(String packageId) { System.out.println("[代收点] 接收包裹:" + packageId); // 增强逻辑 target.deliver(packageId); // 调用原始方法 System.out.println("[代收点] 签收完成"); // 增强逻辑 } } // 使用 ExpressService proxy = new StaticProxy(); proxy.deliver("PKG-001"); ``` - **缺点**: - 每新增一个快递公司(如京东物流),就需要新建一个代理类 - 代理类和目标类**强耦合** --- #### 2. **动态代理** → **智能快递柜** - **特点**: - **运行时动态生成代理类** - 一个代理类可代理多个目标类 - 通过反射机制实现 - **核心优势**: ```text ┌─────────────┐ ┌───────────────┐ │ 客户端调用 │───▶ │ 动态代理类 │ └─────────────┘ └───────────────┘ │ 反射调用 ▼ ┌─────────────┐ │ 目标对象 │ └─────────────┘ ``` --- ### 二、动态代理两种实现方式 #### 方式1:JDK动态代理(基于接口) - **实现原理**: - 通过`java.lang.reflect.Proxy`类生成代理对象 - 要求目标类**必须实现接口** - **代码示例**: ```java // 动态代理处理器 class JdkProxyHandler implements InvocationHandler { private Object target; public JdkProxyHandler(Object target) { this.target = target; } public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println("[JDK代理] 开始处理"); Object result = method.invoke(target, args); // 反射调用目标方法 System.out.println("[JDK代理] 处理完成"); return result; } } // 使用 ExpressService target = new SFExpress(); ExpressService proxy = (ExpressService) Proxy.newProxyInstance( target.getClass().getClassLoader(), target.getClass().getInterfaces(), new JdkProxyHandler(target) ); proxy.deliver("PKG-002"); ``` - **关键特点**: - 生成的文件名格式:`$Proxy0` - 通过`ProxyGenerator`生成字节码 - **只能代理接口方法** --- #### 方式2:CGLIB动态代理(基于继承) - **实现原理**: - 通过**继承目标类**生成子类代理 - 使用ASM字节码操作框架 - 不要求目标类实现接口 - **代码示例**: ```java // 目标类(没有实现接口) class ZTOExpress { public void deliver(String packageId) { System.out.println("中通正在派送包裹:" + packageId); } } // CGLIB代理工厂 class CglibProxyFactory implements MethodInterceptor { public Object getProxy(Class<?> clazz) { Enhancer enhancer = new Enhancer(); enhancer.setSuperclass(clazz); enhancer.setCallback(this); return enhancer.create(); } public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable { System.out.println("[CGLIB代理] 开始处理"); Object result = proxy.invokeSuper(obj, args); // 调用父类方法 System.out.println("[CGLIB代理] 处理完成"); return result; } } // 使用 CglibProxyFactory factory = new CglibProxyFactory(); ZTOExpress proxy = (ZTOExpress) factory.getProxy(ZTOExpress.class); proxy.deliver("PKG-003"); ``` - **关键特点**: - 生成的文件名格式:`TargetClass$$EnhancerByCGLIB$$...` - 需要添加CGLIB依赖(Spring-core已包含) - **无法代理final类/方法** --- ### 三、核心差异对比表 | 对比维度 | JDK动态代理 | CGLIB动态代理 | |-------------------|-------------------------------------|----------------------------------------| | **实现基础** | 基于接口 | 基于继承 | | **目标类要求** | 必须实现接口 | 不需要实现接口 | | **生成方式** | 使用Proxy类生成 | 使用Enhancer生成 | | **方法调用速度** | 较慢(反射调用) | 较快(MethodProxy直接调用) | | **生成文件体积** | 较小 | 较大(生成子类包含更多信息) | | **适用场景** | 代理接口方法 | 代理普通类方法 | | **Spring默认策略** | 当Bean实现接口时使用 | 当Bean没有接口时使用 | --- ### 四、选择策略(Spring AOP的决策逻辑) ```text ┌──────────────┐ │ 目标类检查 │ └──────┬───────┘ ˅ ┌─────────────┴─────────────┐ │ 是否有实现接口? │ └─────────────┬─────────────┘ ˅ ┌──────────────┴──────────────┐ ▼ ▼ ┌─────────────┐ ┌───────────────┐ │ JDK动态代理 │ │ CGLIB动态代理 │ └─────────────┘ └───────────────┘ ``` --- ### 五、性能注意事项 1. **JDK 8+优化**:反射调用性能已大幅提升 2. **CGLIB的FastClass机制**:通过索引直接调用方法,避免反射 3. **实际选择建议**: - 优先使用JDK动态代理(符合面向接口编程原则) - 需要代理非接口方法时再使用CGLIB --- ### 六、代码验证技巧 1. **查看代理类类型**: ```java System.out.println(proxy.getClass()); // 输出示例: // class com.sun.proxy.$Proxy0 → JDK代理 // class ZTOExpress$$EnhancerByCGLIB$$ → CGLIB代理 ``` 2. **保存生成的代理类**(调试用): ```bash # JDK代理 System.setProperty("jdk.proxy.ProxyGenerator.saveGeneratedFiles", "true"); # CGLIB代理 System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "cglib_output"); ```
评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值