2. 程式人生 > 程式設計 >Java反射原理分析 - Method篇

Java反射原理分析 - Method篇

阿新 • • 發佈：2019-12-31
反射方法剖析

Class物件提供以下獲取物件的方法(Method):

  • getMethod - 返回類或介面的特定方法,只能是public修飾的方法。
  • getDeclaredMethod - 返回類或介面的特定方法。
  • getMethods - 返回類或介面的所有public方法，包括父類的public方法。
  • getDeclaredMethods - 返回類或介面的所有方法，包括 public、protected、預設（包）訪問和 private 方法，但不包括繼承的方法。

測試用例

//父類
public class RefFather {
    public void refFatherMethod
 
(){
        System.out.println("我是父類方法 refFatherMethod");
    }
}

//子類
public class RefSon extends RefFather{
    private void refSonMethod(){
        System.out.println("我是子類方法 refMethod");
    }
}

//測試方法
public static void main(String[] args) {
    try {
            //類的全限定名 即包名+類名
            Class<?> clz = Class.forName("main.ref.RefSon"
 
);
            Object obj = clz.newInstance();
            Method refFatherMethod = clz.getMethod("refFatherMethod");
            Method refSonMethod = clz.getDeclaredMethod("refSonMethod");
            refSonMethod.invoke(obj);
     } catch (Exception e) {
            e.printStackTrace();
     }
}
複製程式碼
Method

先看Class.getMethod(String name,Class<?>... parameterTypes)的原始碼：

    @CallerSensitive
    public Method getMethod(String name,Class<?>... parameterTypes)
        throws NoSuchMethodException,SecurityException {
        checkMemberAccess(Member.PUBLIC,Reflection.getCallerClass(),true);
        Method method = getMethod0(name,parameterTypes,true);
        if (method == null) {
            throw new NoSuchMethodException(getName() + "." + name + argumentTypesToString(parameterTypes));
        }
        return method;
    }
複製程式碼

上面原始碼我們只需要重點解決以下疑問就可以知道 getMethod方法究竟是怎麼實現的。

  1. @CallerSensitive
  2. checkMemberAccess(Member.PUBLIC,true);
  3. Reflection.getCallerClass()
  4. Method method = getMethod0(name,true);
@CallerSensitive

其實這個註解是Java修復漏洞用的。防止使用者使用雙重反射來提升許可權，原理是因為當時反射只檢查深度的呼叫者的類是否有許可權，本來我本身的類是沒有這麼高許可權的，但是我可以通過多重反射來提高呼叫的許可權。

舉個栗子，比如在反射類中某個方法需要向上找固定兩層的呼叫者是否有許可權（反射相關的類許可權是比較高的），我可以通過 我自己的類 -> 反射1 ->反射2這樣的呼叫鏈上，反射2檢查的是反射1的許可權，導致安全漏洞。使用這樣的註解，那麼 getCallerClass 就會直接跳過有 @CallerSensitive 修飾的介面方法，直接查詢真實的呼叫者（actual caller）。

checkMemberAccess

先看這個方法的原始碼：

private void checkMemberAccess(int which,Class<?> caller,boolean checkProxyInterfaces) {
        final SecurityManager s = System.getSecurityManager();
        if (s != null) {
            final ClassLoader ccl = ClassLoader.getClassLoader(caller);
            final ClassLoader cl = getClassLoader0();
            if (which != Member.PUBLIC) {
                if (ccl != cl) {
                    s.checkPermission(SecurityConstants.CHECK_MEMBER_ACCESS_PERMISSION);
                }
            }
            this.checkPackageAccess(ccl,checkProxyInterfaces);
        }
    }
複製程式碼

他的功能主要是檢查是否允許客戶端訪問成員。

預設策略:允許所有客戶端使用普通Java訪問許可權進行訪問控制。

什麼意思呢？

就是如果你沒有主動配置 SecurityManager 安全管理器，則按照Class類的訪問修飾符來判斷是否有許可權。例如 protected 只允許同包，或者子類訪問，跨包則變為 private 禁止訪問。

final ClassLoader ccl = ClassLoader.getClassLoader(caller);

final ClassLoader cl = getClassLoader0();

如果有自定義的 SecurityManager（呼叫 System.setSecurityManager(new MySecurityManager())），就會去判斷呼叫方與訪問方是否具有相同的類載入器，如果有，即便不是public訪問修飾符，也沒有許可權的限制。一般情況下這裡的類載入器 ClassLoader 都是 應用程式類載入器 Application ClassLoader 。

這裡簡單介紹一下Application ClassLoader :

這個類載入器負責載入使用者類路徑(CLASSPATH)下的類庫,一般我們編寫的java類都是由這個類載入器載入,這個類載入器是CLassLoader中的getSystemClassLoader()方法的返回值,所以也稱為系統類載入器.一般情況下這就是系統預設的類載入器.

Reflection.getCallerClass()

繼續看原始碼:

    /** @deprecated */
    @Deprecated
    public static native Class<?> getCallerClass(int var0);
複製程式碼

native 代表這個方法其實是由其他語言實現的，所以這裡只說明用法。

簡單介紹一下 Reflection.getCallerClass(int var0) ，有興趣的可以瞭解一下。

如果var0 的值 等於0或者小於0，則返回 class sun.reflect.Reflection;

如果var0 的值 等於1，則返回返回自己的類。 即是這行程式碼在哪個類裡面，就返回這個類。

如果var0 的值 等於2，則返回返回呼叫者的類。舉個栗子，這個方法在A的methodA中，在方法B中呼叫A的methodA，這時候 Reflection.getCallerClass(int var0) 返回的就是 class B。

getMethod0(name,true)

繼續原始碼OvO:

private Method getMethod0(String name,Class<?>[] parameterTypes,boolean includeStaticMethods) {
        MethodArray interfaceCandidates = new MethodArray(2);
        Method res =  privateGetMethodRecursive(name,includeStaticMethods,interfaceCandidates);
        if (res != null)
            return res;

        // Not found on class or superclass directly
        interfaceCandidates.removeLessSpecifics();
        return interfaceCandidates.getFirst(); // may be null
    }

 private Method privateGetMethodRecursive(String name,boolean includeStaticMethods,MethodArray allInterfaceCandidates) {
        Method res;
        // Search declared public methods
        if ((res = searchMethods(privateGetDeclaredMethods(true),name,parameterTypes)) != null) {
            if (includeStaticMethods || !Modifier.isStatic(res.getModifiers()))
                return res;
        }
        // Search superclass's methods
        if (!isInterface()) {
            Class<? super T> c = getSuperclass();
            if (c != null) {
                if ((res = c.getMethod0(name,true)) != null) {
                    return res;
                }
            }
        }
        // Search superinterfaces' methods
        Class<?>[] interfaces = getInterfaces();
        for (Class<?> c : interfaces)
            if ((res = c.getMethod0(name,false)) != null)
                allInterfaceCandidates.add(res);
        // Not found
        return null;
    }

	private static Method searchMethods(Method[] methods,String name,Class<?>[] parameterTypes)
    {
        Method res = null;
        String internedName = name.intern();
        for (int i = 0; i < methods.length; i++) {
            Method m = methods[i];
            if (m.getName() == internedName
                && arrayContentsEq(parameterTypes,m.getParameterTypes())
                && (res == null
                    || res.getReturnType().isAssignableFrom(m.getReturnType())))
                res = m;
        }

        return (res == null ? res : getReflectionFactory().copyMethod(res));
    }

  private Method[] privateGetDeclaredMethods(boolean publicOnly) {
        checkInitted();
        Method[] res;
        ReflectionData<T> rd = reflectionData();
        if (rd != null) {
            res = publicOnly ? rd.declaredPublicMethods : rd.declaredMethods;
            if (res != null) return res;
        }
        // No cached value available; request value from VM
        res = Reflection.filterMethods(this,getDeclaredMethods0(publicOnly));
        if (rd != null) {
            if (publicOnly) {
                rd.declaredPublicMethods = res;
            } else {
                rd.declaredMethods = res;
            }
        }
        return res;
    }
複製程式碼

當呼叫 getMethod0 時，他呼叫了Class 私有的方法 privateGetMethodRecursive 遞迴獲得這個類的所有 public 修飾的方法（包含父類）。

在privateGetMethodRecursive 中 會先對當前類所有方法進行匹配，如果不存在則會查詢他的父類，如果父類也沒有則會繼續遞迴，直到頂級父類 Object。如果存在則返回這個Method的副本。

privateGetDeclaredMethods(boolean publicOnly) 引數為true，則返回這個類的所有 public方法，否則返回所有修飾符的方法。

根據privateGetDeclaredMethods，我們不難理解為什麼getMethods()返回的是包含父類的所有public方法，而getDeclaredFields()獲得是當前方法的所有修飾符方法。

大膽推測一下，getMethods()應該是遞迴呼叫 privateGetDeclaredMethods(true)的方法，而getDeclaredMethods()應該只呼叫了一次 privateGetDeclaredMethods(false)的方法。

getMethods

看看原始碼：

    @CallerSensitive
    public Method[] getMethods() throws SecurityException {
        checkMemberAccess(Member.PUBLIC,true);
        return copyMethods(privateGetPublicMethods());
    }
    
    private Method[] privateGetPublicMethods() {
        checkInitted();
        Method[] res;
        ReflectionData<T> rd = reflectionData();
        if (rd != null) {
            res = rd.publicMethods;
            if (res != null) return res;
        }
      
      	//沒有可用的快取值；遞迴計算值。
				//從獲取公共宣告的方法開始
      	MethodArray methods = new MethodArray();
        {
            //請注意這裡
            Method[] tmp = privateGetDeclaredMethods(true);
            methods.addAll(tmp);
        }
        ...
        return res;
    }
複製程式碼
getDeclaredMethods

原始碼如下：

    @CallerSensitive
    public Method[] getDeclaredMethods() throws SecurityException {
        checkMemberAccess(Member.DECLARED,true);
        //請注意這裡
        return copyMethods(privateGetDeclaredMethods(false));
    }
複製程式碼

果然都和預想中的一樣。

最後還有一個getDeclaredMethod 方法沒有介紹，但相信大家看了以上的原始碼一定也能猜到實現的過程了。

    @CallerSensitive
    public Method getDeclaredMethod(String name,SecurityException {
        checkMemberAccess(Member.DECLARED,true);
        Method method = searchMethods(privateGetDeclaredMethods(false),parameterTypes);
        if (method == null) {
            throw new NoSuchMethodException(getName() + "." + name + argumentTypesToString(parameterTypes));
        }
        return method;
    }
複製程式碼

以上所有關於Class的獲取方法原始碼分析都已梳理完畢，~(@^_^@)~喜歡的話還請頂一個贊，您的支援是我更新的最大動力。

由於筆者技術有限，文章難免有些許錯誤，歡迎━(｀∀´)ノ指正！

參考資料

jvm註解 @CallerSensitive的用處

大家都說 Java 反射效率低，你知道原因在哪裡麼

相關推薦

Java反射原理分析 - Method篇

反射方法剖析 Class物件提供以下獲取物件的方法(Method): getMethod - 返回類或介面的特定方法,只能是public修飾的方法。

深入剖析java反射原理

Java高階之反射 Class類 從java世界理解Class 問題一：類和物件的關係？ 答曰：類是抽象的概念，它是具有相同屬性和方法的一組物件集合，它代表著事物的模板；而物件是能夠真正“感覺的到、看得見，摸得著的”具

Java ThreadLocal 原理分析

原作者：https://www.jianshu.com/p/c64f06f0823b ThreadLocal提供了執行緒本地變數，它可以保證訪問到的變數屬於當前執行緒，每個執行緒都儲存有一個變數副本，每個執行緒的變數都不同。ThreadLocal相當於提供了一

java反射原理與使用

一，反射是什麼（反射是框架設計的靈魂） 1，JAVA反射機制是在執行狀態中 對於任意一個類，都能夠知道這個類的所有屬性和方法；

Java反射原理總結

技術標籤：JavaJVMjava 反射是Java 中非常重要的特性，它允許正在執行的Java程式觀測，甚至是修改程式的動態行為。 例如：我們可以通過Class 物件枚舉出該類所有方法，我們還可以通過Method.Accessible 繞過Java

Java反射技術原理與用法例項分析

本文例項講述了Java反射技術原理與用法。分享給大家供大家參考，具體如下：

Java程式執行原理分析

class檔案內容 class檔案包含Java程式執行的位元組碼 資料嚴格按照格式緊湊排列在class檔案的二進位制流，中間無分割符

Java記憶體模型中的虛擬機器棧原理分析

　　Java虛擬機器在執行Java程式的過程中會把它所管理的記憶體劃分為若干個不同的資料區域，這些區域都會有各自的用途，以及建立和銷燬的時間，有的區域會隨著虛擬機器程序的啟動而存在，有些區域則依賴使用者執行緒

Java 反射機制原理與用法詳解

本文例項講述了Java 反射機制原理與用法。分享給大家供大家參考，具體如下：

Java區域性變數執行緒安全原理分析

這篇文章主要介紹了Java區域性變數執行緒安全原理分析,文中通過示例程式碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下

java設計模式之委派模式原理分析

委派模式（Delegate）原理： 類B和類A是兩個互相沒有任何關係的類，但是B具有和A一模一樣的方法和屬性；並且呼叫B中的方法/屬性就是呼叫A中同名的方法和屬性。

Java基礎之反射原理與用法詳解

本文例項講述了Java基礎之反射原理與用法。分享給大家供大家參考，具體如下：

Java均攤複雜度和防止複雜度的震盪原理分析

本文例項講述了Java均攤複雜度和防止複雜度的震盪。分享給大家供大家參考，具體如下：

Java記憶體溢位案例模擬和原理分析過程

在JVM虛擬機器規範中，Java虛擬機器執行時資料區域除了程式計數器（Program Counter Register）外都有可能出現OutOfMemoryError的情況，使用Hotspot虛擬機器簡單的模擬堆疊記憶體溢位的場景，方便快速定位是什麼區域

深入分析JAVA 反射和泛型

從 JDK5 以後，Java 的 Class 類增加了泛型功能，從而允許使用泛型來限制 Class 類，例如，String.class 的型別實際上是 Class<String>。如果 Class 對應的類暫時未知，則使用 Class<?>。通過在反射

JAVA多執行緒(五) volatile原理分析

volatile: 能夠保證執行緒可見性，當一個執行緒修改主記憶體共享變數能夠保證對外一個執行緒可見性，但是他不能保證共享變數的原子性問題。

JAVA多執行緒(七) ReentrantLock原理分析

JUC是JDK中提供的併發工具包,裡面提供了很多併發程式設計中很常用的實用工具類，比如atomic原子操作、比如lock同步鎖、fork/join、CountDownLatch（訊號量）、Semaphore （計數器）等。

Java高階特性——反射機制(第三篇)

獲取類執行時的結構 通過反射獲取執行時類的完整結構 Field、Method、Constructor、Superclass、Interface、Annotation

Java集合包（六）——Map實現類之HashMap與HashTable 原理分析

一：HashMap特徵 　　1、HashMap 是一個散列表，它儲存的內容是鍵值對(key-value)對映。

Java HashMap實現原理分析（一）

從本文開始，介紹一下最常用的一個集合物件HashMap，HashMap儲存的是鍵值對，本文采用的基於JDK11的原始碼實現。 一般大家都知道HashMap是通過put操作把一組鍵值對（key和value）儲存到HashMap中，然後可以通過get(k