这里的动态代理对象$ProxyN 一次可以为好多个代理类创建代理对象，比如 spring aop 里面在配置切面 aop 的时候，是用 excution 后面加上一个package 里面的“所有类”的所有在 advice（通知）里面配置的方法做代理，这里的“所有类”也体现了可以一次代理多个类（其实是类里面的方法）的代理对象

目的：主要用来做方法的增强，让你可以在不修改源码（不用改变这个方法的签名，原来调用这个方法的类依然能正常工作）的情况下，增强一些方法。在方法执行前后做任何你想做的事情（甚至根本不去执行这个方法），因为在InvocationHandler的invoke方法中，你可以直接获取正在调用方法对应的Method对象，具体应用的话，比如可以添加调用日志，做事务控制等。

还有一个有趣的作用是可以用作远程调用，比如现在有Java接口，这个接口的实现部署在其它服务器上，在编写客户端代码的时候，没办法直接调用接口方法，因为接口是不能直接生成对象的，这个时候就可以考虑代理模式（动态代理）了，通过Proxy.newProxyInstance代理一个该接口对应的InvocationHandler对象，然后在InvocationHandler的invoke方法内封装通讯细节就可以了。具体的应用，最经典的当然是Java标准库的RMI，其它比如hessian，各种webservice框架中的远程调用，大致都是这么实现的。
而像 AspectJ 这种 AOP 刚不同，它直接把人家的 class 代码修改了，它就不需要使用代理。
这些在新的 JDK 6 中都可以通过 Instrument 来做到，不过也是个通用的方法，还得通过规则来定制什么情况下处理，什么时候不处理。

protected  Proxy(InvocationHandler h)  //使用其调用处理程序的指定值从子类（通常为动态代理类）构建新的 Proxy 实例。
static InvocationHandler getInvocationHandler(Object proxy) //返回指定代理实例的调用处理程序。
static Class<?> getProxyClass(ClassLoader loader, Class<?>... interfaces) //返回代理类的 java.lang.Class 对象，并向其提供类加载器和接口数组。
static boolean isProxyClass(Class<?> cl) //当且仅当指定的类通过 getProxyClass 方法或 newProxyInstance 方法动态生成为代理类时，返回 true。
static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) //返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序。

Object invoke(Object proxy, Method method, Object[] args)

public interface Subject
{public void rent();public void hello(String str);
}

public class RealSubject implements Subject
{@Overridepublic void rent(){System.out.println("I want to rent my house");}@Overridepublic void hello(String str){System.out.println("hello: " + str);}
}

public class DynamicProxy implements InvocationHandler
{//　这个就是我们要代理的真实对象private Object subject;//    构造方法，给我们要代理的真实对象赋初值public DynamicProxy(Object subject){this.subject = subject;}@Overridepublic Object invoke(Object object, Method method, Object[] args)throws Throwable{//　　在代理真实对象前我们可以添加一些自己的操作System.out.println("before rent house");System.out.println("Method:" + method);//    当代理对象调用真实对象的方法时，其会自动的跳转到代理对象关联的handler对象的invoke方法来进行调用method.invoke(subject, args);//　　在代理真实对象后我们也可以添加一些自己的操作System.out.println("after rent house");return null;}}

public class Client
{public static void main(String[] args){//    我们要代理的真实对象Subject realSubject = new RealSubject();//    我们要代理哪个真实对象，就将该对象传进去，最后是通过该真实对象来调用其方法的InvocationHandler handler = new DynamicProxy(realSubject);/** 通过Proxy的newProxyInstance方法来创建我们的代理对象，我们来看看其三个参数* 第一个参数 handler.getClass().getClassLoader() ，我们这里使用handler这个类的ClassLoader对象来加载我们的代理对象* 第二个参数realSubject.getClass().getInterfaces()，我们这里为代理对象提供的接口是真实对象所实行的接口，表示我要代理的是该真实对象，这样我就能调用这组接口中的方法了* 第三个参数handler， 我们这里将这个代理对象关联到了上方的 InvocationHandler 这个对象上*/Subject subject = (Subject)Proxy.newProxyInstance(handler.getClass().getClassLoader(), realSubject.getClass().getInterfaces(), handler);System.out.println(subject.getClass().getName());subject.rent();subject.hello("world");}
}

$Proxy0

before rent house
Method:public abstract void com.xiaoluo.dynamicproxy.Subject.rent()
I want to rent my house
after rent housebefore rent house
Method:public abstract void com.xiaoluo.dynamicproxy.Subject.hello(java.lang.String)
hello: world
after rent house

Subject subject = (Subject)Proxy.newProxyInstance(handler.getClass().getClassLoader(), realSubject.getClass().getInterfaces(), handler);

public Object invoke(Object object, Method method, Object[] args)throws Throwable{//　　在代理真实对象前我们可以添加一些自己的操作System.out.println("before rent house");System.out.println("Method:" + method);//    当代理对象调用真实对象的方法时，其会自动的跳转到代理对象关联的handler对象的invoke方法来进行调用method.invoke(subject, args);//　　在代理真实对象后我们也可以添加一些自己的操作System.out.println("after rent house");return null;}

public abstract void com.xiaoluo.dynamicproxy.Subject.rent()public abstract void com.xiaoluo.dynamicproxy.Subject.hello(java.lang.String)

// 映射表：用于维护类装载器对象到其对应的代理类缓存
private static Map loaderToCache = new WeakHashMap(); // 标记：用于标记一个动态代理类正在被创建中
private static Object pendingGenerationMarker = new Object(); // 同步表：记录已经被创建的动态代理类类型，主要被方法 isProxyClass 进行相关的判断
private static Map proxyClasses = Collections.synchronizedMap(new WeakHashMap()); // 关联的调用处理器引用
protected InvocationHandler h;

// 由于 Proxy 内部从不直接调用构造函数，所以 private 类型意味着禁止任何调用
private Proxy() {} // 由于 Proxy 内部从不直接调用构造函数，所以 protected 意味着只有子类可以调用
protected Proxy(InvocationHandler h) {this.h = h;} 

public static Object newProxyInstance(ClassLoader loader, Class<?>[]interfaces,InvocationHandler h) throws IllegalArgumentException { // 检查 h 不为空，否则抛异常if (h == null) { throw new NullPointerException(); } // 获得与指定类装载器和一组接口相关的代理类类型对象Class cl = getProxyClass(loader, interfaces); // 通过反射获取构造函数对象并生成代理类实例try { Constructor cons = cl.getConstructor(constructorParams); return (Object) cons.newInstance(new Object[] { h }); } catch (NoSuchMethodException e) { throw new InternalError(e.toString()); } catch (IllegalAccessException e) { throw new InternalError(e.toString()); } catch (InstantiationException e) { throw new InternalError(e.toString()); } catch (InvocationTargetException e) { throw new InternalError(e.toString()); }
}

public static byte[] generateProxyClass(final String name, Class[] interfaces)

import java.lang.reflect.*;
public final class ProxySubject extends Proxy   implements Subject
{   private static Method m1;   private static Method m0;   private static Method m3;   private static Method m2;   public ProxySubject(InvocationHandler invocationhandler)   {   super(invocationhandler);   }   public final boolean equals(Object obj)   {   try  {   return ((Boolean)super.h.invoke(this, m1, new Object[] {   obj   })).booleanValue();   }   catch(Error _ex) { }   catch(Throwable throwable)   {   throw new UndeclaredThrowableException(throwable);   }   }   public final int hashCode()   {   try  {   return ((Integer)super.h.invoke(this, m0, null)).intValue();   }   catch(Error _ex) { }   catch(Throwable throwable)   {   throw new UndeclaredThrowableException(throwable);   }   }   public final void doSomething()   {   try  {   super.h.invoke(this, m3, null);   return;   }   catch(Error _ex) { }   catch(Throwable throwable)   {   throw new UndeclaredThrowableException(throwable);   }   }   public final String toString()   {   try  {   return (String)super.h.invoke(this, m2, null);   }   catch(Error _ex) { }   catch(Throwable throwable)   {   throw new UndeclaredThrowableException(throwable);   }   }   static    {   try  {   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]);   m3 = Class.forName("Subject").getMethod("doSomething", new Class[0]);   m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);   }   catch(NoSuchMethodException nosuchmethodexception)   {   throw new NoSuchMethodError(nosuchmethodexception.getMessage());   }   catch(ClassNotFoundException classnotfoundexception)   {   throw new NoClassDefFoundError(classnotfoundexception.getMessage());   }   }
}  

private byte[] generateClassFile() {   /*  * Record that proxy methods are needed for the hashCode, equals,  * and toString methods of java.lang.Object.  This is done before  * the methods from the proxy interfaces so that the methods from  * java.lang.Object take precedence over duplicate methods in the  * proxy interfaces.  */  addProxyMethod(hashCodeMethod, Object.class);   addProxyMethod(equalsMethod, Object.class);   addProxyMethod(toStringMethod, Object.class);   /*  * Now record all of the methods from the proxy interfaces, giving  * earlier interfaces precedence over later ones with duplicate  * methods.  */  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.  */  try {   methods.add(generateConstructor());   for (List<ProxyMethod> sigmethods : proxyMethods.values()) {   for (ProxyMethod pm : sigmethods) {   // add static field for method's Method object   fields.add(new FieldInfo(pm.methodFieldName,   "Ljava/lang/reflect/Method;",   ACC_PRIVATE | ACC_STATIC));   // generate code for proxy method and add it   methods.add(pm.generateMethod());   }   }   methods.add(generateStaticInitializer());   } catch (IOException e) {   throw new InternalError("unexpected I/O Exception");   }   /* ============================================================  * Step 3: Write the final class file.  */  /*  * Make sure that constant pool indexes are reserved for the  * following items before starting to write the final class file.  */  cp.getClass(dotToSlash(className));   cp.getClass(superclassName);   for (int i = 0; i < interfaces.length; i++) {   cp.getClass(dotToSlash(interfaces[i].getName()));   }   /*  * Disallow new constant pool additions beyond this point, since  * we are about to write the final constant pool table.  */  cp.setReadOnly();   ByteArrayOutputStream bout = new ByteArrayOutputStream();   DataOutputStream dout = new DataOutputStream(bout);   try {   /*  * Write all the items of the "ClassFile" structure.  * See JVMS section 4.1.  */  // 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();