主要介紹以下幾方面內容
- 理解 Class 類
- 理解 Java 的類加載機制
- 學會使用 ClassLoader 進行類加載
- 理解反射的機制
- 掌握 Constructor、Method、Field 類的用法
- 理解並掌握動態代理
1.理解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實例
定義一個Person類
通過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反射機制主要提供了以下功能：
- 在運行時構造任意一個類的對象
- 在運行時獲取任意一個類所具有的成員變量和方法
- 在運行時調用任意一個對象的方法（屬性）
- 生成動態代理
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() 獲取泛型參數的數組.