Java 世界的法外狂徒：反射

概述

反射（Reflection）機制是指在運行時動態地獲取類的信息以及操作類的成員（字段、方法、構造函數等）的能力。通過反射，我們可以在編譯時期未知具體類型的情況下，通過運行時的動態查找和調用。雖然 Java 是靜態的編譯型語言，但是反射特性的加入，提供一種直接操作對象外的另一種方式，讓 Java 具備的一些靈活性和動態性，我們可以通過本篇文章來詳細瞭解它

爲什麼需要反射？

Java 需要用到反射的主要原因包括以下幾點：

運行時動態加載，創建類：Java中的類是在編譯時加載的，但有時希望在運行時根據某些條件來動態加載和創建所需要類。反射就提供這種能力，這樣的能力讓程序可以更加的靈活，動態
動態的方法調用：根據反射獲取的類和對象，動態調用類中的方法，這對於一些類增強框架（例如 Spring 的 AOP），還有安全框架（方法調用前進行權限驗證），還有在業務代碼中注入一些通用的業務邏輯（例如一些日誌，等，動態調用的能力都非常有用
獲取類的信息：通過反射，可以獲取類的各種信息，如類名、父類、接口、字段、方法等。這使得我們可以在運行時檢查類的屬性和方法，並根據需要進行操作

一段示例代碼

以下是一個簡單的代碼示例，展示基本的反射操作：

import java.lang.reflect.Method;

public class ReflectionExample {
    public static void main(String[] args) {
        // 假設在運行時需要調用某個類的方法，但該類在編譯時未知
        String className = "com.example.MyClass";

        try {
            // 使用反射動態加載類
            Class<?> clazz = Class.forName(className);

            // 使用反射獲取指定方法
            Method method = clazz.getMethod("myMethod");

            // 使用反射創建對象
            Object obj = clazz.newInstance();

            // 使用反射調用方法
            method.invoke(obj);

        } catch (ClassNotFoundException e) {
            System.out.println("類未找到：" + className);
        } catch (NoSuchMethodException e) {
            System.out.println("方法未找到");
        } catch (IllegalAccessException | InstantiationException e) {
            System.out.println("無法實例化對象");
        } catch (Exception e) {
            System.out.println("其他異常：" + e.getMessage());
        }
    }
}

在這個示例中，我們假設在編譯時並不知道具體的類名和方法名，但在運行時需要根據動態情況來加載類、創建對象並調用方法。使用反射機制，我們可以通過字符串形式傳遞類名，使用 Class.forName() 動態加載類。然後，通過 getMethod() 方法獲取指定的方法對象，使用 newInstance() 創建類的實例，最後通過 invoke() 方法調用方法。

使用場景

技術再好，如果無法落地，那麼始終都是空中樓閣，在日常開發中，我們常常可以在以下的場景中看到反射的應用：

框架和庫：許多框架和庫使用反射來實現插件化架構或擴展機制。例如，Java 的 Spring 框架使用反射來實現依賴注入（Dependency Injection）和 AOP（Aspect-Oriented Programming）等功能。
ORM（對象關係映射）：ORM 框架用於將對象模型和關係數據庫之間進行映射。通過反射，ORM 框架可以在運行時動態地讀取對象的屬性和註解信息，從而生成相應的 SQL 語句並執行數據庫操作。
動態代理：動態代理是一種常見的設計模式，通過反射可以實現動態代理。動態代理允許在運行時創建代理對象，並攔截對原始對象方法的調用。這在實現日誌記錄、性能統計、事務管理等方面非常有用
反射調試工具：在開發和調試過程中，有時需要查看對象的結構和屬性，或者動態調用對象的方法來進行測試。反射提供了一種方便的方式來檢查和操作對象的內部信息，例如使用getDeclaredFields()獲取對象的所有字段，或使用getMethod()獲取對象的方法
單元測試：在單元測試中，有時需要模擬或替換某些對象的行爲，以便進行有效的測試。通過反射，可以在運行時創建對象的模擬實例，並在測試中替換原始對象，以便控制和驗證測試的行爲

Class 對象

Class 對象是反射的第一步，我們先從 Class 對象聊起，因爲在反射中，只要你想在運行時使用類型信息，就必須先得到那個 Class 對象的引用，他是反射的核心，它代表了Java類的元數據信息，包含了類的結構、屬性、方法和其他相關信息。通過Class對象，我們可以獲取和操作類的成員，實現動態加載和操作類的能力。

常見的獲取 Class 對象的方式幾種：

// 使用類名獲取
Class<?> clazz = Class.forName("com.example.MyClass");

// 使用類字面常量獲取
Class<?> clazz = MyClass.class;

// 使用對象的 getClass() 方法獲取
MyClass obj = new MyClass();
Class<?> clazz = obj.getClass();

需要注意的是，如果 Class.forName() 找不到要加載的類，它就會拋出異常 ClassNotFoundException

正如上面所說，獲取 Class 對象是第一步，一旦獲取了Class對象，我們可以使用它來執行各種反射操作，例如獲取類的屬性、方法、構造函數等。示例：

String className = clazz.getName(); // 獲取類的全限定名
int modifiers = clazz.getModifiers(); // 獲取類的修飾符，如 public、abstract 等
Class<?> superClass = clazz.getSuperclass(); // 獲取類的直接父類
Class<?> superClass = clazz.getSuperclass(); // 獲取類的直接父類
Class<?>[] interfaces = clazz.getInterfaces(); // 獲取類實現的接口數組
Constructor<?>[] constructors = clazz.getConstructors(); // 獲取類的公共構造函數數組
Method[] methods = clazz.getMethods(); // 獲取類的公共方法數組
Field[] fields = clazz.getFields(); // 獲取類的公共字段數組
Object obj = clazz.newInstance(); // 創建類的實例，相當於調用無參構造函數

上述示例僅展示了Class對象的一小部分使用方法，還有許多其他方法可用於獲取和操作類的各個方面。通過Class對象，我們可以在運行時動態地獲取和操作類的信息，實現反射的強大功能。

類型檢查

在反射的代碼中，經常會對類型進行檢查和判斷，從而對進行對應的邏輯操作，下面介紹幾種 Java 中對類型檢查的方法

`instanceof` 關鍵字

instanceof 是 Java 中的一個運算符，用於判斷一個對象是否屬於某個特定類或其子類的實例。它返回一個布爾值，如果對象是指定類的實例或其子類的實例，則返回true，否則返回false。下面來看看它的使用示例

1：避免類型轉換錯誤

在進行強制類型轉換之前，使用 instanceof 可以檢查對象的實際類型，以避免類型轉換錯誤或 ClassCastException 異常的發生：

if (obj instanceof MyClass) {
    MyClass myObj = (MyClass) obj;
    // 執行鍼對 MyClass 類型的操作
}

2：多態性判斷

使用 instanceof 可以判斷對象的具體類型，以便根據不同類型執行不同的邏輯。例如：

if (animal instanceof Dog) {
    Dog dog = (Dog) animal;
    dog.bark();
} else if (animal instanceof Cat) {
    Cat cat = (Cat) animal;
    cat.meow();
}

3：接口實現判斷

在使用接口時，可以使用 instanceof 判斷對象是否實現了某個接口，以便根據接口進行不同的處理

if (obj instanceof MyInterface) {
    MyInterface myObj = (MyInterface) obj;
    myObj.doSomething();
}

4：繼承關係判斷

instanceof 可以用於判斷對象是否是某個類的子類的實例。這在處理繼承關係時非常有用，可以根據對象的具體類型執行相應的操作

if (obj instanceof MyBaseClass) {
    MyBaseClass myObj = (MyBaseClass) obj;
    // 執行 MyBaseClass 類型的操作
}

instanceof 看似可以做很多事情，但是在使用時也有很多限制，例如：

無法和基本類型進行匹配：instanceof 運算符只能用於引用類型，無法用於原始類型
不能和 Class 對象類型匹配：只可以將它與命名類型進行比較
無法判斷泛型類型參數：由於Java的泛型在運行時會進行類型擦除，instanceof 無法直接判斷對象是否是某個泛型類型的實例

instanceof 看似方便，但過度使用它可能表明設計上的缺陷，可能違反了良好的面向對象原則。應儘量使用多態性和接口來實現對象行爲的差異，而不是過度依賴類型檢查。

`isInstance()` 函數

java.lang.Class 類也提供 isInstance() 類型檢查方法，用於判斷一個對象是否是指定類或其子類的實例。更適合在反射的場景下使用，代碼示例：

Class<?> clazz = MyClass.class;
boolean result = clazz.isInstance(obj);

如上所述，相比 instanceof 關鍵字，isInstance() 提供更靈活的類型檢查，它們的區別如下：

isInstance() 方法的參數是一個對象，而 instanceof 關鍵字的操作數是一個引用類型。因此，使用 isInstance() 方法時，可以動態地確定對象的類型，而 instanceof 關鍵字需要在編譯時指定類型。
isInstance()方法可以應用於任何Class對象。它是一個通用的類型檢查方法。而instanceof關鍵字只能應用於引用類型，用於檢查對象是否是某個類或其子類的實例。
isInstance()方法是在運行時進行類型檢查，它的結果取決於實際對象的類型。而instanceof關鍵字在編譯時進行類型檢查，結果取決於代碼中指定的類型。
由於Java的泛型在運行時會進行類型擦除，instanceof無法直接檢查泛型類型參數。而isInstance()方法可以使用通配符類型（<?>）進行泛型類型參數的檢查。

總體而言，isInstance()方法是一個動態的、通用的類型檢查方法，可以在運行時根據實際對象的類型來判斷對象是否屬於某個類或其子類的實例。與之相比，instanceof關鍵字是在編譯時進行的類型檢查，用於檢查對象是否是指定類型或其子類的實例。它們在表達方式、使用範圍和檢查方式等方面有所差異。在具體的使用場景中，可以根據需要選擇合適的方式進行類型檢查。

代理

代理模式

代理模式是一種結構型設計模式，其目的是通過引入一個代理對象，控制對原始對象的訪問。代理對象充當了原始對象的中間人，可以在不改變原始對象的情況下，對其進行額外的控制和擴展。這是一個簡單的代理模式示例：

// 定義抽象對象接口
interface Image {
    void display();
}

// 定義原始對象
class RealImage implements Image {
    private String fileName;

    public RealImage(String fileName) {
        this.fileName = fileName;
        loadFromDisk();
    }

    private void loadFromDisk() {
        System.out.println("Loading image:" + fileName);
    }

    @Override
    public void display() {
        System.out.println("Displaying image:" + fileName);
    }
}

// 定義代理對象
class ImageProxy implements Image {
    private String filename;
    private RealImage realImage;

    public ImageProxy(String filename) {
        this.filename = filename;
    }

    @Override
    public void display() {
        if (realImage == null) {
            realImage = new RealImage(filename);
        }
        realImage.display();
    }
}

public class ProxyPatternExample {
    public static void main(String[] args) {
        // 使用代理對象訪問實際對象
        Image image = new ImageProxy("test_10mb.jpg");
        // 第一次訪問，加載實際對象
        image.display();
        // 第二次訪問，直接使用已加載的實際對象
        image.display();
    }
}

輸出結果：

Loading image:test_10mb.jpg
Displaying image:test_10mb.jpg
Displaying image:test_10mb.jpg

在上述代碼中，我們定義了一個抽象對象接口 Image，並有兩個實現類：RealImage 代表實際的圖片對象，ImageProxy 代表圖片的代理對象。在代理對象中，通過控制實際對象的加載和訪問，實現了延遲加載和額外操作的功能。客戶端代碼通過代理對象來訪問圖片，實現了對實際對象的間接訪問。

動態代理

Java的動態代理是一種在運行時動態生成代理類和代理對象的機制，它可以在不事先定義代理類的情況下，根據接口或父類來動態創建代理對象。動態代理使用Java的反射機制來實現，通過動態生成的代理類，可以在方法調用前後插入額外的邏輯。

以下是使用動態代理改寫上述代碼的示例：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

// 定義抽象對象接口
interface Image {
    void display();
}

// 定義原始對象
class RealImage implements Image {
    private String filename;

    public RealImage(String filename) {
        this.filename = filename;
        loadFromDisk();
    }

    private void loadFromDisk() {
        System.out.println("Loading image: " + filename);
    }

    public void display() {
        System.out.println("Displaying image: " + filename);
    }
}

// 實現 InvocationHandler 接口的代理處理類
class ImageProxyHandler implements InvocationHandler {

    private Object realObject;

    public ImageProxyHandler(Object realObject) {
        this.realObject = realObject;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object result = null;
        if (method.getName().equals("display")) {
            System.out.println("Proxy: before display");
            result = method.invoke(realObject, args);
            System.out.println("Proxy: after display");
        }
        return result;
    }
}

public class DynamicProxyExample {

    public static void main(String[] args) {
        // 創建原始對象
        Image realImage = new RealImage("image.jpg");
        // 創建動態代理對象
        Image proxyImage = (Image) Proxy.newProxyInstance(Image.class.getClassLoader(), new Class[]{Image.class}, new ImageProxyHandler(realImage));
        // 使用代理對象訪問實際對象
        proxyImage.display();
    }
}

在上述代碼中，我們使用 java.lang.reflect.Proxy 類創建動態代理對象。我們定義了一個 ImageProxyHandler 類，實現了 java.lang.reflect.InvocationHandler 接口，用於處理代理對象的方法調用。在 invoke() 方法中，我們可以在調用實際對象的方法之前和之後執行一些額外的邏輯。

輸出結果：

Loading image: image.jpg
Proxy: before display
Displaying image: image.jpg
Proxy: after display

在客戶端代碼中，我們首先創建了實際對象 RealImage，然後通過 Proxy.newProxyInstance() 方法創建了動態代理對象 proxyImage，並指定了代理對象的處理類爲 ImageProxyHandler。最後，我們使用代理對象來訪問實際對象的 display() 方法。

通過動態代理，我們可以更加靈活地對實際對象的方法進行控制和擴展，而無需顯式地創建代理類。動態代理在實際開發中常用於 AOP（面向切面編程）等場景，可以在方法調用前後添加額外的邏輯，如日誌記錄、事務管理等。

違反訪問權限

在 Java 中，通過反射機制可以突破對私有成員的訪問限制。以下是一個示例代碼，展示瞭如何使用反射來訪問和修改私有字段：

import java.lang.reflect.Field;

class MyClass {
    private String privateField = "Private Field Value";
}

public class ReflectionExample {

    public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException {
        MyClass myObj = new MyClass();
        // 獲取私有字段對象
        Field privateField = MyClass.class.getDeclaredField("privateField");

        // 取消對私有字段的訪問限制
        privateField.setAccessible(true);

        // 獲取私有字段的值
        String fieldValue = (String) privateField.get(myObj);
        System.out.println("Original value of privateField: " + fieldValue);

        // 修改私有字段的值
        privateField.set(myObj, "New Field Value");

        // 再次獲取私有字段的值
        fieldValue = (String) privateField.get(myObj);
        System.out.println("Modified value of privateField: " + fieldValue);
    }
}

在上述代碼中，我們定義了一個 MyClass 類，其中包含一個私有字段 privateField。在 ReflectionExample 類的 main 方法中，我們使用反射獲取了 privateField 字段，並通過 setAccessible(true) 方法取消了對私有字段的訪問限制。然後，我們使用 get() 方法獲取私有字段的值並輸出，接着使用 set() 方法修改私有字段的值。最後，再次獲取私有字段的值並輸出，驗證字段值的修改。

輸出結果：

Original value of privateField: Private Field Value
Modified value of privateField: New Field Value

除了字段，通過反射還可以實現以下違反訪問權限的操作：

調用私有方法
實例化非公開的構造函數
訪問和修改靜態字段和方法
繞過訪問修飾符檢查

雖然反射機制可以突破私有成員的訪問限制，但應該慎重使用。私有成員通常被設計爲內部實現細節，並且具有一定的安全性和封裝性。過度依賴反射訪問私有成員可能會破壞代碼的可讀性、穩定性和安全性。因此，在使用反射突破私有成員限制時，請確保瞭解代碼的設計意圖和潛在風險，並謹慎操作。

總結

反射技術自 JDK 1.1 版本引入以來，一直被廣泛使用。它爲開發人員提供了一種在運行時動態獲取類的信息、調用類的方法、訪問和修改類的字段等能力。在過去的應用開發中，反射常被用於框架、工具和庫的開發，以及動態加載類、實現註解處理、實現代理模式等場景。反射技術爲Java的靈活性、可擴展性和動態性增添了強大的工具。

當下，反射技術仍然發揮着重要的作用。它被廣泛應用於諸多領域，如框架、ORM（對象關係映射）、AOP（面向切面編程）、依賴注入、單元測試等。反射技術爲這些領域提供了靈活性和可擴展性，使得開發人員能夠在運行時動態地獲取和操作類的信息，以實現更加靈活和可定製的功能。同時，許多流行的開源框架和庫，如 Spring、Hibernate、JUnit 等，也廣泛使用了反射技術。

反射技術可能繼續發展和演進。隨着 Java 平臺的不斷髮展和語言特性的增強，反射技術可能會在性能優化，安全性，模塊化等方面進一步完善和改進反射的應用。然而，需要注意的是，反射技術應該謹慎使用。由於反射涉及動態生成代碼、繞過訪問限制等操作，如果使用不當，可能導致代碼的可讀性和性能下降，甚至引入安全漏洞。因此，開發人員在使用反射時應該充分理解其工作原理和潛在的風險，並且遵循最佳實踐。

Java 世界的法外狂徒：反射

概述

爲什麼需要反射？

一段示例代碼

使用場景

Class 對象

類型檢查

`instanceof` 關鍵字

`isInstance()` 函數

代理

代理模式

動態代理

違反訪問權限

總結

加密的藝術：密文的創建和校驗

憑證管理揭祕：Cookie-Session 與 JWT 方案的對決

4A 安全之授權：編程的門禁，你能解開嗎？

身份認證的盡頭竟然是無密碼？

被別嚇到了，很多複雜事情的背後其實是簡單

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結

Java 世界的法外狂徒：反射

概述

爲什麼需要反射 ？

一段示例代碼

使用場景

Class 對象

類型檢查

instanceof 關鍵字

isInstance() 函數

代理

代理模式

動態代理

違反訪問權限

總結

爲什麼需要反射？

`instanceof` 關鍵字

`isInstance()` 函數