反射

使用反射獲取程式執行時的物件和類的真實資訊。

獲取 Class 物件

每個類被載入之後，系統會為該類生成一個對應的 Class 物件，通過該 Class 物件可以訪問到 JVM 中的這個類。

• 使用 Class 類的 forName(String clazzName) 靜態方法。字串引數的值是某個類的全限定類名，必須包含完整的包名

• 呼叫某個類的 class 屬性

• 呼叫某個物件的 getClass() 方法。該方法是 java.lang.Object 類中的一個方法，所有的 Java 物件都可以呼叫，返回該物件所屬類對應的 Class 物件

獲取 Class 物件中資訊

Class 類提供了大量的例項方法來獲取該 class 物件所對應的類的詳細資訊。更多請參考 API。

import java.lang.reflect.*;
import java.lang.annotation.*;

public class ClassTest {
    private ClassTest() {
    }

    public ClassTest(String name) {
        System.out.println("執行有引數的構造器");
    }

    public void info() {
        System.out.println("執行無引數的info方法");
    }

    public void info(String str) {
        System.out.println("執行有引數的info方法" + ",其 str 引數值: " + str);
    }

    class Inner {
    }

    public static void main(String[] args) throws Exception {
        Class<ClassTest> clazz = ClassTest.class;
      
        // 獲取 clazz 物件所對應類的全部構造器
        Constructor<?>[] ctros = clazz.getDeclaredConstructors();
        System.out.println("ClassTest 的全部構造器如下: ");
        for (Constructor c : ctros) {
            System.out.println(c);
        }
      
        // 獲取 clazz 物件所對應類的全部 public 構造器
        Constructor<?>[] publicCtors = clazz.getConstructors();
        System.out.println("ClassTest的全部public構造器如下：");
        for (Constructor c : publicCtors) {
            System.out.println(c);
        }
      
        // 獲取 clazz 物件所對應類的全部 public 方法
        Method[] mtds = clazz.getMethods();
        System.out.println("ClassTest 的全部 public 方法如下： ");
        for (Method md : mtds) {
            System.out.println(md);
        }
      
        // 獲取 clazz 物件所對應類的指定方法
        System.out.println("ClassTest 裡帶一個字串引數的 info 方法為:" + clazz.getMethod("info", String.class));
      
        // 獲取 clazz 物件所對應類的全部註解
        Annotation[] anns = clazz.getAnnotations();
        System.out.println("ClassTest 的全部 Annotation 如下： ");
        for (Annotation an : anns) {
            System.out.println(an);
        }
      
        // 獲取 clazz 物件所對應類的全部內部類
        Class<?>[] inners = clazz.getDeclaredClasses();
        System.out.println("ClassTest 的全部內部類如下： ");
        for (Class c : inners) {
            System.out.println(c);
        }
      
        // 使用 Class.forName() 方法載入 ClassTest 的 Inner 內部類
        Class inClazz = Class.forName("ClassTest$Inner");
      
        // 訪問該類所在的外部類
        System.out.println("inClazz 對應類的外部類為: " + inClazz.getDeclaringClass());

        System.out.println("ClassTest 的包為：" + clazz.getPackage());
        System.out.println("ClassTest 的父類為：" + clazz.getSuperclass());

    }
}
 

應用

Class 物件可以獲得對應類的方法（由 Method 表示）、構造器（由 Constructor 表示）、成員變數（由 Field 物件表示），且這個三個類都實現了 java.lang.reflect.Member 介面。程式可以通過 Method 物件來執行對應的方法，通過 Constructor 物件來呼叫對應的構造器建立例項，通過 Field 物件直接訪問並修改物件的成員變數值。

建立物件

• 使用 Class 物件的 newInstance() 方法來建立 Class 物件對應類的例項。要求該 Class 物件的對應類有預設構造器

• 先使用 Class 物件獲取指定的 Constructor 物件，再呼叫 Constructor 物件的 newInstance() 方法來建立該 Class 物件對應類的例項。這種方式可以選擇使用指定的構造器來建立例項

方式一

實現了一個簡單的物件池，該物件池會根據配置檔案讀取 key-value 對，然後建立這些物件並放入 HashMap 中

import java.io.FileInputStream;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;

public class ObjectPoolFactory {
    private Map<String, Object> objectPool = new HashMap<>();

    private Object createObject(String clazzName) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
        Class<?> clazz = Class.forName(clazzName);
        // 使用 Class 物件對應的類的預設構造器
        return clazz.newInstance();
    }

    public void initPool(String fileName) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
        try (
                FileInputStream fis = new FileInputStream(fileName)
        ) {
            Properties props = new Properties();
            props.load(fis);
            for ( String name: props.stringPropertyNames()) {
                objectPool.put(name, createObject(props.getProperty(name)));
            }
        } catch (IOException ex) {
            System.out.println("讀取" + fileName + "異常");
        }
    }

    public Object getObject(String name) {
        return objectPool.get(name);
    }

    public static void main(String[] args) throws Exception{
        ObjectPoolFactory pf = new ObjectPoolFactory();
        pf.initPool("obj.txt");
        System.out.println(pf.getObject("a"));
        System.out.println(pf.getObject("b"));
    }
}
/*
obj.txt 內容：

a=java.util.Date
b=javax.swing.JFrame
*/

方式二

import java.lang.reflect.Constructor;

public class CreateJFrame {
    public static void main(String[] args) throws Exception {
        Class<?> jframeClazz = Class.forName("javax.swing.JFrame");
        // 選擇使用指定的構造器
        Constructor ctor = jframeClazz.getConstructor(String.class);
        Object obj = ctor.newInstance("測試視窗");
        System.out.println(obj);
    }
}

呼叫方法

每個 Method 物件對應一個方法，獲得 Method 物件後，就可以通過該 Method 來呼叫它對應的方法。

Method 包含一個 invoke() 方法，該方法的簽名如下：

• Object invoke(Object obj, Object... args)：該方法中的 obj 是執行方法的主調（即類的例項物件），後面的 args 是執行該方法的實參

下面是對之前的物件工廠池進行增強，允許在配置檔案中增加配置物件的成員變數值，物件池工廠會讀取該物件配置的成員變數值，並利用該物件對應的 setter 方法設定成員變數的值：

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

public class ExtendedObjectPoolFactory {
    // 定義一個物件池，前面是物件名，後面是實際的物件
    private Map<String, Object> objectPool = new HashMap<>();
    private Properties config = new Properties();
    // 從指定檔案中初始化 Properties 物件
    public void init(String fileName) {
        try (
                FileInputStream fis = new FileInputStream(fileName);
        ) {
            config.load(fis);
        } catch (IOException ex) {
            System.out.println("讀取" + fileName + "異常");
        }
    }
    // 定義建立物件的方法
    private Object createObject(String clazzName) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
        // 根據字串來獲取對應的 Class 物件
        Class<?> clazz = Class.forName(clazzName);
        // 使用 clazz 對應類的預設構造器建立例項
        return clazz.newInstance();
    }

    // 初始化物件池
    public void initPool() throws InstantiationException, IllegalAccessException, ClassNotFoundException {
        for (String name : config.stringPropertyNames()) {
            if (!name.contains("%")) {
                objectPool.put(name, createObject(config.getProperty(name)));
            }
        }
    }

    // 根據屬性檔案來呼叫指定物件的 setter 方法
    public void initProperty() throws InvocationTargetException, IllegalAccessException, NoSuchMethodException {
        for (String name : config.stringPropertyNames()) {
            if (name.contains("%")) {
                String[] objAndProp = name.split("%");
                Object target = getObject(objAndProp[0]);
                String mtdName = "set" + objAndProp[1].substring(1);
                // 通過 target 的 getClass() 獲取它的實現類所對應的 Class 物件
                Class<?> targetClass = target.getClass();
                // 獲取希望呼叫的 setter 方法
                Method mtd = targetClass.getMethod(mtdName, String.class);
                // 通過 Method 的 invoke 方法執行 setter 方法
                mtd.invoke(target, config.getProperty(name));
            }
        }
    }

    public Object getObject(String name) {
        // 從 objectPool 中取出指定 name 對應的物件
        return objectPool.get(name);
    }

    public static void main(String[] args) throws Exception {
        ExtendedObjectPoolFactory epf = new ExtendedObjectPoolFactory();
        epf.init("extObj.txt");
        epf.initPool();
        epf.initProperty();
        System.out.println(epf.getObject("a"));
    }
}

/* extObj.txt 內容

a=java.util.Date
b=javax.swing.JFrame
# set the title of a
a%title=Test Title
*/

PS：當通過 Method 的 invoke() 方法來呼叫對應的方法時，Java 會要求程式必須有呼叫該方法的許可權。如果需要呼叫某個物件的 private 方法，則可以先呼叫 Method 物件的如下方法：

• setAccessible(boolean flag)：值為 true，表示該 Method 在使用時取消訪問許可權檢查

訪問成員變數值

Filed 提供如下兩組方法來讀取或設定成員變數值：

• getXxx(Object obj)：獲取 obj 物件的該成員變數的值。此處的 Xxx 對應 8 中基本型別。如果成員變數的型別是引用型別，則直接使用 get

• setXxx(Object obj, Xxx val)：將 obj 物件的成員變數值設為 val 值。此處的 Xxx 對應 8 中基本型別。如果成員變數的型別是引用型別，則直接使用 set

public class Person {
    private String name;
    private int age;

    public String toString() {
        return "Person[name:" + name + ", age:" + age + "]";
    }
}

import java.lang.reflect.Field;

public class FieldTest {
    public static void main(String[] args) throws Exception {
        Person p = new Person();
        Class<Person> personClazz = Person.class;
        Field nameField = personClazz.getDeclaredField("name");
        nameField.setAccessible(true);
        nameField.set(p, "crazy");
        Field ageField = personClazz.getDeclaredField("age");
        ageField.setAccessible(true);
        ageField.setInt(p, 30);
        System.out.println(p);
    }
}

泛型在反射中的應用

在反射中使用泛型，反射生成的物件就不需要進行強制型別轉換。

import java.util.Date;

public class CrazyitObjectFactory {
    public static <T> T getinstance(Class<T> cls) {
        try {
            return cls.newInstance();
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    public static void main(String[] args) {
        // 獲取例項後無需進行型別轉換
        Date d = CrazyitObjectFactory.getinstance(Date.class);
    }
}

歡迎關注我的公眾號

相關推薦