溫馨提示×
您好，登錄后才能下訂單哦！
點(diǎn)擊 登錄注冊(cè) 即表示同意《億速云用戶服務(wù)條款》
您好，登錄后才能下訂單哦！
Java反射原理是什么？這個(gè)問題可能是我們?nèi)粘W(xué)習(xí)或工作經(jīng)常見到的。希望通過這個(gè)問題能讓你收獲頗深。下面是小編給大家?guī)淼膮⒖純?nèi)容，讓我們一起來看看吧！
說到Java 中的反射，初學(xué)者在剛剛接觸到反射的各種高級(jí)特性時(shí)，往往表示十分興奮，甚至?xí)谝恍┎恍枰褂梅瓷涞膱?chǎng)景中強(qiáng)行使用反射來「炫技」。而經(jīng)驗(yàn)較為豐富的長者，看到反射時(shí)往往會(huì)發(fā)出靈魂三問：為什么要用反射？反射不會(huì)降低性能么？不用還有什么辦法可以解決這個(gè)問題？
那么今天我們就來深入探討下，反射到底對(duì)性能有多大影響？順便探討下，反射為什么對(duì)性能有影響？
在我們分析具體原理之前，我們可以通過編寫代碼做實(shí)驗(yàn)得出結(jié)論。
反射可能會(huì)涉及多種類型的操作，比如生成實(shí)例，獲取/設(shè)置變量屬性，調(diào)用方法等。經(jīng)過簡(jiǎn)單的思考，我們認(rèn)為生成實(shí)例對(duì)性能的影響相對(duì)其他操作要大一些，所以我們采用生成實(shí)例來做試驗(yàn)。
在如下代碼中，我們定義了一個(gè)類 InnerClass，我們測(cè)試分別使用new和反射來生成 MAX_TIMES個(gè)實(shí)例，并打印出耗時(shí)時(shí)間。
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 {
}
}復(fù)制代碼輸出日志：
2020-03-19 22:34:49.738 2151-2151/? E/MainAc: totalTime: 15 2020-03-19 22:34:50.409 2151-2151/? E/MainAc: totalTime2: 670復(fù)制代碼
使用反射生成 10萬 個(gè)實(shí)例，耗時(shí) 670ms，明顯高于直接使用 new關(guān)鍵字的 15ms，所以反射性能低。別急，這個(gè)結(jié)論總結(jié)的還有點(diǎn)早，我們將要生成的實(shí)例總數(shù)改為 1000個(gè)試試，輸出日志：
2020-03-19 22:39:21.287 3641-3641/com.example.myapplication E/MainAc: totalTime: 2 2020-03-19 22:39:21.296 3641-3641/com.example.myapplication E/MainAc: totalTime2: 9復(fù)制代碼
使用反射生成 1000 個(gè)實(shí)例，雖然需要9ms，高于new的 2ms，但是 9ms 和 2ms 的差距本身肉眼不可見，而且通常我們?cè)跇I(yè)務(wù)中寫的反射一般來說執(zhí)行頻率也未必會(huì)超過 1000 次，這種場(chǎng)景下，我們還能理直氣壯地說反射性能很低么？
很顯然，不能。
除了代碼執(zhí)行耗時(shí)，我們?cè)倏纯捶瓷鋵?duì)內(nèi)存的影響。我們?nèi)匀灰陨?10萬 個(gè)實(shí)例為目標(biāo)，對(duì)上述代碼做略微改動(dòng)，依次只保留 new 方式和反射方式，然后運(yùn)行程序，觀察內(nèi)存占用情況。
使用 new 方式
使用反射
對(duì)比兩圖，我們可以看到第二張圖中多了很多 Constructor和Class對(duì)象實(shí)例，這兩部分占用的內(nèi)存2.7M。因此，我們可以得出結(jié)論，反射會(huì)產(chǎn)生大量的臨時(shí)對(duì)象，并且會(huì)占用額外內(nèi)存空間。
我們以前面試驗(yàn)中反射生成實(shí)例的代碼為入口。
首先回顧下虛擬機(jī)中類的生命周期：加載，連接（驗(yàn)證，準(zhǔn)備，解析），初始化，使用，卸載。在加載的過程 中，虛擬機(jī)會(huì)把類的字節(jié)碼轉(zhuǎn)換成運(yùn)行時(shí)數(shù)據(jù)結(jié)構(gòu)，并保存在方法區(qū)，在內(nèi)存中會(huì)生成一個(gè)代表這個(gè)類數(shù)據(jù)結(jié)構(gòu)的 java.lang.Class 對(duì)象，后續(xù)訪問這個(gè)類的數(shù)據(jù)結(jié)構(gòu)就可以通過這個(gè) Class 對(duì)象來訪問。
public InnerClass newInstanceByReflection() { // 獲取虛擬機(jī)中 InnerClass 類的 Class 對(duì)象
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;
}復(fù)制代碼代碼中 clazz.getDeclaredConstructor() 用于獲取類中定義的構(gòu)造方法，由于我們沒有顯式定義構(gòu)造方法，所以會(huì)返回編譯器為我們自己生成的默認(rèn)無參構(gòu)造方法。
下面我們看下 getDeclaredConstructor是如何返回構(gòu)造方法的。以下均以 jdk 1.8代碼為源碼。
@CallerSensitivepublic Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)
throws NoSuchMethodException, SecurityException { // 權(quán)限檢查
checkMemberAccess(Member.DECLARED, Reflection.getCallerClass(), true); return getConstructor0(parameterTypes, Member.DECLARED);
}復(fù)制代碼getDeclaredConstructor 方法首先做了權(quán)限檢查，然后直接調(diào)用 getConstructor0 方法。
private Constructor<T> getConstructor0(Class<?>[] parameterTypes, int which) throws NoSuchMethodException{ // privateGetDeclaredConstructors 方法是獲取所有的構(gòu)造方法數(shù)組
Constructor<T>[] constructors = privateGetDeclaredConstructors((which == Member.PUBLIC)); // 遍歷所有的構(gòu)造方法數(shù)組，根據(jù)傳入的參數(shù)類型依次匹配，找到合適的構(gòu)造方法后就會(huì)拷貝一份作為返回值
for (Constructor<T> constructor : constructors) { if (arrayContentsEq(parameterTypes,
constructor.getParameterTypes())) { // 拷貝構(gòu)造方法
return getReflectionFactory().copyConstructor(constructor);
}
} // 沒有找到的話，就拋出異常
throw new NoSuchMethodException(getName() + ".<init>" + argumentTypesToString(parameterTypes));
}復(fù)制代碼getConstructor0 方法主要做了兩件事：
遍歷匹配沒啥好說的，我們重點(diǎn)看下第一件事，怎么獲取的所有構(gòu)造方法數(shù)組，也就是這個(gè)方法 privateGetDeclaredConstructors。
private Constructor<T>[] privateGetDeclaredConstructors(boolean publicOnly) {
checkInitted();
Constructor<T>[] res; // 獲取緩存的 ReflectionData 數(shù)據(jù)
ReflectionData<T> rd = reflectionData(); // 如果緩存中有 ReflectionData，就先看看 ReflectionData 中的 publicConstructors 或 declaredConstructors是否為空
if (rd != null) {
res = publicOnly ? rd.publicConstructors : rd.declaredConstructors; if (res != null) return res;
} // 如果沒有緩存，或者緩存中構(gòu)造方法數(shù)組為空
// No cached value available; request value from VM
// 對(duì)接口類型的字節(jié)碼特殊處理
if (isInterface()) { @SuppressWarnings("unchecked") // 如果是接口類型，那么生成一個(gè)長度為0的構(gòu)造方法數(shù)組
Constructor<T>[] temporaryRes = (Constructor<T>[]) new Constructor<?>[0];
res = temporaryRes;
} else { // 如果不是接口類型，就調(diào)用 getDeclaredConstructors0 獲取構(gòu)造方法數(shù)組
res = getDeclaredConstructors0(publicOnly);
} // 獲取到構(gòu)造方法數(shù)組后，再賦值給緩存 ReflectionData 中的對(duì)應(yīng)屬性
if (rd != null) { if (publicOnly) {
rd.publicConstructors = res;
} else {
rd.declaredConstructors = res;
}
} return res;
}復(fù)制代碼上述代碼中我已經(jīng)對(duì)關(guān)鍵代碼進(jìn)行了注釋，在講解整個(gè)流程之前，我們看到了一個(gè)陌生的類型 ReflectionData。它對(duì)應(yīng)的數(shù)據(jù)結(jié)構(gòu)是：
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;
}
}復(fù)制代碼ReflectionData 這個(gè)類就是用來保存從虛擬機(jī)中獲取到的一些數(shù)據(jù)。同時(shí)我們可以看到所有反射屬性都使用了 volatile關(guān)鍵字修飾。
獲取緩存的 ReflectionData 數(shù)據(jù)是通過調(diào)用reflectionData()方法獲取的。
// 定義在 Class 類中的反射緩存對(duì)象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);
}復(fù)制代碼我們可以看到 reflectionData實(shí)際上是一個(gè)軟引用，軟引用會(huì)在內(nèi)存不足的情況下被虛擬機(jī)回收，所以reflectionData()方法在開始的地方，先判斷了是否可以使用緩存以及緩存是否失效，如果失效了，就會(huì)調(diào)用 newReflectionData方法生成一個(gè)新的 ReflectionData 實(shí)例。
接下來看看 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;
}
}
}復(fù)制代碼newReflectionData中使用 volatile + 死循環(huán) + CAS 機(jī)制 保證線程安全。注意到這里的死循環(huán)每執(zhí)行一次都會(huì)構(gòu)造一個(gè)新的 ReflectionData 實(shí)例。
你可能會(huì)有疑問，Class 中 reflectionData屬性什么時(shí)候被賦值的，其實(shí)是封裝在Atomic.casReflectionData這個(gè)方法里了，他會(huì)檢測(cè)當(dāng)前Class對(duì)象中的reflectionData是否與oldReflectionData相等，如果相等，就會(huì)把new SoftReference<>(rd)賦值給 reflectionData。
到現(xiàn)在為止，關(guān)于 ReflectionData的背景知識(shí)都介紹完了。我們?cè)倩氐?privateGetDeclaredConstructors中看看獲取構(gòu)造方法的流程。
privateGetDeclaredConstructors流程圖
可以看到對(duì)于普通類，最終通過調(diào)用 getDeclaredConstructors0方法獲取的構(gòu)造方法列表。
private native Constructor<T>[] getDeclaredConstructors0(boolean publicOnly);復(fù)制代碼
這個(gè)方法是 native 的，具體邏輯在 jdk 源碼中。
在 native/java/lang/Class_getDeclaredConstructors0.c 文件中，
void getDeclaredConstructors0(Frame * frame){ // Frame 可以理解為調(diào)用native方法時(shí)，java層傳遞過來的數(shù)據(jù)的一種封裝
LocalVars * vars = frame->localVars;
Object * classObj = getLocalVarsThis(vars); // 取得java方法的入?yún)?
bool publicOnly = getLocalVarsBoolean(vars, 1); uint16_t constructorsCount = 0; // 獲取要查詢的類的 Class 對(duì)象
Class * c = classObj->extra; // 獲取這個(gè)類的所有構(gòu)造方法，且數(shù)量保存在 constructorsCount 中
Method* * constructors = getClassConstructors(c, publicOnly, &constructorsCount); // 獲取 java 方法調(diào)用所屬的 classLoader
ClassLoader * classLoader = frame->method->classMember.attachClass->classLoader; // 拿到 Constructor 對(duì)應(yīng)的 class 對(duì)象
Class * constructorClass = loadClass(classLoader, "java/lang/reflect/Constructor"); //創(chuàng)建一個(gè)長度為 constructorsCount 的數(shù)組保存構(gòu)造方法
Object * constructorArr = newArray(arrayClass(constructorClass), constructorsCount);
pushOperandRef(frame->operandStack, constructorArr); // 后面是具體的賦值邏輯。將native中的Method對(duì)象轉(zhuǎn)化為java層的Constructor對(duì)象
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);
}
}
}復(fù)制代碼從上面的邏輯，可以知道獲取構(gòu)造方法的核心方法是 getClassConstructors ，所在文件為 rtda/heap/class.c。
Method* * getClassConstructors(Class * self, bool publicOnly, uint16_t * constructorsCount){ // 分配大小為 sizeof(Method) 的長度為 methodsCount 的連續(xù)內(nèi)存地址，即數(shù)組
Method* * constructors = calloc(self->methodsCount, sizeof(Method));
*constructorsCount = 0; // 在native 層，構(gòu)造方法和普通方法都存在 methods 中，逐一遍歷
for (uint16_t i = 0; i < self->methodsCount; i++)
{
Method * method = self->methods + i; // 判斷是否是構(gòu)造方法
if (isMethodConstructor(method))
{ // 檢查權(quán)限
if (!publicOnly || isMethodPublic(method))
{ // 符合條件的構(gòu)造方法依次存到數(shù)組中
constructors[*constructorsCount] = method;
(*constructorsCount)++;
}
}
} return constructors;
}復(fù)制代碼可以看到getClassConstructors實(shí)際上就是對(duì) methods 進(jìn)行了一次過濾，過濾的條件為：1.是構(gòu)造方法；2.權(quán)限一致。
isMethodConstructor 方法的判斷邏輯也是十分簡(jiǎn)單，不是靜態(tài)方法，而且方法名是<init>即可。
bool isMethodConstructor(Method * self){ return !isMethodStatic(self) && strcmp(self->classMember.name, "<init>") == 0;
}復(fù)制代碼所以核心的邏輯變成了Class中的 methods數(shù)組何時(shí)被初始化賦值的？我們刨根問底的追蹤下。
我們先找到類加載到虛擬機(jī)中的入口方法 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);
} // 解析字節(jié)碼文件
loadClass = parseClassFile(classContent, classSize);
loadClass->classLoader = classLoader; // 加載
defineClass(classLoader, loadClass); // 鏈接
linkClass(classLoader, loadClass); //printf("[Loaded %s\n", loadClass->name);
return loadClass;
}復(fù)制代碼在 parseClassFile方法中，調(diào)用了newClass方法。
Class * parseClassFile(char * classContent, int32_t classSize){
ClassFile * classFile = NULL;
classFile = parseClassData(classContent, classSize); return newClass(classFile);
}復(fù)制代碼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;
}復(fù)制代碼可以看到，在native層創(chuàng)建了一個(gè)Class對(duì)象，我們重點(diǎn)看newMethods(c, classFile)方法啊，這個(gè)方法定義在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;
}復(fù)制代碼上述代碼可以看出，實(shí)際上就是把ClassFile中解析到的方法逐一賦值給了 Class 對(duì)象的 methods 數(shù)組。
總算梳理清楚了，反射創(chuàng)建對(duì)象的調(diào)用鏈為：
loadClass -> loadNonArrayClass -> parseClassFile -> newMethods -> Class 的 methods數(shù)組 privateGetDeclaredConstructors -> getDeclaredConstructors0 -> getClassConstructors (過濾Class 的 methods數(shù)組)復(fù)制代碼
到目前為止，我們搞明白反射時(shí)如何找到對(duì)應(yīng)的構(gòu)造方法的。下面我們來看 newInstance 方法。
(InnerClass) clazz.getDeclaredConstructor().newInstance();復(fù)制代碼
public T newInstance(Object ... initargs)
throws InstantiationException, IllegalAccessException,
IllegalArgumentException, InvocationTargetException { // 構(gòu)造方法是否被重載了
if (!override) { if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
Class<?> caller = Reflection.getCallerClass(); // 檢查權(quán)限
checkAccess(caller, clazz, null, modifiers);
}
} // 枚舉類型報(bào)錯(cuò)
if ((clazz.getModifiers() & Modifier.ENUM) != 0) throw new IllegalArgumentException("Cannot reflectively create enum objects"); // ConstructorAccessor 是緩存的，如果為空，就去創(chuàng)建一個(gè)
ConstructorAccessor ca = constructorAccessor; // read volatile
if (ca == null) { // 創(chuàng)建 ConstructorAccessor
ca = acquireConstructorAccessor();
} @SuppressWarnings("unchecked") // 使用 ConstructorAccessor 的 newInstance 構(gòu)造實(shí)例
T inst = (T) ca.newInstance(initargs); return inst;
}復(fù)制代碼接著看下 acquireConstructorAccessor 方法。
private ConstructorAccessor acquireConstructorAccessor() { // First check to see if one has been created yet, and take it
// if so.
ConstructorAccessor tmp = null; // 可以理解為緩存的對(duì)象
if (root != null) tmp = root.getConstructorAccessor(); if (tmp != null) {
constructorAccessor = tmp;
} else { // Otherwise fabricate one and propagate it up to the root
// 生成一個(gè) ConstructorAccessor，并緩存起來
tmp = reflectionFactory.newConstructorAccessor(this);
setConstructorAccessor(tmp);
} return tmp;
}復(fù)制代碼繼續(xù)走到newConstructorAccessor方法。
public ConstructorAccessor newConstructorAccessor(Constructor<?> var1) {
checkInitted();
Class var2 = var1.getDeclaringClass(); // 如果是抽象類，報(bào)錯(cuò)
if (Modifier.isAbstract(var2.getModifiers())) { return new InstantiationExceptionConstructorAccessorImpl((String)null);
}
// 如果 Class 類報(bào)錯(cuò)
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 來生成實(shí)例
else {
NativeConstructorAccessorImpl var3 = new NativeConstructorAccessorImpl(var1);
DelegatingConstructorAccessorImpl var4 = new DelegatingConstructorAccessorImpl(var3);
var3.setParent(var4); return var4;
}
}復(fù)制代碼具體邏輯，在上述代碼中已經(jīng)注釋了。這里提一下 noInflation。
ReflectionFactory在執(zhí)行所有方法前會(huì)檢查下是否執(zhí)行過了checkInitted方法，這個(gè)方法會(huì)把noInflation的值和inflationThreshold從虛擬機(jī)的環(huán)境變量中讀取出來并賦值。
當(dāng)noInflation 為 false而且不是匿名類時(shí)，就會(huì)使用MethodAccessorGenerator方式。否則就是用 NativeConstructorAccessorImpl的方式來生成。
默認(rèn)noInflation 為false，所以我們先看native調(diào)用的方式。關(guān)注 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;
}復(fù)制代碼我們可以看到 NativeConstructorAccessorImpl 中維護(hù)了一個(gè)計(jì)數(shù)器numInvocations,在每次調(diào)用newInstance方法生成實(shí)例時(shí)，就會(huì)對(duì)計(jì)數(shù)器自增，當(dāng)計(jì)數(shù)器超過ReflectionFactory.inflationThreshold()的閾值，默認(rèn)為15，就會(huì)使用 ConstructorAccessorImpl替換 NativeConstructorAccessorImpl,后面就會(huì)直接調(diào)用MethodAccessorGenerator中的方法了。
我們先看看沒到達(dá)閾值前，會(huì)調(diào)用native方法 newInstance0,這個(gè)方法定義在native/sun/reflect/NativeConstructorAccessorImpl.c中，具體newInstance0的流程我就不分析了，大致邏輯是操作堆棧執(zhí)行方法。
然后我們?cè)倏纯闯^閾值后，執(zhí)行的是 MethodAccessorGenerator生成構(gòu)造器的方式。這種方式與newConstructorAccessor方法中noInflation 為 false的處理方式一樣。所以可以解釋為：java虛擬機(jī)在執(zhí)行反射操作時(shí)，如果同一操作執(zhí)行次數(shù)超過閾值，會(huì)從native生成實(shí)例的方式轉(zhuǎn)變?yōu)閖ava生成實(shí)例的方式。
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);
}復(fù)制代碼繼續(xù)跟蹤下去可以發(fā)現(xiàn)，反射調(diào)用構(gòu)造方法實(shí)際上是動(dòng)態(tài)編寫字節(jié)碼，并且在虛擬機(jī)中把編好的字節(jié)碼加載成一個(gè)Class，這個(gè)Class實(shí)際上是 ConstructorAccessorImpl 類型的，然后調(diào)用這個(gè)動(dòng)態(tài)類的newInstance方法。回看剛剛我們梳理的newConstructorAccessor代碼，可以看到第三個(gè)邏輯：
// 如果是 ConstructorAccessorImpl 的子類的話，返回 BootstrapConstructorAccessorImpl else if (Reflection.isSubclassOf(var2, ConstructorAccessorImpl.class)) { return new BootstrapConstructorAccessorImpl(var1);
}
復(fù)制代碼最終執(zhí)行的是 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);
}
}
}復(fù)制代碼最后是通過使用Unsafe類分配了一個(gè)實(shí)例。
到現(xiàn)在為止，我們已經(jīng)把反射生成實(shí)例的所有流程都搞清楚了。回到文章開頭的問題，我們現(xiàn)在反思下，反射性能低么？為什么？
在Android中，我們可以在某些情況下對(duì)反射進(jìn)行優(yōu)化。舉個(gè)例子，EventBus 2.x 會(huì)在 register 方法運(yùn)行時(shí)，遍歷所有方法找到回調(diào)方法；而EventBus 3.x 則在編譯期間，將所有回調(diào)方法的信息保存的自己定義的 SubscriberMethodInfo 中，這樣可以減少對(duì)運(yùn)行時(shí)的性能影響。
感謝各位的閱讀！看完上述內(nèi)容，你們對(duì)Java反射原理是什么大概了解了嗎？希望文章內(nèi)容對(duì)大家有所幫助。如果想了解更多相關(guān)文章內(nèi)容，歡迎關(guān)注億速云行業(yè)資訊頻道。
免責(zé)聲明：本站發(fā)布的內(nèi)容（圖片、視頻和文字）以原創(chuàng)、轉(zhuǎn)載和分享為主，文章觀點(diǎn)不代表本網(wǎng)站立場(chǎng)，如果涉及侵權(quán)請(qǐng)聯(lián)系站長郵箱：is@yisu.com進(jìn)行舉報(bào)，并提供相關(guān)證據(jù)，一經(jīng)查實(shí)，將立刻刪除涉嫌侵權(quán)內(nèi)容。
億速云公眾號(hào)
手機(jī)網(wǎng)站二維碼