代理模式

最新推荐文章于 2025-07-18 09:42:11 发布

原创最新推荐文章于 2025-07-18 09:42:11 发布 · 86 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#代理模式 #java

代理模式

14.9.JDK动态代理与CGlib代理的区别？

JDK动态代理：

动态代理相比于静态代理，动态代理的代理类是在动态生成的，也就是jvm通过反射获取代码生成代理类，所以用户并不能决定代理角色和真实角色之间的联系，而是由程序运行时候决定的。

相比于静态代理，动态代理的优势在于可以很方便的对代理类的函数进行统一的处理，而不用修改每个代理类的函数。

动态代理实现的三步走：

1.实现InvocationHandler接口，创建自己的调用处理器。

2.给Proxy类提供ClassLoader和代理接口类型数组创建动态代理类。

3.执行真实角色具体任务。

要想创建处理器必须实现InvocationHandler接口，之后通过类装载器创建代理类。每一个动态代理类都必须要实现InvocationHandler这个接口，并且每个代理类的实例都关联到了一个

handler，当我们通过代理对象调用一个方法的时候，这个方法的调用就会被转发为由InvocationHandler这个接口的 invoke 方法来进行调用。

Object invoke(Object proxy, Method method, Object[] args) throws Throwable

proxy:指代我们所代理的那个真实对象

method:指代的是我们所要调用真实对象的某个方法的Method对象

args:指代的是调用真实对象某个方法时接受的参数

我们依旧要创建抽象角色和真实角色类：

package com.wangxing.proxy3;
/**
 * 提供售票业务的接口
 * @author Administrator
 *
 */
public interface SellePiaoService {
	void  maipiao();
}

package com.wangxing.proxy3;
/**
 * 火车站
 * @author Administrator
 *
 */
public class HuoCheZhan implements SellePiaoService{
	@Override
	public void maipiao() {
		System.out.println("我家距离火车站近，我就出火车站买票");
	}
}

代理角色：和静态代理相比，静态代理运用对象调用完成代理，而动态代理通过实现InvocationHandler接口，创建了一个调用处理器，其实是通过Java的反射机制完成.

package com.wangxing.proxy3;

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

/**
 * 1.需要让生成代理类对象的java类实现InvocationHandler接口
 * 2.重写InvocationHandler接口的invoke方法
 * 3.创建生成代理对象的方法
 * @author Administrator
 *
 */
public class CreateDaiShouDianObject implements InvocationHandler{
	 //定义目标对象[具体需要代理对象的java类]
	private Object targetObject;
	public  CreateDaiShouDianObject(Object targetObject){
		this.targetObject=targetObject;
	}
	//通过java提供的Proxy类创建出代理对象
	public  Object getProxyObject(){
		return  Proxy.newProxyInstance(this.getClass().getClassLoader(),
				targetObject.getClass().getInterfaces(), this);
	}
	//用来执行具体的代理动作
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		return method.invoke(targetObject, args);
	}
}

package com.wangxing.proxy3;

public class TestMain {

	public static void main(String[] args) {
		//根据家距离火车站的远近，决定去什么地方买票
		//家距离火车站近，选择火车站
		HuoCheZhan  hcz=new HuoCheZhan();
		//hcz.maipiao();
		//家距离火车站远，选择代售点
		//创建火车站的代理对象
		CreateDaiShouDianObject  cpo=new CreateDaiShouDianObject(hcz);
		//得到代理对象
		SellePiaoService  proxy=(SellePiaoService)cpo.getProxyObject();
		proxy.maipiao();
	}

}

看上去实现很简单，我们只需要实现接口，调用其中的方法就可以实现动态代理。

通过newProxyInstance方法获取代理类实例，而后我们便可以通过这个代理类实例调用代理类的方法，对代理类的方法的调用实际上都会调用中介类(调用处理器)的invoke方法。

注意：JDK动态代理只能处理有接口实现关系的java类

Cglib代理：

cglib是一个强大的高性能的代码生成包，广泛的被许多AOP的框架使用，它的开源地址在https://github.com/cglib/cglib，通过它实现动态代理，主要用到import net.sf.cglib.proxy包下的

MethodInterceptor、MethodProxy和Enhancer类

(1)、MethodInterceptor

MethodInterceptor类是方法拦截器，代理类实例的方法被调用时会回调MethodInterceptor的intercept()方法拦截，用来实现自己的代理逻辑，类似于jdk动态代理的InvocationHandler接口

(2)、MethodProxy

MethodProxy是intercept()方法中的第四个参数的类型，它是实际类方法的代理引用，使用methodProxy比使用jdk自身的method在效率上会有提升

(3)、Enhancer

Enhancer用来动态创建实际类子类的代理类实例，setSuperclass()方法设置实际类为父类，setCallback()方法建立方法回调，create()方法创建一个代理类实例

package com.wangxing.proxy4;
/**
 * 火车站
 * @author Administrator
 *
 */
public class HuoCheZhan {
	public void maipiao() {
		System.out.println("我家距离火车站近，我就出火车站买票");
	}
}

package com.wangxing.proxy4;


import java.lang.reflect.Method;

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

/**
 * 1.需要让生成代理类对象的java类实现MethodInterceptor接口
 * 2.重写MethodInterceptor接口的intercept方法
 * 3.创建生成代理对象的方法
 * @author Administrator
 *
 */
public class CreateDaiShouDianObject implements MethodInterceptor{
	 //定义目标对象[具体需要代理对象的java类]
	private Object targetObject;
	public  CreateDaiShouDianObject(Object targetObject){
		this.targetObject=targetObject;
	}
	//创建代理对象
	public  Object getProxyObject(){
		Enhancer  enhancer=new Enhancer();
		enhancer.setSuperclass(targetObject.getClass());
		enhancer.setCallback(this);
		return  enhancer.create();
	}
	//用来执行具体的代理动作
	@Override
	public Object intercept(Object proxy, Method method, Object[] arg2, MethodProxy methodproxy) throws Throwable {
		return methodproxy.invokeSuper(proxy, arg2);
	}
}

package com.wangxing.proxy4;

public class TestMain {

	public static void main(String[] args) {
		//根据家距离火车站的远近，决定去什么地方买票
		//家距离火车站近，选择火车站
		HuoCheZhan  hcz=new HuoCheZhan();
		hcz.maipiao();
		//家距离火车站远，选择代售点
		//创建火车站的代理对象
		CreateDaiShouDianObject  cpo=new CreateDaiShouDianObject(hcz);
		//得到代理对象
		HuoCheZhan  proxy=(HuoCheZhan)cpo.getProxyObject();
		proxy.maipiao();
	}

}

比较：

1.静态代理是通过在代码中显式定义一个业务实现类一个代理，在代理类中对同名的业务方法进行包装，用户通过代理类调用被包装过的业务方法；

手动创建一个与目标类相同接口的子类，包装目标类。

2.JDK动态代理是通过接口中的方法名，在动态生成的代理类中调用业务实现类的同名方法；【兄弟模式】

通过jdk提供的反射包中Proxy这个类，动态的创建一个与目标类实现相同接口的子类对象，包装目标。

3.CGlib动态代理是通过继承业务类，生成的动态代理类是业务类的子类，通过重写业务方法进行代理。【父子模式】

通过CGlib提供的Enhancer这个类，动态的创建一个目标类的子类对象，包装目标类。

静态代理	JDK动态代理	CGlib动态代理
手动创建代理类	动态生成代理类对象	动态生成代理类对象
	jdk提供的反射包中Proxy这个类	CGlib提供的Enhancer这个类
	只能为实现过接口的Java类创建代理对象	为任何Java类创建代理对象