public interface Subject {
  public void sayHello();
  public void sayGoodBye();
}

public class RealSubject implements Subject {
  public void sayHello() {
    System.out.println("Hello World");
  }
  public void sayGoodBye() {
    System.out.println("GoodBye World");
  }
}

public class StaticProxy implements Subject {
  Private RealSubject realSubject = null;
  public StaticProxy() {}
  public void sayHello() {
    //用到時(shí)候才加載， 懶加載
    if(realSubject == null) {
      realSubject = new RealSubject();
    }
    realSubject.sayHello();
  }
  //sayGoodbye方法同理
  ...
}

public class Client {
  public static void main(String [] args) {
    StaticProxy sp = new StaticProxy();
    sp.sayHello();
    sp.sayGoodBye();
  }
}

public class dynamicProxy implements InvocationHandler {
  private RealSubject = null;
  public Object invoke(Object proxy, Method method, Object[] args){
    if(RealSubject == null) {
      RealSubject = new RealSubject();
    }
    method.invoke(RealSubject, args);
    return RealSubject;
  }
}

public class Client {
  public static void main(Strings[] args) {
    Subject subject = (Subject)Proxy.newInstance(ClassLoader.getSystemLoader(), RealSubject.class.getInterfaces(), new DynamicProxy());
    Subject.sayHello();
    Subject.sayGoodBye();
  }
}

public class DynamicProxy implements InvokeHandler {
  //你想代理的類
  private TargetClass targetClass = null;
  //初始化該類
  public DynamicProxy(TargetClass targetClass) {
    this.targetClass = targetClass;
  }
  public Object invoke(Object proxy, Method method, Object[] args) {
    //利用反射獲取你想代理的類的方法
    Method myMethod = targetClass.getClass().getDeclaredMethod(method.getName(), method.getParameterTypes());
    myMethod.setAccessible(true);
    return myMethod.invoke(targetClass, args);
  }
}

public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException {
  }
  //獲取接口信息
  final Class<?>[] intfs = interfaces.clone();
  final SecurityManager sm = System.getSecurityManager();
  if (sm != null) {
    checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
  }
  //生成代理類
  Class<?> cl = getProxyClass0(loader, intfs);
  // ...OK我們先看前半截
  }

private static Class<?> getProxyClass0(ClassLoader loader, Class<?>... interfaces) {
  //接口列表數(shù)目不能超過0xFFFF
  if (interfaces.length > 65535) {
    throw new IllegalArgumentException("interface limit exceeded");
  }
  //注意這里, 下面詳細(xì)解釋 
    return proxyClassCache.get(loader, interfaces);
  }

 private static final WeakCache<ClassLoader, Class<?>[], Class<?>>
    proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());

final class WeakCache<K, P, V> {
  ...
  public V get(K key, P parameter) {}
}

public V get(K key, P parameter) {
  //java7 NullObject判斷方法， 如果parameter為空則拋出帶有指定消息的異常。 如果不為空則返回。
  Objects.requireNonNull(parameter);
  //清理持有弱引用的WeakHashMap這種數(shù)據(jù)結(jié)構(gòu)，一般用于緩存
  expungeStaleEntries();
  //從隊(duì)列中獲取cacheKey
  Object cacheKey = CacheKey.valueOf(key, refQueue);
  //利用懶加載的方式填充Supplier， Concurrent是一種線程安全的map
  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;
      }
    }
    // create subKey and retrieve the possible Supplier<V> stored by that
    // subKey from valuesMap
  Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));
  Supplier<V> supplier = valuesMap.get(subKey);
  Factory factory = null;
  while (true) {
    if (supplier != null) {
    // 從supplier中獲取Value，這個(gè)Value可能是一個(gè)工廠或者Cache的實(shí)
    //下面這三句代碼是核心代碼， 返回實(shí)現(xiàn)InvokeHandler的類并包含了所需要的信息。
    V value = supplier.get();
      if (value != null) {
        return value;
      }
    }
    // else no supplier in cache
    // or a supplier that returned null (could be a cleared CacheValue
    // or a Factory that wasn't successful in installing the CacheValue)
    //下面這個(gè)過程就是填充supplier的過程
    if(factory == null) {
      //創(chuàng)建一個(gè)factory
    }
    if(supplier == null) {
      //填充supplier
    }else {
      //填充supplier
    }
  }

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 {
      //加載每一個(gè)接口運(yùn)行時(shí)的信息
      interfaceClass = Class.forName(intf.getName(), false, loader);
    } catch (ClassNotFoundException e) {
    }
  //如果使用你自己的classload加載的class與你傳入的class不相等，拋出異常
  if (interfaceClass != intf) {
    throw new IllegalArgumentException(
    intf + " is not visible from class loader");
  }
  //如果傳入不是一個(gè)接口類型
    if (!interfaceClass.isInterface()) {
      throw new IllegalArgumentException(
        interfaceClass.getName() + " is not an interface");
    }
   //驗(yàn)證接口是否重復(fù)
    if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
      throw new IllegalArgumentException("repeated interface: " + interfaceClass.getName());
    }
  }
  String proxyPkg = null;   // package to define proxy class in
  /* 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.
  */
  //這一段是看你傳入的接口中有沒有不是public的接口，如果有，這些接口必須全部在一個(gè)包里定義的，否則拋異常 
  for (Class<?> intf : interfaces) {
    int flags = intf.getModifiers();
    if (!Modifier.isPublic(flags)) {
      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) {
    // if no non-public proxy interfaces, use com.sun.proxy package
    proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
  }
  /*
  * Choose a name for the proxy class to generate.
  */
  long num = nextUniqueNumber.getAndIncrement();
  //生成隨機(jī)代理類的類名， $Proxy + num
  String proxyName = proxyPkg + proxyClassNamePrefix + num;
  /*
  * 生成代理類的class文件， 返回字節(jié)流
  */
  byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces);
  try {
    return defineClass0(loader, proxyName, proxyClassFile, 0, proxyClassFile.length);
  } catch (ClassFormatError e) {
        //結(jié)束
        throw new IllegalArgumentException(e.toString());
      }
    }
  }

  private byte[] generateClassFile() {
    /*
     * Step 1: Assemble ProxyMethod objects for all methods to
     * generate proxy dispatching code for.
     */
     //addProxyMethod方法，就是將方法都加入到一個(gè)列表中，并與對應(yīng)的class對應(yīng)起來 
    //這里給Object對應(yīng)了三個(gè)方法hashCode，toString和equals 
    addProxyMethod(hashCodeMethod, Object.class);
    addProxyMethod(equalsMethod, Object.class);
    addProxyMethod(toStringMethod, Object.class);
    //將接口列表中的接口與接口下的方法對應(yīng)起來
    for (int i = 0; i < interfaces.length; i++) {
      Method[] methods = interfaces[i].getMethods();
      for (int j = 0; j < methods.length; j++) {
        addProxyMethod(methods[j], interfaces[i]);
      }
    }
    /*
     * For each set of proxy methods with the same signature,
     * verify that the methods' return types are compatible.
     */
    for (List<ProxyMethod> sigmethods : proxyMethods.values()) {
      checkReturnTypes(sigmethods);
    }
    /*
     * Step 2: Assemble FieldInfo and MethodInfo structs for all of
     * fields and methods in the class we are generating.
     */
     //方法中加入構(gòu)造方法，這個(gè)構(gòu)造方法只有一個(gè)，就是一個(gè)帶有InvocationHandler接口的構(gòu)造方法 
     //這個(gè)才是真正給class文件，也就是代理類加入方法了，不過還沒真正處理，只是先加進(jìn)來等待循環(huán)，構(gòu)造方法在class文件中的名稱描述是<init> 
  try {
    methods.add(generateConstructor());
    for (List<ProxyMethod> sigmethods : proxyMethods.values()) {
      for (ProxyMethod pm : sigmethods) {
 //給每一個(gè)代理方法加一個(gè)Method類型的屬性，數(shù)字10是class文件的標(biāo)識符，代表這些屬性都是private static的 
        fields.add(new FieldInfo(pm.methodFieldName,
          "Ljava/lang/reflect/Method;",
           ACC_PRIVATE | ACC_STATIC));
        //將每一個(gè)代理方法都加到代理類的方法中 
        methods.add(pm.generateMethod());
      }
    }
  //加入一個(gè)靜態(tài)初始化塊，將每一個(gè)屬性都初始化，這里靜態(tài)代碼塊也叫類構(gòu)造方法，其實(shí)就是名稱為<clinit>的方法，所以加到方法列表 
      methods.add(generateStaticInitializer());
    } catch (IOException e) {
      throw new InternalError("unexpected I/O Exception");
    }
  //方法和屬性個(gè)數(shù)都不能超過65535，包括之前的接口個(gè)數(shù)也是這樣， 
  //這是因?yàn)樵赾lass文件中，這些個(gè)數(shù)都是用4位16進(jìn)制表示的，所以最大值是2的16次方-1 
    if (methods.size() > 65535) {
      throw new IllegalArgumentException("method limit exceeded");
    }
    if (fields.size() > 65535) {
      throw new IllegalArgumentException("field limit exceeded");
    }
  //接下來就是寫class文件的過程， 包括魔數(shù)， 類名，常量池等一系列字節(jié)碼的組成，就不一一細(xì)說了。需要的可以參考JVM虛擬機(jī)字節(jié)碼的相關(guān)知識。
    cp.getClass(dotToSlash(className));
    cp.getClass(superclassName);
    for (int i = 0; i < interfaces.length; i++) {
      cp.getClass(dotToSlash(interfaces[i].getName()));
    }
    cp.setReadOnly();
    ByteArrayOutputStream bout = new ByteArrayOutputStream();
    DataOutputStream dout = new DataOutputStream(bout);
    try {
                    // u4 magic;
      dout.writeInt(0xCAFEBABE);
                    // u2 minor_version;
      dout.writeShort(CLASSFILE_MINOR_VERSION);
                    // u2 major_version;
      dout.writeShort(CLASSFILE_MAJOR_VERSION);
      cp.write(dout);       // (write constant pool)
                    // u2 access_flags;
      dout.writeShort(ACC_PUBLIC | ACC_FINAL | ACC_SUPER);
                    // u2 this_class;
      dout.writeShort(cp.getClass(dotToSlash(className)));
                    // u2 super_class;
      dout.writeShort(cp.getClass(superclassName));
                    // u2 interfaces_count;
      dout.writeShort(interfaces.length);
                    // u2 interfaces[interfaces_count];
      for (int i = 0; i < interfaces.length; i++) {
        dout.writeShort(cp.getClass(
          dotToSlash(interfaces[i].getName())));
      }
                    // u2 fields_count;
      dout.writeShort(fields.size());
                    // field_info fields[fields_count];
      for (FieldInfo f : fields) {
        f.write(dout);
      }
                    // u2 methods_count;
      dout.writeShort(methods.size());
                    // method_info methods[methods_count];
      for (MethodInfo m : methods) {
        m.write(dout);
      }
                     // u2 attributes_count;
      dout.writeShort(0); // (no ClassFile attributes for proxy classes)
    } catch (IOException e) {
      throw new InternalError("unexpected I/O Exception");
    }
    return bout.toByteArray();
  }

public class TestGeneratorProxy {
  public static void main(String[] args) throws IOException {
    byte[] classFile = ProxyGenerator.generateProxyClass("TestProxyGen", Subject.class.getInterfaces());
    File file = new File("/Users/yadoao/Desktop/TestProxyGen.class");
    FileOutputStream fos = new FileOutputStream(file); 
    fos.write(classFile); 
    fos.flush(); 
    fos.close(); 
  }
}

import com.su.dynamicProxy.ISubject;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
public final class TestProxyGen extends Proxy
 implements ISubject
{
 private static Method m3;
 private static Method m1;
 private static Method m0;
 private static Method m4;
 private static Method m2;
 public TestProxyGen(InvocationHandler paramInvocationHandler)
  throws 
 {
  super(paramInvocationHandler);
 }
 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 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);
  }
 }
 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);
  }
 }
 public final void sayGoodBye()
  throws 
 {
  try
  {
   this.h.invoke(this, m4, 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);
  }
 }
 static
 {
  try
  {
   m3 = Class.forName("com.su.dynamicProxy.ISubject").getMethod("sayHello", new Class[0]);
   m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });
   m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
   m4 = Class.forName("com.su.dynamicProxy.ISubject").getMethod("sayGoodBye", 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());
  }
 }
}