JDK中的动态代理机制

定义

代理模式：为其余对象提供一种代理以控制对这个对象的访问。

事例

小明是一个程序员，在公司负责项目的研发工做。有一天，客户打电话进来，沟通以后，原来客户是有个模块需求要变更一下。小明却没有应允，而是让客户去找产品经理老王沟通。

是小明偷懒不想干活吗？显然不是。咱们把这个事例对应到上面的定义上，程序员小明能够映射为其余对象，产品经理老王是小明的代理。它来控制小明这个对象的访问。

咱们看上面的类图，能够简单概括如下角色。

• Subject 某一类主题。 好比工程师
• Proxy 代理对象。 好比产品经理老王
• RealSubject 真实对象。 好比程序员小明

静态代理

咱们经过代码来重现上面的场景。

首先定义一个 工程师的接口，它有一个编码的方法。

public interface Engineer {
	
	void coding();
}
复制代码

小明是个Java码农，啊呸。是个Java工程师，要实现工程师这个接口。

public class JavaEngineer implements Engineer{

	private String name;
	
	public JavaEngineer(String name){
		this.name = name;
	}
	
	public void coding() {
		
		System.out.println(name+" :正在努力的coding...");
		System.out.println(name+" :终于改完了!");
	}
}
复制代码

产品经理老王也让他实现工程师的接口。他代理了公司里的Java工程师对象，当客户有需求提出来，他要整理评估一下，当须要coding的时候，他直接转交给具体的工程师去处理。

public class ProductManager implements Engineer{

	private String name;
	private JavaEngineer engineer;
	
	public ProductManager(JavaEngineer engineer,String name){
		this.engineer = engineer;
		this.name = name;
	}
	
	public void coding() {
		arrange();
		engineer.coding();
		appease();
	}
	
	
	private void arrange(){
		System.out.println(this.name+"：整理客户需求中...");
		System.out.println(this.name+"：输出需求文档，交给码农去完成!");
	}

	private void appease(){
		System.out.println(this.name+"：哎，需求变好屡次了.得安抚一下这个码农才好!");
	}
}
复制代码

咱们来重现一下这个场景。

//有一个美丽的Java工程师，他的名字叫小明。
JavaEngineer engineer = new JavaEngineer("XiaoMing");

//一样，还有一个猥琐的老王。
ProductManager manager = new ProductManager(engineer,"老王");

//有新需求的时候，老王负责去沟通搞定。
manager.coding();

System.out.println("------------------输出结果-----------------------");
//老王：整理客户需求中...
//老王：输出需求文档，交给码农去完成!
//XiaoMing :正在努力的coding...
//XiaoMing :终于改完了!
//老王：哎，需求变好屡次了.得安抚一下这个码农才好!
复制代码

动态代理

JDK经过反射机制给咱们提供了动态代理的实现，容许开发人员在运行时刻动态的建立出代理类及其对象。当使用者调用了代理对象所代理的接口中的方法的时候，这个调用的信息会被传递给InvocationHandler的invoke方法。在 invoke方法的参数中能够获取到代理对象、方法对应的Method对象和调用的实际参数。invoke方法的返回值被返回给使用者。这种作法实际上至关于对方法调用进行了拦截。

关键有两个类，Proxy和InvocationHandler 。

• Proxy 用于生成代理类
• InvocationHandler 用于调用目标类的方法，而且容许在调用先后插入其余的逻辑

上面的事例咱们改为动态代理方式来看一下。先定义一个调用处理程序

public class ProxyHandler implements InvocationHandler{

	private Object target;
	private String name;
	
	public ProxyHandler(Object target,String name){
		this.target = target;
		this.name = name;
	}
	
	
	public Object invoke(Object proxy, Method method, Object[] args)throws Throwable {
		arrange();
		method.invoke(target, args);
		appease();
		return null;
	}

	
	private void arrange(){
		System.out.println(this.name+"：整理客户需求中...");
		System.out.println(this.name+"：输出需求文档，交给工程师去完成!");
	}

	private void appease(){
		System.out.println(this.name+"：哎，需求变好屡次了.得安抚一下这个码农才好!");
	}
}
复制代码

而后咱们来测试一下

//有一个美丽的Java工程师，他的名字叫小明。
Engineer engineer = new JavaEngineer("XiaoMing");

//代理实例的调用处理程序
ProxyHandler handler = new ProxyHandler(engineer, "老王");

//返回指定接口的代理类实例，该接口能够将方法指派到指定的handler
Engineer proxy = (Engineer) Proxy.newProxyInstance(Engineer.class.getClassLoader(), 
			new Class[]{Engineer.class}, handler);

proxy.coding();

System.out.println("------------------输出结果-----------------------");
//老王：整理客户需求中...
//老王：输出需求文档，交给码农去完成!
//XiaoMing :正在努力的coding...
//XiaoMing :终于改完了!
//老王：哎，需求变好屡次了.得安抚一下这个码农才好!
复制代码

内存中的代理类实例长啥样？

咱们看到，Proxy类经过静态方法newProxyInstance就生成了一个代理类的实例。先无论它是怎么样生成的，可是我想关心它到底长什么样子呢？把它拿出来看看。 JDK生成的代理类以$Porxy开头，后面跟一个从0开始的自增加数字。好比，$Proxy0，经过下面这段代码，能够将代理类实例输出到$Proxy0.class文件中。

byte[] data = ProxyGenerator.generateProxyClass("$Proxy0",new Class[] {Engineer.class});	
FileOutputStream fileOutputStream = new FileOutputStream("$Proxy0.class");
fileOutputStream.write(data);
fileOutputStream.close();
复制代码

经过反编译class文件，获得代理类删减整理以下：

public class $Proxy0 extends Proxy implements Engineer {

	private static final long serialVersionUID = 1L;
	private static Method m3;

	protected $Proxy0(InvocationHandler h) {
		//经过构造方法 把代理实例的调用处理程序传进来
		super(h);
	}
	public final void coding() {
		try {
			//此处的h是父类Proxy的属性，对应的就是ProxyHandler
			//invoke就至关于ProxyHandler.invoke(this, m3, null);
			this.h.invoke(this, m3, null);
			return;
		} catch (RuntimeException localRuntimeException) {
			throw localRuntimeException;
		} catch (Throwable localThrowable) {
			throw new UndeclaredThrowableException(localThrowable);
		}
	}
	static {
		try {
			//经过反射拿到指定接口的方法
			m3 = Class.forName("proxy.proxy2.Engineer").getMethod("coding",
					new Class[0]);
		} catch (NoSuchMethodException localNoSuchMethodException) {
			throw new NoSuchMethodError(localNoSuchMethodException.getMessage());
		} catch (ClassNotFoundException localClassNotFoundException) {
			throw new NoClassDefFoundError(
					localClassNotFoundException.getMessage());
		}
	}
}
复制代码

若是咱们把经过反编译获得的class文件写成一个Java类，调用它一样能够实现代理功能。

Engineer engineer = new JavaEngineer("XiaoMing");
ProxyHandler handler = new ProxyHandler(engineer, "老王");
$Proxy0 p0 = new $Proxy0(handler);
p0.coding();
System.out.println("------------------输出结果-----------------------");
//老王：整理客户需求中...
//老王：输出需求文档，交给码农去完成!
//XiaoMing :正在努力的coding...
//XiaoMing :终于改完了!
//老王：哎，需求变好屡次了.得安抚一下这个码农才好!
复制代码

总结

关于动态代理建立对象的过程，咱们大概能够这样总结一下。

• 一、经过实现InvocationHandler接口建立本身的调用处理器
• 二、经过为Proxy类指定ClassLoader对象和一组interface建立动态代理类
• 三、经过反射机制获取动态代理类的构造函数，其参数类型是调用处理器接口类型
• 四、经过构造函数建立代理类实例，此时需将调用处理器对象做为参数被传入

Proxy类的newProxyInstance方法封装了2-4，只需2步就完成了代理对象的建立。 生成的代理对象集成Proxy，实现被代理对象接口。被代理对象接口的方法实际调用处理器的invoke方法，而处理器的invoke方法利用反射调用的是被代理对象的的方法method.invoke(target,args)。