JVM反射原理是什么-創(chuàng)新互聯(lián)
這篇文章主要介紹了JVM反射原理是什么，具有一定借鑒價值，需要的朋友可以參考下。希望大家閱讀完這篇文章后大有收獲。下面讓小編帶著大家一起了解一下。
反射定義
1，JAVA反射機制是在運行狀態(tài)中
對于任意一個類，都能夠知道這個類的所有屬性和方法；
對于任意一個對象，都能夠調(diào)用它的任意一個方法和屬性；
這種動態(tài)獲取的信息以及動態(tài)調(diào)用對象的方法的功能稱為java語言的反射機制。
反射提供的功能：
- 在運行時判斷任意一個對象所屬的類
- 在運行時構(gòu)造任意一個類的對象
- 在運行時判斷任意一個類所具有的成員變量和方法
- 在運行時調(diào)用任意一個對象的方法
（如果屬性是private，正常情況下是不允許外界操作屬性值，這里可以用Field類的setAccessible(true)方法，暫時打開操作的權(quán)限）
反射的使用場景
- Java編碼時知道類和對象的具體信息，此時直接對類和對象進行操作即可，無需反射
- 如果編碼時不知道類或者對象的具體信息，此時應(yīng)該使用反射來實現(xiàn)
反射源碼解析
舉例API ：
Class.forName("com.my.reflectTest").newInstance()復(fù)制代碼1. 反射獲取類實例 Class.forName("xxx");
首先調(diào)用了 java.lang.Class 的靜態(tài)方法，獲取類信息！
注意：forName()反射獲取類信息，并沒有將實現(xiàn)留給了java,而是交給了jvm去加載！
主要是先獲取 ClassLoader, 然后調(diào)用 native 方法，獲取信息，加載類則是回調(diào) 入?yún)lassLoader 進類加載！
@CallerSensitive
public static Class<?> forName(String className)
throws ClassNotFoundException {
// 先通過反射，獲取調(diào)用進來的類信息，從而獲取當(dāng)前的 classLoader
Class<?> caller = Reflection.getCallerClass();
// 調(diào)用native方法進行獲取class信息
return forName0(className, true, ClassLoader.getClassLoader(caller), caller);
}復(fù)制代碼2. java.lang.ClassLoader-----loadClass()
// java.lang.ClassLoader
protected Class<?> loadClass(String name, boolean resolve)
throws ClassNotFoundException
{
// 先獲取鎖
synchronized (getClassLoadingLock(name)) {
// First, check if the class has already been loaded
// 如果已經(jīng)加載了的話，就不用再加載了
Class<?> c = findLoadedClass(name);
if (c == null) {
long t0 = System.nanoTime();
try {
// 雙親委托加載
if (parent != null) {
c = parent.loadClass(name, false);
} else {
c = findBootstrapClassOrNull(name);
}
} catch (ClassNotFoundException e) {
// ClassNotFoundException thrown if class not found
// from the non-null parent class loader
}
// 父類沒有加載到時，再自己加載
if (c == null) {
// If still not found, then invoke findClass in order
// to find the class.
long t1 = System.nanoTime();
c = findClass(name);
// this is the defining class loader; record the stats
sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
sun.misc.PerfCounter.getFindClasses().increment();
}
}
if (resolve) {
resolveClass(c);
}
return c;
}
}
protected Object getClassLoadingLock(String className) {
Object lock = this;
if (parallelLockMap != null) {
// 使用 ConcurrentHashMap來保存鎖
Object newLock = new Object();
lock = parallelLockMap.putIfAbsent(className, newLock);
if (lock == null) {
lock = newLock;
}
}
return lock;
}
protected final Class<?> findLoadedClass(String name) {
if (!checkName(name))
return null;
return findLoadedClass0(name);
}復(fù)制代碼3. newInstance()
newInstance() 其實相當(dāng)于調(diào)用類的無參構(gòu)造函數(shù),主要做了三件事復(fù)制代碼
權(quán)限檢測，如果不通過直接拋出異常；
查找無參構(gòu)造器，并將其緩存起來；
調(diào)用具體方法的無參構(gòu)造方法，生成實例并返回；
// 首先肯定是 Class.newInstance
@CallerSensitive
public T newInstance()
throws InstantiationException, IllegalAccessException
{
if (System.getSecurityManager() != null) {
checkMemberAccess(Member.PUBLIC, Reflection.getCallerClass(), false);
}
// NOTE: the following code may not be strictly correct under
// the current Java memory model.
// Constructor lookup
// newInstance() 其實相當(dāng)于調(diào)用類的無參構(gòu)造函數(shù)，所以，首先要找到其無參構(gòu)造器
if (cachedConstructor == null) {
if (this == Class.class) {
// 不允許調(diào)用 Class 的 newInstance() 方法
throw new IllegalAccessException(
"Can not call newInstance() on the Class for java.lang.Class"
);
}
try {
// 獲取無參構(gòu)造器
Class<?>[] empty = {};
final Constructor<T> c = getConstructor0(empty, Member.DECLARED);
// Disable accessibility checks on the constructor
// since we have to do the security check here anyway
// (the stack depth is wrong for the Constructor's
// security check to work)
java.security.AccessController.doPrivileged(
new java.security.PrivilegedAction<Void>() {
public Void run() {
c.setAccessible(true);
return null;
}
});
cachedConstructor = c;
} catch (NoSuchMethodException e) {
throw (InstantiationException)
new InstantiationException(getName()).initCause(e);
}
}
Constructor<T> tmpConstructor = cachedConstructor;
// Security check (same as in java.lang.reflect.Constructor)
int modifiers = tmpConstructor.getModifiers();
if (!Reflection.quickCheckMemberAccess(this, modifiers)) {
Class<?> caller = Reflection.getCallerClass();
if (newInstanceCallerCache != caller) {
Reflection.ensureMemberAccess(caller, this, null, modifiers);
newInstanceCallerCache = caller;
}
}
// Run constructor
try {
// 調(diào)用無參構(gòu)造器
return tmpConstructor.newInstance((Object[])null);
} catch (InvocationTargetException e) {
Unsafe.getUnsafe().throwException(e.getTargetException());
// Not reached
return null;
}
}復(fù)制代碼4. getConstructor0() 為獲取匹配的構(gòu)造方器；分三步：
1. 先獲取所有的constructors, 然后通過進行參數(shù)類型比較； 2. 找到匹配后，通過 ReflectionFactory copy一份constructor返回； 3. 否則拋出 NoSuchMethodException;
private Constructor<T> getConstructor0(Class<?>[] parameterTypes,
int which) throws NoSuchMethodException
{
// 獲取所有構(gòu)造器
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));
}復(fù)制代碼5. privateGetDeclaredConstructors(), 獲取所有的構(gòu)造器主要步驟；
1. 先嘗試從緩存中獲??； 2. 如果緩存沒有，則從jvm中重新獲取，并存入緩存，緩存使用軟引用進行保存，保證內(nèi)存可用；
// 獲取當(dāng)前類所有的構(gòu)造方法，通過jvm或者緩存
// Returns an array of "root" constructors. These Constructor
// objects must NOT be propagated to the outside world, but must
// instead be copied via ReflectionFactory.copyConstructor.
private Constructor<T>[] privateGetDeclaredConstructors(boolean publicOnly) {
checkInitted();
Constructor<T>[] res;
// 調(diào)用 reflectionData(), 獲取保存的信息，使用軟引用保存，從而使內(nèi)存不夠可以回收
ReflectionData<T> rd = reflectionData();
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")
Constructor<T>[] temporaryRes = (Constructor<T>[]) new Constructor<?>[0];
res = temporaryRes;
} else {
// 使用native方法從jvm獲取構(gòu)造器
res = getDeclaredConstructors0(publicOnly);
}
if (rd != null) {
// 最后，將從jvm中讀取的內(nèi)容，存入緩存
if (publicOnly) {
rd.publicConstructors = res;
} else {
rd.declaredConstructors = res;
}
}
return res;
}
// Lazily create and cache 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);
}
// 新創(chuàng)建緩存，保存反射信息
private ReflectionData<T> newReflectionData(SoftReference<ReflectionData<T>> oldReflectionData,
int classRedefinedCount) {
if (!useCaches) return null;
// 使用cas保證更新的線程安全性，所以反射是保證線程安全的
while (true) {
ReflectionData<T> rd = new ReflectionData<>(classRedefinedCount);
// try to CAS it...
if (Atomic.casReflectionData(this, oldReflectionData, new SoftReference<>(rd))) {
return rd;
}
// 先使用CAS更新，如果更新成功，則立即返回，否則測查當(dāng)前已被其他線程更新的情況，如果和自己想要更新的狀態(tài)一致，則也算是成功了
oldReflectionData = this.reflectionData;
classRedefinedCount = this.classRedefinedCount;
if (oldReflectionData != null &&
(rd = oldReflectionData.get()) != null &&
rd.redefinedCount == classRedefinedCount) {
return rd;
}
}
}復(fù)制代碼另外，使用 relactionData() 進行緩存保存；ReflectionData 的數(shù)據(jù)結(jié)構(gòu)如下！
// reflection data that might get invalidated when JVM TI RedefineClasses() is called
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ù)制代碼6.通過上面，獲取到 Constructor 了！接下來就只需調(diào)用其相應(yīng)構(gòu)造器的 newInstance()，即返回實例了！
// return tmpConstructor.newInstance((Object[])null);
// java.lang.reflect.Constructor
@CallerSensitive
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 ca = constructorAccessor; // read volatile
if (ca == null) {
ca = acquireConstructorAccessor();
}
@SuppressWarnings("unchecked")
T inst = (T) ca.newInstance(initargs);
return inst;
}
// sun.reflect.DelegatingConstructorAccessorImpl
public Object newInstance(Object[] args)
throws InstantiationException,
IllegalArgumentException,
InvocationTargetException
{
return delegate.newInstance(args);
}
// sun.reflect.NativeConstructorAccessorImpl
public Object newInstance(Object[] args)
throws InstantiationException,
IllegalArgumentException,
InvocationTargetException
{
// We can't inflate a constructor belonging to a vm-anonymous class
// because that kind of class can't be referred to by name, hence can't
// be found from the generated bytecode.
if (++numInvocations > ReflectionFactory.inflationThreshold()
&& !ReflectUtil.isVMAnonymousClass(c.getDeclaringClass())) {
ConstructorAccessorImpl acc = (ConstructorAccessorImpl)
new MethodAccessorGenerator().
generateConstructor(c.getDeclaringClass(),
c.getParameterTypes(),
c.getExceptionTypes(),
c.getModifiers());
parent.setDelegate(acc);
}
// 調(diào)用native方法，進行調(diào)用 constructor
return newInstance0(c, args);
}復(fù)制代碼返回構(gòu)造器的實例后，可以根據(jù)外部進行進行類型轉(zhuǎn)換，從而使用接口或方法進行調(diào)用實例功能了。
感謝你能夠認(rèn)真閱讀完這篇文章，希望小編分享JVM反射原理是什么內(nèi)容對大家有幫助，同時也希望大家多多支持創(chuàng)新互聯(lián)，關(guān)注創(chuàng)新互聯(lián)-成都網(wǎng)站建設(shè)公司行業(yè)資訊頻道，遇到問題就找創(chuàng)新互聯(lián)，詳細的解決方法等著你來學(xué)習(xí)!
名稱欄目：JVM反射原理是什么-創(chuàng)新互聯(lián)
轉(zhuǎn)載源于：http://muchs.cn/article18/ioggp.html
成都網(wǎng)站建設(shè)公司_創(chuàng)新互聯(lián)，為您提供微信小程序、網(wǎng)站導(dǎo)航、商城網(wǎng)站、做網(wǎng)站、域名注冊、網(wǎng)站改版
聲明：本網(wǎng)站發(fā)布的內(nèi)容（圖片、視頻和文字）以用戶投稿、用戶轉(zhuǎn)載內(nèi)容為主，如果涉及侵權(quán)請盡快告知，我們將會在第一時間刪除。文章觀點不代表本網(wǎng)站立場，如需處理請聯(lián)系客服。電話：028-86922220；郵箱：631063699@qq.com。內(nèi)容未經(jīng)允許不得轉(zhuǎn)載，或轉(zhuǎn)載時需注明來源： 創(chuàng)新互聯(lián)
猜你還喜歡下面的內(nèi)容
- win7C盤的User文件夾轉(zhuǎn)移到D盤-創(chuàng)新互聯(lián)
- 作為一個純粹數(shù)據(jù)結(jié)構(gòu)的RedisStreams-創(chuàng)新互聯(lián)
- Html5怎么實現(xiàn)在兩個div元素之間拖放圖像-創(chuàng)新互聯(lián)
- Shell腳本實現(xiàn)備份系統(tǒng)文件并郵件發(fā)送功能-創(chuàng)新互聯(lián)
- Java中怎么求數(shù)組交集-創(chuàng)新互聯(lián)
- java?調(diào)用webservice接口過程-創(chuàng)新互聯(lián)
- django配置app中的靜態(tài)文件步驟-創(chuàng)新互聯(lián)
- 企業(yè)網(wǎng)站制作做成怎樣才有特色 2014-01-28
- 企業(yè)網(wǎng)站制作一定要了解的問題 2015-06-07
- 企業(yè)網(wǎng)站制作需要注意的四大問題 2016-08-09
- 企業(yè)網(wǎng)站制作設(shè)計需要注意的問題點 2016-10-15
- 企業(yè)網(wǎng)站制作過程中 色調(diào)和設(shè)計風(fēng)格配搭需要注意什么 2022-06-28
- 網(wǎng)站建設(shè)企業(yè)網(wǎng)站制作時還需要注意哪些基礎(chǔ)問題？ 2021-05-28
- 企業(yè)網(wǎng)站制作性價比最重要而不是價格 2013-09-22
- 專業(yè)成都企業(yè)網(wǎng)站制作公司的售后服務(wù) 2023-03-18
- 行業(yè)龍頭企業(yè)網(wǎng)站制作的要素有哪些？ 2014-10-23
- 企業(yè)網(wǎng)站制作所造成難以收錄的主因是什么 2022-10-20
- 企業(yè)網(wǎng)站制作需要注意幾個方面 2022-05-15
- 哪些出色的企業(yè)網(wǎng)站制作能夠吸引來訪者？ 2015-10-01