主要介紹以下幾方面內容
- 理解 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(); } }
通過Class類獲取類對象
public class ReflectionTest { @Test public void testClass() { Class clazz = null; //1.得到Class對象 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類的常用方法
| 方法名 |
功能說明 |
| static Class forName(String name) |
返回指定類名 name 的 Class 對象 |
| Object newInstance() |
調用缺省構造函數，返回該Class對象的一個實例 |
| Object newInstance(Object []args) |
調用當前格式構造函數，返回該Class對象的一個實例 |
| getName() |
返回此Class對象所表示的實體（類、接口、數組類、基本類型或void）名稱 |
| Class getSuperClass() |
返回當前Class對象的父類的Class對象 |
| Class [] getInterfaces() |
獲取當前Class對象的接口 |
| ClassLoader getClassLoader() |
返回該類的類加載器 |
| Class getSuperclass() |
返回表示此Class所表示的實體的超類的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); } //結果是：com.atguigu.java.fanshe.Person@2866bb78
可以看出確實是創建了一個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); } } //結果： //sun.misc.Launcher$AppClassLoader@5ffdfb42 //sun.misc.Launcher$ExtClassLoader@1b7adb4a //null //sun.misc.Launcher$AppClassLoader@5ffdfb42 //null
使用類加載器獲取當前類目錄下的文件
首先，系統類加載器可以加載當前項目src目錄下面的所有類，如果文件也放在src下面，也可以用類加載器來加載
調用 getResourceAsStream 獲取類路徑下的文件對應的輸入流.
、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); //結果是：com.atguigu.java.fanshe.PersonDAO@66588ec0 //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 } }
反射小結
1. Class: 是一個類; 一個描述類的類.
封裝了描述方法的 Method,
描述字段的 Filed,
描述構造器的 Constructor 等屬性.
2. 如何得到 Class 對象:
2.1 Person.class
2.2 person.getClass()
2.3 Class.forName("com.atguigu.javase.Person")
3. 關於 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);
4. 關於 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)
5. 了解 Constructor 和 Annotation
6. 反射和泛型.
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; } }