java 中的反射理解

阿新 • • 發佈：2019-01-09

部落格引用處（以下內容在原有部落格基礎上進行補充或更改，謝謝這些大牛的部落格指導）：
java中的反射

主要介紹以下幾方面內容

理解 Class 類
理解 Java 的類載入機制
學會使用 ClassLoader 進行類載入
理解反射的機制
掌握 Constructor、Method、Field 類的用法
理解並掌握動態代理

1.理解Class類
　　–物件照鏡子後可以得到的資訊：某個類的資料成員名、方法和構造器、某個類到底實現了哪些介面。對於每個類而言，JRE 都為其保留一個不變的 Class 型別的物件。一個 Class 物件包含了特定某個類的有關資訊。
　　–Class 物件只能由系統建立物件
　　–一個類在 JVM 中只會有一個Class例項
　　–每個類的例項都會記得自己是由哪個 Class 例項所生成
1： Class是什麼？
Class是一個類：

public class ReflectionTest {
    @Test
    public void testClass() {
       Class clazz = null;
    }
}


//Class的定義
public final
    class Class<T> implements java.io.Serializable,
                              java.lang.reflect.GenericDeclaration,
                              java.lang.reflect.Type,
                              java.lang.reflect.AnnotatedElement {

.....
.....
.....
}
//小寫class表示是一個類型別，大寫Class表示這個類的名稱

2：Class這個類封裝了什麼資訊？

Class是一個類，封裝了當前物件所對應的類的資訊
　　一個類中有屬性，方法，構造器等，比如說有一個Person類，一個Order類，一個Book類，這些都是不同的類，現在需要一個類，用來描述類，這就是Class，它應該有類名，屬性，方法，構造器等。Class是用來描述類的類

Class類是一個物件照鏡子的結果，物件可以看到自己有哪些屬性，方法，構造器，實現了哪些介面等等

3.對於每個類而言，JRE 都為其保留一個不變的 Class 型別的物件。一個 Class 物件包含了特定某個類的有關資訊。

4.Class 物件只能由系統建立物件，一個類（而不是一個物件）在 JVM 中只會有一個Class例項

package com.atguigu.java.fanshe;

public class Person {
    String name;
    private int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    
    //包含一個帶參的構造器和一個不帶參的構造器
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public Person() {
        super();
    }

}

定義一個Person類

通過Class類獲取類物件

public class ReflectionTest {
    @Test
    public void testClass() {
       Class clazz = null;
       
       //1.得到Class物件，這裡必須用類名，不能是字串包裹的類名，如：“Person" 這樣是不行的。
       clazz = Person.class;
       
       System.out.println();  //插入斷點
    }
}

在斷點處就可以看到Class對像包含的資訊
在這裡插入圖片描述
同樣，這些屬性值是可以獲取的

public class ReflectionTest {
    @Test
    public void testClass() {
       Class clazz = null;
       
       //1.得到Class物件
       clazz = Person.class;
       //2.返回欄位的陣列
       Field[] fields = clazz.getDeclaredFields();
       
       System.out.println();  //插入斷點
    }
}

檢視fields的內容

物件為什麼需要照鏡子呢？

1. 有可能這個物件是別人傳過來的

2. 有可能沒有物件，只有一個全類名

通過反射，可以得到這個類裡面的資訊

獲取Class物件的三種方式

1.通過類名獲取類名.class

2.通過物件獲取物件名.getClass()

3.通過全類名獲取 Class.forName(全類名)

public class ReflectionTest {
    @Test
    public void testClass() throws ClassNotFoundException {
       Class clazz = null;
       
       //1.通過類名
       clazz = Person.class;
       

       //2.通過物件名
       //這種方式是用在傳進來一個物件，卻不知道物件型別的時候使用
       Person person = new Person();
       clazz = person.getClass();
       //上面這個例子的意義不大，因為已經知道person型別是Person類，再這樣寫就沒有必要了
       //如果傳進來是一個Object類，這種做法就是應該的
       Object obj = new Person();
       clazz = obj.getClass();
       

       //3.通過全類名(會丟擲異常)
       //一般框架開發中這種用的比較多，因為配置檔案中一般配的都是全類名，通過這種方式可以得到Class例項
       String className=" com.atguigu.java.fanshe.Person";
       clazz = Class.forName(className);       
       


       
       //字串的例子
       clazz = String.class;
       
       clazz = "javaTest".getClass();
       
       clazz = Class.forName("java.lang.String");
       
       System.out.println(); 
    }
}

Class類的常用方法

在這裡插入圖片描述

Class類的newInstance（）方法

public void testNewInstance() throws ClassNotFoundException, InstantiationException, IllegalAccessException{
        //1.獲取Class物件
        String className="com.atguigu.java.fanshe.Person";
        Class clazz = Class.forName(className);  
        
        //利用Class物件的newInstance方法建立一個類的例項
        Object obj =  clazz.newInstance();
        System.out.println(obj);
    }
    //結果是：[email protected]

可以看出確實是建立了一個Person例項
　　
但是Person類有兩個構造方法，到底是呼叫的哪一個構造方法呢？

實際呼叫的是類的無引數的構造器。所以在我們在定義一個類的時候，定義一個有引數的構造器，作用是對屬性進行初始化，還要寫一個無引數的構造器，作用就是反射時候用。

一般地、一個類若宣告一個帶參的構造器，同時要宣告一個無引數的構造器。

2.ClassLoader

類裝載器(類載入器)是用來把類(class)裝載進 JVM 的。JVM 規範定義了兩種型別的類裝載器：啟動類裝載器(bootstrap)和使用者自定義裝載器(user-defined class loader)。 JVM在執行時會產生3個由類載入器組成的初始化載入器層，如下圖所示：
在這裡插入圖片描述

public class ReflectionTest {
    @Test
    public void testClassLoader() throws ClassNotFoundException, FileNotFoundException{
        //1. 獲取一個系統的類載入器(可以獲取，當前這個類PeflectTest就是它載入的)
        ClassLoader classLoader = ClassLoader.getSystemClassLoader();
        System.out.println(classLoader);
        

        //2. 獲取系統類載入器的父類載入器（擴充套件類載入器，可以獲取）. 
        classLoader = classLoader.getParent();
        System.out.println(classLoader); 
        

        //3. 獲取擴充套件類載入器的父類載入器（引導類載入器，不可獲取）.
        classLoader = classLoader.getParent();
        System.out.println(classLoader);
        

        //4. 測試當前類由哪個類載入器進行載入（系統類載入器）: 
        classLoader = Class.forName("com.atguigu.java.fanshe.ReflectionTest")
             .getClassLoader();
        System.out.println(classLoader);
    

        //5. 測試 JDK 提供的 Object 類由哪個類載入器負責載入（引導類）
        classLoader = Class.forName("java.lang.Object")
                 .getClassLoader();
        System.out.println(classLoader); 
    }
}
//結果：
//[email protected]
//[email protected]
//null
//[email protected]
//null

使用類載入器獲取當前類目錄下的檔案
　在這裡插入圖片描述
　

、public class ReflectionTest {
    @Test
    public void testClassLoader() throws FileNotFoundException{
        //src目錄下，直接載入
        InputStream in1 = null;
        in1 = this.getClass().getClassLoader().getResourceAsStream("test1.txt");
        
        //放在內部資料夾，要寫全路徑
        InputStream in2 = null;
        in2 = this.getClass().getClassLoader().getResourceAsStream("com/atguigu/java/fanshe/test2.txt");
    }
}

3.反射

反射概述
Reflection（反射）是Java被視為動態語言的關鍵，反射機制允許程式在執行期藉助於Reflection API取得任何類的內部資訊，並能直接操作任意物件的內部屬性及方法。

Java反射機制主要提供了以下功能：

在執行時構造任意一個類的物件
在執行時獲取任意一個類所具有的成員變數和方法
在執行時呼叫任意一個物件的方法（屬性）
生成動態代理

Class 是一個類; 一個描述類的類.

封裝了描述方法的 Method,
描述欄位的 Filed,
描述構造器的 Constructor 等屬性.

3.1如何描述方法-Method

public class ReflectionTest {
    @Test
    public void testMethod() throws Exception{
        Class clazz = Class.forName("com.atguigu.java.fanshe.Person");
        
        //
        //1.獲取方法
      //  1.1 獲取取clazz對應類中的所有方法--方法陣列（一）
        //     不能獲取private方法,且獲取從父類繼承來的所有方法
        Method[] methods = clazz.getMethods();
        for(Method method:methods){
            System.out.print(" "+method.getName());
        }
        System.out.println();
        
        //
        //  1.2.獲取所有方法，包括私有方法 --方法陣列（二）
        //  所有宣告的方法，都可以獲取到，且只獲取當前類的方法
        methods = clazz.getDeclaredMethods();
        for(Method method:methods){
            System.out.print(" "+method.getName());
        }
        System.out.println();
        
        //
        //  1.3.獲取指定的方法
        //  需要引數名稱和引數列表，無參則不需要寫
        //  對於方法public void setName(String name) {  }
        Method method = clazz.getDeclaredMethod("setName", String.class);
        System.out.println(method);
        //  而對於方法public void setAge(int age) {  }
        method = clazz.getDeclaredMethod("setAge", Integer.class);
        System.out.println(method);
        //  這樣寫是獲取不到的，如果方法的引數型別是int型
        //  如果方法用於反射，那麼要麼int型別寫成Integer： public void setAge(Integer age) {  }
　　　　 //  要麼獲取方法的引數寫成int.class
        
        //
        //2.執行方法
        //  invoke第一個引數表示執行哪個物件的方法，剩下的引數是執行方法時需要傳入的引數
        Object obje = clazz.newInstance();
        method.invoke(obje,2);

　　　　//如果一個方法是私有方法，第三步是可以獲取到的，但是這一步卻不能執行
　　　　//私有方法的執行，必須在呼叫invoke之前加上一句method.setAccessible（true）;
    }
}

主要用到兩個方法

/**
         * @param name the name of the method
         * @param parameterTypes the list of parameters
         * @return the {@code Method} object that matches the specified
         */
        public Method getMethod(String name, Class<?>... parameterTypes){
            
        }
        
        /**
         * @param obj  the object the underlying method is invoked from
         * @param args the arguments used for the method call
         * @return  the result of dispatching the method represented by
         */
        public Object invoke(Object obj, Object... args){
            
        }

自定義工具方法

自定義一個方法

把類物件和類方法名作為引數，執行方法

把全類名和方法名作為引數，執行方法

比如Person裡有一個方法

public void test(String name,Integer age){
        System.out.println("呼叫成功");
    }

那麼我們自定義一個方法
1. 把類物件和類方法名作為引數，執行方法

/**
     * 
     * @param obj: 方法執行的那個物件. 
     * @param methodName: 類的一個方法的方法名. 該方法也可能是私有方法. 
     * @param args: 呼叫該方法需要傳入的引數
     * @return: 呼叫方法後的返回值
     *  
     */
      public Object invoke(Object obj, String methodName, Object ... args) throws Exception{
        //1. 獲取 Method 物件
        //   因為getMethod的引數為Class列表型別，所以要把引數args轉化為對應的Class型別。
        
        Class [] parameterTypes = new Class[args.length];
        for(int i = 0; i < args.length; i++){
            parameterTypes[i] = args[i].getClass();
            System.out.println(parameterTypes[i]); 
        }
        
        Method method = obj.getClass().getDeclaredMethod(methodName, parameterTypes);
        //如果使用getDeclaredMethod，就不能獲取父類方法，如果使用getMethod，就不能獲取私有方法
　　　　
　　　　　//
　　　　　//2. 執行 Method 方法
        //3. 返回方法的返回值
        return method.invoke(obj, args);
      }

呼叫：

 @Test
        public void testInvoke() throws Exception{
            Object obj = new Person();            
            invoke(obj, "test", "wang", 1);             
        }

這樣就通過物件名，方法名，方法引數執行了該方法

2.把全類名和方法名作為引數，執行方法

/**
         * @param className: 某個類的全類名
         * @param methodName: 類的一個方法的方法名. 該方法也可能是私有方法. 
         * @param args: 呼叫該方法需要傳入的引數
         * @return: 呼叫方法後的返回值
         */
        public Object invoke(String className, String methodName, Object ... args){
            Object obj = null;
            
            try {
                obj = Class.forName(className).newInstance();
                //呼叫上一個方法
                return invoke(obj, methodName, args);
            }catch(Exception e) {
                e.printStackTrace();
            }            
            return null;
        }

呼叫

@Test
        public void testInvoke() throws Exception{
                
            invoke("com.atguigu.java.fanshe.Person", 
                    "test", "zhagn", 12);         
        }

使用系統方法（前提是此類有一個無參的構造器（檢視API））

@Test
        public void testInvoke() throws Exception{
            Object result = 
                    invoke("java.text.SimpleDateFormat", "format", new Date());
            System.out.println(result);          
        }

這種反射實現的主要功能是可配置和低耦合。只需要類名和方法名，而不需要一個類物件就可以執行一個方法。如果我們把全類名和方法名放在一個配置檔案中，就可以根據呼叫配置檔案來執行方法

如何獲取父類定義的（私有）方法?

前面說一般使用getDeclaredMethod獲取方法（因為此方法可以獲取類的私有方法，但是不能獲取父類方法）

如何獲取父類方法呢，上一個例子format方法其實就是父類的方法（獲取的時候用到的是getMethod）

首先我們要知道，如何獲取類的父親：

比如有一個類，繼承自Person

使用

public class ReflectionTest {
    @Test
    public void testGetSuperClass() throws Exception{
        String className = "com.atguigu.java.fanshe.Student";
        
        Class clazz = Class.forName(className);
        Class superClazz = clazz.getSuperclass();
        
        System.out.println(superClazz); 
    }
}
//結果是 “ class com.atguigu.java.fanshe.Person ”

此時如果Student中有一個方法是私有方法method1(int age); Person中有一個私有方法method2();怎麼呼叫?

定義一個方法，不但能訪問當前類的私有方法，還要能父類的私有方法

/**
     * 
     * @param obj: 某個類的一個物件
     * @param methodName: 類的一個方法的方法名. 
     * 該方法也可能是私有方法, 還可能是該方法在父類中定義的(私有)方法
     * @param args: 呼叫該方法需要傳入的引數
     * @return: 呼叫方法後的返回值
     */
    public Object invoke2(Object obj, String methodName, 
            Object ... args){
        //1. 獲取 Method 物件
        Class [] parameterTypes = new Class[args.length];
        for(int i = 0; i < args.length; i++){
            parameterTypes[i] = args[i].getClass();
        }
        
        try {
            Method method = getMethod(obj.getClass(), methodName, parameterTypes);
            method.setAccessible(true);
            //2. 執行 Method 方法
            //3. 返回方法的返回值
            return method.invoke(obj, args);
        } catch (Exception e) {
            e.printStackTrace();
        }
        
        return null;
    }
    
    /**
     * 獲取 clazz 的 methodName 方法. 該方法可能是私有方法, 還可能在父類中(私有方法)
     * 如果在該類中找不到此方法，就向他的父類找，一直到Object類為止
　　　* 這個方法的另一個作用是根據一個類名，一個方法名，追蹤到並獲得此方法
     * @param clazz
     * @param methodName
     * @param parameterTypes
     * @return
     */
    public Method getMethod(Class clazz, String methodName, 
            Class ... parameterTypes){
        
        for(;clazz != Object.class; clazz = clazz.getSuperclass()){
            try {
                Method method = clazz.getDeclaredMethod(methodName, parameterTypes);
                return method;
            } catch (Exception e) {}            
        }
        
        return null;
    }

3.2 如何描述欄位-Field

@Test
    public void testField() throws Exception{
        String className = "com.atguigu.java.fanshe.Person";        
        Class clazz = Class.forName(className); 
        
        //1.獲取欄位
      //  1.1 獲取所有欄位 -- 欄位陣列
        //     可以獲取公用和私有的所有欄位，但不能獲取父類欄位
        Field[] fields = clazz.getDeclaredFields();
        for(Field field: fields){
            System.out.print(" "+ field.getName());
        }
        System.out.println();
        
        //  1.2獲取指定欄位
        Field field = clazz.getDeclaredField("name");
        System.out.println(field.getName());
        
        Person person = new Person("ABC",12);
        
        //2.使用欄位
      //  2.1獲取指定物件的指定欄位的值
        Object val = field.get(person);
        System.out.println(val);
        
        //  2.2設定指定物件的指定物件Field值
        field.set(person, "DEF");
        System.out.println(person.getName());
        
        //  2.3如果欄位是私有的，不管是讀值還是寫值，都必須先呼叫setAccessible（true）方法
        //     比如Person類中，欄位name欄位是公用的，age是私有的
        field = clazz.getDeclaredField("age");
        field.setAccessible(true);
        System.out.println(field.get(person));        
    }

但是如果需要訪問父類中的（私有）欄位：

/**
     * //建立 className 對應類的物件, 併為其 fieldName 賦值為 val
     * //Student繼承自Person,age是Person類的私有欄位/
     public void testClassField() throws Exception{
        String className = "com.atguigu.java.fanshe.Student";
        String fieldName = "age"; //可能為私有, 可能在其父類中. 
        Object val = 20;        
        
        Object obj = null;
        //1.建立className 對應類的物件
        Class clazz = Class.forName(className);
        //2.建立fieldName 物件欄位的物件
        Field field = getField(clazz, fieldName);
        //3.為此物件賦值
        obj = clazz.newInstance();
        setFieldValue(obj, field, val);
        //4.獲取此物件的值
        Object value = getFieldValue(obj,field);
    }
    
    public Object getFieldValue(Object obj, Field field) throws Exception{
        field.setAccessible(true);
        return field.get(obj);
    }

    public void setFieldValue(Object obj, Field field, Object val) throws Exception {
        field.setAccessible(true);
        field.set(obj, val);
    }

    public Field getField(Class clazz, String fieldName) throws Exception {
        Field field = null;
        for(Class clazz2 = clazz; clazz2 != Object.class;clazz2 = clazz2.getSuperclass()){        
                field = clazz2.getDeclaredField(fieldName);
        }
        return field;
    }

3.3如何描述構造器-Constructor

@Test
    public void testConstructor() throws Exception{
        String className = "com.atguigu.java.fanshe.Person";
        Class<Person> clazz = (Class<Person>) Class.forName(className);
        
        //1. 獲取 Constructor 物件
        //   1.1 獲取全部
        Constructor<Person> [] constructors = 
                (Constructor<Person>[]) Class.forName(className).getConstructors();
        
        for(Constructor<Person> constructor: constructors){
            System.out.println(constructor); 
        }
        
        //  1.2獲取某一個，需要引數列表
        Constructor<Person> constructor = clazz.getConstructor(String.class, int.class);
        System.out.println(constructor); 
        
        //2. 呼叫構造器的 newInstance() 方法建立物件
        Object obj = constructor.newInstance("zhagn", 1);                
    }

3.4 如何描述註解 – Annotation

定義一個Annotation

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;


@Retention(RetentionPolicy.RUNTIME)
@Target(value={ElementType.METHOD})
public @interface AgeValidator {
    public int min();
    public int max();
}

此註解只能用在方法上

@AgeValidator(min=18,max=35)
    public void setAge(int age) {
        this.age = age;
    }

那麼我們在給Person類物件的age賦值時，是感覺不到註解的存在的

@Test
    public void testAnnotation() throws Exception{
        Person person = new Person();    
        person.setAge(10);
    }

必須通過反射的方式為屬性賦值，才能獲取到註解

/** Annotation 和 反射:
         * 1. 獲取 Annotation
         * 
         * getAnnotation(Class<T> annotationClass) 
         * getDeclaredAnnotations() 
         * 
         */
    @Test
    public void testAnnotation() throws Exception{
        String className = "com.atguigu.java.fanshe.Person";
        
        Class clazz = Class.forName(className);
        Object obj = clazz.newInstance();    
        
        Method method = clazz.getDeclaredMethod("setAge", int.class);
        int val = 6;
        
        //獲取指定名稱的註解
        Annotation annotation = method.getAnnotation(AgeValidator.class);
        if(annotation != null){
            if(annotation instanceof AgeValidator){
                AgeValidator ageValidator = (AgeValidator) annotation;                
                if(val < ageValidator.min() || val > ageValidator.max()){
                    throw new RuntimeException("年齡非法");
                }
            }
        }        
        method.invoke(obj, 20);
        System.out.println(obj);          
    }

如果在程式中要獲取註解，然後獲取註解的值進而判斷我們賦值是否合法，那麼類物件的建立和方法的建立必須是通過反射而來的

4.反射與泛型## 標題
　　定義一個泛型類

public class DAO<T> {
    //根據id獲取一個物件
    T get(Integer id){
        
        return null;
    }
    
    //儲存一個物件
    void save(T entity){
        
    }
}

再定義一個子類，繼承這個泛型類：

public class PersonDAO extends DAO<Person> {

}

父類中的泛型T，就相當於一個引數，當子類繼承這個類時，就要給這個引數賦值，這裡是把Person型別傳給了父類

或者還有一種做法

public class PersonDAO<T> extends DAO<T> {

}

然後進行測試

@Test
    public void testAnnotation() throws Exception{
       PersonDAO personDAO = new PersonDAO();
       Person entity = new Person();
       //呼叫父類的save方法，同時也把Person這個“實參”傳給了父類的T
       personDAO.save(entity);       
       //這句的本意是要返回一個Person型別的物件
       Person result = personDAO.get(1); 
       System.out.print(result);
    }

問題出來了。這裡的get方法是父類的get方法，對於父類而言，方法返回值是一個T型別，當T的值為Person時，本該返回一個Person型別，但是必須用反射來建立這個物件（泛型方法返回一個物件），方法無非就是clazz.newInstance(); 所以關鍵點就是根據T得到其對於的Class物件。

那麼首先，在父類中定義一個欄位，表示T所對應的Class，然後想辦法得到這個clazz的值

public class DAO<T> {
    private Class<T> clazz;
    
    T get(Integer id){
        
        return null;
    }
}

如何獲得這個clazz呢？

@Test
    public void test() throws Exception{
       PersonDAO personDAO = new PersonDAO();
       
       Person result = personDAO.get(1); 
       System.out.print(result);
    }

public DAO(){
        //1.
        System.out.println("DAO's Constrctor...");
        System.out.println(this);           //結果是：[email protected]
        //this：父類構造方法中的this指的是子類物件，因為此時是PersonDAO物件在呼叫
        System.out.println(this.getClass()); //結果是：class com.atguigu.java.fanshe.PersonDAO
        //2.
        //獲取DAO子類的父類
        Class class1 = this.getClass().getSuperclass();
        System.out.println(class1);         //結果是：class com.atguigu.java.fanshe.DAO
        //此時只能獲的父類的型別名稱，卻不可以獲得父類的泛型引數
        //3.
        //獲取DAO子類帶泛型引數的子類
        Type type=this.getClass().getGenericSuperclass();
        System.out.println(type);         //結果是：com.atguigu.java.fanshe.DAO<com.atguigu.java.fanshe.Person>
        //此時獲得了泛型引數，然後就是把它提取出來
        //4.
        //獲取具體的泛型引數 DAO<T>
        //注意Type是一個空的介面，這裡使用它的子類ParameterizedType，表示帶引數的類型別（即泛型）
        if(type instanceof ParameterizedType){
            ParameterizedType parameterizedType = (ParameterizedType) type;
            Type [] arges = parameterizedType.getActualTypeArguments();
            System.out.println(Arrays.asList(arges));    //結果是：[class com.atguigu.java.fanshe.Person]
            //得到的是一個數組，因為可能父類是多個泛型引數public class DAO<T,PK>{}
            if(arges != null && arges.length >0){
                Type arg = arges[0];
                System.out.println(arg);      //結果是：class com.atguigu.java.fanshe.Person
                //獲得第一個引數
                if(arg instanceof Class){
                    clazz = (Class<T>) arg;
                    //把值賦給clazz欄位
                }
            }
        }        
    }

所以就定義一個方法，獲得 Class 定義中宣告的父類的泛型引數型別

public class ReflectionTest {    
    /**
     * 通過反射, 獲得定義 Class 時宣告的父類的泛型引數的型別
     * 如: public EmployeeDao extends BaseDao<Employee, String>
     * @param clazz: 子類對應的 Class 物件
     * @param index: 子類繼承父類時傳入的泛型的索引. 從 0 開始
     * @return
     */
    @SuppressWarnings("unchecked")
    public  Class getSuperClassGenricType(Class clazz, int index){
        
        Type type = clazz.getGenericSuperclass();
        
        if(!(type instanceof ParameterizedType)){
            return null;
        }
        
        ParameterizedType parameterizedType = 
                (ParameterizedType) type;
        
        Type [] args = parameterizedType.getActualTypeArguments();
        
        if(args == null){
            return null;
        }
        
        if(index < 0 || index > args.length - 1){
            return null;
        }
        
        Type arg = args[index];
        if(arg instanceof Class){
            return (Class) arg;
        }        
        return null;
    }
    
    @SuppressWarnings("unchecked")
    public  Class getSuperGenericType(Class clazz){
        return getSuperClassGenricType(clazz, 0);
    }
    

    @Test
    public  void testGetSuperClassGenricType(){
        Class clazz = PersonDAO.class;
        //PersonDAO.class
        Class argClazz = getSuperClassGenricType(clazz, 0);
        System.out.println(argClazz);
        //結果是class com.atguigu.java.fanshe.Person        
    }
}

反射小結

Class: 是一個類; 一個描述類的類.

封裝了描述方法的 Method,

描述欄位的 Filed,

          描述構造器的 Constructor 等屬性.

如何得到 Class 物件:
　　2.1 Person.class
　　2.2 person.getClass()
　　2.3 Class.forName(“com.atguigu.javase.Person”)
關於 Method:
　　3.1 如何獲取 Method:
　　　　1). getDeclaredMethods: 得到 Method 的陣列.
　　　　2). getDeclaredMethod(String methondName, Class … parameterTypes)

3.2 如何呼叫 Method
　　　　1). 如果方法時 private 修飾的, 需要先呼叫 Method 的　setAccessible(true), 使其變為可訪問
　　　　2). method.invoke(obj, Object … args);

關於 Field:
　　4.1 如何獲取 Field: getField(String fieldName)
　　4.2 如何獲取 Field 的值:
　　　　1). setAccessible(true)
　　　　2). field.get(Object obj)
　　4.3 如何設定 Field 的值:
　　　　field.set(Obejct obj, Object val)
瞭解 Constructor 和 Annotation
反射和泛型.
　　6.1 getGenericSuperClass: 獲取帶泛型引數的父類, 返回值為: BaseDao<Employee, String>
　　6.2 Type 的子介面: ParameterizedType
　　6.3 可以呼叫 ParameterizedType 的 Type[] getActualTypeArguments() 獲取泛型引數的陣列.

package com.atguigu.javase.lesson12;

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

/**
 * 反射的 Utils 函式集合
 * 提供訪問私有變數, 獲取泛型型別 Class, 提取集合中元素屬性等 Utils 函式
 * @author Administrator
 *
 */
public class ReflectionUtils {

    
    /**
     * 通過反射, 獲得定義 Class 時宣告的父類的泛型引數的型別
     * 如: public EmployeeDao extends BaseDao<Employee, String>
     * @param clazz
     * @param index
     * @return
     */
    @SuppressWarnings("unchecked")
    public static Class getSuperClassGenricType(Class clazz, int index){
        Type genType = clazz.getGenericSuperclass();
        
        if(!(genType instanceof ParameterizedType)){
            return Object.class;
        }
        
        Type [] params = ((ParameterizedType)genType).getActualTypeArguments();
        
        if(index >= params.length || index < 0){
            return Object.class;
        }
        
        if(!(params[index] instanceof Class)){
            return Object.class;
        }
        
        return (Class) params[index];
    }
    
    /**
     * 通過反射, 獲得 Class 定義中宣告的父類的泛型引數型別
     * 如: public EmployeeDao extends BaseDao<Employee, String>
     * @param <T>
     * @param clazz
     * @return
     */
    @SuppressWarnings("unchecked")
    public static<T> Class<T> getSuperGenericType(Class clazz){
        return getSuperClassGenricType(clazz, 0);
    }
    
    /**
     * 迴圈向上轉型, 獲取物件的 DeclaredMethod
     * @param object
     * @param methodName
     * @param parameterTypes
     * @return
     */
    public static Method getDeclaredMethod(Object object, String methodName, Class<?>[] parameterTypes){
        
        for(Class<?> superClass = object.getClass(); superClass != Object.class; superClass = superClass.getSuperclass()){
            try {
                //superClass.getMethod(methodName, parameterTypes);
                return superClass.getDeclaredMethod(methodName, parameterTypes);
            } catch (NoSuchMethodException e) {
                //Method 不在當前類定義, 繼續向上轉型
            }
            //..
        }
        
        return null;
    }
    
    /**
     * 使 filed 變為可訪問
     * @param field
     */
    public static void makeAccessible(Field field){
        if(!Modifier.isPublic(field.getModifiers())){
            field.setAccessible(true);
        }
    }
    
    /**
     * 迴圈向上轉型, 獲取物件的 DeclaredField
     * @param object
     * @param filedName
     * @return
     */
    public static Field getDeclaredField(Object object, String filedName){
        
        for(Class<?> superClass = object.getClass(); superClass != Object.class; superClass = superClass.getSuperclass()){
            try {
                return superClass.getDeclaredField(filedName);
            } catch (NoSuchFieldException e) {
                //Field 不在當前類定義, 繼續向上轉型
            }
        }
        return null;
    }
    
    /**
     * 直接呼叫物件方法, 而忽略修飾符(private, protected)
     * @param object
     * @param methodName
     * @param parameterTypes
     * @param parameters
     * @return
     * @throws InvocationTargetException 
     * @throws IllegalArgumentException 
     */
    public static Object invokeMethod(Object object, String methodName, Class<?> [] parameterTypes,
            Object [] parameters) throws InvocationTargetException{
        
        Method method = getDeclaredMethod(object, methodName, parameterTypes);
        
        if(method == null){
            throw new IllegalArgumentException("Could not find method [" + methodName + "] on target [" + object + "]");
        }
        
        method.setAccessible(true);
        
        try {
            return method.invoke(object, parameters);
        } catch(IllegalAccessException e) {
            System.out.println("不可能丟擲的異常");
        } 
        
        return null;
    }
    
    /**
     * 直接設定物件屬性值, 忽略 private/protected 修飾符, 也不經過 setter
     * @param object
     * @param fieldName
     * @param value
     */
    public static void setFieldValue(Object object, String fieldName, Object value){
        Field field = getDeclaredField(object, fieldName);
        
        if (field == null)
            throw new IllegalArgumentException("Could not find field [" + fieldName + "] on target [" + object + "]");
        
        makeAccessible(field);
        
        try {
            field.set(object, value);
        } catch (IllegalAccessException e) {
            System.out.println("不可能丟擲的異常");
        }
    }
    
    /**
     * 直接讀取物件的屬性值, 忽略 private/protected 修飾符, 也不經過 getter
     * @param object
     * @param fieldName
     * @return
     */
    public static Object getFieldValue(Object object, String fieldName){
        Field field = getDeclaredField(object, fieldName);
        
        if (field == null)
            throw new IllegalArgumentException("Could not find field [" + fieldName + "] on target [" + object + "]");
        
        makeAccessible(field);
        
        Object result = null;
        
        try {
            result = field.get(object);
        } catch (IllegalAccessException e) {
            System.out.println("不可能丟擲的異常");
        }
        
        return result;
    }
}

反射的 Utils 函式集合

java 中的反射理解

物件為什麼需要照鏡子呢？

獲取Class物件的三種方式

Class類的常用方法

Class類的newInstance（）方法

2.ClassLoader

3.反射

3.1如何描述方法-Method

3.2 如何描述欄位-Field

3.3如何描述構造器-Constructor

3.4 如何描述註解 – Annotation

反射小結

對Java中“反射”的理解

Java中反射代碼實例

JAVA中反射機制五（JavaBean的內省與BeanUtils庫）

JAVA中反射機制六（java.lang.reflect包）

Java中反射機制詳解

java中反射：加載類的構造方法

java中反射知識點總結

關於Java中反射問題的權威解答，歡迎查閱！

java中反射的應用

Java中反射技術的例項

Java中反射實現Bean轉化

Java中反射機制（Reflection）研究及原始碼演示

java中Properties理解

Java中反射效能測試

Java中反射機制和Class.forName、例項物件.class(屬性)、例項物件getClass()的區別

Java中如何理解Static，Final，Static Final

Java中switch理解

Java中反射的實現方式

Java基礎13——深入理解java中的反射機制

java 中的反射理解

java 中的反射理解

物件為什麼需要照鏡子呢？

獲取Class物件的三種方式

Class類的常用方法

Class類的newInstance（）方法

2.ClassLoader

3.反射

3.1如何描述方法-Method

3.2 如何描述欄位-Field

3.3如何描述構造器-Constructor

3.4 如何描述註解 – Annotation

反射小結

相關推薦