深度剖析java中JDK动态代理机制
程序员文章站
2024-03-01 22:22:04
摘要
相比于静态代理，动态代理避免了开发人员编写各个繁锁的静态代理类，只需简单地指定一组接口及目标类对象就能动态的获得代理对象。
代理模式
使用代理模式必须要让代...
摘要
相比于静态代理，动态代理避免了开发人员编写各个繁锁的静态代理类，只需简单地指定一组接口及目标类对象就能动态的获得代理对象。
代理模式
使用代理模式必须要让代理类和目标类实现相同的接口，客户端通过代理类来调用目标方法，代理类会将所有的方法调用分派到目标对象上反射执行，还可以在分派过程中添加"前置通知"和后置处理（如在调用目标方法前校验权限，在调用完目标方法后打印日志等）等功能。
使用动态代理的五大步骤
1.通过实现invocationhandler接口来自定义自己的invocationhandler;
2.通过proxy.getproxyclass获得动态代理类
3.通过反射机制获得代理类的构造方法，方法签名为getconstructor(invocationhandler.class)
4.通过构造函数获得代理对象并将自定义的invocationhandler实例对象传为参数传入
5.通过代理对象调用目标方法
动态代理的使用
例1(方式一)
public class myproxy {
public interface ihello{
void sayhello();
}
static class hello implements ihello{
public void sayhello() {
system.out.println("hello world!!");
}
}
//自定义invocationhandler
static class hwinvocationhandler implements invocationhandler{
//目标对象
private object target;
public hwinvocationhandler(object target){
this.target = target;
}
public object invoke(object proxy, method method, object[] args) throws throwable {
system.out.println("------插入前置通知代码-------------");
//执行相应的目标方法
object rs = method.invoke(target,args);
system.out.println("------插入后置处理代码-------------");
return rs;
}
}
public static void main(string[] args) throws nosuchmethodexception, illegalaccessexception, invocationtargetexc eption, instantiationexception {
//生成$proxy0的class文件
system.getproperties().put("sun.misc.proxygenerator.savegeneratedfiles", "true");
//获取动态代理类
class proxyclazz = proxy.getproxyclass(ihello.class.getclassloader(),ihello.class);
//获得代理类的构造函数，并传入参数类型invocationhandler.class
constructor constructor = proxyclazz.getconstructor(invocationhandler.class);
//通过构造函数来创建动态代理对象，将自定义的invocationhandler实例传入
ihello ihello = (ihello) constructor.newinstance(new hwinvocationhandler(new hello()));
//通过代理对象调用目标方法
ihello.sayhello();
}
}
输出：
------插入前置通知代码-------------
hello world!!
------插入后置处理代码-------------
proxy类中还有个将2~4步骤封装好的简便方法来创建动态代理对象，其方法签名为：newproxyinstance(classloader loader,class<?>[] instance, invocationhandler h)，如下例：
(方式二)
public static void main(string[] args) throws nosuchmethodexception, illegalaccessexception, invocationtargetexception, instantiationexception {
//生成$proxy0的class文件
system.getproperties().put("sun.misc.proxygenerator.savegeneratedfiles", "true");
ihello ihello = (ihello) proxy.newproxyinstance(ihello.class.getclassloader(), //加载接口的类加载器
new class[]{ihello.class}, //一组接口
new hwinvocationhandler(new hello())); //自定义的invocationhandler
ihello.sayhello();
}
输出结果一样.
下面以newproxyinstance方法为切入点来剖析代理类的生成及代理方法的调用
（为了篇幅整洁去掉了次要的代码）
public static object newproxyinstance(classloader loader,
class<!--?-->[] interfaces,
invocationhandler h)
throws illegalargumentexception
{
if (h == null) { //如果h为空直接抛出异常，所以invocationhandler实例对象是必须的
throw new nullpointerexception();
}
//对象的拷贝,暂不知道这里拷贝下的意义是啥？
final class<!--?-->[] intfs = interfaces.clone();
//一些安全的权限检查
final securitymanager sm = system.getsecuritymanager();
if (sm != null) {
checkproxyaccess(reflection.getcallerclass(), loader, intfs);
}
//产生代理类
class<!--?--> cl = getproxyclass0(loader, intfs);
//获取代理类的构造函数对象
//参数constructorparames为常量值：private static final class<!--?-->[] constructorparams = { invocationhandler.class };
final constructor<!--?--> cons = cl.getconstructor(constructorparames);
final invocationhandler ih = h;
//根据代理类的构造函数对象来创建代理类对象
return newinstance(cons, ih);
}
这段代码就是对代理类对象的创建，就是对例1中34~38行封装，其中getproxyclass0就是生成代理类的方法
getproxyclass0方法剖析
private static class<!--?--> getproxyclass0(classloader loader,
class<!--?-->... interfaces) {
//接口数不得超过65535个
if (interfaces.length > 65535) {
throw new illegalargumentexception("interface limit exceeded");
}
//代理类缓存，如果缓存中有代理类了直接返回，否则将由proxyclassfactory创建代理类
return proxyclasscache.get(loader, interfaces);
}
看看proxyclassfactory是怎样生成代理类的?
private static final class proxyclassfactory
implements bifunction<classloader, class<?="">[], class<!--?-->>
{
//统一代理类的前缀名都以$proxy开关
private static final string proxyclassnameprefix = "$proxy";
//使用唯一的编号给作为代理类名的一部分，如$proxy0,$proxy1等
private static final atomiclong nextuniquenumber = new atomiclong();
@override
public class<!--?--> apply(classloader loader, class<!--?-->[] interfaces) {
map<class<?>, boolean> interfaceset = new identityhashmap<>(interfaces.length);
for (class<!--?--> intf : interfaces) {
//验证指定的类加载器(loader)加载接口所得到的class对象(interfaceclass)是否与intf对象相同
class<!--?--> interfaceclass = null;
try {
interfaceclass = class.forname(intf.getname(), false, loader);
} catch (classnotfoundexception e) {
}
if (interfaceclass != intf) {
throw new illegalargumentexception(
intf + " is not visible from class loader");
}
//验证该class对象是不是接口
if (!interfaceclass.isinterface()) {
throw new illegalargumentexception(
interfaceclass.getname() + " is not an interface");
}
// 验证该接口是否重复了
if (interfaceset.put(interfaceclass, boolean.true) != null) {
throw new illegalargumentexception(
"repeated interface: " + interfaceclass.getname());
}
}
//声明代理类所在包
string proxypkg = null;
/*验证你传入的接口中是否有非public接口，只要有一个接口是非public的，那么这些接口都必须在同一包中
这里的接口修饰符直接影响到system.getproperties().put("sun.misc.proxygenerator.savegeneratedfiles", "true")所生成
的代理类的路径，往下看！！*/
for (class<!--?--> intf : interfaces) {
int flags = intf.getmodifiers();
if (!modifier.ispublic(flags)) {
string name = intf.getname();
int n = name.lastindexof('.');
//截取完整包名
string pkg = ((n == -1) ? "" : name.substring(0, n + 1));
if (proxypkg == null) {
proxypkg = pkg;
} else if (!pkg.equals(proxypkg)) {
throw new illegalargumentexception(
"non-public interfaces from different packages");
}
}
}
if (proxypkg == null) {
/*如果都是public接口，那么生成的代理类就在com.sun.proxy包下如果报java.io.filenotfoundexception: com\sun\proxy\$proxy0.c lass (系统找不到指定的路径。)的错误，就先在你项目中创建com.sun.proxy路径*/
proxypkg = reflectutil.proxy_package + ".";
}
//将当前nextuniquenumber的值以原子的方式的加1，所以第一次生成代理类的名字为$proxy0.class
long num = nextuniquenumber.getandincrement();
//代理类的完全限定名，如com.sun.proxy.$proxy0.calss,
string proxyname = proxypkg + proxyclassnameprefix + num;
//生成代理类字节码文件
byte[] proxyclassfile = proxygenerator.generateproxyclass(
proxyname, interfaces);
try {
return defineclass0(loader, proxyname,
proxyclassfile, 0, proxyclassfile.length);
} catch (classformaterror e) {
throw new illegalargumentexception(e.tostring());
}
}
}</class<?></classloader,>
而生成代理类字节码文件又主要通过proxygenerate的generateproxyclass(proxyname，interfaces)
public static byte[] generateproxyclass(final string var0, class[] var1) {
proxygenerator var2 = new proxygenerator(var0, var1);
//生成代理类字节码文件的真正方法
final byte[] var3 = var2.generateclassfile();
//保存文件
if(savegeneratedfiles) {
accesscontroller.doprivileged(new privilegedaction() {
public void run() {
try {
fileoutputstream var1 = new fileoutputstream(proxygenerator.dottoslash(var0) + ".class");
var1.write(var3);
var1.close();
return null;
} catch (ioexception var2) {
throw new internalerror("i/o exception saving generated file: " + var2);
}
}
});
}
return var3;
}
层层调用后，最终generateclassfile才是真正生成代理类字节码文件的方法，注意开头的三个addproxymethod方法是只将object的hashcode,equals,tostring方法添加到代理方法容器中，代理类除此之外并没有重写其他object的方法，所以除这三个方法外，代理类调用其他方法的行为与object调用这些方法的行为一样不通过invoke
private byte[] generateclassfile() {
/addproxymethod系列方法就是将接口的方法和object的hashcode,equals,tostring方法添加到代理方法容器(proxymethods),
其中方法签名作为key,proxymethod作为value*/
/*hashcodemethod方法位于静态代码块中通过object对象获得，hashcodemethod=object.class.getmethod("hashcode",new class[0]),
相当于从object中继承过来了这三个方法equalsmethod,tostringmethod*/
this.addproxymethod(hashcodemethod, object.class); -->
this.addproxymethod(equalsmethod, object.class);
this.addproxymethod(tostringmethod, object.class);
int var1;
int var3;
//获得所有接口中的所有方法，并将方法添加到代理方法中
for(var1 = 0; var1 < this.interfaces.length; ++var1) {
method[] var2 = this.interfaces[var1].getmethods();
for(var3 = 0; var3 < var2.length; ++var3) {
this.addproxymethod(var2[var3], this.interfaces[var1]);
}
}
iterator var7 = this.proxymethods.values().iterator();
list var8;
while(var7.hasnext()) {
var8 = (list)var7.next();
checkreturntypes(var8); //验证具有相同方法签名的的方法的返回值类型是否一致，因为不可能有两个方法名相同,参数相同，而返回值却不同的方法
};
//接下来就是写代理类文件的步骤了
iterator var11
try {
//生成代理类的构造函数
this.methods.add(this.generateconstructor());
var7 = this.proxymethods.values().iterator();
while(var7.hasnext()) {
var8 = (list)var7.next();
var11 = var8.iterator();
while(var11.hasnext()) {
proxygenerator.proxymethod var4 = (proxygenerator.proxymethod)var11.next();
/将代理字段声明为method，10为acc_private和acc_stataic的与运算，表示该字段的修饰符为private static
所以代理类的字段都是private static method xxx*/
this.fields.add(new proxygenerator.fieldinfo(var4.methodfieldname, "ljava/lang/reflect/method;", 10));
//生成代理类的代理方法
this.methods.add(var4.generatemethod());
}
}
//为代理类生成静态代码块，对一些字段进行初始化
this.methods.add(this.generatestaticinitializer());
} catch (ioexception var6) {
throw new internalerror("unexpected i/o exception");
}
if(this.methods.size() > '\uffff') { //代理方法超过65535将抛出异常
throw new illegalargumentexception("method limit exceeded");
} else if(this.fields.size() > '\uffff') { //代理类的字段超过65535将抛出异常
throw new illegalargumentexception("field limit exceeded");
} else {
//这里开始就是一些代理类文件的过程，此过程略过
this.cp.getclass(dottoslash(this.classname));
this.cp.getclass("java/lang/reflect/proxy");
for(var1 = 0; var1 < this.interfaces.length; ++var1) {
this.cp.getclass(dottoslash(this.interfaces[var1].getname()));
}
this.cp.setreadonly();
bytearrayoutputstream var9 = new bytearrayoutputstream();
dataoutputstream var10 = new dataoutputstream(var9);
try {
var10.writeint(-889275714);
var10.writeshort(0);
var10.writeshort(49);
this.cp.write(var10);
var10.writeshort(49);
var10.writeshort(this.cp.getclass(dottoslash(this.classname)));
var10.writeshort(this.cp.getclass("java/lang/reflect/proxy"));
var10.writeshort(this.interfaces.length);
for(var3 = 0; var3 < this.interfaces.length; ++var3) {
var10.writeshort(this.cp.getclass(dottoslash(this.interfaces[var3].getname())));
}
var10.writeshort(this.fields.size());
var11 = this.fields.iterator();
while(var11.hasnext()) {
proxygenerator.fieldinfo var12 = (proxygenerator.fieldinfo)var11.next();
var12.write(var10);
}
var10.writeshort(this.methods.size());
var11 = this.methods.iterator();
while(var11.hasnext()) {
proxygenerator.methodinfo var13 = (proxygenerator.methodinfo)var11.next();
var13.write(var10);
}
var10.writeshort(0);
return var9.tobytearray();
} catch (ioexception var5) {
throw new internalerror("unexpected i/o exception");
}
}
}
addproxymethod方法剖析
private void addproxymethod(method var1, class var2) {
string var3 = var1.getname(); //方法名
class[] var4 = var1.getparametertypes(); //方法参数类型数组
class var5 = var1.getreturntype(); //返回值类型
class[] var6 = var1.getexceptiontypes(); //异常类型
string var7 = var3 + getparameterdescriptors(var4); //方法签名
object var8 = (list)this.proxymethods.get(var7); //根据方法签名却获得proxymethods的value
if(var8 != null) { //处理多个代理接口中重复的方法的情况
iterator var9 = ((list)var8).iterator();
while(var9.hasnext()) {
proxygenerator.proxymethod var10 = (proxygenerator.proxymethod)var9.next();
if(var5 == var10.returntype) {
/*归约异常类型以至于让重写的方法抛出合适的异常类型，我认为这里可能是多个接口中有相同的方法，而这些相同的方法抛出的异常类 型又不同，所以对这些相同方法抛出的异常进行了归约*/
arraylist var11 = new arraylist();
collectcompatibletypes(var6, var10.exceptiontypes, var11);
collectcompatibletypes(var10.exceptiontypes, var6, var11);
var10.exceptiontypes = new class[var11.size()];
//将arraylist转换为class对象数组
var10.exceptiontypes = (class[])var11.toarray(var10.exceptiontypes);
return;
}
}
} else {
var8 = new arraylist(3);
this.proxymethods.put(var7, var8);
}
((list)var8).add(new proxygenerator.proxymethod(var3, var4, var5, var6, var2, null));
/*24~27行的意思就是如果var8为空，就创建一个数组，并以方法签名为key,proxymethod对象数组为value添加到proxymethods*/
}
invocationhandler的作用
在动态代理中invocationhandler是核心，每个代理实例都具有一个关联的调用处理程序(invocationhandler)。对代理实例调用方法时，将对方法调用进行编码并将其指派到它的调用处理程序(invocationhandler)的 invoke 方法。所以对代理方法的调用都是通invocationhadler的invoke来实现中，而invoke方法根据传入的代理对象，方法和参数来决定调用代理的哪个方法
invoke方法签名：invoke（object proxy，method method，object[] args）
$proxy0.class
来看看例1(myproxy)的代理类是怎样的？
public final class $proxy0 extends proxy implements ihello { //继承了proxy类和实现ihello接口
//变量，都是private static method xxx
private static method m3;
private static method m1;
private static method m0;
private static method m2;
//代理类的构造函数，其参数正是是invocationhandler实例，proxy.newinstance方法就是通过通过这个构造函数来创建代理实例的
public $proxy0(invocationhandler var1) throws {
super(var1);
}
//接口代理方法
public final void sayhello() throws {
try {
super.h.invoke(this, m3, (object[])null);
} catch (runtimeexception | error var2) {
throw var2;
} catch (throwable var3) {
throw new undeclaredthrowableexception(var3);
}
}
//以下object中的三个方法
public final boolean equals(object var1) throws {
try {
return ((boolean)super.h.invoke(this, m1, new object[]{var1})).booleanvalue();
} catch (runtimeexception | error var3) {
throw var3;
} catch (throwable var4) {
throw new undeclaredthrowableexception(var4);
}
}
public final int hashcode() throws {
try {
return ((integer)super.h.invoke(this, m0, (object[])null)).intvalue();
} 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);
}
}
//对变量进行一些初始化工作
static {
try {
m3 = class.forname("com.mobin.proxy.ihello").getmethod("sayhello", new class[0]);
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]);
m2 = class.forname("java.lang.object").getmethod("tostring", new class[0]);
} catch (nosuchmethodexception var2) {
throw new nosuchmethoderror(var2.getmessage());
} catch (classnotfoundexception var3) {
throw new noclassdeffounderror(var3.getmessage());
}
}
}
以上就是对代理类如何生成，代理类方法如何被调用的分析！在很多框架都使用了动态代理如spring,hdfs的rpc调用等等，分析过程中收获很多，如果想深入的了解jdk动态代理机制一定要深入到源码去剖析！！希望对大家的学习有所帮助，也希望大家多多支持。