2. 程式人生 > 實用技巧 >java反射技術，逆向開發必備技能

java反射技術，逆向開發必備技能

阿新 • • 發佈：2020-08-28

相信很多人都知道反射可以說是Java中最強大的技術了，它可以做的事情太多太多，很多優秀的開源框架都是通過反射完成的，比如最初的很多註解框架，後來因為java反射影響效能，所以被執行時註解APT替代了，java反射有個開源框架jOOR相信很多人都用過，不過我們還是要學習反射的基礎語法，這樣才能自己寫出優秀的框架，當然這裡所講的反射技術，是學習Android外掛化技術、Hook技術等必不可少的！

一、基本反射技術

1.1 根據一個字串得到一個類

getClass方法

  1. Stringname="Huanglinqing";
  2. Classc1=name.getClass();
  3. System.out.println(c1.getName());

列印結果如下：

Class.forName

比如我們獲取java.lang.String的類名

  1. Stringname="java.lang.String";
  2. Classc1=null;
  3. try{
  4. c1=Class.forName(name);
  5. System.out.println(c1.getName());
  6. }catch(ClassNotFoundExceptione){
  7. }

這裡也通過捕獲異常，因為我們傳的這個字串可能不合法，字串合法命名是類的名稱空間和類的名稱組成

列印結果如下：


我們還可以通過c1.getSuperclass()獲取到他的父類

Type屬性

基本型別都有type屬性，可以得到這個基本型別的型別，比如：

  1. Classc1=Boolean.TYPE;
  2. Classc2=Byte.TYPE;
  3. Classc3=Float.TYPE;
  4. Classc4=Double.TYPE; 
 停停停！這些東西有啥子用，如此雞肋！ 別急，一切都是為後續做準備。

二、獲取類的成員

當類中方法定義為私有的時候我們能呼叫？不能！當變數是私有的時候我們能獲取嗎？不能！但是反射可以，比如原始碼中有你需要用到的方法，但是那個方法是私有的，這個時候你就可以通過反射去執行這個私有方法，並且獲取私有變數。

獲取類的建構函式

為了便於測試，我們定義一個Test類，Test類如下：（省略get和set方法）

Test類中我們定義是三個私有變數，生成兩個公有的含參構造方法和一個私有的含參構造方法以及一個公有的無參構造方法。

  1. publicclassTest{
  3. privateintage;
  4. privateStringname;
  5. privateinttestint;
  7. publicTest(intage){
  8. this.age=age;
  9. }
  11. publicTest(intage,Stringname){
  12. this.age=age;
  13. this.name=name;
  14. }
  16. privateTest(Stringname){
  17. this.name=name;
  18. }
  20. publicTest(){
  21. }

下面我們通過反射獲取這些構造方法

獲取類的所有構造方法

  1. Testtest=newTest();
  2. Classc4=test.getClass();
  3. Constructor[]constructors;
  4. constructors=c4.getDeclaredConstructors();

通過getDeclaredConstructors可以返回類的所有構造方法，返回的是一個數組因為構造方法可能不止一個，通過getModifiers可以得到構造方法的型別，getParameterTypes可以得到構造方法的所有引數，返回的是一個Class陣列，所以我們如果想獲取所有構造方法以及每個構造方法的引數型別，可以有如下程式碼：

  1. for(inti=0;i<constructors.length;i++){
  2. System.out.print(Modifier.toString(constructors[i].getModifiers())+"引數：");
  3. Class[]parametertypes=constructors[i].getParameterTypes();
  4. for(intj=0;j<parametertypes.length;j++){
  5. System.out.print(parametertypes[j].getName()+"");
  6. }
  7. System.out.println("");
  8. }

執行結果如下所示：

這樣我們就得到了類中所有構造方法和構造方法中的引數，那麼我們如何獲取特定的構造方法呢？

獲取類中特定的構造方法

我們可以通過getConstructors方法獲取類中 所有的public型別的構造方法，程式碼和上面一樣就不演示了。

我們可以通過getDeclaredConstructor()方法傳參獲取特定引數型別的構造方法，這裡注意是getDeclaredConstructor()不是 getDeclaredConstructors() ，所以返回的是一個Class物件而不是一個Class陣列。

獲取無參構造方法直接不傳引數，如下所示:

  1. try{
  2. constructors=c4.getDeclaredConstructor();
  3. System.out.print(Modifier.toString(constructors.getModifiers())+);
  4. }catch(NoSuchMethodExceptione){
  5. e.printStackTrace();
  6. }

這裡要進行異常捕獲，因為可能不存在對應的構造方法，列印結果如下：


如果我們想獲取有兩個引數分別為int和String型別的構造方法，程式碼如下：

  1. Class[]p={int.class,String.class};
  2. try{
  3. constructors=c4.getDeclaredConstructor(p);
  4. System.out.print(Modifier.toString(constructors.getModifiers())+"引數:");
  5. Class[]parametertypes=constructors.getParameterTypes();
  6. for(intj=0;j<parametertypes.length;j++){
  7. System.out.print(parametertypes[j].getName()+"");
  8. }
  9. }catch(NoSuchMethodExceptione){
  10. e.printStackTrace();
  11. }

這裡我們同樣打印出構造方法的引數：


呼叫構造方法

從這裡開始慢慢到了關鍵的一步，得到類的例項，我們主要藉助於newInstance方法，為了方便演示我們將測試類的兩個構造方法打印出來.

  1. publicTest(intage,Stringname){
  2. this.age=age;
  3. this.name=name;
  4. System.out.println("hello"+name+"iam"+age);
  5. }
  8. privateTest(Stringname){
  9. this.name=name;
  10. System.out.println("MyNameis"+
  11. name);
  12. }

我們先來呼叫public的方法，如下所示：

  1. Class[]p={int.class,String.class};
  2. constructors=c4.getDeclaredConstructor(p);
  3. constructors.newInstance(24,"HuangLinqing");

執行列印結果如下：


那麼呼叫私有構造方法呢，和上面一樣，只是我們要設定constructors.setAccessible(true);程式碼如下：

  1. Class[]p={String.class};
  2. constructors=c4.getDeclaredConstructor(p);
  3. constructors.setAccessible(true);
  4. constructors.newInstance("HuangLinqing");

列印結果如下：


呼叫類的私有方法

如何呼叫類中的私有方法呢，我們先在測試類中編寫一個測試的私有方法 如下：

  1. privatevoidwelcome(Stringtips){
  2. System.out.println(tips);
  3. }

我們知道如果我們要正常的呼叫類的方法都是通過類.方法呼叫，所以我們呼叫私有方法也需要得到類的例項，而我們上面newInstace已經得到了類的例項，這樣就好辦了。

  1. Class[]p4={String.class};
  2. Methodmethod=c4.getDeclaredMethod("welcome",p4);
  3. method.setAccessible(true);

我們首先通過getDeclaredMethod方法獲取到這個私有方法，第一個引數是方法名，第二個引數是引數型別

然後通過invoke方法執行，invoke需要兩個引數一個是類的例項，一個是方法引數。

  1. Class[]p4={String.class};
  2. Methodmethod=c4.getDeclaredMethod("welcome",p4);
  3. method.setAccessible(true);
  4. Objectarg1s[]={"歡迎關注程式碼男人技術公眾號"};
  5. method.invoke(test,arg1s);

test類的例項當不能new 獲取的時候我們也可以通過反射獲取，就是上面的newInstance方法。列印結果如下：


獲取類的私有欄位並修改值

看到這裡你可能會說，有了set方法，什麼私有不私有，test.set不就可以了，但是這裡要注意我們是沒有辦法得到這個類的例項的，要不然都可以得到例項就沒有反射一說了。我們在通過反射得到類的例項之後先獲取欄位：

  1. Fieldfield=c4.getDeclaredField("name");
  2. field.setAccessible(true);
  3. field.set(o,"程式碼男人");

o是我們上面通過反射構造方法獲取的例項，列印field.get(o).toString()的值如下：

不過要注意的是我們修改了name的值只對當前的例項物件有效。

Java的基本反射語法就是這樣了，歡迎加入技術群一起探討！

最後反射封裝類如下：

  1. package jnidemo.hlq.com.hookdemo;
  3. import java.lang.reflect.Constructor;
  4. import java.lang.reflect.Field;
  5. import java.lang.reflect.Method;
  7. /**
  8. * @author Huanglinqing
  9. * @date 2019/4/28
  10. */
  12. public class Reflex {
  14. /**
  15. * 獲取無參建構函式
  16. * @param className
  17. * @return
  18. */
  19. public static Object createObject(String className) {
  20. Class[] pareTyples = new Class[]{};
  21. Object[] pareVaules = new Object[]{};
  23. try {
  24. Class r = Class.forName(className);
  25. return createObject(r, pareTyples, pareVaules);
  26. } catch (ClassNotFoundException e) {
  27. e.printStackTrace();
  28. }
  30. return null;
  31. }
  33. /**
  34. * 獲取無參構造方法
  35. * @param clazz
  36. * @return
  37. */
  38. public static Object createObject(Class clazz) {
  39. Class[] pareTyple = new Class[]{};
  40. Object[] pareVaules = new Object[]{};
  42. return createObject(clazz, pareTyple, pareVaules);
  43. }
  45. /**
  46. * 獲取一個引數的建構函式 已知className
  47. *
  48. * @param className
  49. * @param pareTyple
  50. * @param pareVaule
  51. * @return
  52. */
  53. public static Object createObject(String className, Class pareTyple, Object pareVaule) {
  55. Class[] pareTyples = new Class[]{pareTyple};
  56. Object[] pareVaules = new Object[]{pareVaule};
  58. try {
  59. Class r = Class.forName(className);
  60. return createObject(r, pareTyples, pareVaules);
  61. } catch (ClassNotFoundException e) {
  62. e.printStackTrace();
  63. }
  65. return null;
  66. }
  69. /**
  70. * 獲取單個引數的構造方法 已知類
  71. *
  72. * @param clazz
  73. * @param pareTyple
  74. * @param pareVaule
  75. * @return
  76. */
  77. public static Object createObject(Class clazz, Class pareTyple, Object pareVaule) {
  78. Class[] pareTyples = new Class[]{pareTyple};
  79. Object[] pareVaules = new Object[]{pareVaule};
  81. return createObject(clazz, pareTyples, pareVaules);
  82. }
  84. /**
  85. * 獲取多個引數的構造方法 已知className
  86. * @param className
  87. * @param pareTyples
  88. * @param pareVaules
  89. * @return
  90. */
  91. public static Object createObject(String className, Class[] pareTyples, Object[] pareVaules) {
  92. try {
  93. Class r = Class.forName(className);
  94. return createObject(r, pareTyples, pareVaules);
  95. } catch (ClassNotFoundException e) {
  96. e.printStackTrace();
  97. }
  99. return null;
  100. }
  103. /**
  104. * 獲取構造方法
  105. *
  106. * @param clazz
  107. * @param pareTyples
  108. * @param pareVaules
  109. * @return
  110. */
  111. public static Object createObject(Class clazz, Class[] pareTyples, Object[] pareVaules) {
  112. try {
  113. Constructor ctor = clazz.getDeclaredConstructor(pareTyples);
  114. ctor.setAccessible(true);
  115. return ctor.newInstance(pareVaules);
  116. } catch (Exception e) {
  117. e.printStackTrace();
  118. }
  120. return null;
  121. }
  124. /**
  125. * 獲取多個引數的方法
  126. * @param obj
  127. * @param methodName
  128. * @param pareTyples
  129. * @param pareVaules
  130. * @return
  131. */
  132. public static Object invokeInstanceMethod(Object obj, String methodName, Class[] pareTyples, Object[] pareVaules) {
  133. if (obj == null) {
  134. return null;
  135. }
  137. try {
  138. //呼叫一個private方法 //在指定類中獲取指定的方法
  139. Method method = obj.getClass().getDeclaredMethod(methodName, pareTyples);
  140. method.setAccessible(true);
  141. return method.invoke(obj, pareVaules);
  143. } catch (Exception e) {
  144. e.printStackTrace();
  145. }
  147. return null;
  148. }
  150. /**
  151. * 獲取一個引數的方法
  152. * @param obj
  153. * @param methodName
  154. * @param pareTyple
  155. * @param pareVaule
  156. * @return
  157. */
  158. public static Object invokeInstanceMethod(Object obj, String methodName, Class pareTyple, Object pareVaule) {
  159. Class[] pareTyples = {pareTyple};
  160. Object[] pareVaules = {pareVaule};
  162. return invokeInstanceMethod(obj, methodName, pareTyples, pareVaules);
  163. }
  165. /**
  166. * 獲取無參方法
  167. * @param obj
  168. * @param methodName
  169. * @return
  170. */
  171. public static Object invokeInstanceMethod(Object obj, String methodName) {
  172. Class[] pareTyples = new Class[]{};
  173. Object[] pareVaules = new Object[]{};
  175. return invokeInstanceMethod(obj, methodName, pareTyples, pareVaules);
  176. }
  179. /**
  180. * 無參靜態方法
  181. * @param className
  182. * @param method_name
  183. * @return
  184. */
  185. public static Object invokeStaticMethod(String className, String method_name) {
  186. Class[] pareTyples = new Class[]{};
  187. Object[] pareVaules = new Object[]{};
  189. return invokeStaticMethod(className, method_name, pareTyples, pareVaules);
  190. }
  192. /**
  193. * 獲取一個引數的靜態方法
  194. * @param className
  195. * @param method_name
  196. * @param pareTyple
  197. * @param pareVaule
  198. * @return
  199. */
  200. public static Object invokeStaticMethod(String className, String method_name, Class pareTyple, Object pareVaule) {
  201. Class[] pareTyples = new Class[]{pareTyple};
  202. Object[] pareVaules = new Object[]{pareVaule};
  204. return invokeStaticMethod(className, method_name, pareTyples, pareVaules);
  205. }
  207. /**
  208. * 獲取多個引數的靜態方法
  209. * @param className
  210. * @param method_name
  211. * @param pareTyples
  212. * @param pareVaules
  213. * @return
  214. */
  215. public static Object invokeStaticMethod(String className, String method_name, Class[] pareTyples, Object[] pareVaules) {
  216. try {
  217. Class obj_class = Class.forName(className);
  218. return invokeStaticMethod(obj_class, method_name, pareTyples, pareVaules);
  219. } catch (Exception e) {
  220. e.printStackTrace();
  221. }
  223. return null;
  224. }
  226. /**
  227. * 無參靜態方法
  228. * @param method_name
  229. * @return
  230. */
  231. public static Object invokeStaticMethod(Class clazz, String method_name) {
  232. Class[] pareTyples = new Class[]{};
  233. Object[] pareVaules = new Object[]{};
  235. return invokeStaticMethod(clazz, method_name, pareTyples, pareVaules);
  236. }
  238. /**
  239. * 一個引數靜態方法
  240. * @param clazz
  241. * @param method_name
  242. * @param classType
  243. * @param pareVaule
  244. * @return
  245. */
  246. public static Object invokeStaticMethod(Class clazz, String method_name, Class classType, Object pareVaule) {
  247. Class[] classTypes = new Class[]{classType};
  248. Object[] pareVaules = new Object[]{pareVaule};
  250. return invokeStaticMethod(clazz, method_name, classTypes, pareVaules);
  251. }
  253. /**
  254. * 多個引數的靜態方法
  255. * @param clazz
  256. * @param method_name
  257. * @param pareTyples
  258. * @param pareVaules
  259. * @return
  260. */
  261. public static Object invokeStaticMethod(Class clazz, String method_name, Class[] pareTyples, Object[] pareVaules) {
  262. try {
  263. Method method = clazz.getDeclaredMethod(method_name, pareTyples);
  264. method.setAccessible(true);
  265. return method.invoke(null, pareVaules);
  266. } catch (Exception e) {
  267. e.printStackTrace();
  268. }
  270. return null;
  271. }
  274. public static Object getFieldObject(String className, Object obj, String filedName) {
  275. try {
  276. Class obj_class = Class.forName(className);
  277. return getFieldObject(obj_class, obj, filedName);
  278. } catch (ClassNotFoundException e) {
  279. e.printStackTrace();
  280. }
  281. return null;
  282. }
  284. public static Object getFieldObject(Class clazz, Object obj, String filedName) {
  285. try {
  286. Field field = clazz.getDeclaredField(filedName);
  287. field.setAccessible(true);
  288. return field.get(obj);
  289. } catch (Exception e) {
  290. e.printStackTrace();
  291. }
  293. return null;
  294. }
  297. public static void setFieldObject(Class clazz, Object obj, String filedName, Object filedVaule) {
  298. try {
  299. Field field = clazz.getDeclaredField(filedName);
  300. field.setAccessible(true);
  301. field.set(obj, filedVaule);
  302. } catch (Exception e) {
  303. e.printStackTrace();
  304. }
  305. }
  307. public static void setFieldObject(String className, Object obj, String filedName, Object filedVaule) {
  308. try {
  309. Class obj_class = Class.forName(className);
  310. setFieldObject(obj_class, obj, filedName, filedVaule);
  311. } catch (ClassNotFoundException e) {
  312. e.printStackTrace();
  313. }
  314. }
  317. public static Object getStaticFieldObject(String className, String filedName) {
  318. return getFieldObject(className, null, filedName);
  319. }
  321. public static Object getStaticFieldObject(Class clazz, String filedName) {
  322. return getFieldObject(clazz, null, filedName);
  323. }
  325. public static void setStaticFieldObject(String classname, String filedName, Object filedVaule) {
  326. setFieldObject(classname, null, filedName, filedVaule);
  327. }
  329. public static void setStaticFieldObject(Class clazz, String filedName, Object filedVaule) {
  330. setFieldObject(clazz, null, filedName, filedVaule);
  331. }
  332. }

相關推薦

java反射技術，逆向開發必備技能

相信很多人都知道反射可以說是Java中最強大的技術了，它可以做的事情太多太多，很多優秀的開源框架都是通過反射完成的，比如最初的很多註解框架，後來因為java反射影響效能，所以被執行時註解APT替代了，java反射

乾貨 | Dubbo 介面測試技術，測試開發進階必備

Dubbo 介面測試為霍格沃茲測試學院特色課程，全網深度領先，想一起系統進階的同學文末加群交流。

1-3年的Android開發工程師看過來，架構師必備技能

正文 我們今天將說明以下 14 種模式： 1．滑動視窗 2．二指標或迭代器 3．快速和慢速指標或迭代器

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

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

基於Java反射技術實現簡單IOC容器

前言 首先思考一個問題,如果你正在做一個複雜的系統,一個系統模組內有幾百個功能業務類,這些類需要使用同一些物件來進行工作。那麼，你會怎樣去管理這些通用且一樣的物件呢？

Java反射技術詳解及例項解析

前言 相信很多人都知道反射可以說是Java中最強大的技術了，它可以做的事情太多太多，很多優秀的開源框架都是通過反射完成的，比如最初的很多註解框架，後來因為java反射影響效能，所以被執行時註解APT替代了，java

【記錄】利用java反射技術掃描包中包含某註解 類集合

public static List<Class> scanClass(String classPath, Class<? extends Annotation> annotation) {

JAVA反射技術之自動裝載/自動驗參

>>> 對於一個後端API專案，令我們感到繁瑣的，無非就引數的驗證。 傳統的做法，在每個介面內部，寫一大堆if else判斷。且響應，容易遺漏。

利用Java反射機制，獲取ThreadPoolExecutor執行緒池中的workers執行緒佇列

應用場景： 將若干有唯一任務Id的執行緒放到ThreadPoolExecutor中執行，在此之前儲存任務Id和執行緒的關係：Map<String, TestThread> taskIdCutThreadMap

IDEA的幾個常用配置，日常開發必備

用了IDEA有很長時間了，身邊的同事朋友也都慢慢的開始都從Eclipse切換到IDEA了，其實無論是Eclipse還是IntelliJ IDEA都是開發工具而已，各自都有優點。但是剛從Eclipse切換到IDEA的時候還是很不適應的，有些人用

TwentyFiveDay-java 反射機制，註解

1、資源繫結器 資源繫結器，便於獲取屬性配置檔案中的內容 使用一下這種方式的時候，屬性配置檔案xxx.properties必須放在類路徑下

2021金三銀四面試季！《Android面試題及解析》分享給大家，大廠面試必備技能

前言 金三銀四到來了，找工作的好時候到了，小夥伴們是不是都在忙著找工作呢，小弟前一陣也是忙著在找工作，面試了好多公司，所幸的是進到了自己心儀的公司，也是很幸運的。下面我將自己親身實戰的面試題及收到的面

2021年最新Java面試經歷，架構師必備

騰訊 一面（支付） 1.jqc的介紹 2.如何確保多臺機器不會重複消費 3.如何確保消費了反饋失效問題（用事務管理，先儲存再消費，失敗就回滾）

使用WCF進行跨平臺開發之三(JAVA呼叫WCF服務)1.開發必備2.生成WCF客戶端3.開發程式4.結束語

     前兩篇寫了在.net中和php中呼叫WCF。這一篇將要解決java中呼叫WCF的問題，使用的依舊是上一篇中託管在IIS中的WCF服務，本來我是打算用axis來寫這篇文章的，可就在我開始之前，無意中發現了在java包中自帶的

高階測試開發必備技能: k8s入門

每天進步一點點，關注我們哦，每天分享測試技術文章 本文章出自【碼同學軟體測試】

Docker技術丨架構師之路必備技能，阿里架構師Docker文件資料

什麼是Docker Docker 是一個開源的應用容器引擎，讓開發者可以打包他們的應用以及依賴包到一個可移植的映象中，然後釋出到任何流行的 Linux或Windows 機器上，也可以實現虛擬化。容器是完全使用沙箱機制，

Java程式設計師進階必備技能，程式設計師升職加薪寶典！

前言 有很多程式設計師工作兩三年了，每天就是增刪改查，沒有目標，想換個工作環境，但是又怕自己技術不行，找不到好工作，今天小編總結了幾點Java程式設計師進階必須要掌握的技能，分享給大家，希望能幫助

多執行緒和鎖，Java架構師必備技能！

你經常面向CRUD工作嗎？ 如果說程式設計只是單純的承接產品需求開發系統功能，那麼基本可以把程式開發簡單理解成按照需求PRD，定義屬性、建立方法、呼叫展示，這三個步驟。

鴻蒙手機 OS 等開發必備工具，華為 DevEco Studio 2.1 Beta 3 釋出：雙向預覽，Java UI 介面資料模擬 ...

4月1日訊息HUAWEI DevEco Studio（以下簡稱 DevEco Studio）是面向華為終端全場景多裝置的一站式整合開發環境（IDE），為開發者提供工程模板建立、開發、編譯、除錯、測試、釋出等 E2E 的 HarmonyOS 應用開發服務。獲

java雲平臺開發技術，成功定級騰訊T3-2

java雲平臺開發技術，成功定級騰訊T3-2 NO1：說說zookeeper是什麼？ ZooKeeper是一個分散式的，開放原始碼的分散式應用程式協調服務，是Google的Chubby一個開源的實現（Chubby是不開源的），它是叢集的管理者，監