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的动态代理是怎么实现的了。

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