相關(guān)文章：
Android APT 系列 （一）：APT 筑基之反射
https://juejin.cn/post/6977679823132950536
什么是反射？
簡(jiǎn)單來(lái)講谒主，反射就是：已知一個(gè)類(lèi)朝扼，可以獲取這個(gè)類(lèi)的所有信息
一般情況下，根據(jù)面向?qū)ο蠓庋b原則霎肯，Java實(shí)體類(lèi)的屬性都是私有的擎颖，我們不能獲取類(lèi)中的屬性。但我們可以根據(jù)反射观游，獲取私有變量搂捧、方法、構(gòu)造方法懂缕，注解允跑，泛型等等，非常的強(qiáng)大
注意：Google在 Android 9.0及之后對(duì)反射做了限制搪柑，被使用 @hide標(biāo)記的屬性和方法通過(guò)反射拿不到
反射使用
//包路徑
package com.dream.aptdemo;
//自定義注解1
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface CustomAnnotation1{
}
//自定義注解2
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface CustomAnnotation2{
}
//自定義注解3
@Target(ElementType.TYPE)
@Inherited
@Retention(RetentionPolicy.RUNTIME)
@interface CustomAnnotation3{
}
//接口
interface ICar {
void combine();
}
//車(chē)
@CustomAnnotation3
class Car<K,V> {
private String carDesign = "設(shè)計(jì)稿";
public String engine = "發(fā)動(dòng)機(jī)";
public void run(long kilometer) {
System.out.println("Car run " + kilometer + " km");
}
}
//==============================上面這些都是為下面這臺(tái)奔馳服務(wù)的??===========================
//奔馳
@CustomAnnotation1
@CustomAnnotation2
class Benz extends Car<String,Integer> implements ICar {
private String carName = "奔馳";
public String carColor = "白色";
public Benz() {
}
private Benz(String carName) {
this.carName = carName;
}
public Benz(String carName, String carColor) {
this.carName = carName;
this.carColor = carColor;
}
@Override
public void combine() {
System.out.println("組裝一臺(tái)奔馳");
}
private void privateMethod(String params){
System.out.println("我是私有方法: " + params);
}
}
類(lèi)
獲取類(lèi)
3 種方式去獲取類(lèi)對(duì)象
1）Benz.class：類(lèi)獲取
2）benz.getClass：對(duì)象獲取
3）Class.forName：靜態(tài)獲取
Benz benz = new Benz();
Class benzClass = Benz.class;
Class benzClass1 = benz.getClass();
Class benzClass2 = Class.forName("com.dream.aptdemo.Benz");
注意：
1聋丝、在一個(gè)JVM中，一種類(lèi)拌屏，只會(huì)有一個(gè)類(lèi)對(duì)象存在潮针。所以以上三種方式取出來(lái)的類(lèi)對(duì)象，都是一樣的倚喂。
2、無(wú)論哪種途徑獲取類(lèi)對(duì)象瓣戚，都會(huì)導(dǎo)致靜態(tài)屬性被初始化端圈，而且只會(huì)執(zhí)行一次。（除了直接使用Benz.class類(lèi)獲取這種方式子库，這種方式不會(huì)導(dǎo)致靜態(tài)屬性被初始化）
獲取類(lèi)名
String className = benzClass.getSimpleName();
System.out.println(className);
//打印結(jié)果
Benz
獲取類(lèi)路徑
String classPath1 = benzClass.getName();
String classPath2 = benzClass.getCanonicalName();
System.out.println(classPath1);
System.out.println(classPath2);
//打印結(jié)果
com.pf.reflect.Benz
com.pf.reflect.Benz
這里可能大家會(huì)有個(gè)疑問(wèn)：benzClass.getName()和 benzClass.getCanonicalName()有啥區(qū)別嗎舱权？
從上面打印結(jié)果來(lái)看，沒(méi)啥區(qū)別仑嗅，但是如果我們?cè)?code>Benz這個(gè)里面加個(gè)內(nèi)部類(lèi)宴倍，然后獲取內(nèi)部類(lèi)的路徑，你就會(huì)看到區(qū)別了：
//...
class Benz extends Car implements ICar {
//...
class InnerClass{
}
}
Class<Benz.InnerClass> innerClass = Benz.InnerClass.class;
System.out.println(innerClass.getName());
System.out.println(innerClass.getCanonicalName());
//打印結(jié)果
com.pf.reflect.Benz$InnerClass
com.pf.reflect.Benz.InnerClass
獲取父類(lèi)名
String fatherClassName = benzClass.getSuperclass().getSimpleName();
System.out.println(fatherClassName);
//打印結(jié)果
Car
獲取接口
Class[] interfaces = benzClass.getInterfaces();
for (Class anInterface : interfaces) {
System.out.println(anInterface.getName());
}
//打印結(jié)果
com.pf.reflect.inter.ICar
創(chuàng)建實(shí)例對(duì)象
//獲取構(gòu)造方法
Constructor constructor = benzClass.getDeclaredConstructor();
//創(chuàng)建實(shí)例
Benz myBenz = (Benz) constructor.newInstance();
//修改屬性
myBenz.carColor = "黑色";
myBenz.combine();
System.out.println(myBenz.carColor);
//打印結(jié)果
組裝一臺(tái)奔馳
黑色
注意：下面要講的關(guān)于帶Declare 的屬性和方法和不帶Declare 區(qū)別：
1仓技、帶Declare 的屬性和方法獲取的是本類(lèi)所有的屬性和方法鸵贬，不包含繼承得來(lái)的
2、不帶Declare的屬性和方法獲取的是所有public修飾的屬性和方法脖捻，包含繼承得來(lái)的
3阔逼、訪問(wèn)private 修飾的屬性和方法，需調(diào)用 setAccessible設(shè)置為true地沮，表示允許我們?cè)L問(wèn)私有變量
屬性
獲取單個(gè)屬性
Field carName = benzClass.getDeclaredField("carName");
獲取多個(gè)屬性
//獲取本類(lèi)全部屬性
Field[] declaredFields = benzClass.getDeclaredFields();
for (Field declaredField : declaredFields) {
System.out.println("屬性: " + declaredField.getName());
}
//打印結(jié)果
屬性: carName
屬性: carColor
//獲取本類(lèi)及父類(lèi)全部 public 修飾的屬性
Field[] fields = benzClass.getFields();
for (Field field : fields) {
System.out.println("屬性: " + field.getName());
}
//打印結(jié)果
屬性: carColor
屬性: engine
設(shè)置允許訪問(wèn)私有變量
carName.setAccessible(true);
獲取屬性名
System.out.println(carName.getName());
//打印結(jié)果
carName
獲取變量類(lèi)型
System.out.println(carName.getType().getName());
//打印結(jié)果
java.lang.String
獲取對(duì)象中該屬性的值
System.out.println(carName.get(benz));
//打印結(jié)果
奔馳
給屬性設(shè)置值
carName.set(benz,"sweetying");
System.out.println(carName.get(benz));
//打印結(jié)果
sweetying
方法
獲取單個(gè)方法
//獲取 public 方法
Method publicMethod = benzClass.getMethod("combine");
//獲取 private 方法
Method privateMethod = benzClass.getDeclaredMethod("privateMethod",String.class);
獲取多個(gè)方法
//獲取本類(lèi)全部方法
Method[] declaredMethods = benzClass.getDeclaredMethods();
for (Method declaredMethod : declaredMethods) {
System.out.println("方法名: " + declaredMethod.getName());
}
//打印結(jié)果
方法名: privateMethod
方法名: combine
//獲取本類(lèi)及父類(lèi)全部 public 修飾的方法
Method[] methods = benzClass.getMethods();
for (Method method : methods) {
System.out.println("方法名: " + method.getName());
}
//打印結(jié)果 因?yàn)樗蓄?lèi)默認(rèn)繼承 Object , 所以打印了 Object 的一些方法
方法名: combine
方法名: run
方法名: wait
方法名: wait
方法名: wait
方法名: equals
方法名: toString
方法名: hashCode
方法名: getClass
方法名: notify
方法名: notifyAll
方法調(diào)用
Method privateMethod = benzClass.getDeclaredMethod("privateMethod",String.class);
privateMethod.setAccessible(true);
privateMethod.invoke(benz,"接收傳入的參數(shù)");
//打印結(jié)果
我是私有方法: 接收傳入的參數(shù)
構(gòu)造方法
獲取單個(gè)構(gòu)造方法
//獲取本類(lèi)單個(gè)構(gòu)造方法
Constructor declaredConstructor = benzClass.getDeclaredConstructor(String.class);
//獲取本類(lèi)單個(gè) public 修飾的構(gòu)造方法
Constructor singleConstructor = benzClass.getConstructor(String.class,String.class);
獲取多個(gè)構(gòu)造方法
//獲取本類(lèi)全部構(gòu)造方法
Constructor[] declaredConstructors = benzClass.getDeclaredConstructors();
for (Constructor declaredConstructor1 : declaredConstructors) {
System.out.println("構(gòu)造方法: " + declaredConstructor1);
}
//打印結(jié)果
構(gòu)造方法: public com.dream.aptdemo.Benz()
構(gòu)造方法: public com.dream.aptdemo.Benz(java.lang.String,java.lang.String)
構(gòu)造方法: private com.dream.aptdemo.Benz(java.lang.String)
//獲取全部 public 構(gòu)造方法, 不包含父類(lèi)的構(gòu)造方法
Constructor[] constructors = benzClass.getConstructors();
for (Constructor constructor1 : constructors) {
System.out.println("構(gòu)造方法: " + constructor1);
}
//打印結(jié)果
構(gòu)造方法: public com.dream.aptdemo.Benz()
構(gòu)造方法: public com.dream.aptdemo.Benz(java.lang.String,java.lang.String)
構(gòu)造方法實(shí)例化對(duì)象
//以上面 declaredConstructor 為例
declaredConstructor.setAccessible(true);
Benz declareBenz = (Benz) declaredConstructor.newInstance("");
System.out.println(declareBenz.carColor);
//打印結(jié)果
白色
//以上面 singleConstructor 為例
Benz singleBenz = (Benz) singleConstructor.newInstance("奔馳 S ","香檳金");
System.out.println(singleBenz.carColor);
//打印結(jié)果
香檳金
泛型
獲取父類(lèi)的泛型
Type genericType = benzClass.getGenericSuperclass();
if (genericType instanceof ParameterizedType) {
Type[] actualType = ((ParameterizedType) genericType).getActualTypeArguments();
for (Type type : actualType) {
System.out.println(type.getTypeName());
}
}
//打印結(jié)果
java.lang.String
java.lang.Integer
注解
獲取單個(gè)注解
//獲取單個(gè)本類(lèi)或父類(lèi)注解
Annotation annotation1 = benzClass.getAnnotation(CustomAnnotation1.class);
System.out.println(annotation1.annotationType().getSimpleName());
Annotation annotation3 = benzClass.getAnnotation(CustomAnnotation3.class);
System.out.println(annotation3.annotationType().getSimpleName());
//打印結(jié)果
CustomAnnotation1
CustomAnnotation3
//獲取單個(gè)本類(lèi)注解
Annotation declaredAnnotation1 = benzClass.getDeclaredAnnotation(CustomAnnotation2.class);
System.out.println(declaredAnnotation1.annotationType().getSimpleName());
//打印結(jié)果
CustomAnnotation2
獲取全部注解
//獲取本類(lèi)和父類(lèi)的注解(父類(lèi)的注解需用 @Inherited 表示可被繼承)
Annotation[] annotations = benzClass.getAnnotations();
for (Annotation annotation : annotations) {
System.out.println("注解名稱(chēng): " + annotation.annotationType().getSimpleName());
}
//打印結(jié)果
注解名稱(chēng): CustomAnnotation3
注解名稱(chēng): CustomAnnotation1
注解名稱(chēng): CustomAnnotation2
//獲取本類(lèi)的注解
Annotation[] declaredAnnotations = benzClass.getDeclaredAnnotations();
for (Annotation declaredAnnotation : declaredAnnotations) {
System.out.println("注解名稱(chēng): " + declaredAnnotation.annotationType().getSimpleName());
}
//打印結(jié)果
注解名稱(chēng): CustomAnnotation1
注解名稱(chēng): CustomAnnotation2
反射實(shí)踐
需求大概就是：通過(guò)后臺(tái)配置下發(fā)嗜浮，完成 App 業(yè)務(wù)功能的切換羡亩。因?yàn)橹皇悄M，我們這里就以通過(guò)讀取本地配置文件完成 App 業(yè)務(wù)功能的切換：
首先準(zhǔn)備兩個(gè)業(yè)務(wù)類(lèi)危融，假設(shè)他們的功能都很復(fù)雜
//包名
package com.dream.aptdemo;
//業(yè)務(wù)1
class Business1 {
public void doBusiness1Function(){
System.out.println("復(fù)雜業(yè)務(wù)功能1");
}
}
//業(yè)務(wù)2
class Business2 {
public void doBusiness2Function(){
System.out.println("復(fù)雜業(yè)務(wù)功能2");
}
}
非反射方式
public class Client {
@Test
public void test() {
//業(yè)務(wù)功能1
new Business1().doBusiness1Function();
}
}
假設(shè)這個(gè)時(shí)候需要從第一個(gè)業(yè)務(wù)功能切換到第二個(gè)業(yè)務(wù)功能畏铆，使用非反射方式，必須修改代碼吉殃，并且重新編譯運(yùn)行及志，才可以達(dá)到效果。那么我們可以通過(guò)反射去通過(guò)讀取配置從而完成功能的切換寨腔，這樣我們就不需要修改代碼且代碼變得更加通用
反射方式
首先準(zhǔn)備一個(gè)配置文件速侈，如下圖：
配置文件截圖.png
讀取配置文件，反射創(chuàng)建實(shí)例并調(diào)用方法
public class Client {
@Test
public void test() throws Exception {
try {
//獲取文件
File springConfigFile = new File("/Users/zhouying/AndroidStudioProjects/AptDemo/config.txt");
//讀取配置
Properties config= new Properties();
config.load(new FileInputStream(springConfigFile));
//獲取類(lèi)路徑
String classPath = (String) config.get("class");
//獲取方法名
String methodName = (String) config.get("method");
//反射創(chuàng)建實(shí)例并調(diào)用方法
Class aClass = Class.forName(classPath);
Constructor declaredConstructor = aClass.getDeclaredConstructor();
Object o = declaredConstructor.newInstance();
Method declaredMethod = aClass.getDeclaredMethod(methodName);
declaredMethod.invoke(o);
} catch (Exception e) {
e.printStackTrace();
}
}
}
完成上面兩步后迫卢，后續(xù)我們就只需要修改配置文件就能完成 App 業(yè)務(wù)功能的切換了
