深入理解反射

1. Class對象

【1】要想理解反射的原理,首先要了解什麼是類型信息。Java讓我們在運行時識別對象和類的信息,主要有2種方式:一種是傳統的RTTI,它假定我們在編譯時已經知道了所有的類型信息;另一種是反射機制,它允許我們在運行時發現和使用類的信息。

  1. 基本解釋

【0】RTTI,即Run-Time Type Identification,運行時類型識別。RTTI能在運行時就能夠自動識別每個編譯時已知的類型。

【1】理解RTTI在Java中的工作原理,首先需要知道類型信息在運行時是如何表示的,這是由Class對象來完成的,它包含了與類有關的信息。Class對象就是用來創建所有“常規”對象的,Java使用Class對象來執行RTTI,即使你正在執行的是類似類型轉換這樣的操作。

【2】每個類都會產生一個對應的Class對象,也就是保存在.class文件中。所有類都是在對其第一次使用時,動態加載到JVM的,當程序創建一個對類的靜態成員的引用時,就會加載這個類。Class對象僅在需要的時候纔會加載,static初始化是在類加載時進行的。

2、補充解釋:
【1】很多時候需要進行向上轉型,比如Base類派生出Derived類,但是現有的方法只需要將Base對象作爲參數,實際傳入的則是其派生類的引用。那麼RTTI就在此時起到了作用,比如通過RTTI能識別出Derive類是Base的派生類,這樣就能夠向上轉型爲Derived。類似的,在用接口作爲參數時,向上轉型更爲常用,RTTI此時能夠判斷是否可以進行向上轉型。

class Base { }
class Derived extends Base { }

public class Main {
    public static void main(String[] args) {
        Base base = new Derived();
        if (base instanceof Derived) {
            // 這裏可以向下轉換了
            System.out.println("ok");
        }
        else {
            System.out.println("not ok");
        }
    }
}

【2】而這些類型信息是通過Class對象(java.lang.Class)的特殊對象完成的,它包含跟類相關的信息。每當編寫並編譯一個類時就會產生一個.class文件,保存着Class對象,運行這個程序的Java虛擬機(JVM)將使用被稱爲類加載器(Class Loader)的子系統。而類加載器並非在程序運行之前就加載所有的Class對象,如果尚未加載,默認的類加載器就會根據類名查找.class文件(例如,某個附加類加載器可能會在數據庫中查找字節碼),在這個類的字節碼被加載時接受驗證,以確保沒有被破壞並且不包含不良Java代碼。這也是Java中的類型安全機制之一。一旦某個類的Class對象被載入內存,就可以創建該類的所有對象。

public class TestMain {
   public static void main(String[] args) {
       System.out.println(XYZ.name);
   }
}

class XYZ {
   public static String name = "luoxn28";

   static {
       System.out.println("xyz靜態塊");
   }

   public XYZ() {
       System.out.println("xyz構造了");
   }
}
輸出結果爲:
xyz靜態塊
xyz構造了

3.反射機制的類型識別原理
【1】類加載器首先會檢查這個類的Class對象是否已被加載過,如果尚未加載,默認的類加載器就會根據類名查找對應的.class文件。

【2】想在運行時使用類型信息,反射機制也必須獲取對象(比如類Base對象)的Class對象的引用,經常使用的功能是Class.forName(“Base”)或者使用Base.class。
【3】注意,有一點很有趣,使用功能”.class”來創建Class對象的引用時,不會自動初始化該Class對象。使用forName()會自動初始化該Class對象。

public class Base {
    static int num = 1;
    
    static {
        System.out.println("Base " + num);
    }
}
public class Main {
    public static void main(String[] args) {
        // 不會初始化靜態塊
        Class clazz1 = Base.class;
        System.out.println("------");
        // 會初始化
        Class clazz2 = Class.forName("zzz.Base");
    }
}

常用的獲取Class對象方法

//第一種方式 通過對象getClass方法
Person person = new Person();
Class<?> class1 = person.getClass();
//第二種方式 通過類的class屬性
class1 = Person.class;
try {
    //第三種方式 通過Class類的靜態方法——forName()來實現
    class1 = Class.forName("com.whoislcj.reflectdemo.Person");
} catch (ClassNotFoundException e) {
    e.printStackTrace();
}

【4】爲了使用類而做的準備工作一般有以下3個步驟:

  • 加載:由類加載器完成,找到對應的字節碼,創建一個Class對象
  • 鏈接:驗證類中的字節碼,爲靜態域分配空間
  • 初始化:如果該類有超類,則對其初始化,執行靜態初始化器和靜態初始化塊

2、反射:運行時類信息

【1 】如果不知道某個對象的確切類型,RTTI可以告訴你,但是有一個前提:這個類型在編譯時必須已知,這樣才能使用RTTI來識別它。
Class類與java.lang.reflect類庫一起對反射進行了支持,這些類的對象由JVM在啓動時創建,用以表示未知類裏對應的成員。這些成員包含

  • java.lang.Class; //類
  • java.lang.reflect.Constructor;//構造方法
  • java.lang.reflect.Field; //類的成員變量
  • java.lang.reflect.Method;//類的方法
  • java.lang.reflect.Modifier;//訪問權限

【2 】這樣的話就可以使用Contructor創建新的對象,用get()和set()方法獲取和修改類中與Field對象關聯的字段,用invoke()方法調用與Method對象關聯的方法。另外,還可以調用getFields()、getMethods()和getConstructors()等許多便利的方法,以返回表示字段、方法、以及構造器對象的數組,這樣,對象信息可以在運行時被完全確定下來,而在編譯時不需要知道關於類的任何事情。

【3】反射機制並沒有什麼神奇之處,當通過反射與一個未知類型的對象打交道時,JVM只是簡單地檢查這個對象,看它屬於哪個特定的類。因此,那個類的.class對於JVM來說必須是可獲取的,要麼在本地機器上,要麼從網絡獲取【如RPC】。所以對於RTTI和反射之間的真正區別只在於:

  • RTTI:編譯器在編譯時打開和檢查.class文件
  • 反射:運行時打開和檢查.class文件
public class Person implements Serializable {

    private String name;
    private int age;
// get/set方法
}
public static void main(String[] args) {
    Person person = new Person("luoxn28", 23);
    Class clazz = person.getClass();

    Field[] fields = clazz.getDeclaredFields();
    for (Field field : fields) {
        String key = field.getName();
        PropertyDescriptor descriptor = new PropertyDescriptor(key, clazz);
        Method method = descriptor.getReadMethod();
        Object value = method.invoke(person);

        System.out.println(key + ":" + value);

    }
}

以上通過getReadMethod()方法調用類的get函數,可以通過getWriteMethod()方法來調用類的set方法。通常來說,我們不需要使用反射工具,但是它們在創建動態代碼會更有用,反射在Java中用來支持其他特性的,例如對象的序列化和JavaBean等。

3、反射應用的常用場景

【1 】反射機制的應用場景:

  • 逆向代碼 ,例如反編譯
  • 編寫自定義註解
  • 單純的反射機制應用框架 例如EventBus 2.x
  • 動態代理

【2 】反射機制的優缺點:
優點:
運行期類型的判斷,動態類加載,動態代理使用反射。

缺點:
性能是一個問題,反射相當於一系列解釋操作,通知jvm要做的事情,性能比直接的java代碼要慢很多。

【3 】總結:
Java的反射機制在平時的業務開發過程中很少使用到,但是在一些基礎框架的搭建上應用非常廣泛,今天簡單的總結學習了一下,還有很多未知的知識等以後用到再做補充。

4、動態代理

代理模式是爲了提供額外或不同的操作,而插入的用來替代”實際”對象的對象,這些操作涉及到與”實際”對象的通信,因此代理通常充當中間人角色。Java的動態代理比代理的思想更前進了一步,它可以動態地創建並代理並動態地處理對所代理方法的調用。在動態代理上所做的所有調用都會被重定向到單一的調用處理器上,它的工作是揭示調用的類型並確定相應的策略。以下是一個動態代理示例:

public interface Interface {
    void doSomething();
    void somethingElse(String arg);
}
public class RealObject implements Interface {
    public void doSomething() {
        System.out.println("doSomething.");
    }
    public void somethingElse(String arg) {
        System.out.println("somethingElse " + arg);
    }
}
public class DynamicProxyHandler implements InvocationHandler {
    private Object proxyed;
    
    public DynamicProxyHandler(Object proxyed) {
        this.proxyed = proxyed;
    }
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
        System.out.println("代理工作了.");
        return method.invoke(proxyed, args);
    }
}
public class Main {
    public static void main(String[] args) {
        RealObject real = new RealObject();
        Interface proxy = (Interface) Proxy.newProxyInstance(
                Interface.class.getClassLoader(), new Class[] {Interface.class},
                new DynamicProxyHandler(real));
        
        proxy.doSomething();
        proxy.somethingElse("luoxn28");
    }
}

輸出結果如下:

代理工作了.
doSomething.
代理工作了.
somethingElse luoxn28

通過調用Proxy靜態方法Proxy.newProxyInstance()可以創建動態代理,這個方法需要得到一個類加載器,一個你希望該代理實現的接口列表(不是類或抽象類),以及InvocationHandler的一個實現類。動態代理可以將所有調用重定向到調用處理器,因此通常會調用處理器的構造器傳遞一個”實際”對象的引用,從而將調用處理器在執行中介任務時,將請求轉發。

參考:

1、《Java編程思想-第4版》類型信息章節

發表評論
所有評論
還沒有人評論,想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章