1. 程式人生 > >java基礎學習總結(二十一):自己寫一個java.lang.reflect.Proxy代理的實現

java基礎學習總結(二十一):自己寫一個java.lang.reflect.Proxy代理的實現

     動態代理裡面用到了一個類就是java.lang.reflect.Proxy,這個類是根據代理內容為傳入的介面生成代理用的。本文就自己寫一個Proxy類出來,功能和java.lang.reflect.Proxy一樣,傳入介面、代理內容,生成代理。

 動態代理的實現應用到的技術

      1、動態編譯技術,可以使用Java自帶的JavaCompiler類,也可以使用CGLIB、ASM等位元組碼增強技術,Java的動態代理包括Spring的內部實現貌似用的都是這個

      2、反射,包括對於類.class和getClass()方法的理解,Method類、Constructor類的理解

     3、IO流,主要就是字元輸出流FileWriter

     4、對於ClassLoader的理解

基礎類

先把基礎類定義在這兒,首先是一個HelloWorld介面:

public interface HelloWorld
{
    void print();
}

HelloWorld介面的實現類:

public class HelloWorldImpl implements HelloWorld
{
    public void print()
    {
        System.out.println("Hello World");
    }
}

為這個介面寫一個簡單的靜態代理類:

public class StaticProxy implements HelloWorld
{
    private HelloWorld helloWorld;
    
    public StaticProxy(HelloWorld helloWorld)
    {
        this.helloWorld = helloWorld;
    }
    
    public void print()
    {
        System.out.println("Before Hello World!");
        helloWorld.print();
        System.out.println("After Hello World!");
    }
}

版本1:為一個靜態代理動態生成一個代理類

      我們知道如果用靜態代理的話,那麼每個介面都要為之寫一個.java的代理類,這樣就可能造成代理類無限膨脹,如果可以讓Java幫我們自動生成一個就好了,不過還真的可以,看下第一個版本的程式碼:

package proxy;

import javax.tools.JavaCompiler;
import javax.tools.JavaFileObject;
import javax.tools.StandardJavaFileManager;
import javax.tools.ToolProvider;
import java.io.File;
import java.io.FileWriter;
import java.io.Serializable;
import java.io.Writer;
import java.lang.reflect.Constructor;
import java.net.URL;
import java.net.URLClassLoader;

/**
 * @author of  laomumu
 * @create 2018-10-22 14:59
 **/
public class ProxyVersion_0 implements Serializable {

    private static final  long serialVersionUID = 1L;

    public static  Object newProxyInstance() throws Exception{

        String src = "package proxy;\n\n" +
                "public class StaticProxy implements HelloWorld\n" +
                "{\n" +
                "\tHelloWorld helloWorld;\n\n" +
                "\tpublic StaticProxy(HelloWorld helloWorld)\n" +
                "\t{\n" +
                "\t\tthis.helloWorld = helloWorld;\n" +
                "\t}\n\n" +
                "\tpublic void print()\n" +
                "\t{\n" +
                "\t\tSystem.out.println(\"Before Hello World!\");\n" +
                "\t\thelloWorld.print();\n" +
                "\t\tSystem.out.println(\"After Hello World!\");\n" +
                "\t}\n" +
                "}";
        /** 生成一段Java程式碼 */
        String fileDir = System.getProperty("user.dir");
        String fileName = fileDir + "\\src\\main\\java\\proxy\\StaticProxy.java";
        File javaFile = new File(fileName);
        Writer writer = new FileWriter(javaFile);
        writer.write(src);
        writer.close();
        /** 動態編譯這段Java程式碼,生成.class檔案 */
        JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
        StandardJavaFileManager sjfm = compiler.getStandardFileManager(null, null, null);
        Iterable<? extends JavaFileObject> iter = sjfm.getJavaFileObjects(fileName);
        JavaCompiler.CompilationTask ct = compiler.getTask(null, sjfm, null, null, null, iter);
        ct.call();
        sjfm.close();
        /** 將生成的.class檔案載入記憶體,預設的ClassLoader只能載入CLASSPATH下的.class檔案 */
        URL[] urls = new URL[] {(new URL("file:\\" + System.getProperty("user.dir") + "\\src"))};
        URLClassLoader ul = new URLClassLoader(urls);
        Class<?> c = ul.loadClass("proxy.StaticProxy");
        /** 利用反射將c例項化出來 */
        Constructor<?> constructor = c.getConstructor(HelloWorld.class);
        HelloWorld helloWorldImpl = new HelloWorldImpl();
        HelloWorld helloWorld = (HelloWorld)constructor.newInstance(helloWorldImpl);
        /** 使用完畢刪除生成的代理.java檔案和.class檔案,這樣就看不到動態生成的內容了 */
        File classFile = new File(fileDir + "\\src\\main\\java\\proxy\\StaticProxy.class");
        javaFile.delete();
        classFile.delete();
        return helloWorld;
    }

}

每一步的註釋都在上面了,解釋一下大致思路:

1、我們在另外一個類裡面自己拼一段靜態代理的程式碼的字串

2、為這個字串生成一個.java檔案,並放在我們工程的某個目錄下面,因為是.java檔案,所以在src下

3、利用JavaCompiler類動態編譯這段.java程式碼使之被編譯成一個.class檔案,JavaCompiler不熟悉沒關係,知道就好了

4、因為在src下生成編譯之後的.java檔案,而預設的ClassLoader只能載入CLASSPATH下的.class檔案,所以用URLClassLoader

5、由於代理類只有一個帶引數的構造方法,所以要用java.lang.reflect.Constructor

6、最後把生成的StaticProxy.class檔案刪除(最好生成的StaticProxy.java也刪除,這裡沒刪除,是因為StaticProxy是生成的一個重要的中間類,功能都在它這兒,所以不刪,出了錯都要靠看這個類來定位問題的),這樣代理的中間內容都沒了,把反射newInstance()出來的內容返回出去就大功告成了

可以自己看一下生成的StaticProxy.java對不對,寫一段程式碼測試一下:

public static void main(String[] args) throws Exception
{    
    long start = System.currentTimeMillis();
    HelloWorld helloWorld = (HelloWorld)ProxyVersion_0.newProxyInstance();
    System.out.println("動態生成代理耗時:" + (System.currentTimeMillis() - start) + "ms");
    helloWorld.print();
    System.out.println();        
}

結果為:

動態代理耗時:827ms
Before Hello World!
Hello World
After Hello World!

   沒有問題。可能有些人執行會報錯"Exception in thread "main" java.lang.ClassNotFoundException: proxy.StaticProxy",沒關係,那是因為雖然你的src目錄下生成了StaticProxy.class,但沒有出來,點選src資料夾,再按F5(或者右鍵,點選Refresh也行)重新整理一下就可以了。或者將StaticProxy.class檔案刪除重新執行。

版本二:為指定介面生成代理類

    版本一已經實現了動態生成一個代理的.class檔案了,算是成功的第一步,接下來要做進一步的改進。版本一隻可以為固定的一個介面生成代理,現在改進成,傳入某個介面的java.lang.Class物件,可以為這個介面及裡面的方法都生成代理內容,程式碼這麼寫:

package proxy;

import javax.tools.JavaCompiler;
import javax.tools.JavaFileObject;
import javax.tools.StandardJavaFileManager;
import javax.tools.ToolProvider;
import java.io.File;
import java.io.FileWriter;
import java.io.Serializable;
import java.io.Writer;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.net.URL;
import java.net.URLClassLoader;

/**
 * 
 * @create 2018-10-22 15:41
 **/
public class ProxyVersion_1 implements Serializable {

    private static final long serialVersionUID = 1L;

    public static Object newProxyInstance(Class<?> interfaces) throws Exception {
        Method[] methods = interfaces.getMethods();

        StringBuilder sb = new StringBuilder(700);

        sb.append("package proxy;\n\n");
        sb.append("public class StaticProxy implements " + interfaces.getSimpleName() + "\n");
        sb.append("{\n");
        sb.append("\t" + interfaces.getSimpleName() + " interfaces;\n\n");
        sb.append("\tpublic StaticProxy(" + interfaces.getSimpleName() + " interfaces)\n");
        sb.append("\t{\n");
        sb.append("\t\tthis.interfaces = interfaces;\n");
        sb.append("\t}\n\n");
        for (Method m : methods) {
            sb.append("\tpublic " + m.getReturnType() + " " + m.getName() + "()\n");
            sb.append("\t{\n");
            sb.append("\t\tSystem.out.println(\"Before Hello World!\");\n");
            sb.append("\t\tinterfaces." + m.getName() + "();\n");
            sb.append("\t\tSystem.out.println(\"After Hello World!\");\n");
            sb.append("\t}\n");
        }
        sb.append("}");

        /** 生成一段Java程式碼 */
        String fileDir = System.getProperty("user.dir");
        String fileName = fileDir + "\\src\\main\\java\\proxy\\StaticProxy.java";
        File javaFile = new File(fileName);
        Writer writer = new FileWriter(javaFile);
        writer.write(sb.toString());
        writer.close();
        /** 動態編譯這段Java程式碼,生成.class檔案 */
        JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
        StandardJavaFileManager sjfm = compiler.getStandardFileManager(null, null, null);
        Iterable<? extends JavaFileObject> iter = sjfm.getJavaFileObjects(fileName);
        JavaCompiler.CompilationTask ct = compiler.getTask(null, sjfm, null, null, null, iter);
        ct.call();
        sjfm.close();
        /** 將生成的.class檔案載入記憶體,預設的ClassLoader只能載入CLASSPATH下的.class檔案 */
        URL[] urls = new URL[]{(new URL("file:\\" + System.getProperty("user.dir") + "\\src"))};
        URLClassLoader ul = new URLClassLoader(urls);
        Class<?> c = ul.loadClass("proxy.StaticProxy");
        /** 利用反射將c例項化出來 */
        Constructor<?> constructor = c.getConstructor(HelloWorld.class);
        HelloWorld helloWorldImpl = new HelloWorldImpl();
        Object obj = constructor.newInstance(helloWorldImpl);
        /** 使用完畢刪除生成的代理.java檔案和.class檔案,這樣就看不到動態生成的內容了 */
         /*File classFile = new File(fileDir + "\\src\\com\\xrq\\proxy\\StaticProxy.class");
        javaFile.delete();
        classFile.delete();*/
        return obj;
    }

}

      看到下面都沒有變化,變化的地方就是在生成StaticProxy.java的地方,通過反射獲取介面及方法的資訊,這個版本的改進應該很好理解,寫一段程式碼測試一下:

public static void main(String[] args) throws Exception
{    
    long start = System.currentTimeMillis();
    HelloWorld helloWorld = (HelloWorld)ProxyVersion_1.newProxyInstance(HelloWorld.class);
    System.out.println("動態生成代理耗時:" + (System.currentTimeMillis() - start) + "ms");
    helloWorld.print();
    System.out.println();
}

執行結果為:

動態生成代理耗時:883ms
Before Hello World!
Hello World
After Hello World!

版本三:讓代理內容可複用

       接下來要到最後一個版本了,版本二解決的問題是可以為任何介面生成代理,那最後一個版本要解決的問題自然是可以為任何介面生成任何代理的問題了,首先定義一個介面InvocationHandler,這麼起名字是因為JDK提供的代理例項處理程式的介面也是InvocationHandler:

public interface InvocationHandler
{
    void invoke(Object proxy, Method method) throws Exception;
}

所以我們的Proxy類也要修改了,改為:

public class ProxyVersion_2 implements Serializable
{
    private static final long serialVersionUID = 1L;
    
    public static Object newProxyInstance(Class<?> interfaces, InvocationHandler h) throws Exception
    {
        Method[] methods = interfaces.getMethods();        
        StringBuilder sb = new StringBuilder(1024);
        
        sb.append("package proxy;\n\n");
        sb.append("import java.lang.reflect.Method;\n\n");
        sb.append("public class $Proxy1 implements " +  interfaces.getSimpleName() + "\n");
        sb.append("{\n");
        sb.append("\tInvocationHandler h;\n\n");
        sb.append("\tpublic $Proxy1(InvocationHandler h)\n");
        sb.append("\t{\n");
        sb.append("\t\tthis.h = h;\n");
        sb.append("\t}\n\n");
        for (Method m : methods)
        {
            sb.append("\tpublic " + m.getReturnType() + " " + m.getName() + "()\n");
            sb.append("\t{\n");
            sb.append("\t\ttry\n");
            sb.append("\t\t{\n");
            sb.append("\t\t\tMethod md = " + interfaces.getName() + ".class.getMethod(\"" + m.getName() + "\");\n");
            sb.append("\t\t\th.invoke(this, md);\n");
            sb.append("\t\t}\n");
            sb.append("\t\tcatch (Exception e)\n");
            sb.append("\t\t{\n");
            sb.append("\t\t\te.printStackTrace();\n");
            sb.append("\t\t}\n");
            sb.append("\t}\n");
        }
        sb.append("}");
        
        /** 生成一段Java程式碼 */
        String fileDir = System.getProperty("user.dir");
        String fileName = fileDir + "\\src\\main\\java\\proxy\\$Proxy1.java";
        File javaFile = new File(fileName);
        Writer writer = new FileWriter(javaFile);
        writer.write(sb.toString());
        writer.close();
        
        /** 動態編譯這段Java程式碼,生成.class檔案 */
        JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
        StandardJavaFileManager sjfm = compiler.getStandardFileManager(null, null, null);
        Iterable<? extends JavaFileObject> iter = sjfm.getJavaFileObjects(fileName);
        CompilationTask ct = compiler.getTask(null, sjfm, null, null, null, iter);
        ct.call();
        sjfm.close();
        
        /** 將生成的.class檔案載入記憶體,預設的ClassLoader只能載入CLASSPATH下的.class檔案 */
        URL[] urls = new URL[] {(new URL("file:\\" + System.getProperty("user.dir") + "\\src"))};
        URLClassLoader ul = new URLClassLoader(urls);
        Class<?> c = Class.forName("proxy.$Proxy1", false, ul);
        
        /** 利用反射將c例項化出來 */
        Constructor<?> constructor = c.getConstructor(InvocationHandler.class);
        Object obj = constructor.newInstance(h);
        
        /** 使用完畢刪除生成的代理.java檔案和.class檔案,這樣就看不到動態生成的內容了 */
        File classFile = new File(fileDir + "\\src\\main\\java\\proxy\\$Proxy1.class");
        javaFile.delete();               
        classFile.delete();
        
        return obj;
    }
}

 

最明顯的變化,代理的名字變了,從StaticProxy變成了 Proxy1,因為JDK也是這麼命名的,用過代理的應該有印象。這個改進中拼接Proxy1,因為JDK也是這麼命名的,用過代理的應該有印象。這個改進中拼接Proxy1的.java檔案是一個難點,不過我覺得可以不用糾結在這裡,關注重點,看一下生成的$Proxy1.java的內容是什麼:

public class $Proxy1 implements HelloWorld
{
    InvocationHandler h;

    public $Proxy1(InvocationHandler h)
    {
        this.h = h;
    }

    public void print()
    {
        try
        {
            Method md = proxy.HelloWorld.class.getMethod("print");
            h.invoke(this, md);
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }
}

       看到,我們把對於待生成代理的介面方法的呼叫,變成了對於InvocationHandler介面實現類的invoke方法的呼叫(這就是動態代理最關鍵的一點),並傳入了待呼叫的介面方法,這樣不就實現了我們的要求了嗎?我們InvocationHandler介面的實現類寫invoke方法的具體實現,傳入的第二個引數md.invoke就是呼叫被代理物件的方法,在這個方法前後都是代理內容,想加什麼加什麼,不就實現了動態代理了?所以,我們看一個InvocationHandler實現類的寫法:

public class HelloInvocationHandler implements InvocationHandler
{
    private Object obj;
    
    public HelloInvocationHandler(Object obj)
    {
        this.obj = obj;
    }
    
    public void invoke(Object proxy, Method method)
    {
        System.out.println("Before Hello World!");
        try
        {
            method.invoke(obj, new Object[]{});
        } 
        catch (Exception e)
        {
            e.printStackTrace();
        }
        System.out.println("After Hello World!");
    }
}

寫個main函式測試一下:

public static void main(String[] args) throws Exception
{    
    long start = System.currentTimeMillis();
    HelloWorld helloWorldImpl = new HelloWorldImpl();
    InvocationHandler ih = new HelloInvocationHandler(helloWorldImpl);
    HelloWorld helloWorld = (HelloWorld)ProxyVersion_2.newProxyInstance(HelloWorld.class, ih);
    System.out.println("動態生成代理耗時:" + (System.currentTimeMillis() - start) + "ms");
    helloWorld.print();
    System.out.println();
}

執行結果為:

動態生成代理耗時:909ms
Before Hello World!
Hello World
After Hello World!

沒有問題。

後記

雖然我們自己寫了Proxy,但是JDK絕對不會用這種方式實現,原因無他,就是太慢。看到三個版本的程式碼,執行時間都在300ms以上,效率如此低的實現,如何能給開發者使用?我拿JDK提供的Proxy和InvocationHandler自己寫了一個簡單的動態代理,耗時基本只在5ms左右。