大話設計模式之代理模式

    今天我們來總結一下一個常見的設計模式---代理設計模式。首先我們看一下代理模式的UML圖：

                                

    然後呢我們根據UML圖把代碼寫一下：

 public interface Subject{
        public void Request();
    }
    public class RealSubject implements Subject{

        @Override
        public void Request()
        {
            System.out.println("Operate request!");
        }
        
    }
    public class Proxy implements Subject{
        private RealSubject realSubject;
        public Proxy(RealSubject realSubject) {  
        super();  
        this.realSubject= realSubject;  
    }   
        @Override
        public void Request()
        {
            if(realSubject == null){
                realSubject = new RealSubject(); 
            }
            realSubject.Request();  
        }
        
    }
    public static void main(String[] args){ 
        Proxy proxy = new Proxy();
        proxy.Request();
        
    }

    代理(Proxy)是一種設計模式,提供了對目標對象另外的訪問方式;即通過代理對象訪問目標對象.這樣做的好處是:可以在目標對象實現的基礎上,增強額外的功能操作,即擴展目標對象的功能。
    這裏使用到編程中的一個思想:不要隨意去修改別人已經寫好的代碼或者方法,如果需改修改,可以通過代理的方式來擴展該方法。

    舉個例子來說明代理的作用:假設我們想邀請一位明星,那麼並不是直接連接明星,而是聯繫明星的經紀人,來達到同樣的目的.明星就是一個目標對象,他只要負責活動中的節目,而其他瑣碎的事情就交給他的代理人(經紀人)來解決.這就是代理思想在現實中的一個例子。

    

    

    上面講的代理模式是靜態代理：即需要代理的類和代理類必須同時繼承或者實現同一接口，上述採用實現的方式這時代理類需聚合被代理類，這樣可以實現靈活多變。

動態代理

一般來說，對代理模式而言，一個主題類與一個代理類一一對應，這也是靜態代理模式的特點。

但是，也存在這樣的情況，有n各主題類，但是代理類中的“前處理、後處理”都是一樣的，僅調用主題不同。也就是說，多個主題類對應一個代理類，共享“前處理，後處理”功能，動態調用所需主題，大大減小了程序規模，這就是動態代理模式的特點。JDK動態代理

實現

//1. 抽象主題
public interface Moveable {
    void move()  throws Exception;
}
//2. 真實主題
public class Car implements Moveable {
    public void move() throws Exception {
        Thread.sleep(new Random().nextInt(1000));
        System.out.println("汽車行駛中…");
    }
}
//3.事務處理器
public class TimeHandler implements InvocationHandler {
    private Object target;

    public TimeHandler(Object target) {
        super();
        this.target = target;
    }

    /**
     * 參數：
     *proxy 被代理的對象
     *method 被代理對象的方法
     *args 方法的參數
     * 返回：
     *Object 方法返回值
     */
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        long startTime = System.currentTimeMillis();
        System.out.println("汽車開始行駛…");
        method.invoke(target, args);
        long stopTime = System.currentTimeMillis();
        System.out.println("汽車結束行駛…汽車行駛時間：" + (stopTime - startTime) + "毫秒！");
        return null;
    }

}
//測試類
public class Test {
    public static void main(String[] args) throws Exception{
        Car car = new Car();
        InvocationHandler h = new TimeHandler(car);
        Class<?> cls = car.getClass();
        /**
         *loader 類加載器
         *interfaces 實現接口
         *h InvocationHandler
         */
        Moveable m = (Moveable) Proxy.newProxyInstance(cls.getClassLoader(),cls.getInterfaces(), h);
        m.move();
    }
}

代碼講解：

在測試代碼中，Proxy.newProxyInstance()方法需要3個參數：類加載器（要進行代理的類）、被代理類實現的接口，事務處理器。所以先實例化Car，實例化InvocationHandler的子類TimeHandler，將各參數傳入Proxy的靜態方法newProxyInstance()即可獲得Car的代理類，前面的靜態代理，代理類是我們編寫好的，而動態代理則不需要我們去編寫代理類，是在程序中動態生成的。

JDK動態代理步驟

1.       創建一個實現InvocationHandler接口的類，它必須實現invoke()方法

2.       創建被代理的類及接口

3.       調用Proxy的靜態方法，創建一個代理類

4.       通過代理調用方法

而爲什麼要進行如此操作，可以從Proxy和InvocationHandler的源碼中找打答案。對源碼不感興趣的可以將下面的源碼部分小節略過。

JDK動態代理原理與源碼

newProxyInstance()方法的源碼：

    public static Object newProxyInstance(ClassLoader loader,
                                         Class<?>[] interfaces,
                                         InvocationHandler h)
        throws IllegalArgumentException{
        if (h == null) {
            throw new NullPointerException();
        }
        final Class<?>[] intfs = interfaces.clone();
        final SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
        }
        /*查找或生成指定的代理類*/
        Class<?> cl = getProxyClass0(loader, intfs);
        /*用指定的調用處理程序調用它的構造函數.*/
        try {
        //獲得類的構造函數
            final Constructor<?> cons =cl.getConstructor(constructorParams);
            final InvocationHandler ih = h;
            if (sm != null && ProxyAccessHelper.needsNewInstanceCheck(cl)) {
              //當需要代理的類實現了一個非public的接口時，因爲這樣的接口需要特殊的權限，因此調用doPrivilege（native 修飾的方法）創建代理實例。
                return AccessController.doPrivileged(newPrivilegedAction<Object>() {
                    public Object run() {
                        return newInstance(cons,ih);
                    }
                });
            } else {
                return newInstance(cons,ih);
            }
        } catch (NoSuchMethodException e) {
            throw new InternalError(e.toString());
        }
}

可以看到，獲得代理類的代碼是

Class<?>cl = getProxyClass0(loader,intfs);

並由此獲得代理類的構造函數，生成代理類的實例返回給該方法的調用者。

繼續跟進getProxyClass0()方法：

/** 生成代理類。調用該方法前必須使用checkproxyaccess方法執行權限檢查。*/
    private static Class<?> getProxyClass0(ClassLoader loader,
                                          Class<?>... interfaces) {
    //檢查實現的接口數，65535這個數字好特殊，端口數好像也是這個，這個數字是由虛擬機所決定的，2^16-1個
    if (interfaces.length > 65535) {
            throw new IllegalArgumentException("interface limit exceeded");
        }
        // 如果代理類已經通過實現給定接口的類加載器創建了，則返回緩存中的該類的副本；否則將通過ProxyClassFactory創建代理類
        return proxyClassCache.get(loader, interfaces);
}

還是沒有看到代理類是怎麼生成的，只知道代理類是從proxyClassCache中取得的，這個變量是與緩存相關的一個對象，查看該變量的聲明與初始化：

private static final WeakCache<ClassLoader, Class<?>[], Class<?>>
        proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());

可以發現proxyClassCache是個用來緩存代理類的類變量，大家知道類變量的特點是與類一一對應，在一個虛擬機中類只有一個，對應着在一個虛擬機中類變量也只有一個，且在此處，在Proxy類被加載的時候就賦值了。在賦值操作的參數中有ProxyClassFactory()這麼一個構造函數，這個是動態代理中的關鍵：生成代理類的類文件字節碼。繼續跟進去，找到代理類的生成之處了：

/** 根據給定的類加載器和接口數組生成代理類的工廠類*/
private static final class ProxyClassFactory
    implements BiFunction<ClassLoader,Class<?>[], Class<?>>
{
    // 所有代理類名稱的前綴
    private static final String proxyClassNamePrefix = "$Proxy";

    //用於生成唯一代理類名稱的下一個序號
    private static final AtomicLong nextUniqueNumber = new AtomicLong();

    @Override
    public Class<?> apply(ClassLoader loader,Class<?>[] interfaces) {

        Map<Class<?>, Boolean>interfaceSet = new IdentityHashMap<>(interfaces.length);
        for (Class<?> intf : interfaces) {
            /* 驗證類加載器將此接口的名稱解析爲實際對象的名稱。*/
            Class<?> interfaceClass =null;
            try {
                interfaceClass = Class.forName(intf.getName(),false, loader);
            } catch (ClassNotFoundException e) {
            }
            if (interfaceClass != intf) {
                throw new IllegalArgumentException(
                    intf + " is not visible from classloader");
            }
            /* 驗證類對象確實是一個接口。*/
            if (!interfaceClass.isInterface()) {
                throw new IllegalArgumentException(
                   interfaceClass.getName() + " is not an interface");
            }
            /*確保接口唯一*/
            if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
                throw new IllegalArgumentException(
                    "repeated interface: " + interfaceClass.getName());
            }
        }

        String proxyPkg = null;     // 代理類的包名

        /*記錄非公開代理接口的包，以便將代理類定義在同一個包中。確認所有非公共代理接口都在同一個包中。*/
        for (Class<?> intf : interfaces) {
            int flags = intf.getModifiers();
            if (!Modifier.isPublic(flags)) {
                String name =intf.getName();
                int n = name.lastIndexOf('.');
                String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
                if (proxyPkg == null) {
                    proxyPkg = pkg;
                } else if (!pkg.equals(proxyPkg)) {
                    throw new IllegalArgumentException(
                        "non-public interfaces fromdifferent packages");
                }
            }
        }

        if (proxyPkg == null) {
            // 如果沒有非公開的代理接口，使用com.sun.proxy作爲包名
            proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
        }

        /* 生成代理類名的序號*/
        long num = nextUniqueNumber.getAndIncrement();
        //生成全類名
        String proxyName = proxyPkg + proxyClassNamePrefix + num;

        /*生成代理類字節碼 */
        byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName,interfaces);
        try {
            return defineClass0(loader, proxyName,proxyClassFile, 0, proxyClassFile.length);
        } catch (ClassFormatError e) {
            throw new IllegalArgumentException(e.toString());
        }
    }

在ProxyClassFactory中，可以看到產生代理類的具體邏輯，大致上是，根據傳遞的被代理類及其實現的接口生成代理類的字節碼加載到緩存中，但是加載到緩存中只是一個.java文件也不能用，所以底層還有編譯等操作。到這裏，可以大致的看清JDK中動態代理的面孔了，實現的步驟爲：

1.      創建代理類的源碼；

2.      對源碼進行編譯成字節碼；

3.      將字節碼加載到內存；

4.      實例化代理類對象並返回給調用者；

底層的代碼我們看不到，但是我們可以查看其生成的字節碼：

//獲得字節碼的測試方法
    byte[] classFile = ProxyGenerator.generateProxyClass("$Proxy1", Car.class.getInterfaces());
        FileOutputStream out = null;
        try {
            out = new FileOutputStream(System.getProperty("user.dir") + "\\$Proxy1.class");
            out.write(classFile);
            out.flush();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

//生成的字節碼：
importcn.com.goser.proxy.imooc.staticproxy.Moveable;
importjava.lang.reflect.InvocationHandler;
importjava.lang.reflect.Method;
importjava.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

public final class $Proxy1 extends Proxy
  implements Moveable
{
  private static Method m1;
  private static Method m3;
  private static Method m0;
  private static Method m2;

  public $Proxy1(InvocationHandler paramInvocationHandler)
    throws
  {
    super(paramInvocationHandler);
  }

  public final boolean equals(Object paramObject)
    throws
  {
    try
    {
      return ((Boolean)this.h.invoke(this, m1, new Object[] { paramObject })).booleanValue();
    }
    catch (RuntimeException localRuntimeException)
    {
      throw localRuntimeException;
    }
    catch (Throwable localThrowable)
    {
    }
    throw new UndeclaredThrowableException(localThrowable);
  }

  public final void move()
    throws Exception
  {
    try
    {
      this.h.invoke(this, m3, null);
      return;
    }
    catch (Exception localException)
    {
      throw localException;
    }
    catch (Throwable localThrowable)
    {
    }
    throw new UndeclaredThrowableException(localThrowable);
  }

  public final int hashCode()
    throws
  {
    try
    {
      return ((Integer)this.h.invoke(this, m0, null)).intValue();
    }
    catch (RuntimeException localRuntimeException)
    {
      throw localRuntimeException;
    }
    catch (Throwable localThrowable)
    {
    }
    throw new UndeclaredThrowableException(localThrowable);
  }

  public final String toString()
    throws
  {
    try
    {
      return (String)this.h.invoke(this, m2, null);
    }
    catch (RuntimeException localRuntimeException)
    {
      throw localRuntimeException;
    }
    catch (Throwable localThrowable)
    {
    }
    throw new UndeclaredThrowableException(localThrowable);
  }

  static
  {
    try
    {
      m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });
      m3 = Class.forName("cn.com.goser.proxy.imooc.staticproxy.Moveable").getMethod("move", new Class[0]);
      m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
      m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
      return;
    }
    catch (NoSuchMethodExceptionlocalNoSuchMethodException)
    {
      throw new NoSuchMethodError(localNoSuchMethodException.getMessage());
    }
    catch (ClassNotFoundExceptionlocalClassNotFoundException)
    {
    }
    throw new NoClassDefFoundError(localClassNotFoundException.getMessage());
  }
}

生成的字節碼比較長，但是在字節碼中最關鍵的信息是代理類的聲明：

public final class $Proxy1 extends Proxy

可以看到生成的代理類是繼承了Proxy類的，這就是說明了爲什麼使用JDK動態代理不能實現繼承式動態代理，原因是Java不允許多繼承，而生成的代理類本身就已經繼承了Proxy類。

至此，JDK的動態代理的使用及底層原理分析完畢，揭下動態代理的神祕面紗，果然是枚美女。

至於最底層的native方法是怎麼動態生成代理類的字節碼我們也可以簡單的模擬一下，先分析下模擬的步驟：首先要生成一段代理類的源碼，然後將源碼編譯後生成代理類的實例返回給調用者。依據此步驟開始編寫我們的模擬代碼：

/**
 * JDK java.lang.reflect.Proxy的模擬
 * @author Goser    (mailto:[email protected])
 * @Since 2016年9月7日
 */
public class Proxy {
    private static final String  RT = "\r\n";
    public static Object newProxyInstance() throws Exception{
        //聲明一段源碼
        String sourceCode =
        "packagecn.com.goser.proxy.jdk.simulate;"+ RT +
        "importcn.com.goser.proxy.imooc.staticproxy.Admin;" + RT +
        "importcn.com.goser.proxy.imooc.staticproxy.Manager;" + RT +
        "//以聚合方式實現的代理主題" + RT +
        "public class $Proxy0 implementsManager{" + RT +
        "   privateAdmin admin;" + RT +
        "   public$Proxy0(Admin admin) {" + RT +
        "       super();" + RT +
        "       this.admin= admin;" + RT +
        "   }" + RT +
        "   publicvoid doSomething() {" + RT +
        "       System.out.println(\"Log:admin操作開始\");" + RT +
        "       admin.doSomething();" + RT +
        "       System.out.println(\"Log:admin操作結束\");" + RT +
        "   }" + RT +
        "}";
        String filename = System.getProperty("user.dir") + "/src/main/java/cn/com/goser/proxy/jdk/simulate/$Proxy0.java";
        File file = new File(filename);
        //使用org.apache.commons.io.FileUtils.writeStringToFile()將源碼寫入磁盤
        //編寫到處，可以運行一下程序，可以在當前目錄中看到生成的.java文件
        FileUtils.writeStringToFile(file,sourceCode);
        //獲得當前系統中的編譯器
        JavaCompiler complier = ToolProvider.getSystemJavaCompiler();
        //獲得文件管理者
        StandardJavaFileManager fileMgr =complier.getStandardFileManager(null, null, null);
        Iterable its =fileMgr.getJavaFileObjects(filename);
        //編譯任務
        CompilationTask task = complier.getTask(null, fileMgr, null, null, null, its);
        //開始編譯，執行完可在當前目錄下看到.class文件
        task.call();
        fileMgr.close();
        //load到內存
        ClassLoader loader = ClassLoader.getSystemClassLoader();
        Class cls = loader.loadClass("cn.com.goser.proxy.jdk.simulate.$Proxy0");
        //生成代理類對象
        Constructor ct = cls.getConstructor(Admin.class);
        return ct.newInstance(new Admin());
    }
}
class test{
    public static void main(String[] args) throws Exception {
        Manager m = (Manager)Proxy.newProxyInstance();
        m.doSomething();
    }
}

運行測試代碼，結果和手工編寫的結果一致，完成了JDK中動態代理的實現模擬。

cglib動態代理

    前面分析到，因爲Java只允許單繼承，而JDK生成的代理類本身就繼承了Proxy類，因此，使用JDK實現的動態代理不能完成繼承式的動態代理，但是我們可以使用cglib來實現繼承式的動態代理。

大名鼎鼎的Spring中就含有cglib動態代理，在此也以Spring中自帶的cglib完成動態代理的實現：

//1.具體主題
public class Train{
    public void move(){
        System.out.println("火車行駛中…");
    }
}
//2.生成代理
public class CGLibProxy implements MethodInterceptor {
    private Enhancer enhancer = new Enhancer();
    public Object getProxy(Class<?> clazz){
        enhancer.setSuperclass(clazz);
        enhancer.setCallback(this);
        return enhancer.create();
    }
    /**
     * 攔截所有目標類方法的調用
     * 參數：
     * obj目標實例對象
     *method 目標方法的反射對象
     * args方法的參數
     * proxy代理類的實例
     */
    public Object intercept(Object obj, Method method, Object[] args,
            MethodProxy proxy) throws Throwable {
        //代理類調用父類的方法
        System.out.println("日誌開始");
        proxy.invokeSuper(obj, args);
        System.out.println("日誌結束");
        return null;
    }
}
//3.測試
public class Test {
    public static void main(String[] args) {
        CGLibProxy proxy = new CGLibProxy();
        Train t = (Train) proxy.getProxy(Train.class);
        t.move();
    }
}

小結

動態代理與靜態代理相比較，最大的好處是接口中聲明的所有方法都被轉移到調用處理器一個集中的方法中處理。在接口方法數量比較多的時候，我們可以進行靈活處理，而不需要像靜態代理那樣對每一個方法或方法組合進行處理。Proxy 很美很強大，但是僅支持 interface 代理。Java 的單繼承機制註定了這些動態代理類們無法實現對 class 的動態代理。好在有cglib爲Proxy提供了彌補。class與interface的區別本來就模糊，在java8中更是增加了一些新特性，使得interface越來越接近class，當有一日，java突破了單繼承的限制，動態代理將會更加強大。