一烤礁、用法

1仪芒、接口

package com.suncy.article.article11.jdk;

public interface HelloInterface {
    public void sayHi();
}

2胡本、接口實現(xiàn)類（要代理的對象就是這個類的對象）

package com.suncy.article.article11;

import com.suncy.article.article11.jdk.HelloInterface;

public class Hello implements HelloInterface {
    @Override
    public void sayHi() {
        System.out.println("hi");
    }
}

3照藻、執(zhí)行代理對象方法的前后完成自己的操作

package com.suncy.article.article11.jdk;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class JdkProxy implements InvocationHandler {

    private Object object;

    public JdkProxy(Object object){
        this.object = object;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        System.out.println("jdk before");
        method.invoke(object,args);
        System.out.println("jdk after");
        return null;
    }
}

4严嗜、使用

package com.suncy.article.article11.jdk;

import com.suncy.article.article11.Hello;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;

public class JdkTest {
    public static void main(String[] args) {
        //1又活、生成一個普通對象（必須要實現(xiàn)接口）
        Hello hello = new Hello();

        //2册招、代理對象者吁，手動編寫代理方法的前后的操作（這個類模型比較固定）
        InvocationHandler invocationHandler = new JdkProxy(hello);

        //3讳窟、使用反射包中的Proxy.newProxyInstance方法让歼，拿到代理對象（參數(shù)為 被代理對象的類加載器 接口列表Class<?> InvocationHandler）
        HelloInterface helloInterface = (HelloInterface) Proxy.newProxyInstance(
                hello.getClass().getClassLoader(),
                hello.getClass().getInterfaces(),
                invocationHandler
        );

        //4、調(diào)用代理對象的接口方法
        helloInterface.sayHi();
    }
}

5丽啡、測試結(jié)果

image.png

二谋右、源碼分析

（1）Proxy.newProxyInstance()方法
Proxy.newProxyInstance()拿到代理對象

HelloInterface helloInterface = (HelloInterface) Proxy.newProxyInstance(
                hello.getClass().getClassLoader(),
                hello.getClass().getInterfaces(),
                invocationHandler
        );

（2）分析這個方法

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

    //1、拿到接口的Class[] 數(shù)組
    final Class<?>[] intfs = interfaces.clone();
    final SecurityManager sm = System.getSecurityManager();
    if (sm != null) {
        checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
    }

    //2补箍、拿到代理類的Class<?>對象
    Class<?> cl = getProxyClass0(loader, intfs);

    try {
        if (sm != null) {
            checkNewProxyPermission(Reflection.getCallerClass(), cl);
        }

        //3改执、通過Class<?> 拿到Constructor對象
        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;
                }
            });
        }
        //4、通過Constructor返回代理對象
        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);
    }
}

首先看返回值

 return cons.newInstance(new Object[]{h});

然后找到cons

 final Constructor<?> cons = cl.getConstructor(constructorParams);

繼續(xù)找到cl坑雅，發(fā)現(xiàn)通過getProxyClass0方法 返回了一個Class<?> 對象 辈挂，這個getProxyClass0方法的參數(shù)loader和intfs就是傳進來的參數(shù)

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

到這里，我們應(yīng)該知道關(guān)鍵的方法就是在于getProxyClass0裹粤，拿到一個類的Class對象终蒂，之后通過這個Class對象反射出代理對象。

（3）找到getProxyClass0()

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

        return proxyClassCache.get(loader, interfaces);
    }

直接return proxyClassCache.get(loader, interfaces)遥诉。

（4）找到proxyClassCache.get()

public V get(K key, P parameter) {
    Objects.requireNonNull(parameter);

    expungeStaleEntries();

    Object cacheKey = CacheKey.valueOf(key, refQueue);

    ConcurrentMap<Object, Supplier<V>> valuesMap = map.get(cacheKey);
    if (valuesMap == null) {
        ConcurrentMap<Object, Supplier<V>> oldValuesMap
            = map.putIfAbsent(cacheKey,
                              valuesMap = new ConcurrentHashMap<>());
        if (oldValuesMap != null) {
            valuesMap = oldValuesMap;
        }
    }

    Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));
    Supplier<V> supplier = valuesMap.get(subKey);
    Factory factory = null;

    while (true) {
        //第一次進來supplier為null
        //第二次進來supplier不為null 拇泣， 
        if (supplier != null) {
            V value = supplier.get();
            if (value != null) {
                return value;
            }
        }
      
        //第一次循環(huán)，factort為null矮锈，此時會新建new Factory()
        if (factory == null) {
            factory = new Factory(key, parameter, subKey, valuesMap);
        }

        if (supplier == null) {
            supplier = valuesMap.putIfAbsent(subKey, factory);
            if (supplier == null) {
                //第一次循環(huán)會走到這個地方霉翔，將這個factory賦值給supplier
                supplier = factory;
            }
        } else {
            if (valuesMap.replace(subKey, supplier, factory)) {
                supplier = factory;
            } else {
                supplier = valuesMap.get(subKey);
            }
        }
    }
}

先看返回值，在while(true)代碼塊中

if (supplier != null) {
       // supplier might be a Factory or a CacheValue<V> instance
        V value = supplier.get();
        if (value != null) {
              return value;
        }
 }

那就需要找到這個supplier是什么愕难？

斷點測試如下：
第一次循環(huán)

image.png

第二次循環(huán)

image.png

最后我們找到這個supplier,get() 調(diào)用的就是WeakCache類下的一個內(nèi)部類Factory的get方法

（5）分析Factory的get方法

public synchronized V get() { // serialize access
        Supplier<V> supplier = valuesMap.get(subKey);
        if (supplier != this) {
            return null;
        }
      
        V value = null;
        try {
            value = Objects.requireNonNull(valueFactory.apply(key, parameter));
        } finally {
            if (value == null) { // remove us on failure
                valuesMap.remove(subKey, this);
            }
        }
        assert value != null;

        CacheValue<V> cacheValue = new CacheValue<>(value);

        if (valuesMap.replace(subKey, this, cacheValue)) {
            reverseMap.put(cacheValue, Boolean.TRUE);
        } else {
            throw new AssertionError("Should not reach here");
        }

        return value;
    }
}

依舊去找返回值早龟，簡略如下：

value = Objects.requireNonNull(valueFactory.apply(key, parameter));
return value;

Objects.requireNonNull就是為了返回參數(shù)對象惫霸，參數(shù)對象為null，則拋出異常葱弟，方法不關(guān)鍵壹店。
關(guān)鍵方法在于valueFactory.apply(key, parameter)。

（6）找到valueFactory.apply(key, parameter)方法
通過斷點找到的是ProxyClassFactory類下的apply方法

 @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;     // package to define proxy class in
        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;

        //返回值要用到的參數(shù) byte[] proxyClassFile
        byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
            proxyName, interfaces, accessFlags);
        try {
            //返回值芝加，關(guān)鍵地方
            return defineClass0(loader, proxyName,
                                proxyClassFile, 0, proxyClassFile.length);
        } catch (ClassFormatError e) {
            throw new IllegalArgumentException(e.toString());
        }
    }
}

這時候我們發(fā)現(xiàn)這個方法的參數(shù)返回了一個 Class<?>對象硅卢，而且入?yún)⒕褪穷惣虞d器和接口 Class<?>數(shù)組。是不是剛好對應(yīng)了Proxy.newProxyInstance這個方法的兩個入?yún)⒑统鰠⒉卣取Ｄ敲催@個方法一定非常關(guān)鍵了将塑。

（7）defineClass0方法
依舊去看apply方法的返回值：

  return defineClass0(loader, proxyName, proxyClassFile, 0, proxyClassFile.length);

然后我們點擊進入這個defineClass0方法發(fā)現(xiàn)，這是一個native方法蝌麸，返回Class<?>對象点寥，然后我們找一下資料，看一下這個方法的作用来吩。

private static native Class<?> defineClass0(ClassLoader loader, String name,
                                                byte[] b, int off, int len);

通過查找資料敢辩，我們發(fā)現(xiàn)：這個defineClass0方法位于java的反射包當(dāng)中，作用就是將一堆字節(jié)轉(zhuǎn)化為Class<?>對象弟疆。知道了這個戚长，那我們就知道，關(guān)鍵的地方應(yīng)該在于這堆字節(jié)是怎么來的怠苔？

（8）ProxyGenerator.generateProxyClas方法

 byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
            proxyName, interfaces, accessFlags);

進入到generateProxyClass方法當(dāng)中

public static byte[] generateProxyClass(final String var0, Class<?>[] var1, int var2) {
    ProxyGenerator var3 = new ProxyGenerator(var0, var1, var2);
    final byte[] var4 = var3.generateClassFile();
    if (saveGeneratedFiles) {
        AccessController.doPrivileged(new PrivilegedAction<Void>() {
            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));
                        Files.createDirectories(var3);
                        var2 = var3.resolve(var0.substring(var1 + 1, var0.length()) + ".class");
                    } else {
                        var2 = Paths.get(var0 + ".class");
                    }

                    Files.write(var2, var4, new OpenOption[0]);
                    return null;
                } catch (IOException var4x) {
                    throw new InternalError("I/O exception saving generated file: " + var4x);
                }
            }
        });
    }

    return var4;
}

去找返回值同廉，簡略如下：

    ProxyGenerator var3 = new ProxyGenerator(var0, var1, var2);
    final byte[] var4 = var3.generateClassFile();
    return var4;

（9）ProxyGenerator的generateClassFile方法

private byte[] generateClassFile() {
    //為代理類生成hashCode、equales柑司、toString方法
    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);
    }

    Iterator var15;
    try {
        //添加構(gòu)造器方法
        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();
                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);
    }

    //方法和字段集合不能大于65535
    if (this.methods.size() > 65535) {
        throw new IllegalArgumentException("method limit exceeded");
    } else if (this.fields.size() > 65535) {
        throw new IllegalArgumentException("field limit exceeded");
    } else {
        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 {
            //這個地方迫肖，按照Class文件結(jié)構(gòu)進行動態(tài)拼接的
            var14.writeInt(-889275714);
            var14.writeShort(0);
            var14.writeShort(49);
            this.cp.write(var14);
            var14.writeShort(this.accessFlags);
            var14.writeShort(this.cp.getClass(dotToSlash(this.className)));
            var14.writeShort(this.cp.getClass("java/lang/reflect/Proxy"));
            var14.writeShort(this.interfaces.length);
            Class[] var17 = this.interfaces;
            int var18 = var17.length;

            for(int var19 = 0; var19 < var18; ++var19) {
                Class var22 = var17[var19];
                var14.writeShort(this.cp.getClass(dotToSlash(var22.getName())));
            }

            var14.writeShort(this.fields.size());
            var15 = this.fields.iterator();

            while(var15.hasNext()) {
                ProxyGenerator.FieldInfo var20 = (ProxyGenerator.FieldInfo)var15.next();
                var20.write(var14);
            }

            var14.writeShort(this.methods.size());
            var15 = this.methods.iterator();

            while(var15.hasNext()) {
                ProxyGenerator.MethodInfo var21 = (ProxyGenerator.MethodInfo)var15.next();
                var21.write(var14);
            }

            var14.writeShort(0);
            return var13.toByteArray();
        } catch (IOException var9) {
            throw new InternalError("unexpected I/O Exception", var9);
        }
    }
}

（10）流程總結(jié)

1、最終通過generateClassFile方法生成了能夠描述類詳細信息的一堆字節(jié)帜羊。
2咒程、通過defineClass0方法，根據(jù)字節(jié)生成了Class<?>對象讼育。
3帐姻、通過這個Class<?>對象，實例化了代理對象奶段。
4饥瓷、調(diào)用代理對象的接口方法。

三痹籍、查看代理對象的結(jié)構(gòu)

1呢铆、生成代理Class文件

package com.suncy.article.article11.jdk;

import com.suncy.article.article11.Hello;
import sun.misc.ProxyGenerator;

import java.io.FileOutputStream;
import java.io.IOException;

public class JdkProxyTest {
    public static void main(String[] args) {

        byte[] bytes = ProxyGenerator.generateProxyClass("$Proxy0", new Class[]{Hello.class});

        try {
            FileOutputStream fileOutputStream = new FileOutputStream("D:\\work\\tool\\$Proxy0.class");
            fileOutputStream.write(bytes);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2、查看反編譯后的Class代碼

下載并安裝JD-GUI工具蹲缠、打開棺克，并將$Proxy0.class拖入即可

import com.suncy.article.article11.Hello;
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 Hello {
  private static Method m1;
  
  private static Method m3;
  
  private static Method m8;
  
  private static Method m2;
  
  private static Method m5;
  
  private static Method m4;
  
  private static Method m7;
  
  private static Method m9;
  
  private static Method m0;
  
  private static Method m6;
  
  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 error) {
      throw null;
    } catch (Throwable throwable) {
      throw new UndeclaredThrowableException(throwable);
    } 
  }
  
  public final void sayHi() {
    try {
      this.h.invoke(this, m3, null);
      return;
    } catch (Error|RuntimeException error) {
      throw null;
    } catch (Throwable throwable) {
      throw new UndeclaredThrowableException(throwable);
    } 
  }
  
  public final void notify() {
    try {
      this.h.invoke(this, m8, null);
      return;
    } catch (Error|RuntimeException error) {
      throw null;
    } catch (Throwable throwable) {
      throw new UndeclaredThrowableException(throwable);
    } 
  }
  
  public final String toString() {
    try {
      return (String)this.h.invoke(this, m2, null);
    } catch (Error|RuntimeException error) {
      throw null;
    } catch (Throwable throwable) {
      throw new UndeclaredThrowableException(throwable);
    } 
  }
  
  public final void wait(long paramLong) throws InterruptedException {
    try {
      this.h.invoke(this, m5, new Object[] { Long.valueOf(paramLong) });
      return;
    } catch (Error|RuntimeException|InterruptedException error) {
      throw null;
    } catch (Throwable throwable) {
      throw new UndeclaredThrowableException(throwable);
    } 
  }
  
  public final void wait(long paramLong, int paramInt) throws InterruptedException {
    try {
      this.h.invoke(this, m4, new Object[] { Long.valueOf(paramLong), Integer.valueOf(paramInt) });
      return;
    } catch (Error|RuntimeException|InterruptedException error) {
      throw null;
    } catch (Throwable throwable) {
      throw new UndeclaredThrowableException(throwable);
    } 
  }
  
  public final Class getClass() {
    try {
      return (Class)this.h.invoke(this, m7, null);
    } catch (Error|RuntimeException error) {
      throw null;
    } catch (Throwable throwable) {
      throw new UndeclaredThrowableException(throwable);
    } 
  }
  
  public final void notifyAll() {
    try {
      this.h.invoke(this, m9, null);
      return;
    } catch (Error|RuntimeException error) {
      throw null;
    } catch (Throwable throwable) {
      throw new UndeclaredThrowableException(throwable);
    } 
  }
  
  public final int hashCode() {
    try {
      return ((Integer)this.h.invoke(this, m0, null)).intValue();
    } catch (Error|RuntimeException error) {
      throw null;
    } catch (Throwable throwable) {
      throw new UndeclaredThrowableException(throwable);
    } 
  }
  
  public final void wait() throws InterruptedException {
    try {
      this.h.invoke(this, m6, null);
      return;
    } catch (Error|RuntimeException|InterruptedException error) {
      throw null;
    } catch (Throwable throwable) {
      throw new UndeclaredThrowableException(throwable);
    } 
  }
  
  static {
    try {
      m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });
      m3 = Class.forName("com.suncy.article.article11.Hello").getMethod("sayHi", new Class[0]);
      m8 = Class.forName("com.suncy.article.article11.Hello").getMethod("notify", new Class[0]);
      m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
      m5 = Class.forName("com.suncy.article.article11.Hello").getMethod("wait", new Class[] { long.class });
      m4 = Class.forName("com.suncy.article.article11.Hello").getMethod("wait", new Class[] { long.class, int.class });
      m7 = Class.forName("com.suncy.article.article11.Hello").getMethod("getClass", new Class[0]);
      m9 = Class.forName("com.suncy.article.article11.Hello").getMethod("notifyAll", new Class[0]);
      m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
      m6 = Class.forName("com.suncy.article.article11.Hello").getMethod("wait", new Class[0]);
      return;
    } catch (NoSuchMethodException noSuchMethodException) {
      throw new NoSuchMethodError(noSuchMethodException.getMessage());
    } catch (ClassNotFoundException classNotFoundException) {
      throw new NoClassDefFoundError(classNotFoundException.getMessage());
    } 
  }
}

我們發(fā)現(xiàn)動態(tài)代理類繼承了Proxy類悠垛，同時調(diào)用方法采用的是 this.h.invoke(this, m3, null);

h淶源：

  public $Proxy0(InvocationHandler paramInvocationHandler) {
    super(paramInvocationHandler);
  }

父類Proxy的構(gòu)造函數(shù)，將InvocationHandler實例傳進來

    protected Proxy(InvocationHandler h) {
        Objects.requireNonNull(h);
        this.h = h;
    }

m3淶源：

m3 = Class.forName("com.suncy.article.article11.Hello").getMethod("sayHi", new Class[0]);

三娜谊、總結(jié)

到此确买，我們基本上已經(jīng)理清了jdk動態(tài)代理的流程，同樣纱皆，我們也能拿到經(jīng)過代理之后的Class對象湾趾。詳細的東西可以再去分析一下這個Class對象。