设计模式2——Proxy设计模式

Proxy代理设计模式是一种控制对象访问的设计模式，类似于网络代理，网络代理机制如下图：

Proxy代理设计模式机制如下：

代理模式UML图如下：

代理模式顺序图如下：

客户端程序通过代理程序来访问真正的目标程序，代理程序对外隐藏了目标程序。普通代理设计模式例子代码如下：

interface ProxyBase{
	public void f();
	public void g();
	public void h();
}
//代理程序
class Proxy implement ProxyBase{
	private ProxyBase implementation;
	public Proxy(){
		//目标程序
		implementation = new ProxyImplementation();
	}
	public void f(){
		implementation.f();
	}
	public void g(){
		implementation.g();
	}
	public void h(){
		implementation.h();
	}
}
//目标程序
class ProxyImplementation implements ProxyBase{
	public void f(){
		System.out.println(“ProxyImplementation.f()”);
	}
	public void g(){
		System.out.println(“ProxyImplementation.g()”);
	}
	public void h(){
		System.out.println(“ProxyImplementation.h()”);
	}
}
//客户端程序调用代理
public class ProxyDemo{
	public static void main(String[] args){
		//客户端调用代理程序
		Proxy p = new Proxy();
		p.f();
		p.g();
		p.h();
	}
}

从JDK1.3以后，java引入动态代理机制，java的动态代理只能针对接口进行动态代理，即要实现动态代理的类必须实现接口，CGLIB提供了针对类的动态代理功能。JDK动态代理的例子如下：

//代理接口
interface Foo{
	public void f(String s);
	public void g(int i);
	public void h(int i, String s);
}
//接口实现类，即被代理类
class FooImpl implements Foo{
	public void f(String s){
		System.out.println(“FooImpl.f(), s=” + s);
	}
	public void g(int i) {
		System.out.println(“FooImpl.g(), i=” + i);
	}
	public void h(int i, String s) {
		System.out.println(“FooImpl.h(), i=” + i + “, s=” + s);
	}
} 
//动态代理处理类
class ProxyHandler implements InvocationHandler{
	//代理实现类
	private Object delegate;            
     	public ProxyHandler (Object obj) {    
         	delegate = obj;    
     	}    
	public Object invoke(Object proxy, Method method, Object[] args){
  		System.out.println(“Before mothod:” + method);
  		method.invoke(this.delegate, args); 
  		System.out.println(“After mothod:” + method);
  		return null; 
	}
}
public class DynamicProxyDemo{
	public static void main(String[] args){
		Foo foo = new FooImpl();
		ProxyHandler handler = new ProxyHandler(foo);
		//产生动态代理
	Foo proxy = (Foo)Proxy.newProxyInstance(Foo.class.getClassLoader(), new Class[]{Foo.class}, handler);
		proxy.f(“f”);
		proxy.g(1);
		proxy.h(“h”, 2);
	}
}

动态代理和普通的代理模式的区别：动态代理中的代理类是由java.lang.reflect.Proxy类在运行期时根据接口定义，采用Java反射功能动态生成的。和java.lang.reflect.InvocationHandler结合，可以加强现有类的方法实现。动态带来自定义Handler实现InvocationHandler接口，自定义Handler实例化时，将代理的实现类传入自定义Handler对象中。自定义Handler需要实现invoke方法，该方法可以使用Java反射调用实现类的实现的方法，同时当然可以实现其他功能，例如在调用实现类方法前后加入Log，实现安全认证等。而Proxy类根据Handler和需要代理的接口动态生成一个接口实现类的对象。当用户调用这个动态生成的实现类时，实际上是调用了自定义Handler的invoke方法。

JDK中代理模式的应用：

JDK动态代理.

RMI.