Design Pattern—— Dynamic Proxy Pattern 动态代理模式

动态代理模式 Dynamic Proxy Pattern

个人总结：相比较与静态代理模式，动态模式更加灵活。 ，可以对不同的对象进行代理，。对不同的方法进行代理。通过比较会发现，静态代理的做法是将代理与被代理的对象写死，不灵活。而动态代理则通过实现InvocationHandler的invoke方法，用发射机制灵活地代理多种实现相同接口的对象， 动态代理是框架Spring的基石。

下面以一个简单例子说明：

Step One：

创建被代理的类和接口。即是创建真实角色和抽象角色。 真实角色实现抽象角色。

package com.master.proxy;

//接口，抽象角色
public interface AbstractProxy { 

	public abstract void getPhone();
	
	public abstract void getMoney();
	
}

package com.master.proxy;

 // 被代理的类，真实角色，它实现抽象角色AbstractProxy接口
public class RealSub implements AbstractProxy {

	@Override
	public void getPhone() { // method 1
		// TODO Auto-generated method stub
		System.out.println("cost 500 RMB");
		System.out.println("that's the end");
	}
	@Override
	public void getMoney() { // method 2
		System.out.println("say hello.And this is getMoney method");
	}
}

Step Two:

创建一个实现了InvocationHandler接口的实现类。它必须实现invoke方法。

package com.master.proxy;

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

public class ProxyHandle implements InvocationHandler {

	private Object proxyy;

	public ProxyHandle(Object obj) {  //接收传入的被代理的对象
		this.proxyy = obj;
	}

	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {

		System.out.println("before: " + method); // 打印 调用了哪个对象

		method.invoke(proxyy, args);  

		System.out.println("after: " + method);

		return null;
	}
}

Step Three:

通过Proxy的静态方法来创建一个运行时的代理对象!  并通过该代理对象调用方法。

Proxy.newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)

注意，这个对象也是被宣称实现了抽象角色AbstractProxy接口。仔细分析下JDk中的newProxyInstance函数会发现第二个参数接收的是 interfaces ，也就是创建的新的proxy代理对象也是实现了这些接口的，注意是Class<>类型数组，可以有多个接口。

package com.master.proxy;

import java.lang.reflect.Proxy;

public class Client {

	public static void main(String[] args) {

		RealSub realSub = new RealSub();

		ProxyHandle proxyHandle = new ProxyHandle(realSub);

		AbstractProxy obj = (AbstractProxy) Proxy.newProxyInstance(
				ProxyHandle.class.getClassLoader(), realSub.getClass()
						.getInterfaces(), proxyHandle);// obj是运行时动态生成的。
		// getInterfaces宣称实现了哪几种interfaces，则生成实现了哪几接口的代理对象（这里是宣称AbstractProxy接口） 返回值强制为那几种接口的任何一种 

		obj.getPhone();  // 新产生的代理对象obj调用getPhone方法，实际是交给proxyHandler处理。obj是代理角色！
		obj.getMoney();

	}
}

这样，通过newProxyInstance方法new出来的新的代理对象obj 也自热而然地实现了了抽象角色AbstractProxy接口。

输出：

before: public abstract void com.master.proxy.AbstractProxy.getPhone()
cost 500 RMB
that's the end
after: public abstract void com.master.proxy.AbstractProxy.getPhone()
before: public abstract void com.master.proxy.AbstractProxy.getMoney()
say hello.And this is getMoney method
after: public abstract void com.master.proxy.AbstractProxy.getMoney()