JDK動態代理

時間  2019-12-07
標籤 jdk 動態 代理 欄目 Java 简体版
原文   原文鏈接

用戶在調用被動態代理過的對象的方法時，調用的請求會被自動發給代理對象（實現了InvocationHandler接口）的invoke()方法，由invoke()方法來實現對請求的統一處理。java

源碼分析

  • Java.lang.reflect.Proxyc++

public class Proxy implements java.io.Serializable {
private static final Class<?>[] constructorParams =  { InvocationHandler.class };
private static final WeakCache<ClassLoader, Class<?>[], Class<?>>
        proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());
......

    @CallerSensitive
    public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)
        throws IllegalArgumentException
    {
        Objects.requireNonNull(h);

        final Class<?>[] intfs = interfaces.clone();    //淺克隆
        final SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
        }

        //生成代理類的class
        Class<?> cl = getProxyClass0(loader, intfs);

        /*
         * Invoke its constructor with the designated invocation handler.
         */
        try {
            if (sm != null) {
                checkNewProxyPermission(Reflection.getCallerClass(), cl);
            }
            //getConstructor(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;
                    }
                });
            }
            //代理類實例化返回
            return cons.newInstance(new Object[]{h});
        }  
    ......
}

 

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

        // key爲WeakReference，若緩存中存在相同key，則返回ProxyClass，若不存在，則用ProxyClassFactory建立ProxyClass。
        return proxyClassCache.get(loader, interfaces);  //java.lang.reflect.WeakCache 這個內核分析？
    }
......
 }
private static final class ProxyClassFactory implements BiFunction<ClassLoader, Class<?>[], Class<?>> {
        // 全部代理類ProxyClass名字的前綴 
        private static final String proxyClassNamePrefix = "$Proxy";

        // 用計數器生成代理類ProxyClass的名字
        private static final AtomicLong nextUniqueNumber = new AtomicLong();

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

            Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
//對每個interface Class進行驗證
            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) {
                }
                if (interfaceClass != intf) {
                    throw new IllegalArgumentException(
                        intf + " is not visible from class loader");
                }
                /*
                 * Verify that the Class object actually represents an
                 * interface.
                 */
                if (!interfaceClass.isInterface()) {
                    throw new IllegalArgumentException(
                        interfaceClass.getName() + " is not an interface");
                }
                /*
                 * Verify that this interface is not a duplicate.
  * 用IdentityHashMap來驗證interface Class的惟一性，由於IdentityHashMap的key比較是==，即比較內存地址。
                 */
                if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
                    throw new IllegalArgumentException(
                        "repeated interface: " + interfaceClass.getName());
                }
            }

            String proxyPkg = null;      
            int accessFlags = Modifier.PUBLIC | Modifier.FINAL;

            // 對於非公共接口，ProxyClass的包名設置爲接口的包名    
            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");
                    }
                }
            }

            // 對於公共接口，ProxyClass的包名爲com.sun.proxy  
            if (proxyPkg == null) {
                proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
            }

            long num = nextUniqueNumber.getAndIncrement();
            //ProxyClass的徹底限定名
            String proxyName = proxyPkg + proxyClassNamePrefix + num;

            //由c++寫的ProxyGenerator生成代理類的二進制字節碼
            byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                proxyName, interfaces, accessFlags);
            try {
                // 根據二進制字節碼返回相應的ProxyClass  
                return defineClass0(loader, proxyName,
                                    proxyClassFile, 0, proxyClassFile.length);
            } catch (ClassFormatError e) {               
                throw new IllegalArgumentException(e.toString());
            }
        }
}

$Proxy.class

如下是反編譯$Proxy0.class：緩存

public final class $Proxy0 extends Proxy implements MyInterface1{  
  private static Method m1;  
  private static Method m3;  
  private static Method m0;  
  private static Method m2;  
 
  public $Proxy0(InvocationHandler paramInvocationHandler) {  
    super(paramInvocationHandler);  
  }  
  
  public final boolean equals(Object paramObject) {  
    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);  
    }  
  }  
  
  public final void sayHello(String paramString) {  
    try {  
      this.h.invoke(this, m3, new Object[] { paramString });  
      return;  
    }  
    catch (Error|RuntimeException localError) {  
      throw localError;  
    }  
   catch (Throwable localThrowable) {  
      throw new UndeclaredThrowableException(localThrowable);  
    }  
  }  

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

 

$Proxy0.class的總結：app

  1. 對於要代理沒有接口的類，則必須繼承該沒有接口的類，從而覆蓋其方法，但因爲java不能多繼承，這裏代理類已經繼承了Proxy類了，不能再繼承其餘的類，因此JDK的動態代理不支持對實現類的代理，只支持接口的代理。ide

  2. 構造方法的入參爲InvocationHandler，這說明該代理類是實現了InvocationHandler接口的類的代理類，而InvocationHandler實現類再代理真正的實體類。源碼分析

  3. 靜態代碼塊會初始化真正實體類的Method對象，以及Object類的equals、hashCode、toString的Method對象。ui

總結：
Proxy 會從內部類WeakCache中根據ClassLoader 和interfaces獲取ProxyClass（若緩存中存在相同key，則返回ProxyClass，若不存在，則用ProxyClassFactory建立ProxyClass（由ProxyGenerator生成二進制碼，再將寫成*.class文件））。this

AOP JDK動態代理實現

切面InvocationHandler：代理

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {  
    // BeforeAdvice  
    Object retVal = null;  
    try {  
        retVal = method.invoke(target, args);  // AroundAdvice 代替該語句      
        // AfterReturningAdvice  
    }  
    catch (Throwable e) {  
        // AfterThrowingAdvice  
    }  
    finally {  
        //finally塊必定會在return前面執行。
        // AfterAdvice  
    }  
    return retVal;  
}  
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程