java動態代理源碼解析

眾所周知，java動態代理同反射原理一直是許多框架的底層實現，之前一直沒有時間來分析動態代理的底層源碼，現結合源碼分析一下動態代理的底層實現

類和接口

java動態代理的主要類和接口有：java.lang.reflect.Proxy、java.lang.reflect.InvocationHandler

1 java.lang.reflect.Proxy：動態代理機制的主類，提供一組靜態方法為一組接口動態的生成對象和代理類。

1、public static InvocationHandler getInvocationHandler(Object var0) -> 該方法用於獲取指定代理對象所關聯的調用處理器

2、public static Class<?> getProxyClass(ClassLoader var0, Class... var1) -> 該方法用於獲取關聯於指定類裝載器和一組接口的動態代理類的類對象

3、public static Object newProxyInstance(ClassLoader var0, Class<?>[] var1, InvocationHandler var2) ->方法用於為指定類裝載器、一組接口及調用處理器生成動態代理類實例

 

2  java.lang.reflect.InvocationHandler：調用處理器接口，自定義invoke方法，用於實現對於真正委托類的代理訪問

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

3  java.lang.ClassLoader：類裝載器類

　將類的字節碼裝載到 Java 虛擬機（JVM）中並為其定義類對象，然后該類才能被使用。Proxy類與普通類的唯一區別就是其字節碼是由 JVM 在運行時動態生成的而非預存在於任何一個 .class 文件中。

 demo

public interface HelloService {
    void sayHello();
}

public class HelloServiceImpl implements HelloService{
    @Override
    public void sayHello() {
        System.out.println("hello 張三");
    }
}

public class HelloServiceProxy implements InvocationHandler{
    private Object target;

    public Object bind(Object target, Class[] interfaces) {
        this.target = target;
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(),this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object result;
        System.out.println("###########這里是動態代理##########");
        //反射方法前調用
        System.out.println("調用前");
        //反射執行方法  相當於調用target.sayHelllo;
        result = method.invoke(target,args);
        //反射方法后調用.
        System.out.println("調用后");

        return result;
    }
}

public class ProxyTest {

    public static void main(String[] args) {
        HelloServiceProxy proxy = new HelloServiceProxy();
        HelloService service = new HelloServiceImpl();
        HelloService serviceProxy = (HelloService)proxy.bind(service, new Class[] {HelloService.class});

        serviceProxy.sayHello();
    }
}

運行結果：

 源碼分析：

1 Proxy類的靜態方法newProxyInstance方法

    public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException
    {
        //驗證傳入的InvocationHandler是否為空
        Objects.requireNonNull(h);
        
        //克隆代理類實現的接口
        final Class<?>[] intfs = interfaces.clone();
        //獲得安全管理器
        final SecurityManager sm = System.getSecurityManager();
        //檢查創建代理類所需的權限
        if (sm != null) {
            checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
        }

        /*
         * Look up or generate the designated proxy class.
         * 查找或者生成特定的代理類（如果緩存中存在，則直接獲取）
         */
    
        Class<?> cl = getProxyClass0(loader, intfs);

        /*
         * Invoke its constructor with the designated invocation handler.
         */
        try {
            //權限校驗
            if (sm != null) {
                checkNewProxyPermission(Reflection.getCallerClass(), cl);
            }
            //獲取參數類型是InvocationHandler.class的代理類構造器
            final Constructor<?> cons = cl.getConstructor(constructorParams);
            final InvocationHandler ih = h;
            //如果代理類是不可訪問的, 就使用特權將它的構造器設置為可訪問
            if (!Modifier.isPublic(cl.getModifiers())) {
                AccessController.doPrivileged(new PrivilegedAction<Void>() {
                    public Void run() {
                        cons.setAccessible(true);
                        return null;
                    }
                });
            }
            //傳入InvocationHandler實例去構造一個代理類的實例,所有代理類都繼承自Proxy,而Proxy構造方法需要InvocationHandler實例作為參數
            return cons.newInstance(new Object[]{h});
        } catch (IllegalAccessException|InstantiationException e) {
            throw new InternalError(e.toString(), e);
        } catch (InvocationTargetException e) {
            Throwable t = e.getCause();
            if (t instanceof RuntimeException) {
                throw (RuntimeException) t;
            } else {
                throw new InternalError(t.toString(), t);
            }
        } catch (NoSuchMethodException e) {
            throw new InternalError(e.toString(), e);
        }
    }

  從newProxyInstance方法看出，產生代理類核心代碼在getProxyClass0

2 Proxy類的靜態方法getProxyClass0方法

    private static Class<?> getProxyClass0(ClassLoader loader,
                                           Class<?>... interfaces) {
        if (interfaces.length > 65535) {
            throw new IllegalArgumentException("interface limit exceeded");
        }

        // If the proxy class defined by the given loader implementing
        // the given interfaces exists, this will simply return the cached copy;
        // otherwise, it will create the proxy class via the ProxyClassFactory
        //如果由實現給定接口的代理類存在，這將簡單地返回緩存的副本;否則,將通過ProxyClassFactory創建代理類
        return proxyClassCache.get(loader, interfaces);
    }

getProxyClass0通過類加載器和接口集合去緩存里面獲取，如果能找到代理類就直接返回，否則就會調用ProxyClassFactory這個工廠去生成一個代理類，下面我們看下Proxy的靜態內部類ProxyClassFactory

3 ProxyClassFactory

private static final class ProxyClassFactory
        implements BiFunction<ClassLoader, Class<?>[], Class<?>>
    {
        // prefix for all proxy class names 代理類名稱前綴
        private static final String proxyClassNamePrefix = "$Proxy";

        // next number to use for generation of unique proxy class names, 用原子類來生成代理類的序號, 保證序號唯一
        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) {
                /*
                 * Verify that the class loader resolves the name of this
                 * interface to the same Class object.
                 */
                Class<?> interfaceClass = null;
                try {
                    interfaceClass = Class.forName(intf.getName(), false, loader);
                } catch (ClassNotFoundException e) {
                }
                //intf是否可以由指定的類加載進行加載
                if (interfaceClass != intf) {
                    throw new IllegalArgumentException(
                        intf + " is not visible from class loader");
                }
                /*
                 * Verify that the Class object actually represents an
                 * interface.
                 * intf是否是一個接口
                 */
                if (!interfaceClass.isInterface()) {
                    throw new IllegalArgumentException(
                        interfaceClass.getName() + " is not an interface");
                }
                /*
                 * Verify that this interface is not a duplicate.
                 * intf在數組中是否有重復
                 */
                if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
                    throw new IllegalArgumentException(
                        "repeated interface: " + interfaceClass.getName());
                }
            }
            // package to define proxy class in 生成代理類的包名
            String proxyPkg = null;
            // 代理類的訪問標志, 默認是public final
            int accessFlags = Modifier.PUBLIC | Modifier.FINAL;

            /*
             * Record the package of a non-public proxy interface so that the
             * proxy class will be defined in the same package.  Verify that
             * all non-public proxy interfaces are in the same package.
             * 驗證所有非公共代理接口都在同一個包中
             */
            for (Class<?> intf : interfaces) {
                //獲取接口的訪問標志
                int flags = intf.getModifiers();
                //如果接口的訪問標志不是public, 那么生成代理類的包名和接口包名相同
                if (!Modifier.isPublic(flags)) {
                    //生成的代理類的訪問標志設置改為final
                    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)) {
                        //代理類如果實現不同包的接口, 並且接口都不是public的, 那么就會在這里報錯
                        throw new IllegalArgumentException(
                            "non-public interfaces from different packages");
                    }
                }
            }

            if (proxyPkg == null) {
                // if no non-public proxy interfaces, use com.sun.proxy package 如果沒有非公共代理接口，那生成的代理類都放到默認的包下：com.sun.proxy
                proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
            }

            /*
             * Choose a name for the proxy class to generate.
             * 生成代理類的全限定名, 包名+前綴+序號, 例如：com.sun.proxy.$Proxy0
             */
            long num = nextUniqueNumber.getAndIncrement();
            String proxyName = proxyPkg + proxyClassNamePrefix + num;

            /*
             * Generate the specified proxy class.
             * 這里是核心, 用ProxyGenerator來生成字節碼, 該類放在sun.misc包下
             */
            byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                proxyName, interfaces, accessFlags);
            //根據二進制文件生成相應的Class實例
            try {
                return defineClass0(loader, proxyName,
                                    proxyClassFile, 0, proxyClassFile.length);
            } catch (ClassFormatError e) {
                /*
                 * A ClassFormatError here means that (barring bugs in the
                 * proxy class generation code) there was some other
                 * invalid aspect of the arguments supplied to the proxy
                 * class creation (such as virtual machine limitations
                 * exceeded).
                 */
                throw new IllegalArgumentException(e.toString());
            }
        }
    }

ProxyClassFactory中生成代理類核心代碼 byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces, accessFlags);下面我們繼續分析ProxyGenerator.generateProxyClass

4 ProxyGenerator.generateProxyClass

public static byte[] generateProxyClass(final String var0, Class<?>[] var1, int var2) {
        //構造ProxyGenerator對象
        ProxyGenerator var3 = new ProxyGenerator(var0, var1, var2);
        //核心代碼，生成代理類字節碼文件
        final byte[] var4 = var3.generateClassFile();
        //如果需要保存生成的字節碼文件，則將字節碼文件寫入磁盤
        if(saveGeneratedFiles) {
            AccessController.doPrivileged(new PrivilegedAction() {
                public Void run() {
                    try {
                        int var1 = var0.lastIndexOf(46);
                        Path var2;
                        //生成存儲路徑
                        if(var1 > 0) {
                            Path var3 = Paths.get(var0.substring(0, var1).replace('.', File.separatorChar), new String[0]);
                            Files.createDirectories(var3, new FileAttribute[0]);
                            var2 = var3.resolve(var0.substring(var1 + 1, var0.length()) + ".class");
                        } else {
                            var2 = Paths.get(var0 + ".class", new String[0]);
                        }
                        //將字節碼文件寫入磁盤
                        Files.write(var2, var4, new OpenOption[0]);
                        return null;
                    } catch (IOException var4x) {
                        throw new InternalError("I/O exception saving generated file: " + var4x);
                    }
                }
            });
        }
        //返回字節碼文件
        return var4;
    }

5 ProxyGenerator.generateClassFile

跟蹤了這么久源碼，大boss終於出現了，下面我們分析ProxyGenerator.generateClassFile方法

    private byte[] generateClassFile() {
        //1、將所有的方法組裝成ProxyMethod對象
        //首先為代理類生成toString, hashCode, equals等代理方法
        this.addProxyMethod(hashCodeMethod, Object.class);
        this.addProxyMethod(equalsMethod, Object.class);
        this.addProxyMethod(toStringMethod, Object.class);
        Class[] var1 = this.interfaces;
        int var2 = var1.length;

        int var3;
        Class var4;
        //遍歷每一個接口的每一個方法, 並生成ProxyMethod對象
        for(var3 = 0; var3 < var2; ++var3) {
            var4 = var1[var3];
            Method[] var5 = var4.getMethods();
            int var6 = var5.length;

            for(int var7 = 0; var7 < var6; ++var7) {
                Method var8 = var5[var7];
                this.addProxyMethod(var8, var4);
            }
        }

        Iterator var11 = this.proxyMethods.values().iterator();

        List var12;
        while(var11.hasNext()) {
            var12 = (List)var11.next();
            checkReturnTypes(var12);
        }

        //2、組裝要生成的class文件的所有的字段信息和方法信息
        Iterator var15;
        try {
            //添加構造器方法
            this.methods.add(this.generateConstructor());
            var11 = this.proxyMethods.values().iterator();

            //遍歷緩存中的代理方法
            while(var11.hasNext()) {
                var12 = (List)var11.next();
                var15 = var12.iterator();

                while(var15.hasNext()) {
                    ProxyGenerator.ProxyMethod var16 = (ProxyGenerator.ProxyMethod)var15.next();
                    //添加代理類的靜態字段, 例如:private static Method m1;
                    this.fields.add(new ProxyGenerator.FieldInfo(var16.methodFieldName, "Ljava/lang/reflect/Method;", 10));
                    //添加代理類的代理方法
                    this.methods.add(var16.generateMethod());
                }
            }

            //添加代理類的靜態字段初始化方法
            this.methods.add(this.generateStaticInitializer());
        } catch (IOException var10) {
            throw new InternalError("unexpected I/O Exception", var10);
        }

        if(this.methods.size() > '\uffff') {
            throw new IllegalArgumentException("method limit exceeded");
        } else if(this.fields.size() > '\uffff') {
            throw new IllegalArgumentException("field limit exceeded");
        } else {
            //3、寫入最終的class文件
            //驗證常量池中存在代理類的全限定名
            this.cp.getClass(dotToSlash(this.className));
            //驗證常量池中存在代理類父類的全限定名
            this.cp.getClass("java/lang/reflect/Proxy");
            var1 = this.interfaces;
            var2 = var1.length;

            //驗證常量池存在代理類接口的全限定名
            for(var3 = 0; var3 < var2; ++var3) {
                var4 = var1[var3];
                this.cp.getClass(dotToSlash(var4.getName()));
            }

            //接下來要開始寫入文件了,設置常量池只讀
            this.cp.setReadOnly();
            ByteArrayOutputStream var13 = new ByteArrayOutputStream();
            DataOutputStream var14 = new DataOutputStream(var13);

            try {
                //1.寫入魔數
                var14.writeInt(-889275714);
                //2.寫入次版本號
                var14.writeShort(0);
                //3.寫入主版本號
                var14.writeShort(49);
                //4.寫入常量池
                this.cp.write(var14);
                //5.寫入訪問修飾符
                var14.writeShort(this.accessFlags);
                //6.寫入類索引
                var14.writeShort(this.cp.getClass(dotToSlash(this.className)));
                //7.寫入父類索引, 生成的代理類都繼承自Proxy
                var14.writeShort(this.cp.getClass("java/lang/reflect/Proxy"));
                //8.寫入接口計數值
                var14.writeShort(this.interfaces.length);
                
                Class[] var17 = this.interfaces;
                int var18 = var17.length;

                //9.寫入接口集合
                for(int var19 = 0; var19 < var18; ++var19) {
                    Class var22 = var17[var19];
                    var14.writeShort(this.cp.getClass(dotToSlash(var22.getName())));
                }
                //10.寫入字段計數值
                var14.writeShort(this.fields.size());
                var15 = this.fields.iterator();
                //11.寫入字段集合 
                while(var15.hasNext()) {
                    ProxyGenerator.FieldInfo var20 = (ProxyGenerator.FieldInfo)var15.next();
                    var20.write(var14);
                }
                //12.寫入方法計數值
                var14.writeShort(this.methods.size());
                var15 = this.methods.iterator();
                //13.寫入方法集合
                while(var15.hasNext()) {
                    ProxyGenerator.MethodInfo var21 = (ProxyGenerator.MethodInfo)var15.next();
                    var21.write(var14);
                }
                 //14.寫入屬性計數值, 代理類class文件沒有屬性所以為0
                var14.writeShort(0);
                //轉換成二進制數組輸出
                return var13.toByteArray();
            } catch (IOException var9) {
                throw new InternalError("unexpected I/O Exception", var9);
            }
        }
    }

動態代理的本質：通過類加載器獲取類字節碼，通過類實現的接口反射獲得該類的屬性，方法等，並生成新的字節碼文件

6 代理類字節碼文件分析 $Proxy0.class

package com.sun.proxy;

import com.doubibi.framework.util.proxy.HelloService;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

public final class $Proxy0 extends Proxy
  implements HelloService
{
  //equals方法
  private static Method m1;
  //HelloService 的sayHello方法
  private static Method m3;
  //toString方法
  private static Method m2;
  //hashCode方法
  private static Method m0;

  //構造方法
  public $Proxy0(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 (Error|RuntimeException localError)
    {
      throw localError;
    }
    catch (Throwable localThrowable)
    {
      throw new UndeclaredThrowableException(localThrowable);
    }
  }

  //調用了invocationHandler的invoke方法，invoke執行了HelloService 的sayHello方法
  public final void sayHello()
    throws 
  {
    try
    {
      this.h.invoke(this, m3, null);
      return;
    }
    catch (Error|RuntimeException localError)
    {
      throw localError;
    }
    catch (Throwable localThrowable)
    {
      throw new UndeclaredThrowableException(localThrowable);
    }
  }

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

  public final int hashCode()
    throws 
  {
    try
    {
      return ((Integer)this.h.invoke(this, m0, null)).intValue();
    }
    catch (Error|RuntimeException localError)
    {
      throw localError;
    }
    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("com.doubibi.framework.util.proxy.HelloService").getMethod("sayHello", new Class[0]);
      m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
      m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
      return;
    }
    catch (NoSuchMethodException localNoSuchMethodException)
    {
      throw new NoSuchMethodError(localNoSuchMethodException.getMessage());
    }
    catch (ClassNotFoundException localClassNotFoundException)
    {
      throw new NoClassDefFoundError(localClassNotFoundException.getMessage());
    }
  }
}

代理類$Proxy0調用了invocationHandler也就是的helloServiceProxy的invoke方法，而invoke通過反射執行了HelloService 的sayHello方法也就是HelloServiceImpl的sayHello方法。

自此java動態代理源碼分析完成，筆者對動態代理理解更加深刻，如有不當之處還請各位讀者指正