你知道Java中的反射機制嗎？

一.概念

反射就是把Java的各類成分映射成相應的Java類。

Class類的構造方法是private，由JVM建立。

反射是java語言的一個特性，它允程序在運行時（注意不是編譯的時候）來進行自我檢查而且對內部的成員進行操做。例如它容許一個java的類獲取他全部的成員變量和方法而且顯示出來。Java 的這一能力在實際應用中也許用得不是不少，可是在其它的程序設計語言中根本就不存在這一特性。例如，Pascal、C 或者 C++ 中就沒有辦法在程序中得到函數定義相關的信息。（來自Sun）

JavaBean 是 reflection 的實際應用之一，它能讓一些工具可視化的操做軟件組件。這些工具經過 reflection 動態的載入並取得 Java 組件(類) 的屬性。

反射是從1.2就有的，後面的三大框架都會用到反射機制,涉及到類"Class",沒法直接new CLass()，其對象是內存裏的一份字節碼. 

Class 類的實例表示正在運行的 Java 應用程序中的類和接口。枚舉是一種類，註釋是一種接口。每一個數組屬於被映射爲 Class 對象的一個類，全部具備相同元素類型和維數的數組都共享該 Class 對象。

基本的 Java類型（boolean、byte、char、short、int、long、float 和 double）和關鍵字 void 也表示爲 Class 對象。Class 沒有公共構造方法。Class 對象是在加載類時由 Java 虛擬機以及經過調用類加載器中的 defineClass 方法自動構造的。

Person p1 = new Person();
//下面的這三種方式均可以獲得字節碼
CLass c1 = Date.class();
p1.getClass(); 
//若存在則加載，不然新建,每每使用第三種,類的名字在寫源程序時不須要知道，到運行時再傳遞過來
Class.forName("java.lang.String");
複製代碼

CLass.forName()字節碼已經加載到java虛擬機中，去獲得字節碼；java虛擬機中尚未生成字節碼 用類加載器進行加載，加載的字節碼緩衝到虛擬機中。

考慮下面這個簡單的例子，讓咱們看看 reflection 是如何工做的。import java.lang.reflect.*;

public class DumpMethods {  
   public static void main(String args[]) {  
      try {  
           Class c = Class.forName("java.util.Stack");  

           Method m[] = c.getDeclaredMethods();  

           for (int i = 0; i < m.length; i++)  
               System.out.println(m[i].toString());  
      }  
      catch (Throwable e){  
            System.err.println(e);  
      }  
   }  
}
複製代碼

public synchronized java.lang.Object java.util.Stack.pop() 
public java.lang.Object java.util.Stack.push(java.lang.Object) 
public boolean java.util.Stack.empty() 
public synchronized java.lang.Object java.util.Stack.peek() 
public synchronized int java.util.Stack.search(java.lang.Object)
複製代碼

這樣就列出了java.util.Stack 類的各方法名以及它們的限制符和返回類型。這個程序使用 Class.forName 載入指定的類，而後調用 getDeclaredMethods 來獲取這個類中定義了的方法列表。java.lang.reflect.Methods 是用來描述某個類中單個方法的一個類。 如下示例使用 Class 對象來顯示對象的類名：

void printClassName(Object obj) {
       System.out.println("The class of " + obj +
                     " is " + obj.getClass().getName());
}
複製代碼

還可使用一個類字面值（JLS Section 15.8.2）來獲取指定類型（或 void）的 Class 對象。例如：

System.out.println("The name of class Foo is: "+Foo.class.getName());
複製代碼

在沒有對象實例的時候，主要有兩種辦法。

//得到類類型的兩種方式 。
Class cls1 = Role.class;        
Class cls2 = Class.forName("yui.Role");
複製代碼

注意第二種方式中，forName中的參數必定是完整的類名（包名+類名），而且這個方法須要捕獲異常。如今獲得cls1就能夠建立一個Role類的實例了，利用Class的newInstance方法至關於調用類的默認的構造器。

Object o = cls1.newInstance(); 
//建立一個實例        
//Object o1 = new Role();   //與上面的方法等價
複製代碼

二.經常使用方法 

1.isPrimitive(判斷是不是基本類型的字節碼)

public class TestReflect {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String str = "abc";
        Class cls1 = str.getClass();
        Class cls2 = String.class;
        Class cls3 = null;//必需要加上null
        try {
            cls3 = Class.forName("java.lang.String");
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println(cls1==cls2);
        System.out.println(cls1==cls3);

        System.out.println(cls1.isPrimitive());
        System.out.println(int.class.isPrimitive());//斷定指定的 Class 對象是否表示一個基本類型。
        System.out.println(int.class == Integer.class);
        System.out.println(int.class == Integer.TYPE);
        System.out.println(int[].class.isPrimitive());
        System.out.println(int[].class.isArray());
    }
}
/*
 * true
true
false
true
false
true
false
true

 */
*/
複製代碼

2.getConstructor和getConstructors()

java中構造方法沒有前後順序，經過類型和參數個數區分。

public class TestReflect {
    public static void main(String[] args) throws SecurityException, NoSuchMethodException {
        // TODO Auto-generated method stub
        String str = "abc";

        System.out.println(String.class.getConstructor(StringBuffer.class));
    }
}
複製代碼

3.Filed類表明某一類中的一個成員變量。

import java.lang.reflect.Field;
public class TestReflect {
    public static void main(String[] args) throws SecurityException, NoSuchMethodException, NoSuchFieldException, IllegalArgumentException, Exception {
        ReflectPointer rp1 = new ReflectPointer(3,4);
        Field fieldx = rp1.getClass().getField("x");//必須是x或者y
        System.out.println(fieldx.get(rp1));

        /*
         * private的成員變量必須使用getDeclaredField，並setAccessible(true),不然看獲得拿不到
         */
        Field fieldy = rp1.getClass().getDeclaredField("y");
        fieldy.setAccessible(true);//暴力反射
        System.out.println(fieldy.get(rp1));

    }
}

class ReflectPointer {

    public int x = 0;
    private int y = 0;

    public ReflectPointer(int x,int y) {//alt + shift +s至關於右鍵source
        super();
        // TODO Auto-generated constructor stub
        this.x = x;
        this.y = y;
    }
}
複製代碼

三.典型例題

1.將全部String類型的成員變量裏的b改爲a。

import java.lang.reflect.Field;
public class TestReflect {
    public static void main(String[] args) throws SecurityException, NoSuchMethodException, NoSuchFieldException, IllegalArgumentException, Exception {
        ReflectPointer rp1 = new ReflectPointer(3,4);
        changeBtoA(rp1);
        System.out.println(rp1);

    }

    private static void changeBtoA(Object obj) throws RuntimeException, Exception {
        Field[] fields = obj.getClass().getFields();

        for(Field field : fields) {
            //if(field.getType().equals(String.class))
            //因爲字節碼只有一份,用equals語義不許確
            if(field.getType()==String.class) {
                String oldValue = (String)field.get(obj);
                String newValue = oldValue.replace('b', 'a');
                field.set(obj,newValue);
            }
        }
    }
}

class ReflectPointer {

    private int x = 0;
    public int y = 0;
    public String str1 = "ball";
    public String str2 = "basketball";
    public String str3 = "itcat";

    public ReflectPointer(int x,int y) {//alt + shift +s至關於右鍵source
        super();
        // TODO Auto-generated constructor stub
        this.x = x;
        this.y = y;
    }

    @Override
    public String toString() {
        return "ReflectPointer [str1=" + str1 + ", str2=" + str2 + ", str3="
                + str3 + "]";
    }
}
複製代碼

2.寫一個程序根據用戶提供的類名，調用該類的裏的main方法。

爲何要用反射的方式呢？

import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class TestReflect {
    public static void main(String[] args) throws SecurityException, NoSuchMethodException, NoSuchFieldException, IllegalArgumentException, Exception {
        String str = args[0];
        /*
         * 這樣會數組角標越界，由於壓根沒有這個字符數組
         * 須要右鍵在run as-configurations-arguments裏輸入b.Inter（完整類名）
         * 
         */
        Method m = Class.forName(str).getMethod("main",String[].class);
        //下面這兩種方式均可以,main方法須要一個參數

        m.invoke(null, new Object[]{new String[]{"111","222","333"}});
        m.invoke(null, (Object)new String[]{"111","222","333"});//這個能夠說明，數組也是Object
        /*
         * m.invoke(null, new String[]{"111","222","333"})
         * 上面的不能夠,由於java會自動拆包
         */
    }
}

class Inter {
    public static void main(String[] args) {
        for(Object obj : args) {
            System.out.println(obj);
        }
    }
}
複製代碼

3.模擬 instanceof 操做符

class S {  
}   

public class IsInstance {  
   public static void main(String args[]) {  
      try {  
           Class cls = Class.forName("S");  
           boolean b1 = cls.isInstance(new Integer(37));  
           System.out.println(b1);  
           boolean b2 = cls.isInstance(new S());  
           System.out.println(b2);  
      }  
      catch (Throwable e) {  
           System.err.println(e);  
      }  
   }  
}
複製代碼

在這個例子中建立了一個S 類的 Class 對象，而後檢查一些對象是不是S的實例。Integer(37) 不是，但 new S()是。

四.Method類

表明類（不是對象）中的某一方法。

import java.lang.reflect.Field;
import java.lang.reflect.Method;
/*
 * 人在黑板上畫圓，涉及三個對象,畫圓須要圓心和半徑，可是是私有的，畫圓的方法
 * 分配給人不合適。
 * 
 * 司機踩剎車，司機只是給列車發出指令，剎車的動做還須要列車去完成。
 * 
 * 面試常常考面向對象的設計，好比人關門，人只是去推門。
 * 
 * 這就是專家模式：誰擁有數據，誰就是專家,方法就分配給誰
 */
public class TestReflect {
    public static void main(String[] args) throws SecurityException, NoSuchMethodException, NoSuchFieldException, IllegalArgumentException, Exception {
        String str = "shfsfs";
        //包開頭是com表示是sun內部用的，java打頭的纔是用戶的
        Method mtCharAt = String.class.getMethod("charAt", int.class);
        Object ch = mtCharAt.invoke(str,1);//若第一個參數是null，則確定是靜態方法
        System.out.println(ch);

        System.out.println(mtCharAt.invoke(str, new Object[]{2}));//1.4語法

    }

}
複製代碼

五.數組的反射

Array工具類用於完成數組的反射操做。

同類型同緯度有相同的字節碼。

int.class和Integer.class不是同一份字節碼，Integer.TYPE，TYPE表明包裝類對應的基本類的字節碼 int.class==Integer.TYPE。

import java.util.Arrays;

/*
 * 從這個例子看出即使字節碼相同可是對象也不必定相同,根本不是一回事
 * 
 */
public class TestReflect {
    public static void main(String[] args) throws SecurityException, NoSuchMethodException, NoSuchFieldException, IllegalArgumentException, Exception {
        int[] a = new int[3];
        int[] b = new int[]{4,5,5};//直接賦值後不能夠指定長度，不然ＣＥ
        int[][] c = new int[3][2];
        String[] d = new String[]{"jjj","kkkk"};
        System.out.println(a==b);//false
        System.out.println(a.getClass()==b.getClass());//true
        //System.out.println(a.getClass()==d.getClass());    //比較字節碼a和cd也無法比
        System.out.println(a.getClass());//輸出class [I
        System.out.println(a.getClass().getName());//輸出[I,中括號表示數組，I表示整數

        System.out.println(a.getClass().getSuperclass());//輸出class java.lang.Object
        System.out.println(d.getClass().getSuperclass());//輸出class java.lang.Object

        //因爲父類都是Object,下面都是能夠的
        Object obj1 = a;//不但是Object[]
        Object obj2 = b;
        Object[] obj3 = c;//基本類型的一位數組只能夠當作Object，非得還能夠當作Object[]
        Object obj4 = d;

        //注意asList處理int[]和String[]的區別
        System.out.println(Arrays.asList(b));//1.4沒有可變參數，使用的是數組,[[I@1bc4459]
        System.out.println(Arrays.asList(d));//[jjj, kkkk]

    }
}
複製代碼

六.結束語

以上就是反射機制的簡單的使用，顯然學過spring的朋友必定明白了，爲何能夠經過配置文件就可讓咱們得到指定的方法和變量，在咱們建立對象的時候都是經過傳進string實現的，就好像你須要什麼，咱們去爲你生產，還有咱們一直在用Object,這就說明java語言的動態特性，依賴性大大的下降了。