天天看點
傳回

自己實作一個JDK動态代理

回顧JDK代理

Spring AOP 用到了兩種動态代理模式：JDK動态代理和CGLIB動态代理，兩種動态代理形成互補。今天我們來嘗試純手寫一個簡版的JDK動态代理，來了解它的底層實作原理。我們先來回顧一下JDK動态代理

動态代理的條件

  1. 兩個角色： 代理對象，被代理對象
  2. 代理對象需要完成被代理對象的需要完成的業務操作
  3. 代理對象持有被代理對象的引用
  4. JDK動态代理 被代理對象必須實作接口，CGLIB動态代理被代理類和方法不能用final修飾

實作代碼

  1. 被代理對象實作的目标接口 
package com.nqmysb.proxy.jdk;


/**
 * 目标接口
 * @author liaocan
 *
 */
public interface Subject {
    
    /*
     * 抽象業務方法
     */
    void businessMethod();

}
  1. 被代理的目标對象 
package com.nqmysb.proxy.jdk.impl;

import com.nqmysb.proxy.jdk.Subject;

/**
 * 具體的目标對象，實作目标接口的方法
 * @author liaocan
 *
 */
public class RealSubject implements Subject {

    @Override
    public void businessMethod() {
        System.out.println("我在進行具體的業務操作。。。。。。");
    }

}           
package com.nqmysb.proxy.jdk;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;

/**
 * 代理類，必須實作JDK中的InvocationHandler  這是JDK動态代理的标志
 * 可以了解：需要實作JDK的代理，必須要這個證書 
 * @author liaocan
 *
 */
public class DynamicProxy implements InvocationHandler {
    
    private Subject target; //被代理對象的引用  這裡是代理對象的接口  說明 該代理類是可以代理該接口下的所有子類的
    
    //動态生成代理對象
    public Object getInstance(Subject target) throws Exception{
        //擷取代理對象
        this.target = target;
        //代理的對象必須是 suject的實作類
        Class<? extends Subject> clazz = target.getClass();
        
        //被代理對象的class是:class com.nqmysb.proxy.jdk.impl.RealSubject
        System.out.println("被代理對象的class是:"+clazz);
        
        //被代理對象的類加載器:sun.misc.Launcher$AppClassLoader@20eb607d
        ClassLoader classLoader = clazz.getClassLoader();
        System.out.println("被代理對象的類加載器:"+classLoader);
        
        //被代理對象的class是:[Ljava.lang.Class;@602f892f  傳回所有實作接口的數組 [interface com.nqmysb.proxy.jdk.Subject]
        Class<?>[] classs = clazz.getInterfaces();
        System.out.println("被代理對象實作的接口:"+Arrays.asList(classs));
        //proxy的靜态方法 newProxyInstance
        // 參數說明：被代理對象的類加載器 clazz.getClassLoader  ,被代理對象實作的接口 clazz.getInterfaces() ,目前對象 this
        //this 參數傳入 把代理類和被代理類産生關聯 當要執行被代理對象的方法時 會自動調用代理對象invoke方法進行代理執行
        return Proxy.newProxyInstance(classLoader, classs, this);
    }
    

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        
        System.out.println("開始代理...");
        System.out.println("代理之前做的事情...");
        System.out.println("------------"); 
        
        //執行代理方法
        method.invoke(this.target, args);
        
        System.out.println("------------");
        System.out.println("代理之後做的事情...");
        System.out.println("結束代理...");
        return null;
    }
    

}
  1. JDK動态代理測試類 
package com.nqmysb.proxy.jdk;

import com.nqmysb.proxy.jdk.impl.RealSubject;
/**
 * JDK動态代理測試類
 * 
 * @author liaocan
 *
 */
public class DynamicProxyTest {

    public static void main(String[] args) {
        
    try {
                    
        Subject subject = (Subject)new DynamicProxy().getInstance(new RealSubject());
        System.out.println(subject.getClass());
        subject.businessMethod();

        } catch (Exception e) {
            e.printStackTrace();
        }

    }

}
  1. 運作結果如下 
被代理對象的class是:class com.nqmysb.proxy.jdk.impl.RealSubject
被代理對象的類加載器:sun.misc.Launcher$AppClassLoader@73d16e93
被代理對象實作的接口:[interface com.nqmysb.proxy.jdk.Subject]
class com.sun.proxy.$Proxy0
開始代理...
代理之前做的事情...
------------
我在進行具體的業務操作。。。。。。
------------
代理之後做的事情...
結束代理...

手寫JDK動态代理

JDK做了哪些事？

在自己手寫JDK動态代理之前我們分析一下JDK動态代理幫我們做了哪些事情？
  1. 代理類必須實作JDK中的java.lang.reflect.InvocationHandler接口，這個接口中隻有一個方法,如下： 
/**
 * @param   proxy the proxy instance that the method was invoked on
 * @param   method the {@code Method} instance corresponding to
 * the interface method invoked on the proxy instance.  
 * @param   args an array of objects containing the values of the
 * arguments passed in the method invocation on the proxy instance,
 */
 public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable;

代理類需要重寫和實作該方法，在這個方法裡面我們可以進行附加業務操作，再調用被代理對象的方法。進而對被代理對象的方法進行擴充。

  1. 生成代理類對象,代理類中的getInstance(Subject target)方法産生代理對象。關鍵代碼如下： 
/**
* 該方法傳入三個參數：1.類加載，用于加載動态生成代理類。2.被代理類實作的所有接口 3.代理類對象本身引用，用于回調我們實作的invoke方法 
*/
Proxy.newProxyInstance(classLoader, classs, this)

從上面兩點可以得出JDK動态代理幫我們生成了代理類，代理實作了被代理類的所有接口，并将代理類加載到JVM中，生成代理執行個體，并回調我們實作的invoke方法進行動态代理。

JDK給我們提供了 java.lang.reflect.InvocationHandler 接口和 java.lang.reflect.Proxy 代理類 其中JDK1.8版本中的Proxy類中有一個私有的靜态内部類 private static final class ProxyClassFactory 該類用于生成代理類的class對象。源代碼如下：

private static final class ProxyClassFactory
        implements BiFunction<ClassLoader, Class<?>[], Class<?>>
    {
        //$Proxy 作為代理類的标志
        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 class loader");
                }
          
                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;    
            int accessFlags = Modifier.PUBLIC | Modifier.FINAL;

 
            for (Class<?> intf : interfaces) {
                int flags = intf.getModifiers();
                if (!Modifier.isPublic(flags)) {
                    accessFlags = Modifier.FINAL;
                    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 from different packages");
                    }
                }
            }

            if (proxyPkg == null) {
                proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
            }

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

            //動态生成代理類class對象
            byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                proxyName, interfaces, accessFlags);
            try {
                return defineClass0(loader, proxyName,
                                    proxyClassFile, 0, proxyClassFile.length);
            } catch (ClassFormatError e) {
           
                throw new IllegalArgumentException(e.toString());
            }
        }
    }

手寫JDK動态代理代碼實作

前兩個要素不變：目标接口和目标實作類。 
package com.nqmysb.proxy.jdk;


/**
 * 目标接口
 * @author liaocan
 *
 */
public interface Subject {
    
    /*
     * 抽象業務方法
     */
    void businessMethod();

}           
package com.nqmysb.proxy.jdk.impl;

import com.nqmysb.proxy.jdk.Subject;

/**
 * 具體的目标對象，實作目标接口的方法
 * @author liaocan
 *
 */
public class RealSubject implements Subject {

    @Override
    public void businessMethod() {
        System.out.println("我在進行具體的業務操作。。。。。。");
    }

}
  1. 自定義類加載器 
package com.nqmysb.myproxy.proxytools;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.HashMap;


/**
 * 自定義類加載器
 * 
 * 作用：将我們動态生成的class檔案生成class對象加載JVM記憶體中
 * @author liaocan
 *
 */
public class MyClassLoader extends ClassLoader{
    
    private File baseDir;
    
    public MyClassLoader(){
        
        Class<MyClassLoader> clazz = MyClassLoader.class;
        String basePath = clazz.getResource("").getPath();
//        String basePath = clazz.getResource("/").getPath() +"com/nqmysb/myproxy/proxytools";
        this.baseDir = new java.io.File(basePath);
    }
    /**
     * 自定義類加載方法 ，加載自定義類
     */
    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        //擷取需要加載的類的全名  com.nqmysb.myproxy.proxytools.$Proxy0
        String className = MyClassLoader.class.getPackage().getName() + "." + name;
        if(baseDir != null){
            //擷取 class檔案對象 E:\workspace\spring-source-analysis\spring-source-proxy\bin\com\nqmysb\myproxy\proxytools\$Proxy0.class
            File classFile = new File(baseDir,name.replaceAll("\\.", "/") + ".class");
            if(classFile.exists()){
                FileInputStream in = null;
                ByteArrayOutputStream out = null;
                try{
                    in = new FileInputStream(classFile);
                    out = new ByteArrayOutputStream();
                    byte [] buff = new byte[1024];
                    int len;
                    while ((len = in.read(buff)) != -1) {
                        out.write(buff, 0, len);
                    }
                    //根據class檔案和類名生成class對象 并加載到JVM中
                    return defineClass(className, out.toByteArray(), 0,out.size());
                    
                }catch (Exception e) {
                    e.printStackTrace();
                }finally{
                    if(null != in){
                        try {
                            in.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                    if(null != out){
                        try {
                            out.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                    //删除Class檔案
                    classFile.delete();
                }
                
            }
        }
        
        return null;
    }
    
    /**
     * 測試了解Java類加載機制
     * 1.類加載器的作用：類加載器負責将class檔案讀入JVM記憶體，并為之生成對應的java.lang.Class對象。
     * java類加載器分為三類：
     * （Bootstrap ClassLoader） 啟動類加載器 ： 負責加載Java的核心類（如String、System等）, rt.jar
     *                             它比較特殊，因為它是由原生C++代碼實作的，并不是java.lang.ClassLoader的子類
     * （Extension ClassLoader ）擴充類加載器：它負責加載JRE的擴充目錄（%JAVA_HOME%/jre/lib/ext）中JAR包的類，java實作
     *                             我們可以通過把自己開發的類打包成JAR檔案放入擴充目錄來為Java擴充核心類以外的新功能。
     * （ApplicationClassLoader）應用程式類加載器：它負責在JVM啟動時加載來自Java指令的-classpath選項、java.class.path系統屬性，java實作
     *                             或CLASSPATH環境變量所指定的JAR包和類路徑。程式可以通過ClassLoader的靜态方法getSystemClassLoader來擷取系統類加載器：
     * 
     * 類加載機制之雙親委派
     *        加載類時 會現遞歸交于父類加載器加載，如果所有父類沒有加載才有自己加載，好處防止類的重複加載
     * 
     */
    
    public static void main(String[] args) {
        //（Bootstrap ClassLoader） 啟動類加載器 ： 負責加載Java的核心類（如String、System等）rt.jar
        //它比較特殊，因為它是由原生C++代碼實作的，并不是java.lang.ClassLoader的子類 是以輸出結果為null
        //Returns the class loader for the class.  Some implementations may use
        //null to represent the bootstrap class loader. This method will return
        //null in such implementations if this class was loaded by the bootstrap
        //class loader.
        System.out.println(String.class.getClassLoader());
        System.out.println(HashMap.class.getClassLoader());
        
        //sun.misc.Launcher$AppClassLoader
        System.out.println(MyClassLoader.class.getClassLoader().getClass().getName());

        //sun.misc.Launcher$AppClassLoader
        System.out.println(ClassLoader.getSystemClassLoader().getClass().getName());

        
        
    }

}
  1. 自定義 InvocationHandler 接口 
package com.nqmysb.myproxy.proxytools;

import java.lang.reflect.Method;

public interface MyInvocationHandler {

    Object invoke(Object proxy, Method method, Object[] args) throws Throwable;

}
  1. 自定義 Proxy 代理類 
package com.nqmysb.myproxy.proxytools;

import java.io.File;
import java.io.FileWriter;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

import javax.tools.JavaCompiler;
import javax.tools.JavaCompiler.CompilationTask;
import javax.tools.JavaFileObject;
import javax.tools.StandardJavaFileManager;
import javax.tools.ToolProvider;
/**
 * 自己實作的Proxy  對應JDK中的java.lang.reflect.Proxy類
 * 
 * @author liaocan
 *
 */
public class MyProxy {
    
    //換行符
    private static String ln = "\r\n";


    /**
     * 生成代理類對象  
     *  對應JDK中Proxy的newProxyInstance方法生成代理類對象
     *  JDK1.8中的實作是：通過Proxy 中的的靜态内部類ProxyClassFactory =>(private static final class ProxyClassFactory)中的apply方法
     *  注意：JDK1.7中是通過getProxyClass()方法實作 有點小差別 但是核心代碼大緻相同
     *  核心代碼如下：
     *      //所有代理類的字首
     *      private static final String proxyClassNamePrefix = "$Proxy";
     *      //代理類的序号
     *      long num = nextUniqueNumber.getAndIncrement();
     *      //代理類的全名
     *      String proxyName = proxyPkg + proxyClassNamePrefix + num;
     *      //生成代理類class位元組碼檔案 ,反編譯生成的class檔案可以發現代理類繼承Proxy類實作了被代理類的implements的所有接口 =>(public final class $Proxy0 extends Proxy  implements Subject ) 
     *      //generateProxyClass()可以再看看具體實作
     *      byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces, accessFlags);
     *      try {
     *      //根據class位元組碼生成執行個體對象
     *          return defineClass0(loader, proxyName,proxyClassFile, 0, proxyClassFile.length);
     *         } 
     *          
     * @param classLoader
     * @param interfaces
     * @param myInvocationHandler
     * @return
     */
    public static Object newProxyInstance(MyClassLoader classLoader,Class<?>[] interfaces,MyInvocationHandler myInvocationHandler){
        
        
        try{
            //1、動态生成代理類的源代碼 .java檔案
            String proxySrc = generateSrc(interfaces[0]);
            
            
            //2、将生成的源代碼輸出到磁盤，儲存為.java檔案
            String filePath = MyProxy.class.getResource("").getPath(); //打jar包之後抛空指針
//            String filePath = MyProxy.class.getResource("/").getPath() +"com/nqmysb/myproxy/proxytools/";
            File f = new File(filePath + "$Proxy0.java");
            FileWriter fw = new FileWriter(f);
            fw.write(proxySrc);
            fw.flush();
            fw.close();
        
            //3、編譯源代碼，并且生成.class檔案
            JavaCompiler  compiler = ToolProvider.getSystemJavaCompiler();
            StandardJavaFileManager manager = compiler.getStandardFileManager(null, null, null);
            Iterable<? extends JavaFileObject> iterable = manager.getJavaFileObjects(f);
            
            CompilationTask task = compiler.getTask(null, manager, null, null, null, iterable);
            task.call();
            manager.close();
        
            //4.将class檔案中的内容，動态加載到JVM中來
            
            //5.傳回被代理後的代理類class對象
            Class<?> proxyClass = classLoader.findClass("$Proxy0");
            //通過class對象和參數擷取指定構造對象 
            Constructor<?> c = proxyClass.getConstructor(MyInvocationHandler.class);
            //删除Java檔案
            f.delete();
            
            return c.newInstance(myInvocationHandler);
            
        }catch (Exception e) {
            e.printStackTrace();
        }
        
        
        return null;
    }
    
    /**
     * 
     * 動态生成代理類的.java檔案的代碼内容
     * @param interfaces
     * @return
     */
    private static String generateSrc(Class<?> interfaces){
        StringBuffer src = new StringBuffer();
        //代理類包名
        src.append("package com.nqmysb.myproxy.proxytools;" + ln);
        //導入反射包method類  
        src.append("import java.lang.reflect.Method;" + ln);
        //聲明類名 實作被代理類的接口這裡簡化處理隻實作一個接口, JDK中生成的代理類會繼承proxy類 實作被代理類的所有接口
        src.append("public class $Proxy0 implements " + interfaces.getName() + "{" + ln);
        //生成代理類中持有MyInvocationHandler引用
        //JDK中InvocationHandler是Proxy中的成員變量=>(protected InvocationHandler h;)
        //生成的代理類繼承Proxy也繼承了它的protected的成員變量,我們自己生成的代理類沒有繼承Proxy 所有需要自己提供
        src.append("MyInvocationHandler h;" + ln);
        //代理類中構造方法中傳入MyInvocationHandler給InvocationHandler初始化
        src.append("public $Proxy0(MyInvocationHandler h) {" + ln);
        src.append("this.h = h;" + ln);
        src.append("}" + ln);
        //生成所有代理方法
        for (Method m : interfaces.getMethods()) {
            src.append("public " + m.getReturnType().getName() + " " + m.getName() + "(){" + ln);
            src.append("try{" + ln);
            //通過代理方法對象
            src.append("Method m = " + interfaces.getName() + ".class.getMethod(\"" +m.getName()+"\",new Class[]{});" + ln);
            //調用代理方法
            src.append("this.h.invoke(this,m,null);" + ln);
            src.append("}catch(Throwable e){e.printStackTrace();}" + ln);
            src.append("}" + ln);
        }
        
        src.append("}");
        System.out.println("動态生成的代理類$Proxy0:"+ln+src);
        /*
        生成代理類如下：
        package com.nqmysb.myproxy.proxytools;
        
        import java.lang.reflect.Method;
        
        public class $Proxy0 implements com.nqmysb.myproxy.Subject{
        
        MyInvocationHandler h;
        
        public $Proxy0(MyInvocationHandler h) {
            this.h = h;
        }
        
        public void businessMethod(){
        try{
            
                Method m = com.nqmysb.myproxy.Subject.class.getMethod("businessMethod",new Class[]{});
                //此處調用的其實就是傳入的com.nqmysb.myproxy.MyDynamicProxy對象的invoke方法
                //然後再在invoke中對代理對象的方法前後進行業務方法操作
                this.h.invoke(this,m,null);
                
                }catch(Throwable e){
                e.printStackTrace();
                }
            }
        }
        */
        return src.toString();
    }

}
  1. 使用自己手寫的動态代理 
package com.nqmysb.myproxy;

import java.lang.reflect.Method;
import java.util.Arrays;

import com.nqmysb.myproxy.proxytools.MyClassLoader;
import com.nqmysb.myproxy.proxytools.MyInvocationHandler;
import com.nqmysb.myproxy.proxytools.MyProxy;

/**
 * 代理類，必須實作JDK中的InvocationHandler  這是JDK動态代理的标志
 * 可以了解：需要實作JDK的代理，必須要這個證書 
 * @author liaocan
 *
 */
public class MyDynamicProxy implements MyInvocationHandler {
    
    private Subject target; //被代理對象的引用  這裡是代理對象的接口  說明 該代理類是可以代理該接口下的所有子類的
    
    //動态生成代理對象
    public Object getInstance(Subject target) throws Exception{
        //擷取代理對象
        this.target = target;
        //代理的對象必須是 suject的實作類
        Class<? extends Subject> clazz = target.getClass();
        //擷取被代理類實作的所有接口  從這裡可以看出如果被代理類沒有實作接口，是無法使用JDK動态代理的
        Class<?>[] classs = clazz.getInterfaces();
        System.out.println("被代理對象實作的接口:"+Arrays.asList(classs));
        return MyProxy.newProxyInstance(new MyClassLoader(), classs, this);
    }
    

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        
        System.out.println("開始代理...");
        System.out.println("代理之前做的事情...");
        System.out.println("------------"); 
        
        //執行代理方法
        method.invoke(this.target, args);
        
        System.out.println("------------");
        System.out.println("代理之後做的事情...");
        System.out.println("結束代理...");
        return null;
    }
    

}
  1. 測試動态代理 
package com.nqmysb.myproxy;

import com.nqmysb.myproxy.impl.RealSubject;

/**
 * 手寫JDK動态代理測試類
 * 
 * 
 * @author liaocan
 *
 */
public class MyDynamicProxyTest {

    public static void main(String[] args) {
        
    try {
            
            Subject subject = (Subject)new MyDynamicProxy().getInstance(new RealSubject());
            System.out.println(subject.getClass());
            subject.businessMethod();


        } catch (Exception e) {
            e.printStackTrace();
        }

    }

}
  1. 運作結果 
被代理對象實作的接口:[interface com.nqmysb.myproxy.Subject]
動态生成的代理類$Proxy0:
package com.nqmysb.myproxy.proxytools;
import java.lang.reflect.Method;
public class $Proxy0 implements com.nqmysb.myproxy.Subject{
MyInvocationHandler h;
public $Proxy0(MyInvocationHandler h) {
this.h = h;
}
public void businessMethod(){
try{
Method m = com.nqmysb.myproxy.Subject.class.getMethod("businessMethod",new Class[]{});
this.h.invoke(this,m,null);
}catch(Throwable e){e.printStackTrace();}
}
}
class com.nqmysb.myproxy.proxytools.$Proxy0
開始代理...
代理之前做的事情...
------------
我在進行具體的業務操作。。。。。。
------------
代理之後做的事情...
結束代理...

總結

動态代理的底層實作的原理：

  1. 反射機制：擷取被代理類的方法，并實作動态位元組碼重組生成新的代理類

    值得注意：JDK動态代理和CGLIB動态代理使用的反射機制是不一樣的，

分别是：java.lang.reflect.Method和net.sf.cglib.reflect.FastClass 類實作的

  1. 函數回調機制：将代理類需要執行的附加方法傳入新生成的代理類中，執行被代理類方法時會回調代理類的方法

代碼工程

github位址：

https://github.com/nqmysb/spring-source-analysis
前端開發 java c++ spring 移動開發 java前端開發 jdk架構 java移動開發 java前端 java前端問題
上一篇: Java實作的公網映射内網端口的開源工具What is holerHow it worksSupport
下一篇: 資料結構小記

繼續閱讀