JAVA反射
JavaWeb（servlet、filter、listener）是框架的基礎；反射是框架設計的靈魂。
（使用反射的前提條件：必須先得到代表的字節碼的Class，Class類用於表示.class文件（字節碼））
一、反射的概述
JAVA反射機制是在運行狀態中，對於任意一個類，都能夠知道這個類的所有屬性和方法；對於任意一個對象，都能夠調用它的任意一個方法和屬性；這種動態獲取的信息以及動態調用對象的方法的功能稱爲java語言的反射機制。
要想解剖一個類,必須先要獲取到該類的字節碼文件對象。而解剖使用的就是Class類中的方法.所以先要獲取到每一個字節碼文件對應的Class類型的對象。
以上的總結就是什麼是反射
反射就是把java類中的各種成分映射成一個個的Java對象
例如：一個類有：成員變量、方法、構造方法、包等等信息，利用反射技術可以對一個類進行解剖，把個個組成部分映射成一個個對象。
（其實：一個類中這些成員方法、構造方法、在加入類中都有一個類來描述）
如圖是類的正常加載過程：反射的原理在與class對象。
熟悉一下加載的時候：Class對象的由來是將class文件讀入內存，併爲之創建一個Class對象。
二、查看Class類在java中的api詳解（1.7的API）
如何閱讀java中的api詳見java基礎之——String字符串處理
Class 類的實例表示正在運行的 Java 應用程序中的類和接口。也就是jvm中有N多的實例每個類都有該Class對象。（包括基本數據類型）
Class 沒有公共構造方法。Class 對象是在加載類時由 Java 虛擬機以及通過調用類加載器中的defineClass方法自動構造的。也就是這不需要我們自己去處理創建，JVM已經幫我們創建好了。
沒有公共的構造方法，方法共有64個太多了。下面用到哪個就詳解哪個吧
三、反射的使用
反射的使用主要有以下幾個方面：
1、類加載器
1、獲取class對象的三種方式；
2、通過反射獲取構造方式、使用構造方法；
3、獲取成員變量並調用；
4、獲取成員方法並調用；
5、反射main方法；
6、反射方法的其它使用之---通過反射運行配置文件內容；
7、反射方法的其它使用之---通過反射越過泛型檢查。
1、獲取Class對象的三種方式:
Class類
對象照鏡子後可以得到的信息：某個類的數據成員名、方法和構造器、某個類到底實現了哪些接口。對於每個類而言，JRE 都爲其保留一個不變的 Class 類型的對象。一個 Class 對象包含了特定某個類的有關信息。
Class 對象只能由系統建立對象
一個類在 JVM 中只會有一個Class實例
每個類的實例都會記得自己是由哪個 Class 實例所生成
類加載指的是將類的class文件讀入內存，併爲之創建一個java.lang.Class對象，也就是說當程序使用任何一個類時，系統都會爲之生成一個java.lang.Class對象。
類的加載通常由類加載器完成，類加載器通常由JVM提供。
獲取Class對象的三種方法如下：
1) 調用對象的getClass()方法，該方法是java.lang.Object中的一個方法;
2) 通過類的class屬性來獲取該類對應的class對象，如Person.class將返回Person類對應的class對象
3) 使用Class類的forName靜態方法：forName（String className）
其中第一種是因爲Object類中的getClass方法、因爲所有類都繼承Object類。從而調用Object類來獲取
例子：
1、Student.java
package fanshe;
public class Student {
// ---------------構造方法-------------------
// （默認的構造方法）
Student(String str) {
System.out.println("默認的構造方法s=" + str);
}
// 無參構造方法
Student() {
System.out.println("調用了共有、無參構造方法執行了......");
}
// 有一個參數的構造方法
Student(char name) {
System.out.println("姓名：" + name);
}
// 有多個參數的構造方法
Student(String name, int age) {
System.out.println("姓名：" + name + "年齡：" + age);
}
// 受保護的構造方法
protected Student(boolean n) {
System.out.println("受保護的構造方法n=" + n);
}
// 私有構造方法
private Student(int age) {
System.out.println("私有的構造方法 年齡：" + age);
}
}2、Fanshe.java
package fanshe;
/*
* 獲取class對象
*/
public class Fanshe {
public static void main(String[] args) {
// 1.第一種方式：調用對象的getClass()方法獲得class對象
Student stu = new Student(); // new時，創建了一個student對象、一個class對象
Class stuClass1 = stu.getClass();// 獲得class對象
System.out.println(stuClass1.getName());
// 第二種方式：通過類的class屬性來獲得該類對應的class對象
Class stuClass2 = Student.class;
System.out.print("stuClass2 == stuClass1 ： ");
System.out.println(stuClass2 == stuClass1);// 判斷第一種方式獲取的Class對象和第二種方式獲取的是否是同一個
// 第三種方式：使用class類的forname靜態方法
try {
Class stuClass3 = Class.forName("fanshe.Student");// 注意此字符串必須是真實路徑，就是帶包名的類路徑，包名.類名
System.out.print("stuClass3 == stuClass2 ： ");
System.out.println(stuClass3 == stuClass2);// 判斷三種方式是否獲取的是同一個Class對象
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}上面代碼運行結果爲：
調用了公有、無參構造方法執行了。。。
fanshe.Student
stuClass2 == stuClass1 ： true
stuClass3 == stuClass2 ： true注意：在運行期間，一個類，只有一個Class對象產生。
三種方式常用第三種，第一種對象都有了還要反射幹什麼。第二種需要導入類的包，依賴太強，不導包就拋編譯錯誤。一般都第三種，一個字符串可以傳入也可寫在配置文件中等多種方法。
2、通過反射獲取構造方式、使用構造方法
調用方法：
1.獲取構造方法：
1) 批量的方法：
public Constructor[] getConstructors()：所有"公有的"構造方法
public Constructor[] getDeclaredConstructors()：獲取所有的構造方法(包括私有、受保護、默認、公有)
2) 獲取單個的方法，並調用：
public Constructor getConstructor(Class... parameterTypes):獲取單個的"公有的"構造方法：
public Constructor getDeclaredConstructor(Class... parameterTypes):獲取"某個構造方法"可以是私有的，或受保護、默認、公有；
調用構造方法： Constructor-->newInstance(Object... initargs)
2、newInstance是 Constructor類的方法（管理構造函數的類） api的解釋爲： newInstance(Object... initargs)
使用此 Constructor 對象表示的構造方法來創建該構造方法的聲明類的新實例，並用指定的初始化參數初始化該實例。它的返回值是T類型，所以newInstance是創建了一個構造方法的聲明類的新實例對象。併爲之調用
例子：
1)
package fanshe;
import java.lang.reflect.Constructor;
/*
* 通過Class對象可以獲取某個類中的：構造方法、成員變量、成員方法；並訪問成員；
*
* 1.獲取構造方法：
* 1).批量的方法：
* public Constructor[] getConstructors()：所有"公有的"構造方法
public Constructor[] getDeclaredConstructors()：獲取所有的構造方法(包括私有、受保護、默認、公有)
* 2).獲取單個的方法，並調用：
* public Constructor getConstructor(Class... parameterTypes):獲取單個的"公有的"構造方法：
* public Constructor getDeclaredConstructor(Class... parameterTypes):獲取"某個構造方法"可以是私有的，或受保護、默認、公有；
*
* 調用構造方法：
* Constructor-->newInstance(Object... initargs)
*/
public class Constructors {
public static void main(String[] args) throws Exception {
// 1.加載Class對象
Class clazz = Class.forName("fanshe.Student");
// 2.獲取所有公有構造方法
System.out.println("**********************所有公有構造方法*********************************");
Constructor[] conArray = clazz.getConstructors();
for (Constructor c : conArray) {
System.out.println(c);
}
System.out.println("************所有的構造方法(包括：私有、受保護、默認、公有)***************");
conArray = clazz.getDeclaredConstructors();
for (Constructor c : conArray) {
System.out.println(c);
}
System.out.println("*****************獲取公有、無參的構造方法*******************************");
Constructor con = clazz.getConstructor(null);
// 1>、因爲是無參的構造方法所以類型是一個null,不寫也可以：這裏需要的是一個參數的類型，切記是類型
// 2>、返回的是描述這個無參構造函數的類對象。
System.out.println("con = " + con);
// 調用構造方法
Object obj = con.newInstance();
// System.out.println("obj = " + obj);
// Student stu = (Student)obj;
System.out.println("******************獲取私有構造方法，並調用*******************************");
con = clazz.getDeclaredConstructor(char.class);
System.out.println(con);
// 調用構造方法
con.setAccessible(true);// 暴力訪問(忽略掉訪問修飾符)
obj = con.newInstance('男');
}
}2) Student.java 與之前的Student.java一樣
運行結果： **所有公有構造方法*** public fanshe.Student(java.lang.String,int) public fanshe.Student(char) public fanshe.Student() ****所有的構造方法(包括：私有、受保護、默認、公有)* private fanshe.Student(int) protected fanshe.Student(boolean) public fanshe.Student(java.lang.String,int) public fanshe.Student(char) public fanshe.Student() fanshe.Student(java.lang.String) *獲取公有、無參的構造方法*** con = public fanshe.Student() 調用了公有、無參構造方法執行了。。。 **獲取私有構造方法，並調用*** public fanshe.Student(char) 姓名：男
3、獲取成員變量並調用例子：
1) Student1.java
package fanshe;
public class Student1 {
public Student1() {
}
public String name;
protected int age;
char sex;
private String phoneNum;
@Override
public String toString() {
return "Student1 [name=" + name + ", age=" + age + ", sex=" + sex + ", phoneNum=" + phoneNum + "]";
}
}2) Fields.java（測試類）
package fanshe;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
public class Fields {
public static void main(String[] args) throws NoSuchFieldException, SecurityException, InstantiationException,
IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException {
// TODO Auto-generated method stub
// 1.獲取class對象
Class clz = Student1.class;
// 2.獲取所有公有的字段
System.out.println("----------獲取所有公有的字段----------");
Field[] fieldArray = clz.getFields();
for (Field f : fieldArray) {
System.out.println(f);
}
// 3.獲取所有的字段（包括私有、受保護、默認的）
System.out.println("----------獲取所有的字段（包括私有、受保護、默認的）----------");
fieldArray = clz.getDeclaredFields();
for (Field f : fieldArray) {
System.out.println(f);
}
// 4.獲取公有字段並且調用
System.out.println("----------獲取公有字段並且調用----------");
Field f = clz.getField("name");
System.out.println(f);
Object obj = clz.getConstructor().newInstance();
f.set(obj, "James");
Student1 stu = (Student1) obj;
System.out.println(stu.name);
// 5.獲取私有字段並調用
System.out.println("----------獲取私有字段並且調用----------");
f = clz.getDeclaredField("phoneNum");
System.out.println(f);
f.setAccessible(true);// 暴力反射，解除私有限定
f.set(obj, "18888889999");
System.out.println("驗證電話：" + stu);
}
}輸出結果爲：
----------獲取所有公有的字段----------
public java.lang.String fanshe.Student1.name
----------獲取所有的字段（包括私有、受保護、默認的）----------
public java.lang.String fanshe.Student1.name protected int fanshe.Student1.age char fanshe.Student1.sex private java.lang.String fanshe.Student1.phoneNum ----------獲取公有字段並且調用---------- public java.lang.String fanshe.Student1.name James ----------獲取私有字段並且調用---------- private java.lang.String fanshe.Student1.phoneNum 驗證電話：Student1 [name=James, age=0, sex= , phoneNum=18888889999]由此可見調用字段時：需要傳遞兩個參數：Object obj = stuClass.getConstructor().newInstance();//產生Student對象--》Student stu = new Student();
//爲字段設置值
f.set(obj, "James");//爲Student對象中的name屬性賦值--》stu.name = "James"
第一個參數：要傳入設置的對象，第二個參數：要傳入實參
4、獲取成員方法並調用例子：
1) Student2.java
package fanshe;
public class Student2 {
// **************成員方法***************//
public void show1(String s) {
System.out.println("調用了：公有的，String參數的show1(): s = " + s);
}
protected void show2() {
System.out.println("調用了：受保護的，無參的show2()");
}
void show3() {
System.out.println("調用了：默認的，無參的show3()");
}
private String show4(int age) {
System.out.println("調用了，私有的，並且有返回值的，int參數的show4(): age = " + age);
return "abcd";
}
}2) MethodClass.java（測試類）
package fanshe;
import java.lang.reflect.Method;
/*
* 獲取成員方法並調用：
*
* 1.批量的：
* public Method[] getMethods():獲取所有"公有方法"；（包含了父類的方法也包含Object類）
* public Method[] getDeclaredMethods():獲取所有的成員方法，包括私有的(不包括繼承的)
* 2.獲取單個的：
* public Method getMethod(String name,Class<?>... parameterTypes):
* 參數：
* name : 方法名；
* Class ... : 形參的Class類型對象
* public Method getDeclaredMethod(String name,Class<?>... parameterTypes)
*
* 調用方法：
* Method --> public Object invoke(Object obj,Object... args):
* 參數說明：
* obj : 要調用方法的對象；
* args:調用方式時所傳遞的實參；
):
*/
public class MethodClass {
public static void main(String[] args) throws Exception {
// 1.獲取Class對象
Class stuClass = Class.forName("fanshe.Student2");
// 2.獲取所有公有方法
System.out.println("***************獲取所有的”公有“方法*******************");
stuClass.getMethods();
Method[] methodArray = stuClass.getMethods();
for (Method m : methodArray) {
System.out.println(m);
}
System.out.println("***************獲取所有的方法，包括私有的*******************");
methodArray = stuClass.getDeclaredMethods();
for (Method m : methodArray) {
System.out.println(m);
}
System.out.println("***************獲取公有的show1()方法*******************");
Method m = stuClass.getMethod("show1", String.class);
System.out.println(m);
// 實例化一個Student對象
Object obj = stuClass.getConstructor().newInstance();
m.invoke(obj, "劉德華");
System.out.println("***************獲取私有的show4()方法******************");
m = stuClass.getDeclaredMethod("show4", int.class);
System.out.println(m);
m.setAccessible(true);// 解除私有限定
Object result = m.invoke(obj, 20);// 需要兩個參數，一個是要調用的對象（獲取有反射），一個是實參
System.out.println("返回值：" + result);
}
}輸出結果爲：
*獲取所有的”公有“方法***** public void fanshe.Student2.show1(java.lang.String) public final void java.lang.Object.wait() throws java.lang.InterruptedException public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException public boolean java.lang.Object.equals(java.lang.Object) public java.lang.String java.lang.Object.toString() public native int java.lang.Object.hashCode() public final native java.lang.Class java.lang.Object.getClass() public final native void java.lang.Object.notify() public final native void java.lang.Object.notifyAll() *獲取所有的方法，包括私有的***** public void fanshe.Student2.show1(java.lang.String) private java.lang.String fanshe.Student2.show4(int) protected void fanshe.Student2.show2() void fanshe.Student2.show3() *獲取公有的show1()方法***** public void fanshe.Student2.show1(java.lang.String) 調用了：公有的，String參數的show1(): s = 劉德華 ***獲取私有的show4()方法** private java.lang.String fanshe.Student2.show4(int) 調用了，私有的，並且有返回值的，int參數的show4(): age = 20 返回值：abcd由此可見：m = stuClass.getDeclaredMethod("show4", int.class);//調用制定方法（所有包括私有的），需要傳入兩個參數，第一個是調用的方法名稱，第二個是方法的形參類型，切記是類型。
System.out.println(m);
m.setAccessible(true);//解除私有限定
Object result = m.invoke(obj, 20);//需要兩個參數，一個是要調用的對象（獲取有反射），一個是實參
System.out.println("返回值：" + result); 其實這裏的成員方法：在模型中有屬性一詞，就是那些setter（）方法和getter()方法。還有字段組成，這些內容在內省中詳解
5、反射main方法
例子：1) Student3.java
package fanshe;
public class Student3 {
public static void main(String[] args) {
System.out.println("main方法執行了......");
}
}2) Main.java（測試類）
package fanshe;
import java.lang.reflect.Method;
public class Main {
public static void main(String[] args) {
try {
Class clz = Class.forName("fanshe.Student3");
Method methodMain = clz.getMethod("main", String[].class);
methodMain.invoke(null, (Object) new String[] { "a", "b", "c" });
} catch (Exception e) {
e.printStackTrace();
}
}
}輸出結果：
main方法執行了......
6、反射方法的其它使用之---通過反射運行配置文件內容例子：
1) Student4.java
package fanshe;
public class Student4 {
public void show() {
System.out.println("is show()..........");
}
}2) Demo.java
package fanshe;
import java.io.FileReader;
import java.io.IOException;
import java.lang.reflect.Method;
import java.util.Properties;
/*
* 我們利用反射和配置文件，可以使：應用程序更新時，對源碼無需進行任何修改
* 我們只需要將新類發送給客戶端，並修改配置文件即可
*/
public class Demo {
public static void main(String[] args) throws Exception {
// 通過反射獲取Class對象
Class stuClass = Class.forName(getValue("className"));// "cn.fanshe.Student"
// 2獲取show()方法
Method m = stuClass.getMethod(getValue("methodName"));// show
// 3.調用show()方法
m.invoke(stuClass.getConstructor().newInstance());
}
// 此方法接收一個key，在配置文件中獲取相應的value
public static String getValue(String key) throws IOException {
Properties pro = new Properties();// 獲取配置文件的對象
FileReader in = new FileReader("pro.txt");// 獲取輸入流
pro.load(in);// 將流加載到配置文件對象中
in.close();
return pro.getProperty(key);// 返回根據key獲取的value值
}
}3) pro.txt（此文件不要放在src下面，直接放在項目下）
className=fanshe.Student4
methodName=show運行結果： is show()..........
【優勢】 當我們升級這個系統時，不要Student類，而需要新寫一個Student2的類時，這時只需要更改pro.txt的文件內容就可以了。代碼就一點不用改動
要替換的student4類：
public class Student2 {
public void show2(){
System.out.println("is show2()......");
}
}只需要將配置文件修改爲：className = cn.fanshe.Student2
methodName = show2
此時的輸出結果爲： is show2()......
7、反射方法的其它使用之---通過反射越過泛型檢查泛型用在編譯期，編譯過後泛型擦除（消失掉）。所以是可以通過反射越過泛型檢查的測試類：
import java.lang.reflect.Method;
import java.lang.reflect.Method;
import java.util.ArrayList;
/*
* 通過反射越過泛型檢查
*
* 例如：有一個String泛型的集合，怎樣能向這個集合中添加一個Integer類型的值？
*/
public class Demo {
public static void main(String[] args) throws Exception{
ArrayList<String> strList = new ArrayList<>();
strList.add("aaa");
strList.add("bbb");
//strList.add(100);
//獲取ArrayList的Class對象，反向的調用add()方法，添加數據
Class listClass = strList.getClass(); //得到 strList 對象的字節碼 對象
//獲取add()方法
Method m = listClass.getMethod("add", Object.class);
//調用add()方法
m.invoke(strList, 100);
//遍歷集合
for(Object obj : strList){
System.out.println(obj);
}
}控制檯輸出：aaa
bbb
100
//反射就總結到這，下面的內省章節也和反射有關，可以算是反射的高級使用吧，如果有興趣，可以繼續查看總結的內省部分。
【參考文獻】[1].https://blog.csdn.net/sinat_38259539/article/details/71799078