java JDK 动态代理（如何使用，以及工作原理解析）

JDK 动态代理如何使用

1：实现 InvocationHandler 接口
2：有一个自己定义的接口，名称为 InterFace。有一个实现InterFace接口的实现类。
3：使用 Proxy 中的 newProxyInstance 方法创建代理类。

具体的实现是请看下面的代码

被代理接口package com.javaproxy.test;public interface InterFace {    public String interFaceMethod(String str);}被代理接口实现类package com.javaproxy.test;public class InterFaceImpl implements InterFace{    @Override    public String interFaceMethod(String str) {        return str + "+lp";    }}InvocationHandler接口实现类package com.javaproxy.test;import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;public class InvocationHandlerImpl implements InvocationHandler {    //要代理的原始对象    private Object obj;    public InvocationHandlerImpl(Object obj) {        this.obj = obj;    }    @Override    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {        System.out.println("执行被代理方法前，需要做的处理doBefore");        System.out.println("执行被代理方法 ing");        Object result = method.invoke(obj, args);        System.out.println("执行被代理方法后，需要做的处理doAfter");        return result;    }}测试类package com.javaproxy.test;import java.lang.reflect.InvocationHandler;import java.lang.reflect.Proxy;public class TestJavaProxy {    public static void main(String[] args) {        InterFace impl = new InterFaceImpl();        InvocationHandler handler = new InvocationHandlerImpl(impl);        Object proxyObj= Proxy.newProxyInstance(impl.getClass().getClassLoader(), impl.getClass().getInterfaces(), handler);        InterFace inter = (InterFace) proxyObj;        inter.interFaceMethod("lp");    }}运行测试类，结果执行被代理方法前，需要做的处理doBefore执行被代理方法 ing执行被代理方法后，需要做的处理doAfter

JDK动态代理原理解析

JDK提供了sun.misc.ProxyGenerator.generateProxyClass(String proxyName,class[] interfaces) 底层方法来产生动态代理类的字节码：
下面定义了一个工具类，用来将生成的动态代理类保存到硬盘中：

package com.javaproxy.test;import java.io.FileOutputStream;import java.io.IOException;import sun.misc.ProxyGenerator;public class ProxyUtils {    /*     * 将根据类信息 动态生成的二进制字节码保存到硬盘中，     * 默认保存到 D 盘根目录下     * clazz 需要生成动态代理类的类     * proxyName : 为动态生成的代理类的名称     */    public static void generateClassFile(Class<?> clazz, String proxyName) {        // 根据类信息和提供的代理类名称，生成字节码        byte[] classFile = ProxyGenerator.generateProxyClass(proxyName, clazz.getInterfaces());        // String paths = clazz.getResource(".").getPath();        String paths = "D:/";        FileOutputStream out = null;        try {            // 保留到硬盘中            out = new FileOutputStream(paths + proxyName + ".class");            out.write(classFile);            out.flush();        } catch (Exception e) {            e.printStackTrace();        } finally {            try {                out.close();            } catch (IOException e) {                e.printStackTrace();            }        }    }}

在测试类TestJavaProxy 中的main方法中的 Proxy.newProxyInstance代码下面添加代码 ProxyUtils.generateClassFile(proxyObj.getClass(), "ProxyObj");
这样就可以在，D盘的根目录下，找到 ProxyObj.class 文件，使用jd-gui 反编译工具打开。反编译后，代码如下。

import com.javaproxy.test.InterFace;import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;import java.lang.reflect.Proxy;import java.lang.reflect.UndeclaredThrowableException;public final class ProxyObj extends Proxy  implements InterFace{  private static Method m1;  private static Method m0;  private static Method m3;  private static Method m2;  public ProxyObj(InvocationHandler paramInvocationHandler)    throws   {    super(paramInvocationHandler);  }  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 String interFaceMethod(String paramString)    throws   {    try    {      return (String)this.h.invoke(this, m3, new Object[] { paramString });    }    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    {      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("com.javaproxy.test.InterFace").getMethod("interFaceMethod", new Class[] { Class.forName("java.lang.String") });      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());    }  }}

可以看到 通过 java.lang.reflect.Proxy 的方法 newProxyInstance 获取的代理类（ProxyObj），实现了，自己定义的 InterFace接口。所以在测试类里面，可以将 获取的代理类（ProxyObj）强制转换为InterFace对象类型。

再看 获取的代理类（ProxyObj），是如何调用被代理对象的，以及如何调用InvocationHandler接口实现类的。

代理类调用过程
1：获取的代理类强制转换为InterFace对象类型，调用 interFaceMethod 方法。
实际调用的方法 是 类ProxyObj 里面的interFaceMethod方法。
2：那么接着看，类ProxyObj 里面的interFaceMethod方法，方法内的代码是
try
{
return (String)this.h.invoke(this, m3, new Object[] { paramString });
}
catch (Error|RuntimeException localError)
{
throw localError;
}
catch (Throwable localThrowable)
{
throw new UndeclaredThrowableException(localThrowable);
}
方法内，调用了代理类自己的属性 h（从java.lang.reflect.Proxy 继承过来的） 即咱们自己的InvocationHandler 接口的实现类InvocationHandlerImpl，然后调用， h 的 invoke方法。看看 invoke方法的参数，第一个参数传入进入的是代理对象自己，第二参数是静态代码初始化的Method对象
m3 = Class.forName("com.javaproxy.test.InterFace").getMethod("interFaceMethod", new Class[] { Class.forName("java.lang.String") });
第三个参数是，调用代理类对象中的方法是传递进来的参数。

讲到这里大家应该可以理解JDK的动态代理是怎么实现的了。

这个再贴一篇文章的地址，点击打开