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