JDK动态代理原理实现

持有被代理类对象的类称为代理类。

JDK实现动态代理的对象必须实现接口，为什么一定要实现接口？

## 创建接口类

public interface Human {

    void createHourse();
}

## 创建被代理对象

public ITHuman implements Human {

    @Override
    public void cereateHourse() {
        
        System.println.out("我要一所大房子");

    }    
}

## 创建代理类

public class HourseProxy implements InvocationHandler {

    private Object target;

    public HourseProxy(Object target) {

        this.target = target;
    }

    public static Object getProxyInstance() {
        
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(), this)
    }
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        System.out.println("正在帮你筛选房源信息");
        Object obj = method.invoke(target, args);
        System.out.println("你已经拥有了一栋新房子");
        return obj;
    }
    

}

public class ProxyTest {

    public static void main(String[] args) {

        HourseProxy proxy = new HourseProxy(new ITHuman());
        Human me = (Human)proxy.getProxyInstance();
        /** com.sun.proxy.$Proxy4 */
        //以$开头的类都是动态生成的
        System.out.println(me.getClass());
        human.createHourse();
       
    }
}

  打印信息............... 

class com.sun.proxy.$Proxy4
正在帮你筛选房源信息
我要一所大房子
你已经拥有了一栋新房子

可以看到代理对象的类名是以 刀略$Proxy开始的，下面来看看这个动态代理类的代码：

如何来获取这个代理类的呢？注意文件目录里面是找不到的，

         //通过反编译工具查看源代码
        byte[] bytes = ProxyGenerator.generateProxyClass("$Proxy4", new Class[]{Human.class});
        FileOutputStream outputStream = new FileOutputStream("//Users//pengy//$Proxy4s.class");
        outputStream.write(bytes);
        outputStream.close();

import com.gupao.mode.proxy.Human;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

public final class $Proxy4 extends Proxy implements Human {
    private static Method m1;
    private static Method m2;
    private static Method m5;
    private static Method m0;

    public $Proxy4(InvocationHandler var1) throws  {
        super(var1);
    }

    public final boolean equals(Object var1) throws  {
        try {
            return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }


    public final String toString() throws  {
        try {
            return (String)super.h.invoke(this, m2, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final void createHourse() throws  {
        try {
            super.h.invoke(this, m5, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final int hashCode() throws  {
        try {
            return (Integer)super.h.invoke(this, m0, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m5 = Class.forName("com.gupao.mode.proxy.Human").getMethod("createHourse");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

从上可知，我们在main中调用human.createHourse() 的时候实际上是调用的代理类$Proxy4中的createHourse（）方法，

 

 

既然是调用的代理类那么invoke方法当然是代理类中的invoke方法，然后通过反射来调目标方法，到这里对动态代理的思想是不是更深一步呢。还是挺有意思的嘛

 

 动态代理原理：字节码重组

                          1.生成Java 文件

                          2.将java文件写到磁盘

                          3.编译成class 文件

                          4.将class文件加载到JVM中

步骤一生成Java文件就是上面的$Proxy4, 回到了没有IDE的时代，记事本写Java文件，那可是一个标点符号都不错的哦。