技術文章 » 反射

反射

2022-06-19 18:03:33

快速入門：

re.properties檔案：
classfullpath=com.example.Cat
methodName=cry

package com.example.reflection.question;

import java.io.FileInputStream;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Properties;

/**
 * @Author 郜慶輝
 * @Time 2022/6/14 17:13
 * @Version 1.0
 */
public class ReflectionQuestion {
    public static void main(String[] args) throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
        
        
        Properties properties = new Properties();
        properties.load(new FileInputStream("src\\re.properties"));
        String  classfullpath = properties.get("classfullpath").toString();
        String methodName = properties.get("methodName").toString();
        
        System.out.println("classfullpath=" + classfullpath);
        System.out.println("method=" + methodName);
        
        
        //使用反射機制解決
        //1.載入類，返回Class型別的物件cls
        Class cls = Class.forName(classfullpath);
        //2.通過cls得到你載入的類com.example.Cat的物件範例
        //這裡返回的型別是classfullpath所在類的執行型別也就是com.example.Cat
        Object o = cls.newInstance();
        System.out.println("getClass=" + o.getClass());
        
        //3.通過cls得到你載入的類com.example.Cat的methodName hi的方法物件
        //在反射中，萬物皆是物件，包括方法
        Method method = cls.getMethod(methodName);
        
        //4.通過method呼叫方法：即通過方法物件來實現呼叫方法
        System.out.println("=========================");
        method.invoke(o);
    }
}

Cat類：

package com.example;

/**
 * @Author 郜慶輝
 * @Time 2022/6/14 17:05
 * @Version 1.0
 */
public class Cat {
    private String name = "招財貓";
    
    public void hi(){
        System.out.println("hello " + name);
    }
    
    public void cry(){//常用方法
        System.out.println(name + " 喵喵叫");
    }
    
}

簡單一句話：反射的作用就是通過不修改原始碼，修改組態檔來得到程式碼結果的改變；


class 類

  • Class類本身也是一個類，也繼承Object類
  • Class類物件不是new出來的，而是系統建立的
  • 對於某個類的Class物件，在記憶體中只有一份，因為類只載入一次
  • 一個Class物件對應的是一個載入到JVM中的一個.class檔案
  • 每個類的範例都會記得自己是由哪個Class範例所生成
  • 通過Class可以完整的得到一個類中的所有被載入的結構，通過API
  • Class類是Reflection的根源，針對任何你想動態載入、執行的類，唯有先獲得相應的Class物件
  • Class物件是存放在堆中的
  • 類的位元組碼二進位制資料是放在方法區的，有的地方稱為類的元素據


反射機制

1.反射機制允許程式在執行期間藉助與Reflection API取得任何類的內部資訊(比如成員變數，構造器，成員方法等等)，並能操作物件的屬性及方法。

2.載入完類以後，在堆中就產生了一個Class型別的物件(一個類只有一個Class物件)，這個物件包含了類的完整結構資訊。通過這個物件得到類的結構，這個Class物件就像一面鏡子，透過這個鏡子看到類的結構，所以就稱為反射；


反射優點和缺點

優點：可以動態的建立和使用物件(也是框架底層核心)，使用靈活，沒有反射機制，框架技術就失去底層支撐；

缺點：使用反射機制是解釋執行，對執行速度有影響；


反射的常用方法

package com.example.reflection.class_;

/**
 * @Author 郜慶輝
 * @Time 2022/6/15 17:19
 * @Version 1.0
 */
public class Car {
    public String brand = "寶馬";
    public double price = 5000000;
    public String color = "黑色";
    
    @Override
    public String toString() {
        return "Car{" + "brand='" + brand + '\'' + ", price=" + price + ", color='" + color + '\'' + '}';
    }
}

package com.example.reflection.class_;

import java.lang.reflect.Field;

/**
 * @Author 郜慶輝
 * @Time 2022/6/15 17:18
 * @Version 1.0
 * 演示Class類的常用方法
*/
 public class Class02 {
    public static void main(String[] args) throws Exception {
        
        String classAllPath = "com.example.reflection.class_.Car";
        
        //1.獲取到Car類對應的Class物件
        //<?>表示不確定的java型別
        Class<?> cls = Class.forName(classAllPath);
        //2.輸出cls
        //顯示cls物件，是哪個類的Class物件 com.example.reflection.class_.Car
        System.out.println(cls);
        
        //顯示cls執行型別 java.lang.Class
        System.out.println(cls.getClass());
        
        //3.得到包名
        System.out.println(cls.getPackage());
        
        //4.得到完整類名
        System.out.println(cls.getName());
        
        //5.通過cls建立物件範例，預設是Object，cls的執行型別是Car，也可以強轉成Car
        Car car = (Car) cls.newInstance();
        System.out.println(car);
        
        //6.通過反射獲取屬性brand
        Field brand = cls.getField("brand");
        System.out.println(brand.get(car));
        
        //7.通過反射給屬性賦值
        brand.set(car, "勞斯萊斯");
        System.out.println(brand.get(car));
        
        //8.遍歷所有屬性和值
        Field[] fields = cls.getFields();
        for (Field f : fields) {
            System.out.println(f.getName() + "=" + f.get(car));
        }
    
    }
}

建立反射的幾種方式

package com.example.reflection.class_;

/**
 * @Author 郜慶輝
 * @Time 2022/6/15 14:44
 * @Version 1.0
 * <p>
 * 演示class類的建立方式有哪些
 */
public class CreateClass {
    public static void main(String[] args) throws ClassNotFoundException {
        Person student = new Student();
        System.out.println(student.name);
        
        //方式一：通過物件獲得
        //應用場景：
        Class c1 = student.getClass();
        System.out.println(c1);
        
        //方式二：forname獲得
        //前提：已知一個類的全類名，且該類在類路徑下，可通過Class類的靜態方法Class.forName()來獲取
        //應用場景：多用於組態檔，讀取類全路徑，載入類
        Class c2 = Class.forName("com.example.reflection.class_.Student");
        System.out.println(c2);
        
        //方式三：通過類名.class獲得
        //前提：若已知具體的類，通過類的class獲取，該方式最為安全可靠，程式效能最高
        //應用場景：多用於引數傳遞，比如通過反射得到對應構造器物件
        Class c3 = Student.class;
        System.out.println(c3);
        
        //方式4：通過類載入器得到Class物件
        //1.先得到類載入器
        ClassLoader classLoader = student.getClass().getClassLoader();
        //2.通過類載入器得到class物件
        Class c4 = classLoader.loadClass("com.example.reflection.class_.Student");
        System.out.println(c4);
    
        //這4個class物件是同一個
        if(c1.equals(c2) && c3.equals(c4)){
            System.out.println(true);
        }
        
        //5.基本資料型別(int,char,boolean.float.double,byte,long,short)按如下方式得到Class類物件
        Class<Integer> integerClass = int.class;
        Class<Character> characterClass = char.class;
        Class<Double> doubleClass = double.class;
        System.out.println(integerClass);
    
        //6.基本資料型別對應的包裝類可以通過 包裝類.TYPE 得到Class類物件
        Class<Integer> type = Integer.TYPE;
        Class<Character> type1 = Character.TYPE;
        Class<Double> type2 = Double.TYPE;
        //。。。
    }
}

class Person {
    public String name;
    
    public Person() {
    }
    
    public Person(String name) {
        this.name = name;
    }
    
    @Override
    public String toString() {
        return "Person{" + "name='" + name + '\'' + '}';
    }
}

class Student extends Person {
    public Student() {
        this.name = "學生";
    }
}

class Teacher extends Person {
    public Teacher() {
        this.name = "老師";
    }
}

哪些型別有Class物件

1.外部類、成員內部類、靜態內部類、區域性內部類、匿名內部類

2.interface: 介面

3.陣列

4.enum: 列舉

5.annotation: 註解

6.基本資料型別

7.void


類載入

基本說明：

反射機制是java實現動態語言的關鍵，也就是通過反射實現類動態載入；

​ 1.動態載入：編譯時載入相關的類，如果沒有則報錯，依賴性太強；

​ 2.動態載入：執行時載入需要的類，如果執行時不用該類，即使不存在該類，也不儲存，降低了依賴性

類載入時機：

​ 1.當建立物件時(new) //靜態載入

​ 2.當子類被載入時，父類別也載入 //靜態載入

​ 3.呼叫類中的靜態成員時 //靜態載入

​ 4.通過反射 //動態載入

載入階段：

JVM在該階段的主要目的是將位元組碼從不同的資料來源(可能是class檔案，也可能是jar包，甚至網路)轉化為二進位制位元組流載入到記憶體中，並生成一個代表該類的java.lang.Class物件

連線階段--驗證：

1.目的是為了確保Class檔案的位元組流中包含的資訊符合當前虛擬機器器的要求，並且不會危害虛擬機器器自身的安全。

2.包括：檔案格式驗證(是否以魔數 oxcafebabe開頭)、後設資料驗證、位元組碼驗證和符號參照驗證

3.可以考慮使用-Xverify:none 引數來關閉大部分的類驗證措施，縮短虛擬機器器類載入的時間

連線階段--準備

1.JVM在該階段對靜態變數，分配記憶體並預設初始化(對應資料型別的預設初始值，如0、0L、null、false等)，這些變數所使用的內潤都將在方法區中進行分配

class A {
    //分析類載入得 連線階段--準備 屬性是如何處理
    //n1是範例屬性，不是靜態變數，因此在準備階段，是不會分配記憶體的
    //n2是靜態變數，分配記憶體n2是預設初始化為0，到後面inital的時候才賦值為20
    //n3是static final常數，和靜態變數不同，因為一旦賦值就不變，直接就是n3 = 30
    public int n1 = 10;
    public static int n2 =20;
    public static final int n3 = 30;
}

連線階段--解析

虛擬機器器將常數池內的符號參照替換為直接參照的過程

初始化階段(Initialization)：

1.到初始化階段：才真正開始執行類中定義的Java程式程式碼，此階段是執行()方法的過程；

2.()方法是由編譯器按語句在原始檔中出現的順序，依次自動收集類中的所有靜態變數的賦值動作和靜態程式碼塊中的語句，並進行合併(相當於後面相同的屬性名字替換前面的屬性的值)；

3.虛擬機器器會保證一個類的()方法在多執行緒環境中被正確的加鎖、同步、如果多個執行緒同時去初始化一個類，那麼只會有一個執行緒去執行這個類的()方法，其他執行緒都需要阻塞等待，直接活動執行緒執行()方法完畢；


反射爆破

反射爆破建立範例：

package com.example.reflection;

import java.lang.reflect.Constructor;



/**
 * @Author 郜慶輝
 * @Time 2022/6/17 14:25
 * @Version 1.0
 * 演示通過反射機制建立範例
 */
public class ReflecCreateInstance {
    public static void main(String[] args) throws Exception {
        //1.先獲取到User類的Class物件
        Class<?> userClass = Class.forName("com.example.reflection.User");
        
        //2.通過public的無參構造器建立範例
        Object o = userClass.newInstance();
        System.out.println(o);
        
        //3.通過public的有參構造器建立範例
        //3.1先得到對應構造器
        Constructor<?> constructor = userClass.getConstructor(String.class);
        ////3.2 建立範例，並傳入實參
        Object gqh = constructor.newInstance("gqh");
        System.out.println("gqh=" + gqh);
        
        //4.通過非public的有參構造器建立範例
        Constructor<?> declaredConstructor = userClass.getDeclaredConstructor(int.class, String.class);
        //暴破【暴力破解】 , 使用反射可以存取 private 構造器/方法/屬性
        declaredConstructor.setAccessible(true);
        Object user2 = declaredConstructor.newInstance(100, "郜慶輝");
    
        System.out.println("user2=" + user2);
    }
}

class User {//User 類
    private int age = 10;
    private String name = "韓順平教育";
    
    public User() {//無參 public
    }
    
    public User(String name) {//public 的有參構造器
        this.name = name;
    }
    
    private User(int age, String name) {//private 有參構造器
        this.age = age;
        this.name = name;
    }
    
    public String toString() {
        return "User [age=" + age + ", name=" + name + "]";
    }
}

反射爆破操作方法：

package com.example.reflection;

import java.lang.reflect.Field;

/**
 * @Author 郜慶輝
 * @Time 2022/6/17 14:45
 * @Version 1.0
 * 演示反射操作屬性
 */
public class ReflecAccessProperty {
    public static void main(String[] args) throws Exception {
        //1.得到Student類對應的Class物件
        Class<?> stuClass = Class.forName("com.example.reflection.Student");
        
        //2.建立物件
        Object o = stuClass.newInstance();
        System.out.println(o.getClass()); //Student
        
        //3使用反射得到age屬性物件
        Field age = stuClass.getField("age");
        age.set(o,80);
        System.out.println(o);
        System.out.println(age.get(o));
        
        //4.使用反射操作name屬性
        Field name = stuClass.getDeclaredField("name");
        //對 name 進行暴破, 可以操作 private 屬性
        name.setAccessible(true);
        name.set(null,"輝");
        //name.set(o,"郜慶輝");
        System.out.println(o);
        System.out.println(name.get(o));//獲取屬性值
        System.out.println(name.get(null));//獲取屬性值，要求name是static
    }
}

class Student {//類
    public int age;
    private static String name;
    
    public Student() {//構造器
    }
    
    public String toString() {
        return "Student [age=" + age + ", name=" + name + "]";
    }
}

通過反射爆破呼叫方法：


package com.example.reflection;

import java.lang.reflect.Method;

/**
 * @Author 郜慶輝
 * @Time 2022/6/17 15:08
 * @Version 1.0
 * 演示通過反射呼叫方法
 */
public class ReflecAccessMethod {
    public static void main(String[] args) throws Exception {
        //1.得到Boss類對應的Class物件
        Class<?> bossCls = Class.forName("com.example.reflection.Boss");
        //2.建立物件
        Object o = bossCls.newInstance();
        //3.呼叫public的hi方法
        Method hi = bossCls.getDeclaredMethod("hi", String.class);
        hi.invoke(o,"郜慶輝");
        
        //4.呼叫private statice方法
        //4.1得到say方法物件
        Method say = bossCls.getDeclaredMethod("say", int.class, String.class, char.class);
        //4.2 因為 say 方法是 private, 所以需要暴破，原理和前面講的構造器和屬性一樣
        say.setAccessible(true);
        System.out.println(say.invoke(o, 100, "張三", '男'));
    
        //5. 在反射中，如果方法有返回值，統一返回 Object , 但是他執行型別和方法定義的返回型別一致
        Object reVal = say.invoke(null, 300, "王五", '男');
        System.out.println("reVal 的執行型別=" + reVal.getClass());//String
        
        
    }
    
}

class Boss {//類
    public int age;
    private static String name;
    
    public Boss() {//構造器
    }
    
    private static String say(int n, String s, char c) {//靜態方法
        return n + " " + s + " " + c;
    }
    
    public void hi(String s) {//普通 public 方法
        System.out.println("hi " + s);
    }
    
}