【相关学习推荐：java基础教程】
反射到底是好是坏说到java 中的反射，初学者在刚刚接触到反射的各种高级特性时，往往表示十分兴奋，甚至会在一些不需要使用反射的场景中强行使用反射来「炫技」。而经验较为丰富的长者，看到反射时往往会发出灵魂三问：为什么要用反射？反射不会降低性能么？不用还有什么办法可以解决这个问题？
那么今天我们就来深入探讨下，反射到底对性能有多大影响？顺便探讨下，反射为什么对性能有影响？
编码试验在我们分析具体原理之前，我们可以通过编写代码做实验得出结论。
反射可能会涉及多种类型的操作，比如生成实例，获取/设置变量属性，调用方法等。经过简单的思考，我们认为生成实例对性能的影响相对其他操作要大一些，所以我们采用生成实例来做试验。
在如下代码中，我们定义了一个类 innerclass，我们测试分别使用new和反射来生成 max_times个实例，并打印出耗时时间。
public class mainactivity extends appcompatactivity { private static final string tag = "mainac"; private final int max_times = 100 * 1000; private innerclass innerlist[]; @override protected void oncreate(bundle savedinstancestate) { super.oncreate(savedinstancestate); setcontentview(r.layout.activity_main); innerlist = new innerclass[max_times]; long starttime = systemclock.elapsedrealtime(); for (int i=0; i < max_times; i++) { innerlist[i] = new innerclass(); } log.e(tag, "totaltime: " + (systemclock.elapsedrealtime() - starttime)); long starttime2 = systemclock.elapsedrealtime(); for (int i=0; i < max_times; i++) { innerlist[i] = newinstancebyreflection(); } log.e(tag, "totaltime2: " + (systemclock.elapsedrealtime() - starttime2)); } public innerclass newinstancebyreflection() { class clazz = innerclass.class; try { return (innerclass) clazz.getdeclaredconstructor().newinstance(); } catch (nosuchmethodexception e) { e.printstacktrace(); } catch (illegalaccessexception e) { e.printstacktrace(); } catch (instantiationexception e) { e.printstacktrace(); } catch (invocationtargetexception e) { e.printstacktrace(); } return null; } static class innerclass { }}复制代码
输出日志：
2020-03-19 22:34:49.738 2151-2151/? e/mainac: totaltime: 152020-03-19 22:34:50.409 2151-2151/? e/mainac: totaltime2: 670复制代码
使用反射生成 10万 个实例，耗时 670ms，明显高于直接使用 new关键字的 15ms，所以反射性能低。别急，这个结论总结的还有点早，我们将要生成的实例总数改为 1000个试试，输出日志：
2020-03-19 22:39:21.287 3641-3641/com.example.myapplication e/mainac: totaltime: 22020-03-19 22:39:21.296 3641-3641/com.example.myapplication e/mainac: totaltime2: 9复制代码
使用反射生成 1000 个实例，虽然需要9ms，高于new的 2ms，但是 9ms 和 2ms 的差距本身肉眼不可见，而且通常我们在业务中写的反射一般来说执行频率也未必会超过 1000 次，这种场景下，我们还能理直气壮地说反射性能很低么？
很显然，不能。
除了代码执行耗时，我们再看看反射对内存的影响。我们仍然以生成 10万 个实例为目标，对上述代码做略微改动，依次只保留 new 方式和反射方式，然后运行程序，观察内存占用情况。
使用 new 方式
使用反射
对比两图，我们可以看到第二张图中多了很多 constructor和class对象实例，这两部分占用的内存2.7m。因此，我们可以得出结论，反射会产生大量的临时对象，并且会占用额外内存空间。
刨根问底：反射原理是什么我们以前面试验中反射生成实例的代码为入口。
首先回顾下虚拟机中类的生命周期：加载，连接（验证，准备，解析），初始化，使用，卸载。在加载的过程 中，虚拟机会把类的字节码转换成运行时数据结构，并保存在方法区，在内存中会生成一个代表这个类数据结构的 java.lang.class 对象，后续访问这个类的数据结构就可以通过这个 class 对象来访问。
public innerclass newinstancebyreflection() { // 获取虚拟机中 innerclass 类的 class 对象 class clazz = innerclass.class; try { return (innerclass) clazz.getdeclaredconstructor().newinstance(); } catch (nosuchmethodexception e) { e.printstacktrace(); } catch (illegalaccessexception e) { e.printstacktrace(); } catch (instantiationexception e) { e.printstacktrace(); } catch (invocationtargetexception e) { e.printstacktrace(); } return null;}复制代码
代码中 clazz.getdeclaredconstructor() 用于获取类中定义的构造方法，由于我们没有显式定义构造方法，所以会返回编译器为我们自己生成的默认无参构造方法。
下面我们看下 getdeclaredconstructor是如何返回构造方法的。以下均以 jdk 1.8代码为源码。
@callersensitivepublic constructor<t> getdeclaredconstructor(class<?>... parametertypes) throws nosuchmethodexception, securityexception { // 权限检查 checkmemberaccess(member.declared, reflection.getcallerclass(), true); return getconstructor0(parametertypes, member.declared);}复制代码
getdeclaredconstructor 方法首先做了权限检查，然后直接调用 getconstructor0 方法。
private constructor<t> getconstructor0(class<?>[] parametertypes, int which) throws nosuchmethodexception{ // privategetdeclaredconstructors 方法是获取所有的构造方法数组 constructor<t>[] constructors = privategetdeclaredconstructors((which == member.public)); // 遍历所有的构造方法数组，根据传入的参数类型依次匹配，找到合适的构造方法后就会拷贝一份作为返回值 for (constructor<t> constructor : constructors) { if (arraycontentseq(parametertypes, constructor.getparametertypes())) { // 拷贝构造方法 return getreflectionfactory().copyconstructor(constructor); } } // 没有找到的话，就抛出异常 throw new nosuchmethodexception(getname() + ".<init>" + argumenttypestostring(parametertypes));}复制代码
getconstructor0 方法主要做了两件事：
获取所有构造方法组成的数组遍历构造方法数组，找到匹配的遍历匹配没啥好说的，我们重点看下第一件事，怎么获取的所有构造方法数组，也就是这个方法 privategetdeclaredconstructors。
private constructor<t>[] privategetdeclaredconstructors(boolean publiconly) { checkinitted(); constructor<t>[] res; // 获取缓存的 reflectiondata 数据 reflectiondata<t> rd = reflectiondata(); // 如果缓存中有 reflectiondata，就先看看 reflectiondata 中的 publicconstructors 或 declaredconstructors是否为空 if (rd != null) { res = publiconly ? rd.publicconstructors : rd.declaredconstructors; if (res != null) return res; } // 如果没有缓存，或者缓存中构造方法数组为空 // no cached value available; request value from vm // 对接口类型的字节码特殊处理 if (isinterface()) { @suppresswarnings("unchecked") // 如果是接口类型，那么生成一个长度为0的构造方法数组 constructor<t>[] temporaryres = (constructor<t>[]) new constructor<?>[0]; res = temporaryres; } else { // 如果不是接口类型，就调用 getdeclaredconstructors0 获取构造方法数组 res = getdeclaredconstructors0(publiconly); } // 获取到构造方法数组后，再赋值给缓存 reflectiondata 中的对应属性 if (rd != null) { if (publiconly) { rd.publicconstructors = res; } else { rd.declaredconstructors = res; } } return res;}复制代码
上述代码中我已经对关键代码进行了注释，在讲解整个流程之前，我们看到了一个陌生的类型 reflectiondata。它对应的数据结构是：
private static class reflectiondata<t> { volatile field[] declaredfields; volatile field[] publicfields; volatile method[] declaredmethods; volatile method[] publicmethods; volatile constructor<t>[] declaredconstructors; volatile constructor<t>[] publicconstructors; // intermediate results for getfields and getmethods volatile field[] declaredpublicfields; volatile method[] declaredpublicmethods; volatile class<?>[] interfaces; // value of classredefinedcount when we created this reflectiondata instance final int redefinedcount; reflectiondata(int redefinedcount) { this.redefinedcount = redefinedcount; }}复制代码
reflectiondata 这个类就是用来保存从虚拟机中获取到的一些数据。同时我们可以看到所有反射属性都使用了 volatile关键字修饰。
获取缓存的 reflectiondata 数据是通过调用reflectiondata()方法获取的。
// 定义在 class 类中的反射缓存对象private volatile transient softreference<reflectiondata<t>> reflectiondata;private reflectiondata<t> reflectiondata() { softreference<reflectiondata<t>> reflectiondata = this.reflectiondata; int classredefinedcount = this.classredefinedcount; reflectiondata<t> rd; if (usecaches && reflectiondata != null && (rd = reflectiondata.get()) != null && rd.redefinedcount == classredefinedcount) { return rd; } // else no softreference or cleared softreference or stale reflectiondata // -> create and replace new instance return newreflectiondata(reflectiondata, classredefinedcount);}复制代码
我们可以看到 reflectiondata实际上是一个软引用，软引用会在内存不足的情况下被虚拟机回收，所以reflectiondata()方法在开始的地方，先判断了是否可以使用缓存以及缓存是否失效，如果失效了，就会调用 newreflectiondata方法生成一个新的 reflectiondata 实例。
接下来看看 newreflectiondata 方法。
private reflectiondata<t> newreflectiondata(softreference<reflectiondata<t>> oldreflectiondata, int classredefinedcount) { // 如果不允许使用缓存，直接返回 null if (!usecaches) return null; while (true) { reflectiondata<t> rd = new reflectiondata<>(classredefinedcount); // try to cas it... if (atomic.casreflectiondata(this, oldreflectiondata, new softreference<>(rd))) { return rd; } // else retry oldreflectiondata = this.reflectiondata; classredefinedcount = this.classredefinedcount; if (oldreflectiondata != null && (rd = oldreflectiondata.get()) != null && rd.redefinedcount == classredefinedcount) { return rd; } }}复制代码
newreflectiondata中使用 volatile + 死循环 + cas 机制 保证线程安全。注意到这里的死循环每执行一次都会构造一个新的 reflectiondata 实例。
你可能会有疑问，class 中 reflectiondata属性什么时候被赋值的，其实是封装在atomic.casreflectiondata这个方法里了，他会检测当前class对象中的reflectiondata是否与oldreflectiondata相等，如果相等，就会把new softreference<>(rd)赋值给 reflectiondata。
到现在为止，关于 reflectiondata的背景知识都介绍完了。我们再回到 privategetdeclaredconstructors中看看获取构造方法的流程。
privategetdeclaredconstructors流程图
可以看到对于普通类，最终通过调用 getdeclaredconstructors0方法获取的构造方法列表。
private native constructor<t>[] getdeclaredconstructors0(boolean publiconly);复制代码
这个方法是 native 的，具体逻辑在 jdk 源码中。
在 native/java/lang/class_getdeclaredconstructors0.c 文件中，
void getdeclaredconstructors0(frame * frame){ // frame 可以理解为调用native方法时，java层传递过来的数据的一种封装 localvars * vars = frame->localvars; object * classobj = getlocalvarsthis(vars); // 取得java方法的入参 bool publiconly = getlocalvarsboolean(vars, 1); uint16_t constructorscount = 0; // 获取要查询的类的 class 对象 class * c = classobj->extra; // 获取这个类的所有构造方法，且数量保存在 constructorscount 中 method* * constructors = getclassconstructors(c, publiconly, &constructorscount); // 获取 java 方法调用所属的 classloader classloader * classloader = frame->method->classmember.attachclass->classloader; // 拿到 constructor 对应的 class 对象 class * constructorclass = loadclass(classloader, "java/lang/reflect/constructor"); //创建一个长度为 constructorscount 的数组保存构造方法 object * constructorarr = newarray(arrayclass(constructorclass), constructorscount); pushoperandref(frame->operandstack, constructorarr); // 后面是具体的赋值逻辑。将native中的method对象转化为java层的constructor对象 if (constructorscount > 0) { thread * thread = frame->thread; object* * constructorobjs = getobjectrefs(constructorarr); method * constructorinitmethod = getclassconstructor(constructorclass, _constructorconstructordescriptor); for (uint16_t i = 0; i < constructorscount; i++) { method * constructor = constructors[i]; object * constructorobj = newobject(constructorclass); constructorobj->extra = constructor; constructorobjs[i] = constructorobj; operandstack * ops = newoperandstack(9); pushoperandref(ops, constructorobj); pushoperandref(ops, classobj); pushoperandref(ops, toclassarr(classloader, methodparametertypes(constructor), constructor->parseddescriptor->parametertypescount)); if (constructor->exceptions != null) pushoperandref(ops, toclassarr(classloader, methodexceptiontypes(constructor), constructor->exceptions->number_of_exceptions)); else pushoperandref(ops, toclassarr(classloader, methodexceptiontypes(constructor), 0)); pushoperandint(ops, constructor->classmember.accessflags); pushoperandint(ops, 0); pushoperandref(ops, getsignaturestr(classloader, constructor->classmember.signature)); // signature pushoperandref(ops, tobytearr(classloader, constructor->classmember.annotationdata, constructor->classmember.annotationdatalen)); pushoperandref(ops, tobytearr(classloader, constructor->parameterannotationdata, constructor->parameterannotationdatalen)); frame * shimframe = newshimframe(thread, ops); pushthreadframe(thread, shimframe); // init constructorobj invokemethod(shimframe, constructorinitmethod); } }}复制代码
从上面的逻辑，可以知道获取构造方法的核心方法是 getclassconstructors ，所在文件为 rtda/heap/class.c。
method* * getclassconstructors(class * self, bool publiconly, uint16_t * constructorscount){ // 分配大小为 sizeof(method) 的长度为 methodscount 的连续内存地址，即数组 method* * constructors = calloc(self->methodscount, sizeof(method)); *constructorscount = 0; // 在native 层，构造方法和普通方法都存在 methods 中，逐一遍历 for (uint16_t i = 0; i < self->methodscount; i++) { method * method = self->methods + i; // 判断是否是构造方法 if (ismethodconstructor(method)) { // 检查权限 if (!publiconly || ismethodpublic(method)) { // 符合条件的构造方法依次存到数组中 constructors[*constructorscount] = method; (*constructorscount)++; } } } return constructors;}复制代码
可以看到getclassconstructors实际上就是对 methods 进行了一次过滤，过滤的条件为：1.是构造方法；2.权限一致。
ismethodconstructor 方法的判断逻辑也是十分简单，不是静态方法，而且方法名是<init>即可。
bool ismethodconstructor(method * self){ return !ismethodstatic(self) && strcmp(self->classmember.name, "<init>") == 0; }复制代码
所以核心的逻辑变成了class中的 methods数组何时被初始化赋值的？我们刨根问底的追踪下。
我们先找到类加载到虚拟机中的入口方法 loadnonarrayclass：
class * loadnonarrayclass(classloader * classloader, const char * classname){ int32_t classsize = 0; char * classcontent = null; class * loadclass = null; classsize = readclass(classname, &classcontent); if (classsize > 0 && classcontent != null){#if 0 printf("class size:%d,class data:[", classsize); for (int32_t i = 0; i < classsize; i++) { printf("0x%02x ", classcontent[i]); } printf("]\n");#endif } if (classsize <= 0) { printf("could not found target class\n"); exit(127); } // 解析字节码文件 loadclass = parseclassfile(classcontent, classsize); loadclass->classloader = classloader; // 加载 defineclass(classloader, loadclass); // 链接 linkclass(classloader, loadclass); //printf("[loaded %s\n", loadclass->name); return loadclass;}复制代码
在 parseclassfile方法中，调用了newclass方法。
class * parseclassfile(char * classcontent, int32_t classsize){ classfile * classfile = null; classfile = parseclassdata(classcontent, classsize); return newclass(classfile);}复制代码
newclass方法在rtda/heap/class.c文件中。
class * newclass(classfile * classfile){ class * c = calloc(1, sizeof(class)); c->accessflags = classfile->accessflags; c->sourcefile = getclasssourcefilename(classfile); newclassname(c, classfile); newsuperclassname(c, classfile); newinterfacesname(c, classfile); newconstantpool(c, classfile); newfields(c, classfile); newmethods(c, classfile); return c;}复制代码
可以看到，在native层创建了一个class对象，我们重点看newmethods(c, classfile)方法啊，这个方法定义在rtda/heap/method.c中。
method * newmethods(struct class * c, classfile * classfile){ c->methodscount = classfile->methodscount; c->methods = null; if (c->methodscount == 0) return null; c->methods = calloc(classfile->methodscount, sizeof(method)); for (uint16_t i = 0; i < c->methodscount; i++) { c->methods[i].classmember.attachclass = c; copymethodinfo(&c->methods[i], &classfile->methods[i], classfile); copyattributes(&c->methods[i], &classfile->methods[i], classfile); methoddescriptor * md = parsemethoddescriptor(c->methods[i].classmember.descriptor); c->methods[i].parseddescriptor = md; calcargslotcount(&c->methods[i]); if (ismethodnative(&c->methods[i])) { injectcodeattribute(&c->methods[i], md->returntype); } } return null;}复制代码
上述代码可以看出，实际上就是把classfile中解析到的方法逐一赋值给了 class 对象的 methods 数组。
总算梳理清楚了，反射创建对象的调用链为：
loadclass -> loadnonarrayclass -> parseclassfile -> newmethods -> class 的 methods数组privategetdeclaredconstructors -> getdeclaredconstructors0 -> getclassconstructors (过滤class 的 methods数组)复制代码
到目前为止，我们搞明白反射时如何找到对应的构造方法的。下面我们来看 newinstance 方法。
(innerclass) clazz.getdeclaredconstructor().newinstance();复制代码
public t newinstance(object ... initargs) throws instantiationexception, illegalaccessexception, illegalargumentexception, invocationtargetexception { // 构造方法是否被重载了 if (!override) { if (!reflection.quickcheckmemberaccess(clazz, modifiers)) { class<?> caller = reflection.getcallerclass(); // 检查权限 checkaccess(caller, clazz, null, modifiers); } } // 枚举类型报错 if ((clazz.getmodifiers() & modifier.enum) != 0) throw new illegalargumentexception("cannot reflectively create enum objects"); // constructoraccessor 是缓存的，如果为空，就去创建一个 constructoraccessor ca = constructoraccessor; // read volatile if (ca == null) { // 创建 constructoraccessor ca = acquireconstructoraccessor(); } @suppresswarnings("unchecked") // 使用 constructoraccessor 的 newinstance 构造实例 t inst = (t) ca.newinstance(initargs); return inst; }复制代码
接着看下 acquireconstructoraccessor 方法。
private constructoraccessor acquireconstructoraccessor() { // first check to see if one has been created yet, and take it // if so. constructoraccessor tmp = null; // 可以理解为缓存的对象 if (root != null) tmp = root.getconstructoraccessor(); if (tmp != null) { constructoraccessor = tmp; } else { // otherwise fabricate one and propagate it up to the root // 生成一个 constructoraccessor，并缓存起来 tmp = reflectionfactory.newconstructoraccessor(this); setconstructoraccessor(tmp); } return tmp;}复制代码
继续走到newconstructoraccessor方法。
public constructoraccessor newconstructoraccessor(constructor<?> var1) { checkinitted(); class var2 = var1.getdeclaringclass(); // 如果是抽象类，报错 if (modifier.isabstract(var2.getmodifiers())) { return new instantiationexceptionconstructoraccessorimpl((string)null); } // 如果 class 类报错 else if (var2 == class.class) { return new instantiationexceptionconstructoraccessorimpl("can not instantiate java.lang.class"); } // 如果是 constructoraccessorimpl 的子类的话，返回 bootstrapconstructoraccessorimpl else if (reflection.issubclassof(var2, constructoraccessorimpl.class)) { return new bootstrapconstructoraccessorimpl(var1); } // 判断 noinflation , 后面是判断不是匿名类 else if (noinflation && !reflectutil.isvmanonymousclass(var1.getdeclaringclass())) { return (new methodaccessorgenerator()).generateconstructor(var1.getdeclaringclass(), var1.getparametertypes(), var1.getexceptiontypes(), var1.getmodifiers()); } // 使用 nativeconstructoraccessorimpl 来生成实例 else { nativeconstructoraccessorimpl var3 = new nativeconstructoraccessorimpl(var1); delegatingconstructoraccessorimpl var4 = new delegatingconstructoraccessorimpl(var3); var3.setparent(var4); return var4; }}复制代码
具体逻辑，在上述代码中已经注释了。这里提一下 noinflation。
reflectionfactory在执行所有方法前会检查下是否执行过了checkinitted方法，这个方法会把noinflation的值和inflationthreshold从虚拟机的环境变量中读取出来并赋值。
当noinflation 为 false而且不是匿名类时，就会使用methodaccessorgenerator方式。否则就是用 nativeconstructoraccessorimpl的方式来生成。
默认noinflation 为false，所以我们先看native调用的方式。关注 nativeconstructoraccessorimpl类。
class nativeconstructoraccessorimpl extends constructoraccessorimpl { private final constructor<?> c; private delegatingconstructoraccessorimpl parent; private int numinvocations; nativeconstructoraccessorimpl(constructor<?> var1) { this.c = var1; } public object newinstance(object[] var1) throws instantiationexception, illegalargumentexception, invocationtargetexception { if (++this.numinvocations > reflectionfactory.inflationthreshold() && !reflectutil.isvmanonymousclass(this.c.getdeclaringclass())) { constructoraccessorimpl var2 = (constructoraccessorimpl)(new methodaccessorgenerator()).generateconstructor(this.c.getdeclaringclass(), this.c.getparametertypes(), this.c.getexceptiontypes(), this.c.getmodifiers()); this.parent.setdelegate(var2); } return newinstance0(this.c, var1); } void setparent(delegatingconstructoraccessorimpl var1) { this.parent = var1; } private static native object newinstance0(constructor<?> var0, object[] var1) throws instantiationexception, illegalargumentexception, invocationtargetexception;}复制代码
我们可以看到 nativeconstructoraccessorimpl 中维护了一个计数器numinvocations,在每次调用newinstance方法生成实例时，就会对计数器自增，当计数器超过reflectionfactory.inflationthreshold()的阈值，默认为15，就会使用 constructoraccessorimpl替换 nativeconstructoraccessorimpl,后面就会直接调用methodaccessorgenerator中的方法了。
我们先看看没到达阈值前，会调用native方法 newinstance0,这个方法定义在native/sun/reflect/nativeconstructoraccessorimpl.c中，具体newinstance0的流程我就不分析了，大致逻辑是操作堆栈执行方法。
然后我们再看看超过阈值后，执行的是 methodaccessorgenerator生成构造器的方式。这种方式与newconstructoraccessor方法中noinflation 为 false的处理方式一样。所以可以解释为：java虚拟机在执行反射操作时，如果同一操作执行次数超过阈值，会从native生成实例的方式转变为java生成实例的方式。
methodaccessorgenerator的methodaccessorgenerator方法如下。
public constructoraccessor generateconstructor(class<?> var1, class<?>[] var2, class<?>[] var3, int var4) { return (constructoraccessor)this.generate(var1, "<init>", var2, void.type, var3, var4, true, false, (class)null);}复制代码
继续跟踪下去可以发现，反射调用构造方法实际上是动态编写字节码，并且在虚拟机中把编好的字节码加载成一个class，这个class实际上是 constructoraccessorimpl 类型的，然后调用这个动态类的newinstance方法。回看刚刚我们梳理的newconstructoraccessor代码，可以看到第三个逻辑：
// 如果是 constructoraccessorimpl 的子类的话，返回 bootstrapconstructoraccessorimpl else if (reflection.issubclassof(var2, constructoraccessorimpl.class)) { return new bootstrapconstructoraccessorimpl(var1);} 复制代码
最终执行的是 bootstrapconstructoraccessorimpl的newinstance方法。
class bootstrapconstructoraccessorimpl extends constructoraccessorimpl { private final constructor<?> constructor; bootstrapconstructoraccessorimpl(constructor<?> var1) { this.constructor = var1; } public object newinstance(object[] var1) throws illegalargumentexception, invocationtargetexception { try { return unsafefieldaccessorimpl.unsafe.allocateinstance(this.constructor.getdeclaringclass()); } catch (instantiationexception var3) { throw new invocationtargetexception(var3); } }}复制代码
最后是通过使用unsafe类分配了一个实例。
反射带来的问题到现在为止，我们已经把反射生成实例的所有流程都搞清楚了。回到文章开头的问题，我们现在反思下，反射性能低么？为什么？
反射调用过程中会产生大量的临时对象，这些对象会占用内存，可能会导致频繁 gc，从而影响性能。反射调用方法时会从方法数组中遍历查找，并且会检查可见性等操作会耗时。反射在达到一定次数时，会动态编写字节码并加载到内存中，这个字节码没有经过编译器优化，也不能享受jit优化。反射一般会涉及自动装箱/拆箱和类型转换，都会带来一定的资源开销。在android中，我们可以在某些情况下对反射进行优化。举个例子，eventbus 2.x 会在 register 方法运行时，遍历所有方法找到回调方法；而eventbus 3.x 则在编译期间，将所有回调方法的信息保存的自己定义的 subscribermethodinfo 中，这样可以减少对运行时的性能影响。
想了解更多相关学习，敬请关注php培训栏目！
以上就是谈谈java 反射的快慢的详细内容。