Java设计模式笔记之代理模式

1.代理模式

代理模式是对象的结构模式。代理模式给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用。

2.代理的种类

如果按照使用目的来划分，代理有以下几种：

（1）远程代理（Remote）：为一个位于不同的地址空间的对象提供一个局域代表对象。

（2）虚拟代理（Virtual）：根据需要创建一个资源消耗比较大的对象，使得此对象只在需要时才会被真正创建，之前使用的是代理。

（3）Copy-on-write代理：虚拟代理的一种。把复制（克隆）拖延到只有在客户端需要时，才真正采取行动。

（4）保护（Protect or Access）代理：控制对一个对象的访问，如果需要，可以给不同的用户提供不同级别的使用权限。

（5）Cache代理：为某一个目标操作的结果提供临时的存储空间，以便多个客户端乐意共享这些结果。

（6）防火墙（firewall）代理：保护目标，不让恶意用户接近。

（7）同步化（Synchronization）代理：使几个用户能够同时使用一个对象而没有冲突。

（8）智能引用（Smart Referenc）代理：当一个对象被引用是，提供一些额外的操作。

3.代理模式的结构

类图：

抽象主题（Subject）：定义了实际对象和代理对象的共同行为，使得能使用实际对象的地方都能使用代理。

代理主题（Proxy）：代理类，持有一个被代理的类的引用，可以自由操作被代理对象；用户和被代理类相同的接口，在任何环境中都可以代替被代理类；控制对被代理对象的引用；在引用被代理对象的方法前或者后，一般会执行一些额外操作。

真实主题（RealSubject）：被代理类。

4.示例源码

Subject.java

package com.patterns.proxy;abstract public class Subject{    abstract public void request();}

ProxySubject.java

package com.patterns.proxy;public class ProxySubject extends Subject {    private RealSubject realSubject;public ProxySubject(){}public void request(){        preRequest();if( realSubject == null )        {realSubject = new RealSubject();}        realSubject.request();        postRequest();}    private void preRequest()    {        System.out.println("pre request from proxy");    }    private void postRequest()    {        System.out.println("after requet from proxy");    }}

RealSubject.java

package com.patterns.proxy;public class RealSubject extends Subject {public RealSubject(){ }public void request(){ System.out.println("From real subject.");}}

Client.java

package com.patterns.proxy;public class Client{  private static Subject subject;    static public void main(String[] args){ subject = new ProxySubject();subject.request();}}

运行结果：

pre request from proxy
From real subject.
after requet from proxy

代理调用时，在实际对象的调用的前后加入了一些自己的操作（智能引用）。

5.动态代理

在Java中，提供了支持代理模式的接口，可以在运行时间内创建代理对象。

package com.patterns.proxy.reflect;import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;import java.lang.reflect.Proxy;import java.util.ArrayList;import java.util.List;/** *  *与代理类相关联的InvocationHandler对象  * */public class ListProxy implements InvocationHandler{    private Object proxyobj;    public ListProxy(Object obj)    {        proxyobj = obj;    }    /**     *创建代理对象的工厂方法      *     */public static Object factory(Object obj)    {Class<?> cls = obj.getClass();        return Proxy.newProxyInstance( cls.getClassLoader(),            cls.getInterfaces(),//指定被代理的接口函数            new ListProxy(obj) );//指定InvocationHandler    }/** * 调用被代理的接口函数的处理,可以添加一些额外的操作 */    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable    {System.out.println("before calling " + method);        if (args != null)        {for (int i=0; i<args.length; i++)            {                System.out.println(args[i] + "");            }}        Object o = method.invoke(proxyobj, args);System.out.println("after calling " + method);        return o;    }   public static void main(String[] args)    {List<String> v = null;        v = (List<String>) factory(new ArrayList<String>());        v.add("New");        v.add("York");    }}

创建动态代理的过程

（1）指明一系列接口来创建代理对象，上例在工厂方法中指明使用传入参数的接口，如果没有接口的话，本例不适用。

（2）继承InvocationHandler实现一个代理处理器，在创建代理时使用，系统会把它和指定的接口做关联。

（3）invoke函数的改写，invoke函数会拦截被指定的接口，并执行自己的内容。

（4）在运行时，新建代理对象，并运行。

上例中运行结果：

before calling public abstract boolean java.util.List.add(java.lang.Object)
New
after calling public abstract boolean java.util.List.add(java.lang.Object)
before calling public abstract boolean java.util.List.add(java.lang.Object)
York
after calling public abstract boolean java.util.List.add(java.lang.Object)

拦截了被指定的List的接口，包括add()；所以在 v.add("New");  v.add("York");时，其实是执行了ListProxy中的invoke的内容