反射

反射

什麼是反射？

Java反射就是在運行狀態中，對於任意一個類，都能夠知道這個類的所有屬性和方法；對於任意一個對象，都能夠調用它的任意方法和屬性；並且能改變它的屬性。而這也是Java被視爲動態（或準動態，爲啥要說是準動態，因爲一般而言的動態語言定義是程序運行時，允許改變程序結構或變量類型，這種語言稱爲動態語言。從這個觀點看，Perl，Python，Ruby是動態語言，C++，Java，C#不是動態語言。）語言的一個關鍵性質。

反射的功能：

我們知道反射機制允許程序在運行時取得任何一個已知名稱的class的內部信息，包括包括其modifiers(修飾符)，fields(屬性)，methods(方法)等，並可於運行時改變fields內容或調用methods。那麼我們便可以更靈活的編寫代碼，代碼可以在運行時裝配，無需在組件之間進行源代碼鏈接，降低代碼的耦合度；還有動態代理的實現等等；但是需要注意的是反射使用不當會造成很高的資源消耗！

舉例：

public class Person {
    //私有屬性
    private String name = "Tom";
    //公有屬性
    public int age = 18;
    //構造方法
    public Person() {
    }
    //私有方法
    private void say(){
        System.out.println("private say()...");
    }
    //公有方法
    public void work(){
        System.out.println("public work()...");
    }
}

得到 Class 的三種方式

//1、通過對象調用 getClass() 方法來獲取,通常應用在：比如你傳過來一個 Object
//  類型的對象，而我不知道你具體是什麼類，用這種方法
Person p1 = new Person();
Class c1 = p1.getClass();

//2、直接通過 類名.class 的方式得到,該方法最爲安全可靠，程序性能更高
//  這說明任何一個類都有一個隱含的靜態成員變量 class
Class c2 = Person.class;

//3、通過 Class 對象的 forName() 靜態方法來獲取，用的最多，
//   但可能拋出 ClassNotFoundException 異常
Class c3 = Class.forName("com.ys.reflex.Person");

需要注意的是：一個類在 JVM 中只會有一個 Class 實例,即我們對上面獲取的 c1,c2,c3進行 equals 比較，發現都是true

通過 Class 類獲取成員變量、成員方法、接口、超類、構造方法等

//獲得類完整的名字
String className = c2.getName();
System.out.println(className);//輸出com.ys.reflex.Person

//獲得類的public類型的屬性。
Field[] fields = c2.getFields();
for(Field field : fields){
    System.out.println(field.getName());//age
}

//獲得類的所有屬性。包括私有的
Field [] allFields = c2.getDeclaredFields();
for(Field field : allFields){
    System.out.println(field.getName());//name    age
}

//獲得類的public類型的方法。這裏包括 Object 類的一些方法
Method [] methods = c2.getMethods();
for(Method method : methods){
    System.out.println(method.getName());
    //work waid equls toString hashCode等
}

//獲得類的所有方法。
Method [] allMethods = c2.getDeclaredMethods();
for(Method method : allMethods){
    System.out.println(method.getName());//work say
}

//獲得指定的屬性
Field f1 = c2.getField("age");
System.out.println(f1);
//獲得指定的私有屬性
Field f2 = c2.getDeclaredField("name");
//啓用和禁用訪問安全檢查的開關，值爲 true，則表示反射的對象在使用時應該取消 java 語言的訪問檢查；反之不取消
f2.setAccessible(true);
System.out.println(f2);

//創建這個類的一個對象
Object p2 =  c2.newInstance();
//將 p2 對象的  f2 屬性賦值爲 Bob，f2 屬性即爲 私有屬性 name
f2.set(p2,"Bob");
//使用反射機制可以打破封裝性，導致了java對象的屬性不安全。 
System.out.println(f2.get(p2)); //Bob

//獲取構造方法
Constructor [] constructors = c2.getConstructors();
for(Constructor constructor : constructors){
    System.out.println(constructor.toString());
    //public com.ys.reflex.Person()
}

父類

public class Parent {
    public String publicField = "parent_publicField";
    protected String protectField = "parent_protectField";
    String defaultField = "parent_defaultField";
    private String privateField = "parent_privateField";

}

子類

public class Son extends Parent {
}

測試

public class ReflectionTest {
    @Test
    public void testGetParentField() throws Exception{
        Class c1 = Class.forName("com.ys.model.Son");
        //獲取父類私有屬性值
        System.out.println(getFieldValue(c1.newInstance(),"privateField"));
    }

    public static Field getDeclaredField(Object obj,String fieldName) {
        Field field = null;
        Class c = obj.getClass();
        for(; c != Object.class ; c = c.getSuperclass()){
            try {
                field = c.getDeclaredField(fieldName);
                field.setAccessible(true);
                return field;
            }catch (Exception e){
                //這裏甚麼都不要做！並且這裏的異常必須這樣寫，不能拋出去。
                //如果這裏的異常打印或者往外拋，則就不會執行c = c.getSuperclass(),最後就不會進入到父類中了
            }
        }
        return null;
    }
    public static Object getFieldValue(Object object,String fieldName) throws Exception{
        Field field = getDeclaredField(object,fieldName);

        return field.get(object);
    }
}

通過執行上述代碼，我們獲得了父類的私有屬性值，這裏要注意的是直接通過反射獲取子類的對象是不能得到父類的屬性值的，必須根據反射獲得的子類 Class 對象在調用 getSuperclass() 方法獲取父類對象，然後在通過父類對象去獲取父類的屬性值。

總結

靈活使用反射能讓我們代碼更加靈活，這裏比如JDBC原生代碼註冊驅動，Spring 的 AOP等等都有反射的實現。但是凡事都有兩面性，反射也會消耗系統的性能，增加複雜性等，合理使用纔是真！

---

青春短暫，我在路上