前言

很高興遇見(jiàn)你~

這又是一個(gè)新的系列，靈感來(lái)源于最近做的一次布局優(yōu)化，我們知道：Android 中少量的系統(tǒng)控件是通過(guò) new 的方式創(chuàng)建出來(lái)的，而大部分控件如 androidx.appcompat.widget 下的控件，自定義控件，第三方控件等等，都是通過(guò)反射創(chuàng)建的。大量的反射創(chuàng)建多多少少會(huì)帶來(lái)一些性能問(wèn)題，因此我們需要去解決反射創(chuàng)建的問(wèn)題，我的解決思路是：

1、通過(guò)編寫(xiě) Android 插件獲取 Xml 布局中的所有控件

2、拿到控件后，通過(guò) APT 生成用 new 的方式創(chuàng)建 View 的類

3、最后通過(guò)反射獲取當(dāng)前類并在基類里面完成替換

一個(gè)小小的布局優(yōu)化，涉及的東西還挺多的，Android 插件我們后續(xù)在講，話說(shuō) Gradle 系列目前只更了一篇，別急，后面都會(huì)有的。我們這個(gè)系列主要是講 APT，而講 APT ，我們必須先了解兩個(gè)重點(diǎn)知識(shí)：注解和反射

今天就重點(diǎn)來(lái)介紹下反射

Github Demo 地址 , 大家可以看 Demo 跟隨我的思路一起分析

一、什么是反射？

簡(jiǎn)單來(lái)講，反射就是：已知一個(gè)類，可以獲取這個(gè)類的所有信息

一般情況下，根據(jù)面向?qū)ο蠓庋b原則，Java 實(shí)體類的屬性都是私有的，我們不能獲取類中的屬性。但我們可以根據(jù)反射，獲取私有變量、方法、構(gòu)造方法，注解，泛型等等，非常的強(qiáng)大

注意：Google 在 Android 9.0 及之后對(duì)反射做了限制，被使用 @hide 標(biāo)記的屬性和方法通過(guò)反射拿不到

二、反射使用

下面給出一段已知的代碼，我們通過(guò)實(shí)踐來(lái)對(duì)反射進(jìn)行講解：

//包路徑
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();
}

//車
@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);
    }
}

下面所講到的都是關(guān)于反射一些常用的 Api

三、類

我們可以通過(guò) 3 種方式去獲取類對(duì)象：

1）、Benz.class ：類獲取

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 中，一種類，只會(huì)有一個(gè)類對(duì)象存在。所以以上三種方式取出來(lái)的類對(duì)象，都是一樣的。

2、無(wú)論哪種途徑獲取類對(duì)象，都會(huì)導(dǎo)致靜態(tài)屬性被初始化，而且只會(huì)執(zhí)行一次。（除了直接使用 Benz.class 類獲取這種方式，這種方式不會(huì)導(dǎo)致靜態(tài)屬性被初始化）

下面的流程會(huì)經(jīng)常使用到 benz 實(shí)例和 benzClass 類對(duì)象

4）、獲取類名

String className = benzClass.getSimpleName();
System.out.println(className);

//打印結(jié)果
Benz

5）、獲取類路徑

String classPath1 = benzClass.getName();
String classPath2 = benzClass.getCanonicalName();
System.out.println(classPath1);
System.out.println(classPath2);
//打印結(jié)果
com.dream.aptdemo.Benz
com.dream.aptdemo.Benz

這里可能大家會(huì)有個(gè)疑問(wèn)：benzClass.getName() 和 benzClass.getCanonicalName() 有啥區(qū)別嗎？

從上面打印結(jié)果來(lái)看，沒(méi)啥區(qū)別，但是如果我們?cè)?Benz 這個(gè)里面加個(gè)內(nèi)部類，然后獲取內(nè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.dream.aptdemo.Benz$InnerClass
com.dream.aptdemo.Benz.InnerClass

看到區(qū)別了吧，因此我們可以得到結(jié)論：在正常情況下，getCanonicalName和 getName 獲取到的都是包含路徑的類名。但內(nèi)部類有點(diǎn)特殊，getName 獲取的是路徑.類名$內(nèi)部類

6）、獲取父類名

String fatherClassName = benzClass.getSuperclass().getSimpleName();
System.out.println(fatherClassName);
//打印結(jié)果
Car

7）、獲取接口

Class[] interfaces = benzClass.getInterfaces();
for (Class anInterface : interfaces) {
    System.out.println(anInterface.getName());
}
//打印結(jié)果
com.dream.aptdemo.ICar

8）、創(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)的

2、不帶 Declare 的屬性和方法獲取的是所有 public 修飾的屬性和方法，包含繼承得來(lái)的

3、訪問(wèn) private 修飾的屬性和方法，需調(diào)用 setAccessible 設(shè)置為 true ，表示允許我們?cè)L問(wèn)私有變量

四、屬性

1）、獲取單個(gè)屬性

Field carName = benzClass.getDeclaredField("carName");

2）、獲取多個(gè)屬性

//獲取本類全部屬性
Field[] declaredFields = benzClass.getDeclaredFields();
for (Field declaredField : declaredFields) {
    System.out.println("屬性: " + declaredField.getName());
}
//打印結(jié)果
屬性: carName
屬性: carColor

//獲取本類及父類全部 public 修飾的屬性
Field[] fields = benzClass.getFields();
for (Field field : fields) {
    System.out.println("屬性: " + field.getName());
}
//打印結(jié)果
屬性: carColor
屬性: engine

3）、設(shè)置允許訪問(wèn)私有變量

carName.setAccessible(true);

4）、獲取屬性名

System.out.println(carName.getName());
//打印結(jié)果
carName

5）、獲取變量類型

System.out.println(carName.getType().getName());
//打印結(jié)果
java.lang.String

6）、獲取對(duì)象中該屬性的值

System.out.println(carName.get(benz));
//打印結(jié)果
奔馳

7）、給屬性設(shè)置值

carName.set(benz,"sweetying");
System.out.println(carName.get(benz));
//打印結(jié)果
sweetying

五、方法

1）、獲取單個(gè)方法

//獲取 public 方法
Method publicMethod = benzClass.getMethod("combine");

//獲取 private 方法
Method privateMethod = benzClass.getDeclaredMethod("privateMethod",String.class);

2）、獲取多個(gè)方法

//獲取本類全部方法
Method[] declaredMethods = benzClass.getDeclaredMethods();
for (Method declaredMethod : declaredMethods) {
    System.out.println("方法名: " + declaredMethod.getName());
}
//打印結(jié)果
方法名: privateMethod
方法名: combine

//獲取本類及父類全部 public 修飾的方法
Method[] methods = benzClass.getMethods();
for (Method method : methods) {
    System.out.println("方法名: " + method.getName());
}
//打印結(jié)果 因?yàn)樗蓄惸J(rèn)繼承 Object , 所以打印了 Object 的一些方法
方法名: combine
方法名: run
方法名: wait
方法名: wait
方法名: wait
方法名: equals
方法名: toString
方法名: hashCode
方法名: getClass
方法名: notify
方法名: notifyAll

3）、方法調(diào)用

Method privateMethod = benzClass.getDeclaredMethod("privateMethod",String.class);
privateMethod.setAccessible(true);
privateMethod.invoke(benz,"接收傳入的參數(shù)");
//打印結(jié)果
我是私有方法: 接收傳入的參數(shù)

六、構(gòu)造方法

1）、獲取單個(gè)構(gòu)造方法

//獲取本類單個(gè)構(gòu)造方法
Constructor declaredConstructor = benzClass.getDeclaredConstructor(String.class);

//獲取本類單個(gè) public 修飾的構(gòu)造方法
Constructor singleConstructor = benzClass.getConstructor(String.class,String.class);

2）、獲取多個(gè)構(gòu)造方法

//獲取本類全部構(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)造方法, 不包含父類的構(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)

3）、構(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é)果
香檳金

七、泛型

1）、獲取父類的泛型

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

八、注解

1）、獲取單個(gè)注解

//獲取單個(gè)本類或父類注解
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è)本類注解
Annotation declaredAnnotation1 = benzClass.getDeclaredAnnotation(CustomAnnotation2.class);
System.out.println(declaredAnnotation1.annotationType().getSimpleName());
//打印結(jié)果
CustomAnnotation2

2）、獲取全部注解

//獲取本類和父類的注解(父類的注解需用 @Inherited 表示可被繼承)
Annotation[] annotations = benzClass.getAnnotations();
for (Annotation annotation : annotations) {
    System.out.println("注解名稱: " + annotation.annotationType().getSimpleName());
}
//打印結(jié)果
注解名稱: CustomAnnotation3
注解名稱: CustomAnnotation1
注解名稱: CustomAnnotation2

//獲取本類的注解
Annotation[] declaredAnnotations = benzClass.getDeclaredAnnotations();
for (Annotation declaredAnnotation : declaredAnnotations) {
    System.out.println("注解名稱: " + declaredAnnotation.annotationType().getSimpleName());
}
//打印結(jié)果
注解名稱: CustomAnnotation1
注解名稱: CustomAnnotation2

通過(guò)上面的講解，我們把反射大部分知識(shí)點(diǎn)都講完了，可以說(shuō)反射是非常的強(qiáng)大，但是學(xué)習(xí)了之后，你可能會(huì)不知道該如何使用，反而覺(jué)得還不如直接調(diào)用方法來(lái)的直接和方便，下面我們通過(guò)實(shí)踐來(lái)感受一下。

九、反射實(shí)踐

需求大概就是：通過(guò)后臺(tái)配置下發(fā)，完成 App 業(yè)務(wù)功能的切換。因?yàn)橹皇悄M，我們這里就以通過(guò)讀取本地配置文件完成 App 業(yè)務(wù)功能的切換：

1）、首先準(zhǔn)備兩個(gè)業(yè)務(wù)類，假設(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");
    }
}

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ò)讀取配置從而完成功能的切換，這樣我們就不需要修改代碼且代碼變得更加通用

3）、反射方式

1、首先準(zhǔn)備一個(gè)配置文件，如下圖：

2、讀取配置文件，反射創(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));
            //獲取類路徑
            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();
        }
    }
}

3、完成上面兩步后，后續(xù)我們就只需要修改配置文件就能完成 App 業(yè)務(wù)功能的切換了

十、總結(jié)

本篇文章講的一些重點(diǎn)內(nèi)容：

1、反射常用 Api 的使用，注意在訪問(wèn)私有屬性和方法時(shí)，調(diào)用 setAccessible 設(shè)置為 true ，表示允許我們?cè)L問(wèn)私有變量

2、實(shí)踐通過(guò)反射完成 App 業(yè)務(wù)功能的切換

好了，本篇文章到這里就結(jié)束了，希望能給你帶來(lái)幫助 ??

感謝你閱讀這篇文章

下篇預(yù)告

下篇文章我會(huì)講注解，敬請(qǐng)期待吧