文章目錄
- Java反射機制
- 理解Class類
- 獲取Class類實體
- 類的加載程序
- 類加載器ClassLoader
- 創建運行時類的物件
- 獲取運行時類的結構
- 呼叫運行時類的指定結構
- 動態代理
Java反射機制
Reflection是被視為動態語言的關鍵，反射機制允許程式在執行期借助于Reflection API取得任何類的內部資訊，并能直接操作任意物件的內部屬性及方法，
加載完類之后，在堆記憶體的方法區中就產生了一個Class型別的物件（一個類只有一個Class物件），這個物件就包含了完整的類的結構資訊，我們可以通過這個物件看到類的結構，這個物件就像一面鏡子，透過這個鏡子看到類的結構，所以，我們形象的稱之為：反射，
程式經過javac.exe命令以后，會生成一個或多個位元組碼檔案(.class結尾)，接著我們使用java.exe命令對某個位元組碼檔案進行解釋運行，相當于將某個位元組碼檔案
加載到記憶體中，此程序就稱為類的加載，加載到記憶體中的類，我們就稱為運行時類，此運行時類，就作為CLass的一個實體，換句話說，Class 的實體就對應著一個運行時類，
Java反射機制提供的功能：
反射相關的主要API：
理解Class類
在Object類中定義了以下的方法，此方法將被所有子類繼承：
public final Class getClass()
以上的方法回傳值的型別是一個Class類，此類是Java反射的源頭，實際上所謂反射從程式的運行結果來看也很好理解，即：可以通過物件反射求出所屬類，
物件照鏡子后可以得到的資訊：某個類的屬性、方法和構造器、某個類到底實作了哪些介面，對于每個類而言，JRE 都為其保留一個不變的 Class 型別的物件，一個 Class 物件包含了特定某個結構(class/interface/enum/annotation/primitivetype/void/[])的有關資訊，
①Class 本身也是一個類，
②Class 物件只能由系統建立物件，
③一個加載的類在 JVM 中只會有一個Class實體，
④一個Class物件對應的是一個加載到JVM中的一個.class檔案，
⑤通過Class可以完整地得到一個類中的所有被加載的結構，
⑥Class類是Reflection的根源，針對任何想動態加載、運行的類，唯有先獲得相應的Class物件，
獲取Class類實體
加載到記憶體中的運行時類， 會快取一 定的時間，在此時間之內，我們可以通過不同的方式來獲取此運行時類，
import com.atyeman.java.Person;
/**
* @Author: Yeman
* @Date: 2021-09-29-22:39
* @Description:
*/
public class ClassTest {
public static void main(String[] args) throws ClassNotFoundException {
//方式一：呼叫運行時類的屬性：.class
Class clazz1 = Person.class;
System.out.println(clazz1);
//方式二：通過運行時類的物件呼叫getClass()
Person p2 = new Person();
Class clazz2 = p2.getClass();
System.out.println(clazz2);
//方式三：呼叫Class的靜態方法：forName(String,classPath)
Class clazz3 = Class.forName("com.atyeman.java.Person");
System.out.println(clazz3);
//方式四：使用類的加載器ClassLoader
ClassLoader classLoader = ClassTest.class.getClassLoader();
Class clazz4 = classLoader.loadClass("com.atyeman.java.Person");
System.out.println(clazz4);
//比較,true則為同一個運行時類，也證明了就加載了一個而已
System.out.println(clazz1 == clazz2 && clazz2 == clazz3 && clazz3==clazz4);
}
}
哪些型別可以有Class物件？
①class：外部類，成員(成員內部類，靜態內部類)，區域內部類，匿名內部類
②interface：介面
③[]：陣列
④enum：列舉
⑤annotation：注解@interface
⑥primitive type：基本資料型別
⑦void
Class c1 = Object.class;
Class c2 = Comparable.class;
Class c3 = String[].class;
Class c4 = int[][].class;
Class c5 = ElementType.class;
Class c6 = Override.class;
Class c7 = int.class;
Class c8 = void.class;
Class c9 = Class.class;
int[] a = new int[10];
int[] b = new int[100];
Class c10 = a.getClass();
Class c11 = b.getClass();
// 只要元素型別與維度一樣，就是同一個Class
System.out.println(c10 == c11); //true
類的加載程序
當程式主動使用某個類時，如果該類還未被加載到記憶體中，則系統會通過如下三個步驟來對該類進行初始化，
加載：將class檔案位元組碼內容加載到記憶體中，并將這些靜態資料轉換成方法區的運行時資料結構，然后生成一個代表這個類的java.lang.Class物件，作為方法區中類資料的訪問入口（即參考地址），所有需要訪問和使用類資料只能通過該Class物件，這個加載的程序需要類加載器參與，
鏈接：將Java類的二進制代碼合并到JVM的運行狀態之中的程序，
驗證：確保加載類資訊符合JVM規范，例如：以cafe開頭，沒有安全方面的問題，
準備：正式為類變數（static）分配記憶體并設定類變數默認初始值的階段，這些記憶體都將在方法區中進行分配，
決議：虛擬機常量池內的符號參考（常量名）替換為直接參考（地址）的程序，
初始化：執行類構造器<clinit>()方法的程序，類構造器<clinit>()方法是由編譯期自動收集類中所有類變數的賦值動作和靜態代碼塊中的陳述句合并產生的（類構造器是構造類資訊的，不是構造該類物件的構造器），當初始化一個類的時候，如果發現其父類還沒有進行初始化，則需要先觸發其父類的初始化，虛擬機會保證一個類的<clinit>()方法在多執行緒環境中被正確加鎖和同步，
public class ClassLoadingTest {
public static void main(String[] args) {
System.out.println(A.m);
}
}
class A {
static {
m = 300;
}
static int m = 100;
}
//第二步：鏈接結束后m=0
//第三步：初始化后，m的值由<clinit>()方法執行決定
// 這個A的類構造器<clinit>()方法由類變數的賦值和靜態代碼塊中的陳述句按照順序合并產生，相當于
// <clinit>(){
// m = 300;
// m = 100;
// }
什么時候會發生類初始化？
1、類的主動參考（一定會發生類的初始化）
①當虛擬機啟動，先初始化main方法所在的類
②new一個類的物件
③呼叫類的靜態成員（除了final常量）和靜態方法
④使用java.lang.reflect包的方法對類進行反射呼叫
⑤當初始化一個類，如果其父類沒有被初始化，則先會初始化它的父類
2、類的被動參考（不會發生類的初始化）
①當訪問一個靜態域時，只有真正宣告這個域的類才會被初始化
②當通過子類參考父類的靜態變數，不會導致子類初始化
③通過陣列定義類參考，不會觸發此類的初始化
④參考常量不會觸發此類的初始化（常量在鏈接階段就存入呼叫類的常量池中了）
類加載器ClassLoader
類加載器的作用：
①類加載：將class檔案位元組碼內容加載到記憶體中，并將這些靜態資料轉換成方法區的運行時資料結構，然后在堆中生成一個代表這個類的java.lang.Class物件，作為方法區中類資料的訪問入口，
②類快取：標準的JavaSe類加載器可以按要求查找類，但一旦某個類被加載到類加載器中，它將維持加載（快取）一段時間，不過JVM垃圾回識訓制可以回收這些Class物件，
類加載器作用是用來把類(class)裝載進記憶體的，JVM 規范定義了如下型別的類的加載器，
/**
* @Author: Yeman
* @Date: 2021-09-29-22:39
* @Description:
*/
public class ClassTest {
public static void main(String[] args) throws ClassNotFoundException {
//1.獲取一個系統類加載器
ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
System.out.println(systemClassLoader);
//2.獲取系統類加載器的父類加載器，即擴展類加載器
ClassLoader parent1 = systemClassLoader.getParent();
System.out.println(parent1);
//3.獲取擴展類加載器的父類加載器，即引導類加載器
ClassLoader parent2 = parent1.getParent();
System.out.println(parent2);
//4.測驗當前類由哪個類加載器進行加載
Class<?> aClass = Class.forName("com.atyeman.java.Person");
ClassLoader classLoader = aClass.getClassLoader();
System.out.println(classLoader);
//5.測驗JDK提供的Object類由哪個類加載器加載
ClassLoader classLoader1 = Class.forName("java.lang.Object").getClassLoader();
System.out.println(classLoader1); //null則表示是引導類加載器，無法被獲取到
}
}
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
/**
* @Author: Yeman
* @Date: 2021-09-29-22:39
* @Description:
*/
public class ClassTest {
public static void main(String[] args) throws IOException {
Properties pros = new Properties();
//讀取組態檔方式一
// FileInputStream fis = new FileInputStream("ClassTest\\jdbc.properties");
// pros.load(fis);
//讀取組態檔方式二，使用ClassLoader
ClassLoader classLoader = ClassTest.class.getClassLoader();
InputStream is = classLoader.getResourceAsStream("jdbc1.properties");
pros.load(is);
String user = pros.getProperty("user");
String password = pros.getProperty("password");
System.out.println(user + password);
}
}
創建運行時類的物件
public class NewInstanceTest {
public static void main(String[] args) throws InstantiationException, IllegalAccessException {
Class<Person> pc = Person.class;
Person person = pc.newInstance();
System.out.println(person);
}
}
.
呼叫newInstance ()方法，創建對應的運行時類的物件，內部呼叫了運行時類的空參的構造器，
呼叫newInstance()方法正常地創建運行時類的物件，要求：
①運行時類必須提供空參的構造器
②空參的構造器的訪問權限通常為public
在javabean中要求提供一個public的空參構造器， 原因：
①通過反射創建運行時類的物件
②子類繼承此運行時類時，默認呼叫super()時，保證父類有此構造器
獲取運行時類的結構
1、獲取屬性結構
public Field[] getFields()：此Class及其父類、介面中宣告為public的屬性
public Field[] getDeclaredFields()：此Class中宣告的所有屬性
Field方法中：
public int getModifiers()：以整數形式回傳此Field的修飾符，可以使用Modifier.toString(int modifier)還原
public Class<?> getType()：得到Field的屬性型別
public String getName()：回傳Field的名稱
2、獲取方法結構
public Method[] getMethods()：此Class及其父類、介面中宣告為public的方法
public Method[] getDeclaredMethods()：此Class中宣告的所有方法
Method類中：
public Class<?> getReturnType()：取得全部的回傳值
public Class<?>[] getParameterTypes()：取得全部的引數
public int getModifiers()：取得修飾符
public Class<?>[] getExceptionTypes()：取得例外資訊
3、獲取構造器
public Constructor<T>[] getConstructors()：此Class中宣告為public的構造器
public Constructor<T>[] getDeclaredConstructors()：此Class中所有構造器
Constructor類中：
取得修飾符:：public int getModifiers()
取得方法名稱： public String getName()
取得引數的型別：public Class<?>[] getParameterTypes()
4、其他
public Class<?>[] getInterfaces()：此Class實作的所有介面
public Class<? Super T> getSuperclass()：此Class的父類
Type getGenericSuperclass()：此Class帶泛型的父類
get Annotation(Class<T> annotationClass)：此結構的注解
ParameterizedType：此Class的泛型型別
Package getPackage()：此Class所在的包
呼叫運行時類的指定結構
1、呼叫指定屬性
在反射機制中，可以直接通過Field類操作類中的屬性，通過Field類提供的set()和
get()方法就可以完成設定和取得屬性內容的操作，
public Field getField(String name)：回傳此Class物件表示的類或介面的指定的public的Field，（不通用，不常用）
public Field getDeclaredField(String name)：回傳此Class物件表示的類或介面的指定的Field，
在Field中：
public Object get(Object obj)：取得指定物件obj上此Field的屬性內容
public void set(Object obj,Object value)：設定指定物件obj上此Field的屬性內容
import java.lang.reflect.Field;
/**
* @Author: Yeman
* @Date: 2021-10-02-22:18
* @Description:
*/
public class ReflectionTest {
public static void main(String[] args) throws Exception {
Class<Person> personClass = Person.class;
Person person = personClass.newInstance();
//獲取指定的屬性
Field name = personClass.getDeclaredField("name"); //獲取指定屬性
name.setAccessible(true); //非public的需要先進行此步，保證當前屬性可以訪問
name.set(person,"葉綠體"); //設定，第一個引數是哪個物件，第二個引數是值
String pName = (String) name.get(person); //獲取，引數為哪個物件
System.out.println(pName);
}
}
2、呼叫指定方法
通過反射，呼叫類中的方法，通過Method類完成，步驟：
①通過Class類的getMethod(String name,Class…parameterTypes)方法取得一個Method物件，并設定此方法操作時所需要的引數型別，
②使用Object invoke(Object obj, Object[] args)進行呼叫，并向方法中傳遞要設定的obj物件的引數資訊，
import java.lang.reflect.Method;
/**
* @Author: Yeman
* @Date: 2021-10-02-22:18
* @Description:
*/
public class ReflectionTest {
public static void main(String[] args) throws Exception {
Class<Person> personClass = Person.class;
Person person = personClass.newInstance();
//獲取指定的方法，第一個引數為哪個方法，后面引數為形參串列
Method show = personClass.getDeclaredMethod("show", String.class);
//設定可以被訪問
show.setAccessible(true);
//進行具體使用操作invoke()方法，回傳值同原方法一致
//第一個引數為哪個物件，后面引數為傳遞的實參
String nation = (String) show.invoke(person, "中國");
System.out.println(nation);
}
}
3、呼叫指定構造器（不常用）
與屬性和方法類似，
動態代理
使用一個代理將物件包裝起來, 然后用該代理物件取代原始物件，任何對原始物件的呼叫都要通過代理，代理物件決定是否以及何時將方法呼叫轉到原始物件上，靜態代理特征是代理類和目標物件的類都是在編譯期間確定下來，不利于程式的擴展，同時，每一個代理類只能為一個介面服務，這樣一來程式開發中必然產生過多的代理，最好可以通過一個代理類完成全部的代理功能，
動態代理是指客戶通過代理類來呼叫其它物件的方法，并且是在程式運行時根據需要動態創建目標類的代理物件，
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
* @Author: Yeman
* @Date: 2021-10-03-19:33
* @Description:
*/
interface Human {
String getBelief();
void eat(String food);
}
//某被代理類
class superMan implements Human {
@Override
public String getBelief() {
return "I believe the light!";
}
@Override
public void eat(String food) {
System.out.println("吃" + food);
}
}
//動態代理類
class ProxyFactory {
//呼叫此方法，回傳一個代理類的物件
public static Object getProxyInstance(Object obj){ //obj即為被代理類
MyInvocationHandle handle = new MyInvocationHandle();
handle.bind(obj); //將被代理類告知
return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(),handle);
}
}
//用來實作呼叫代理類物件的方法時候呼叫對應的被代理類物件中的同名同參方法
class MyInvocationHandle implements InvocationHandler {
private Object obj; //被代理類的物件
public void bind(Object obj){
this.obj = obj;
}
//當代理類的物件呼叫方法a時，就會自動地呼叫如下的方法
//將被代理類要執行的方法a的功能宣告在invoke()中
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//method：即為代理類物件呼叫的方法，此方法也就作為了被代理類物件呼叫的方法
//obj：被代理類的物件
return method.invoke(obj,args);
}
}
public class ProxyTest {
public static void main(String[] args) {
superMan superMan = new superMan();
Human proxyInstance = (Human) ProxyFactory.getProxyInstance(superMan); //代理類物件
String belief = proxyInstance.getBelief(); //當代理類物件呼叫方法時，呼叫的是被代理里中同名同參方法
System.out.println(belief);
proxyInstance.eat("火鍋");
}
}
Proxy ：專門完成代理的操作類，是所有動態代理類的父類，通過此類為一個或多個介面動態地生成實作類，
提供用于創建動態代理類和動態代理物件的靜態方法：
動態代理步驟：
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/305444.html
標籤：java