java的jdk动态代理，这里的动态是怎么体现的？

Question

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;public class ProxyHandler implements InvocationHandler { private Object obj; public Object bind(Object obj){
this.obj  = obj;
return Proxy.newProxyInstance(obj.getClass().getClassLoader(),
obj.getClass().getInterfaces(),
this);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { Object result = null;
System.out.println("before invoke!*****");
result = method.invoke(obj, args);
System.out.println("after invoke!-----");
return result;
}}
public class RealSubject implements Subject { @Override
public void dosomething() {
System.out.println(" call something! ");

}
}public interface Subject { public void dosomething();
}public class SubjectProxy implements Subject { @Override
public void dosomething() {

}
}
public class TestProxy { public static void main(String args[]){
 ProxyHandler proxy = new ProxyHandler();
         //绑定该类实现的所有接口
         Subject sub = (Subject) proxy.bind(new RealSubject());
         sub.dosomething();
}
}
具体这个代理类，java底层是如何实现的？

Answer 1

import java.lang.reflect.Field;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.Proxy;import com.sun.xml.internal.ws.org.objectweb.asm.ClassReader;
import com.sun.xml.internal.ws.org.objectweb.asm.ClassWriter;
 
public class ProxyHander implements InvocationHandler {
 
    private Object obj;
 
    public Object bind(Object obj){
        this.obj  = obj;
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(),
                obj.getClass().getInterfaces(),
                this);
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    
        Object result = null;
        System.out.println("before invoke!*****");
        result = method.invoke(obj, args);
        System.out.println("after invoke!-----");       
        return result;
    }
 
    public static void main(String args[]){
     RealSubject rs = new RealSubject();
     ProxyHander proxy = new ProxyHander();
        //绑定该类实现的所有接口
        Subject obj = (Subject)proxy.bind(rs);
        obj.dosomething();
        
        Class<?> c = obj.getClass();
        Field[] fs = c.getDeclaredFields();
        
        //定义可变长的字符串，用来存储属性  
        StringBuffer sb = new StringBuffer();  
        //通过追加的方法，将每个属性拼接到此字符串中  
        //最外边的public定义  
        sb.append(Modifier.toString(c.getModifiers()) + " class " + c.getSimpleName() );  
        Class<?>[] interfaces = c.getInterfaces();
        if(interfaces.length>0){
         sb.append(" implements ");
        }
        for(Class<?> i:interfaces){
         sb.append(i.getName()+" ");
        }
        sb.append("{\n");
        //里边的每一个属性  
        for(Field field:fs){  
         field.setAccessible(true);
            sb.append("\t");//空格  
            sb.append(Modifier.toString(field.getModifiers())+" ");//获得属性的修饰符，例如public，static等等  
            sb.append(field.getType().getSimpleName() + " ");//属性的类型的名字  
            sb.append(field.getName()+";\n");//属性的名字+回车  
        }  
        
        Method[] m = c.getDeclaredMethods();
        
        for(Method method:m){
         method.setAccessible(true);
         sb.append("\t");//空格  
            sb.append(Modifier.toString(method.getModifiers())+" ");//获得属性的修饰符，例如public，static等等  
            sb.append(method.getReturnType().getName()+" ");
            Class<?>[] param = method.getParameterTypes();//获取方法类返回型
            sb.append(" "+method.getName()+" (");
            for(int i=0;i<param.length;i++){
             sb.append(param[i].getName()+" "+"arg"+i);
             if(i!=param.length-1){
             sb.append(",");
             }
            }
            sb.append(")\n");
        }
        
        sb.append("}");  
  
        System.out.println(sb);  
        
        
   }
}
 
 
class RealSubject implements Subject {
 
    @Override
    public void dosomething() {
        System.out.println(" call something! ");
         
    }
    
}
 
interface Subject {
 
    public void dosomething();
}
 执行结果
before invoke!*****
 call something! 
after invoke!-----
public final class $Proxy0 implements Subject {
private static Method m1;
private static Method m3;
private static Method m0;
private static Method m2;
public final boolean  equals (java.lang.Object arg0)
public final java.lang.String  toString ()
public final int  hashCode ()
public final void  dosomething ()
}
从上面反射后的class内容可以知道他会用classwrite重新建一个Proxyxx的类并实现你的超类接口，你的dosometing会被重写。你可以把接口换成类试一下，这个代理就会失效了。所以框架注入时都会要求用户写接口也是这样来的。但现在的cglib 可以不写接口也能实现注入