Java之反射
- 2019 年 10 月 3 日
- 筆記
內容介紹
- 類載入器
- 反射構造方法
- 反射成員變數
- 反射成員方法
- 反射配置文件運行類中的方法
1 類載入器
1.1 類的載入
當程式要使用某個類時，如果該類還未被載入到記憶體中，則系統會通過載入，連接，初始化三步來實現對這個類進行初始化。
- 載入
就是指將class文件讀入記憶體，並為之創建一個Class對象。
任何類被使用時系統都會建立一個Class對象
- 連接
驗證 是否有正確的內部結構，並和其他類協調一致
準備 負責為類的靜態成員分配記憶體，並設置默認初始化值
解析 將類的二進位數據中的符號引用替換為直接引用
- 初始化
就是我們以前講過的初始化步驟
1.2 類初始化時機
1. 創建類的實例
2. 類的靜態變數，或者為靜態變數賦值
3. 類的靜態方法
4. 使用反射方式來強制創建某個類或介面對應的java.lang.Class對象
5. 初始化某個類的子類
6. 直接使用java.exe命令來運行某個主類
1.3 類載入器
- 負責將.class文件載入到內在中，並為之生成對應的Class對象。
- 雖然我們不需要關心類載入機制，但是了解這個機制我們就能更好的理解程式的運行
1.4 類載入器的組成
- Bootstrap ClassLoader 根類載入器
也被稱為引導類載入器，負責Java核心類的載入
比如System,String等。在JDK中JRE的lib目錄下rt.jar文件中
- Extension ClassLoader 擴展類載入器
負責JRE的擴展目錄中jar包的載入。
在JDK中JRE的lib目錄下ext目錄
- System ClassLoader 系統類載入器
負責在JVM啟動時載入來自java命令的class文件，以及classpath環境變數所指定的jar包和類路徑。
通過這些描述就可以知道我們常用的類，都是由誰來載入完成的。到目前為止我們已經知道把class文件載入到記憶體了，那麼，如果我們僅僅站在這些class文件的角度，我們如何來使用這些class文件中的內容呢?這就是我們反射要研究的內容。
2 反射
JAVA反射機制是在運行狀態中，對於任意一個類，都能夠知道這個類的所有屬性和方法；對於任意一個對象，都能夠調用它的任意一個方法和屬性；這種動態獲取的資訊以及動態調用對象的方法的功能稱為java語言的反射機制。
要想解剖一個類,必須先要獲取到該類的位元組碼文件對象。而解剖使用的就是Class類中的方法.所以先要獲取到每一個位元組碼文件對應的Class類型的對象。
2.1 Class類
閱讀API的Class類得知，Class 沒有公共構造方法。Class 對象是在載入類時由 Java 虛擬機以及通過調用類載入器中的 defineClass 方法自動構造的
- 獲取Class對象的三種方式
方式一: 通過Object類中的getObject()方法
Person p = new Person(); Class c = p.getClass();
方式二: 通過 類名.class 獲取到位元組碼文件對象（任意數據類型都具備一個class靜態屬性,看上去要比第一種方式簡單）。
Class c2 = Person.class;
方式三: 通過Class類中的方法（將類名作為字元串傳遞給Class類中的靜態方法forName即可）。
Class c3 = Class.forName("Person");
- 注意：第三種和前兩種的區別
前兩種你必須明確Person類型.
後面是指定這種類型的字元串就行.這種擴展更強.我不需要知道你的類.我只提供字元串,按照配置文件載入就可以了
- 程式碼演示
/* * 獲取.class位元組碼文件對象的方式 * 1：通過Object類中的getObject()方法 * 2: 通過 類名.class 獲取到位元組碼文件對象 * 3: 反射中的方法, * public static Class<?> forName(String className) throws ClassNotFoundException * 返回與帶有給定字元串名的類或介面相關聯的 Class 對象 */ public class ReflectDemo { public static void main(String[] args) throws ClassNotFoundException { // 1： 通過Object類中的getObject()方法 // Person p1 = new Person(); // Class c1 = p1.getClass(); // System.out.println("c1 = "+ c1); // 2: 通過 類名.class 獲取到位元組碼文件對象 // Class c2 = Person.class; // System.out.println("c2 = "+ c2); // 3: 反射中的方法 Class c3 = Class.forName("com.test_Reflect.Person");// 包名.類名 System.out.println("c3 = " + c3); } }
- Person類
package com.test_Reflect; public class Person { //成員變數 public String name; public int age; private String address; //構造方法 public Person() { System.out.println("空參數構造方法"); } public Person(String name) { this.name = name; System.out.println("帶有String的構造方法"); } //私有的構造方法 private Person(String name, int age){ this.name = name; this.age = age; System.out.println("帶有String，int的構造方法"); } public Person(String name, int age, String address){ this.name = name; this.age = age; this.address = address; System.out.println("帶有String, int, String的構造方法"); } //成員方法 //沒有返回值沒有參數的方法 public void method1(){ System.out.println("沒有返回值沒有參數的方法"); } //沒有返回值，有參數的方法 public void method2(String name){ System.out.println("沒有返回值，有參數的方法 name= "+ name); } //有返回值，沒有參數 public int method3(){ System.out.println("有返回值，沒有參數的方法"); return 123; } //有返回值，有參數的方法 public String method4(String name){ System.out.println("有返回值，有參數的方法"); return "哈哈" + name; } //私有方法 private void method5(){ System.out.println("私有方法"); } @Override public String toString() { return "Person [name=" + name + ", age=" + age + ", address=" + address+ "]"; } }
2.2 通過反射獲取構造方法並使用
在反射機制中，把類中的成員（構造方法、成員方法、成員變數）都封裝成了對應的類進行表示。其中，構造方法使用類Constructor表示。可通過Class類中提供的方法獲取構造方法：
- 返回一個構造方法
public Constructor<T> getConstructor(Class<?>… parameterTypes) 獲取public修飾, 指定參數類型所對應的構造方法
public Constructor<T> getDeclaredConstructor(Class<?>… parameterTypes) 獲取指定參數類型所對應的構造方法(包含私有的)
- 返回多個構造方法
public Constructor<?>[] getConstructors() 獲取所有的public 修飾的構造方法
public Constructor<?>[] getDeclaredConstructors() 獲取所有的構造方法(包含私有的)
- 獲取構造方法的程式碼演示：
public class ReflectDemo { public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException { //獲取Class對象 Class c = Class.forName("cn.itcast_01_Reflect.Person");//包名.類名 //獲取所有的構造方法 //Constructor[] cons = c.getConstructors(); Constructor[] cons = c.getDeclaredConstructors(); for (Constructor con : cons) { System.out.println(con); } System.out.println("------------------------"); //獲取一個構造方法 //public Person() Constructor con1 = c.getConstructor(null); System.out.println(con1); //public Person(String name) Constructor con2 = c.getConstructor(String.class); System.out.println(con2); //private Person(String name, int age) Constructor con3 = c.getDeclaredConstructor(String.class, int.class); System.out.println(con3); //public Person(String name, int age, String address) Constructor con4 = c.getDeclaredConstructor(String.class, int.class, String.class); System.out.println(con4); } }
2.2.1 通過反射方式，獲取構造方法，創建對象
獲取構造方法，步驟如下：
1. 獲取到Class對象
2. 獲取指定的構造方法
3. 通過構造方法類Constructor中的方法，創建對象
public T newInstance(Object… initargs)
- 程式碼演示
public class ConstructorDemo { public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException { //1,獲取到Class對象 Class c = Class.forName("cn.itcast_01_Reflect.Person");//包名.類名 //2,獲取指定的構造方法 //public Person() //Constructor con = c.getConstructor(null); //public Person(String name, int age, String address) Constructor con = c.getConstructor(String.class, int.class, String.class); //3,通過構造方法類中Constructor的方法，創建對象 //Object obj = con.newInstance(null); Object obj = con.newInstance("小明", 22, "哈爾濱"); //顯示 System.out.println(obj); } }
2.2.2 通過反射方式，獲取私有構造方法，創建對象
AccessibleObject 類是 Field、Method 和 Constructor 對象的父類。它提供了將反射的對象標記為在使用時取消默認 Java 語言訪問控制檢查的能力。
對於公共成員、默認（打包）訪問成員、受保護成員和私有成員，在分別使用 Field、Method 或 Constructor 對象來設置或獲取欄位、調用方法，或者創建和初始化類的新實例的時候，會執行訪問檢查。常用方法如下：
- public void setAccessible(boolean flag) throws SecurityException
參數值為 true 則指示反射的對象在使用時應該取消 Java 語言訪問檢查。參數值為 false 則指示反射的對象應該實施 Java 語言訪問檢查。
獲取私有構造方法，步驟如下：
1. 獲取到Class對象
2. 獲取指定的構造方法
3. 暴力訪問, 通過setAccessible(boolean flag)方法
4. 通過構造方法類Constructor中的方法，創建對象
public T newInstance(Object… initargs)
- 程式碼演示：
public class ConstructorDemo2 { public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException { //1,獲取到Class對象 Class c = Class.forName("cn.itcast_01_Reflect.Person");//包名.類名 //2,獲取指定的構造方法 //private Person(String name, int age) Constructor con = c.getDeclaredConstructor(String.class, int.class); //3,暴力反射 con.setAccessible(true);//取消 Java 語言訪問檢查 //4,通過構造方法類中的功能，創建對象 Object obj = con.newInstance("小明", 23); System.out.println(obj); } }
2.3 通過反射獲取成員變數並使用
在反射機制中，把類中的成員變數使用類Field表示。可通過Class類中提供的方法獲取成員變數：
- 返回一個成員變數
public Field getField(String name) 獲取指定的 public修飾的變數
public Field getDeclaredField(String name) 獲取指定的任意變數
- 返回多個成員變數
public Field[] getFields() 獲取所有public 修飾的變數
public Field[] getDeclaredFields() 獲取所有的 變數 (包含私有)
- 獲取成員變數的程式碼演示：
public class FieldDemo { public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, SecurityException { //獲取Class對象 Class c = Class.forName("cn.itcast_01_Reflect.Person"); //獲取成員變數 //多個變數 //Field[] fields = c.getFields(); Field[] fields = c.getDeclaredFields(); for (Field field : fields) { System.out.println(field); } System.out.println("-----------------"); //一個變數 //public int age; Field ageField = c.getField("age"); System.out.println(ageField); //private String address Field addressField = c.getDeclaredField("address"); System.out.println(addressField); } }
2.3.1 通過反射，創建對象，獲取指定的成員變數，進行賦值與獲取值操作
獲取成員變數，步驟如下：
1. 獲取Class對象
2. 獲取構造方法
3. 通過構造方法，創建對象
4. 獲取指定的成員變數（私有成員變數，通過setAccessible(boolean flag)方法暴力訪問）
5. 通過方法，給指定對象的指定成員變數賦值或者獲取值
public void set(Object obj, Object value) 在指定對象obj中，將此 Field 對象表示的成員變數設置為指定的新值
public Object get(Object obj) 返回指定對象obj中，此 Field 對象表示的成員變數的值
- 程式碼演示：
public class FieldDemo2 { public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchFieldException { //1,獲取Class對象 Class c = Class.forName("cn.itcast_01_Reflect.Person"); //2，獲取構造方法 //public Person(String name) Constructor con = c.getConstructor(String.class); //3，通過構造方法，創建對象 Object obj = con.newInstance("小明"); //4，獲取指定的成員變數 //public String name; Field nameField = c.getField("name"); //public int age; Field ageField = c.getField("age"); //private String address; Field addressField = c.getDeclaredField("address"); addressField.setAccessible(true); //取消 Java 語言訪問檢查 //5，通過方法，給指定對象的指定成員變數賦值或者獲取值 System.out.println("name = "+ nameField.get(obj)); System.out.println("age = "+ ageField.get(obj)); System.out.println("address = "+ addressField.get(obj)); //賦值 ageField.set(obj, 23); addressField.set(obj, "凱利廣場"); System.out.println("------------------------"); System.out.println("name = "+ nameField.get(obj)); System.out.println("age = "+ ageField.get(obj)); System.out.println("address = "+ addressField.get(obj)); } }
2.4 通過反射獲取成員方法並使用
在反射機制中，把類中的成員方法使用類Method表示。可通過Class類中提供的方法獲取成員方法：
- 返回獲取一個方法：
public Method getMethod(String name, Class<?>… parameterTypes)
獲取public 修飾的方法
public Method getDeclaredMethod(String name, Class<?>… parameterTypes)
獲取任意的方法，包含私有的
參數1: name 要查找的方法名稱； 參數2： parameterTypes 該方法的參數類型
- 返回獲取多個方法：
public Method[] getMethods() 獲取本類與父類中所有public 修飾的方法
public Method[] getDeclaredMethods() 獲取本類中所有的方法(包含私有的)
- 獲取成員方法的程式碼演示：
public class MethodDemo { public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException { //獲取Class對象 Class c = Class.forName("cn.itcast_01_Reflect.Person"); //獲取多個方法 //Method[] methods = c.getMethods(); Method[] methods = c.getDeclaredMethods(); for (Method method : methods) { System.out.println(method); } System.out.println("-----------------------"); //獲取一個方法： //public void method1() Method method = c.getMethod("method1", null); System.out.println(method); //public String method4(String name){ method = c.getMethod("method4", String.class); System.out.println(method); //私有方法 //private void method5() method = c.getDeclaredMethod("method5", null); System.out.println(method); } }
2.4.1 通過反射，創建對象，調用指定的方法
獲取成員方法，步驟如下：
1. 獲取Class對象
2. 獲取構造方法
3. 通過構造方法，創建對象
4. 獲取指定的方法
5. 執行找到的方法
public Object invoke(Object obj, Object… args) 執行指定對象obj中，當前Method對象所代表的方法，方法要傳入的參數通過args指定。
- 程式碼演示：
public class MethodDemo2 { public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException { //1， 獲取Class對象 Class c = Class.forName("com.test_Reflect.Person"); //2,獲取構造方法 //public Person(String name, int age, String address){ Constructor con = c.getConstructor(String.class, int.class, String.class); //3，通過構造方法，創建對象 Object obj = con.newInstance("小明", 23, "哈爾濱"); //4，獲取指定的方法 //public void method1() 沒有返回值沒有參數的方法 //Method m1 = c.getMethod("method1", null); //public String method4(String name) Method m4 = c.getMethod("method4", String.class); //5，執行找到的方法 //m1.invoke(obj, null); Object result = m4.invoke(obj, "itcast"); System.out.println("result = " + result); } }
2.4.2 通過反射，創建對象，調用指定的private 方法
獲取私有成員方法，步驟如下：
1. 獲取Class對象
2. 獲取構造方法
3. 通過構造方法，創建對象
4. 獲取指定的方法
5. 開啟暴力訪問
6. 執行找到的方法
public Object invoke(Object obj, Object… args) 執行指定對象obj中，當前Method對象所代表的方法，方法要傳入的參數通過args指定。
- 程式碼演示：
public class MethodDemo3 { public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException { //1， 獲取Class對象 Class c = Class.forName("cn.itcast_01_Reflect.Person"); //2,獲取構造方法 //public Person(String name, int age, String address){ Constructor con = c.getConstructor(String.class, int.class, String.class); //3，通過構造方法，創建對象 Object obj = con.newInstance("小明", 23, "哈爾濱"); //4，獲取指定的方法 //private void method5(){ Method m5 = c.getDeclaredMethod("method5", null); //5,開啟暴力訪問 m5.setAccessible(true); //6，執行找到的方法 m5.invoke(obj, null); } }
3 反射練習
3.1 泛型擦除
思考，將已存在的ArrayList<Integer>集合中添加一個字元串數據，如何實現呢？
我來告訴大家，其實程式編譯後產生的.class文件中是沒有泛型約束的，這種現象我們稱為泛型的擦除。那麼，我們可以通過反射技術，來完成向有泛型約束的集合中，添加任意類型的元素
- 程式碼如下：
public class ReflectTest { public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException { ArrayList<Integer> list = new ArrayList<Integer>(); //添加元素到集合 list.add(new Integer(30)); list.add(new Integer("12345")); list.add(123); //list.add("哈哈");//因為有泛型類型的約束 System.out.println(list); //通過反射技術，實現添加任意類型的元素 //1, 獲取位元組碼文件對象 //Class c = list.getClass(); //Class c = ArrayList.class; Class c = Class.forName("java.util.ArrayList"); //2, 找到add()方法 // public boolean add(E e) Method addMethod = c.getMethod("add", Object.class); //3， 執行add()方法 addMethod.invoke(list, "哈哈");// list.add("哈哈"); System.out.println(list); } }
3.2 反射配置文件
- 通過反射配置文件，運行配置文件中指定類的對應方法
讀取Peoperties.txt文件中的數據，通過反射技術，來完成Person對象的創建
Peoperties.txt文件內容如下：
className=com.test_Reflect.Person methodName=method5
- 讀取配置文件，調用指定類中的對應方法
public class ReflectTest2 { public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException { // 通過Properties集合從文件中讀取數據 Properties prop = new Properties(); // 讀取文件中的數據到集合中 prop.load(new FileInputStream("properties.txt")); // 獲取鍵所對應的值 String className = prop.getProperty("className"); System.out.println(className); // 1，獲取Person.class 位元組碼文件對象 Class c = Class.forName(className); // 2，獲取構造方法 // public Person(String name, int age, String address) Constructor con = c.getConstructor(String.class, int.class, String.class); // 3,創建對象 Object obj = con.newInstance("小明", 20, "中國"); System.out.println(obj); // 4，獲取指定的方法 // private void method5(){} String methodName = prop.getProperty("methodName"); Method m5 = c.getDeclaredMethod(methodName, null); // 5,開啟暴力訪問 m5.setAccessible(true); // 6，執行找到的方法 m5.invoke(obj, null); } }
