动态代理我们都使用过,很多场景下是对被代理类的方法进行增强,那么它反映在字节码中是什么样的呢?
先实现一个动态代理,实现InvocationHandler和代理的接口类如下:
public interface Subject { void test(); }
实现的类:
public class RealSubject implements Subject { @Override public void test() { System.out.println("real subject invoke"); } }
我们的代理类如下
public class DynamicSubject implements InvocationHandler {
private Object obj;
public DynamicSubject(Subject obj) {
this.obj = obj;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("call before:" + method);
//真正执行的方法
method.invoke(this.obj, args);
//真正方法代理结束
System.out.println("call after" + method);
return null;
}
}
上面已经实现了对RealSubject的代理,生成客户端进行调用
public static void main(String[] args) { //需要被代理的类 RealSubject realSubject = new RealSubject(); Class<? extends RealSubject> aClass = realSubject.getClass(); DynamicSubject ds = new DynamicSubject(realSubject); Subject o = (Subject) Proxy.newProxyInstance(aClass.getClassLoader(), aClass.getInterfaces(), ds); System.out.println(o.getClass()); o.test(); } }
下面进入重点,我们看输出结果
产生的Subject对象真正的类型是com.sun.proxy.$Proxy0
那这个对象是怎么产生的呢? 而且调用这个对象的类,怎么进跑到invocationHandler里面去了呢。。。查看Proxy.newPrxoyInstance方式入口查看
上述第二张图先生成Proxy0类对应的字节码数组,然后产生Class对象,通过class对象拿到构造函数,创建真实的实例,其中实现了InvocationHandler的类作为参数传递到了产生Prxoxy0的对象中。
那我们能不能看到代理对象对应的类长啥样呢。。。,我们看下面代码:
我们将属性修改一下,获取System.getproperties().put()方法设置true进去,就可以生成本地字节码文件了,反编译的实体类为
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//
package com.sun.proxy;
import com.example.demo.dynamic.Subject;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
public final class $Proxy0 extends Proxy implements Subject {
private static Method m1;
private static Method m3;
private static Method m2;
private static Method m0;
public $Proxy0(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 void test() throws {
try {
super.h.invoke(this, m3, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
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 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"));
m3 = Class.forName("com.example.demo.dynamic.Subject").getMethod("test");
m2 = Class.forName("java.lang.Object").getMethod("toString");
m0 = Class.forName("java.lang.Object").getMethod("hashCode");
} catch (NoSuchMethodException var2) {
throw new NoSuchMethodError(var2.getMessage());
} catch (ClassNotFoundException var3) {
throw new NoClassDefFoundError(var3.getMessage());
}
}
}
这下就跟前面的对象和H参数对应起来了,Client端调用的tets方法,其实就是调用h.invoke(this,test,null)方法,那么自然就调用到了我们实现了InvocationHYandler接口类中的方法
总结:动态代理的对象产生出来时,把我们代理类的实例作为参数传递进去,后续Proxy0方法调用,其实就是对应代理类Handler中实际的方法。以此达到增加的目的。
pS:我们看Prxoxy0源码得知,动态代理类还将Object中的hashCode,equals,toString方法给复写下来了,意思就是将这三个方法也默认给代理了,具体实现就看实现了InvocationHandler接口的类没有进行重写操作。
以上就是动态代理在字节码层面的实现,具体看到是如何调用我们自己的方法的,一切都是Proxy类和H参数的功能。