设计模式之代理Proxy模式

Bertha 。 2022-09-21 01:14 142阅读 0赞

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

![SouthEast][]

Proxy代理模式如下：

![SouthEast 1][]

代理模式UML图如下：

![SouthEast 2][]

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

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);
    	}
    }

动态代理和普通的代理模式的区别：

动态代理中代理类是有Proxy类在运行时期根据接口定义，采用Java反射功能动态生成的。和InvocationHandler结合，可以加强现有类的方法实现。

代理模式应用的场合：

1 远程代理，为一个对象提供在不同的地址空间的局部代表，隐藏一个对象存在于不同的地址空间的事实。

2 虚拟代理，根据需要来创建开销很大的对象。

3 安全代理，控制对真实对象的访问权限

4 智能代理，调用真实对象的时候，会执行一些其他的行为。

[SouthEast]: /images/20220823/c744b67dd5cf40e6a0c39bd8c3f0755c.png
[SouthEast 1]: /images/20220823/607f765079854bed9001e6fa26971cc4.png
[SouthEast 2]: /images/20220823/51f4e5a577ce4b32af357bd81a293421.png