歡迎光臨
每天分享高質量文章

以Arouter為例談談學習開源框架的最佳姿勢

作者:[email protected]

鏈接:https://blog.csdn.net/Alexwll/article/details/85466069

 

以Arouter為例談談學習開源框架的最佳姿勢。

概述

得益於眾多專案和第三方庫的開源,開發中使用幾行代碼即可實現複雜的功能,但使用只是原始碼庫的搬運工,原始碼中真正牛逼的技術並不屬於我們,所以對原始碼和開源庫的學習成了Android開發者提升技能的必經之路,筆者也曾經認真學習了常用開源框架的原理和實現。

足以在開發和麵試中的問題,就此以為掌握了原始碼(有沒有同道?),直到有一天自己去編寫庫,當面對框架設計、任務調度、任務併發、執行緒切換、快取、檔案等系列問題時,才發現自己的不足,也在反思自己的學習深度;

其實框架中很多知識和代碼都是經過時間的驗證和優化過的,如:Glide的快取、okhttp攔截實現、Retrofit的註解等,其細節完全可以幫助解決開發中的類似問題,原始碼的思想固然重要,但細節優秀的實現同樣不容忽視,這裡給出筆者總結的開源框架的學習方法:

 

1、瞭解開源框架的作用

2、掌握框架的使用方法

3、分析框架的工作原理

4、分析框架原始碼的架構和實現

5、深入框架細節分析功能模塊的實現

6、總結收穫

1、ARouter 作用

談起Arouter便不得不說組件化,隨著專案的發展,開發的功能模塊增多,專案和團隊都會逐漸增大,即使分包和版本管理做的再好,還是無法避免在開發過程中所面臨的問題:

 

  • 開發過程中編譯和修改的過程中會變得更加複雜,編譯事件明顯變長

  • 整個專案為一個整體,代碼牽一發而動全身,專案的維護難度將會增大;

  • 伴隨開發團隊也會增加,嚴重耦合的代碼和業務造成衝突不斷,極大降低開發效率

為瞭解決這些問題組件化應運而生,相信組件化的使用和優勢開發者深有體會,它很針對性的解決了以上問題:

 

  • 組件可以獨立開發、編譯除錯,縮短編譯時間提高開發效率

  • 組件間的解耦和代碼的隔離,使功能模塊和開發團隊之間互不影響

但世界上沒有絕對完美的事,它帶來方便的同時也帶來了一個問題:

 

  • 組件解耦、代碼隔離的同時也阻斷了彼此的通信

那麼實現組件間通信變成了首要要解決的問題,Android原生雖然可以實現脫離界面實現導航的目的,但真實使用時發現代碼嚴重耦合,違背了我們組件化的目的,那麼有沒有一種簡單易管理的通信方案呢?ARouter就是為此誕生,這裡借用官方關於原生和路由的對比圖:

 

 

關於ARouter的介紹這裡提供一個官方的演講內容:

 

Android平臺頁面路由框架ARouter

https://yq.aliyun.com/articles/71687

2、ARouter的使用簡介

知道了框架的作用,下麵自然就是看看如何去使用,本文側重於框架的原始碼和執行流程,不詳細介紹框架的使用,因為下麵分析原始碼的需要,這裡只給出界面跳轉使用,詳細使用方法可以閱讀Arouter的專案介紹:

 

ARouter專案地址

https://github.com/alibaba/ARouter

1、實現界面跳轉:根據跳轉的功能需求,ARouter提供以下界面跳轉方法

普通界面跳轉

 

ARouter.getInstance()
.build("/login/activity")
.navigation()

攜帶Key—Value引數傳遞

 

//ARouter提供withString()方法,引數傳入對應的Key、Value
 ARouter.getInstance().build("/login/activity")
                 .withString("Name""USer")
                 .withInt("Age"10)
                 .navigation()

//使用Autowired註解自動轉換,引數name為傳遞引數的Key(當變數名和Key相同時可不設置name)
@Autowired(name = "Name")
@JvmField var name : String? = null
@Autowired(name = "Age")
@JvmField var age = 0

3、ARouter工作原理

ARouter的工作流程圖

 

一行代碼就搞定了組件間的通信,是不是充滿了疑惑和期待?

下麵看看這一行代碼究竟如何路由起來的?本文的分析基於編寫的組件化Demo中的ARouter的使用,這裡不對它的編寫和使用做介紹,只分析它編譯生成的檔案和執行流程進行分析,本篇以Activity執行為例分析原始碼,先看一下專案的結構和編譯生成的檔案:

 

專案結構:包含base、app、login、share、componenbase組件

編譯檔案:編譯生成routes和modularization包

 

 

Android組件化Demo

https://github.com/AlexTiti/Modularization

3.1、ARouter執行流程

 

由上面使用知道,界面的路由跳轉有一行代碼完成,那流程的分析也就從這行神奇的代碼開始:

 

ARouter.getInstance()
.build("/login/activity")
.navigation()

 

build(String path)

ARouter.getInstance()單利獲取ARouter實體,在ARouter.build()方法中使橋接樣式將任務交給_ARouter的build()方法,方法中重點的就是最後一句話,直接呼叫build()創建PostCard實體:

 

//_ARouter.build()
protected Postcard build(String path, String group{
    if (TextUtils.isEmpty(path) || TextUtils.isEmpty(group)) {
        throw new HandlerException(Consts.TAG + "Parameter is invalid!");
    } else { ......}
        return new Postcard(path, group);//創建PostCard儲存路徑和group
    }
}

PostCard.navigation():build()方法只創建了一個PostCard實體,貌似所有的任務都留給了navigation:

 

protected Object navigation(final Context context, final Postcard postcard, final int requestCode, final NavigationCallback callback) {
    try {
        LogisticsCenter.completion(postcard);//執行複雜的解析和配置
    } catch (NoRouteFoundException ex) {......}
        if (null != callback) {
            callback.onLost(postcard);//如果回呼Callback不為null,回呼onLast()
        } 
    ......
    if (!postcard.isGreenChannel()) { //如果沒有設置綠色通道,要回呼事件攔截
    ......
    } else {
        return _navigation(context, postcard, requestCode, callback);
    }
    return null;
}

整個流程執行到這裡,好像就做了三件事,但這三件事卻完成了整個的導航過程:

 

1、在build()中創建PostCard實體儲存路徑

2、呼叫complete()方法解析postCard

3、呼叫_navigation()執行界面的跳轉

LogisticsCenter.completion(postcard)

在看詳細的代碼之前,先介紹下原始碼中出現的RouteMeta和Warehouse兩個類,很容易看出這兩個類都是儲存資料的類:

1、RouteMeta:儲存每個跳轉信息,如:路徑、group、RouteType、優先級、引數等信息

2、Warehouse:主要在初始化時快取註解的Activity、IProvider、IInterceptor,主要用於快取所有的路由信息

 

class Warehouse {
    //儲存group對應的IRouteGroup檔案類
    static Map<String, Class extends

 IRouteGroup>> groupsIndex = new HashMap<>();
//儲存路徑path對應的RouteMeta信息
static Map<String, RouteMeta> routes = new HashMap<>();
//儲存IProvider信息
static Map providers = new HashMap<>();
static Map<String, RouteMeta> providersIndex = new HashMap<>();
//儲存攔截器IInterceptor信息
static Mapextends IInterceptor>> interceptorsIndex = new UniqueKeyTreeMap<>(“More than one interceptors use same priority [%s]”);
static List interceptors = new ArrayList<>();
}

下麵查看completion(Postcard postcard)解析的代碼:

 

public synchronized static void completion(Postcard postcard{
    RouteMeta routeMeta = Warehouse.routes.get(postcard.getPath()); // 根據路徑從Warehouse.routes中獲取RouteMeta
    if (null == routeMeta) { //若未獲取實體,根據設置的group組獲取groupMeta
        Class extends IRouteGroup> groupMeta = Warehouse.groupsIndex.get(postcard.getGroup());  
        if (null == groupMeta) { //若沒有獲取到分組則跑出異常
            throw new NoRouteFoundException(TAG + "There is no route match the path [" + postcard.getPath() + "], in group [" + postcard.getGroup() + "]");
        } else {
            try {
                IRouteGroup iGroupInstance = groupMeta.getConstructor().newInstance();//反射創建實體
                iGroupInstance.loadInto(Warehouse.routes); //呼叫lodaInfo()將信息加載到Warehouse.groupsIndex中
                Warehouse.groupsIndex.remove(postcard.getGroup());
            } catch (Exception e) {
                throw new HandlerException(TAG + "Fatal exception when loading group meta. [" + e.getMessage() + "]");
            }
            completion(postcard);   // 在第一次根據path獲取為空後會根據group添加,添加之後會再次獲取
        }
    } else {
        postcard.setDestination(routeMeta.getDestination()); //設置postcard資料
        postcard.setType(routeMeta.getType());
        postcard.setPriority(routeMeta.getPriority());
        postcard.setExtra(routeMeta.getExtra());
    }
}

上面代碼註釋很清楚,completion()方法主要是根據初始化時加載的group組,去加載要導航的RouteMeta信息,這裡採用按需加載的方式,先只初始化快取每個group對應的類檔案,然後在第一次執行跳轉時才初始化每個group中所有路徑的信息並快取在Warehouse中,避免了在開始時初始化太多的問題,簡單來說就是執行三步:

 

1、根據路徑path獲取標的註解的RouteMeta,如果未獲取則根據group去查詢當前組編譯生成的類檔案

2、反射呼叫類檔案的loadInto()加載所有註解信息到Warehouse.routes中

3、初始化Warehouse.routes後,再次加載查詢RouteMeta信息並設置跳轉的PostCard

到這裡我們先提出第一個疑問:

 

Warehouse.groupsIndex中的資料是在什麼時候加載的?從哪加載的?

_navigation(context, postcard, requestCode, callback):最終完成Activity的啟動

 

private Object _navigation(final Context context, final Postcard postcard, final int requestCode, final NavigationCallback callback) {
    final Context currentContext = null == context ? mContext : context;

    switch (postcard.getType()) {
        case ACTIVITY: //如果PostCard的目的是Activity,使用Intent啟動Activity
            final Intent intent = new Intent(currentContext, postcard.getDestination());
            intent.putExtras(postcard.getExtras());
            int flags = postcard.getFlags();
            if (-1 != flags) {
                intent.setFlags(flags);
            } else if (!(currentContext instanceof Activity)) {    // Non activity, need less one flag.
                intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
            }
            String action = postcard.getAction();
            if (!TextUtils.isEmpty(action)) {
                intent.setAction(action);
            }
            runInMainThread(new Runnable() {
                @Override
                public void run() {
                    startActivity(requestCode, currentContext, intent, postcard, callback);
                }
            });
            break;
    }
    return null;
}

從_navogation()執行中看出,Activity的啟動過程和平時使用的一樣,最終也是創建Intent,執行startActivity()完成的,到這裡整個執行的流程就結束了,所執行的步驟和邏輯也很容易理解;

 

3.2、ARouter的初始化

 

在上面分析的過程中,我們提出了一個疑問就是Warehouse.groupsIndex的初始化問題,上面查看Warehouse類中知道Warehouse.groupsIndex儲存的是group對應的生成類,現在看看Arouter的初始化;

 

初始化使用

 

ARouter.init(this)

初始化流程

 

//呼叫init()方法初始化
public static void init(Application application) {
    if (!hasInit) {//設置標誌確保只會初始化一次
        hasInit = _ARouter.init(application);//橋接樣式呼叫_ARouter.init()
        if (hasInit) {
            _ARouter.afterInit();
        }
    }
}

//_ARouter.init()
protected static synchronized boolean init(Application application) {
    LogisticsCenter.init(mContext, executor);//真正執行初始化的地方
    hasInit = true;
    return true;
}

ARouter初始化和執行邏輯一樣,都是橋接樣式直接交給_ARouter處理,在ARouter方法中使用了LogisticsCenter.init()方法,所以初始化的所有過程都是在LogisticsCenter.init()中完成的;

 

LogisticsCenter.init(mContext, executor)

 

public static final String ROUTE_ROOT_PAKCAGE="com.alibaba.android.arouter.routes";

public synchronized static void init(Context context, ThreadPoolExecutor tpe) throws HandlerException {
try {Set routerMap;
 routerMap = ClassUtils.getFileNameByPackageName(mContext, ROUTE_ROOT_PAKCAGE);
//掃描指定包下麵的所有ClassName
            for (String className : routerMap) {//遍歷HashSet反射加載配置檔案
                if (className.startsWith(ROUTE_ROOT_PAKCAGE + DOT + SDK_NAME + SEPARATOR + SUFFIX_ROOT)) {
//如果是Root就呼叫loadInto,將IRouteGroup類加載到Warehouse.groupsIndex中,這裡採用按需加載先只加載到group
                    ((IRouteRoot) (Class.forName(className).getConstructor().newInstance())).loadInto(Warehouse.groupsIndex);
                } else if (className.startsWith(ROUTE_ROOT_PAKCAGE + DOT + SDK_NAME + SEPARATOR + SUFFIX_INTERCEPTORS)) {
//如果是Intercept,將IInterceptorGroup類添加到Warehouse.interceptorsIndex中
                    ((IInterceptorGroup) (Class.forName(className).getConstructor().newInstance())).loadInto(Warehouse.interceptorsIndex);
                } else if (className.startsWith(ROUTE_ROOT_PAKCAGE + DOT + SDK_NAME + SEPARATOR + SUFFIX_PROVIDERS)) {
//如果是Provider,將IInterceptorGroup類添加到Warehouse.providersIndex中
                    ((IProviderGroup) (Class.forName(className).getConstructor().newInstance())).loadInto(Warehouse.providersIndex);
            }
        }
    } catch (Exception e) {
        throw new HandlerException(TAG + "ARouter init logistics center exception! [" + e.getMessage() + "]");
    }
}

上面執行的代碼註釋很清楚,執行方法如下:

 

1、首先掃面com.alibaba.android.arouter.routes包下的所有檔案,並將信息儲存在routerMap中

2、遍歷routerMap()中所有儲存的所有類

3、根據className使用反射分別呼叫alibaba包下的loadInto()方法,將生成的IRouteRoot檔案中每個組對應的檔案儲存在Warehouse.groupsIndex中,IInterceptorGroup和IProviderGroup的加載方式也一樣

在(Class.forName(className).getConstructor().newInstance())).loadInto(Warehouse.groupsIndex)的引數中看到了Warehouse.groupsIndex,點擊類中方法查看:

 

//rootApp 儲存app組對應的ARouter$$Group$$app類
public class ARouter$$Root$$app implements IRouteRoot {
  @Override
  public void loadInto(Map<String, Class extends

 IRouteGroup>> routes) {
routes.put(“app”, ARouter$$Group$$app.class);
}
}

loadInto()是把方法中的資料儲存到傳入的引數中,到這裡上面提的第一個疑問也解釋清楚了,Warehouse.groupsIndex的加載過程是在初始化的時候執行的,現在我們在回頭總結一下真個ARouter的整個執行流程:

 

1、在ARouter初始化時,呼叫init()反射獲取alibaba包下的所有類,並呼叫類中的loadInto()將信息儲存在Warehouse中

2、呼叫ARouter.getInstance().build(“/login/activity”)方法,傳入路徑path

3、呼叫_ARouter的build()根據傳入的path、group創建Postcard實體

4、呼叫_ARouter的navigation()方法發送導航請求,根據path、group從Warehouse中獲取儲存信息的RouteMeta

5、呼叫_navigation()方法,根據PostCard的標的Type創建或啟動標的

這裡提出兩個疑問:

1、ARouter$ $Root$ $app 是如何產生的?

2、IRouteRoot是什麼?為什麼實現它?(答案其實已經體現)

4、ARouter原始碼架構和實現

上面ARouter的初始化和工作過程都介紹完畢,知道了整個ARouter的工作流程,但卻有幾個疑問:

 

@Route、@Autowired、@Interceptor註解如何起作用?如何和Activity等系結在一起?

帶著這幾個問題,也帶著對編寫框架的期待,一起分析ARouter組件框架的編寫,原始碼分為arouter-annotation、arouter-api、arouter-compiler三部分,下麵依次看看每個部分的功能和實現:

 

4.1、annotation:宣告ARouter使用的Route、Autowired、Interceptor註解(本文分析以Route為例)

 

Route註解:標記專案中Activity、IProvider的路由路徑,在使用時按照路徑導航加載對應的界面

 

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.CLASS)
public @interface Route {
    String path();  // 宣告路由地址
    String group() default “"// 宣告路由組
    String name() default “”;  // 宣告名稱
    int extras() default Integer.MIN_VALUE; 
    int priority() default -1;  // 宣告路由等級
}

4.2、arouter-compiler

 

implementation 'com.google.auto.service:auto-service:1.0-rc3'
implementation 'com.squareup:javapoet:1.8.0'

 

看到上面的引入就知道,ARouter框架使用APT和javapoet技術,根據註解自動生成代碼,我們常用的框架中很多都有這個技術的身影,關於這兩點點擊以下連接查看:

 

Java反射、註解

https://blog.csdn.net/Alexwll/article/details/82842460

Java註解代碼生成

https://blog.csdn.net/Alexwll/article/details/82852377

以Route註解生成為例,由上面的例子知道Route註解最後生成了RouterApp和GroupApp兩個類,具體代碼如下:

 

//groupApp 儲存路徑path對應的RouteMeta信息
public class ARouter$$Group$$app implements IRouteGroup {
  @Override
  public void loadInto(Map<String, RouteMeta> atlas) {
    atlas.put("/app/webActivity", RouteMeta.build(RouteType.ACTIVITY, WebActivity.class"/app/webactivity""app"new java.util.HashMap<String, Integer>(){{put("url"8); }}, -1-2147483648));
  }
}

這裡提出第四個疑問:

 

IRouteGroup是什麼?為什麼也實現它?

 

Route生成兩個類的過程

 

連接APT技術的都知道,框架編寫的主要內容就在process(Set extends TypeElement> annotations, RoundEnvironment roundEnv)中,它生成類檔案的所有代碼,ARouter的process中直接呼叫了parseRoutes()進行代碼編寫:

 

parseRoutes(Set extends Element> routeElements)

 

//創建Group類中方法的引數型別:Map
ParameterizedTypeName inputMapTypeOfGroup = ParameterizedTypeName.get(
        ClassName.get(Map.class),
        ClassName.get(String.class),
        ClassName.get(RouteMeta.class)
);

//創建loadInto方法中的引數名稱
ParameterSpec groupParamSpec = ParameterSpec.builder(inputMapTypeOfGroup, "atlas").build();

//創建loadInto方法
MethodSpec.Builder loadIntoMethodOfRootBuilder = MethodSpec.methodBuilder(METHOD_LOAD_INTO)
        .addAnnotation(Override.class)
        .addModifiers(PUBLIC)
        .addParameter(rootParamSpec);

上面代碼在APT在編寫的框架中很常見,代碼也只做了一件事:創建生成類檔案中的loadInto()方法;

 

迴圈解析所有的註解類:獲取每個註解的信息儲存到Route實體中

 

//迴圈遍歷所有註解
for (Element element : routeElements) {
TypeMirror tm = element.asType();  //獲取註解型別
Route route = element.getAnnotation(Route.class); //獲取註解的Route.class
if (types.isSubtype(tm, type_Activity)) {  //根據註解型別分別處理,已Activity為例
  routeMeta = new RouteMeta(route, element, RouteType.ACTIVITY, paramsType);//創建 RouteMeta儲存屬性值和屬性信息
   categories(routeMete) //解析儲存所有信息的routeMeta
    }
}

categories(RouteMeta routeMete):將RouteMeta實體儲存到groupMap中

 

//1、將每個創建的RouteMeta儲存在 Set中,然後將Set以group為健儲存在groupMap中
private void categories(RouteMeta routeMete{
    if (routeVerify(routeMete)) {
        Set routeMetas = groupMap.get(routeMete.getGroup());//判斷是否儲存過次Group組
        if (CollectionUtils.isEmpty(routeMetas)) {
            Set routeMetaSet = new TreeSet<>(new Comparator() {......});
            routeMetaSet.add(routeMete);   //將routeMete添加到結合routeMetaSet中
            groupMap.put(routeMete.getGroup(), routeMetaSet);//將routeMetaSet使用group為鍵儲存到groupMap中
        } else {
            routeMetas.add(routeMete); 
        }
    } else {
    }
}

上面執行代碼見註釋,簡單來說就是將相同group組註解的信息儲存在Set中,然後以group為鍵將set集合儲存到groupMap中,現在所有的註解信息都儲存在groupMap中,接下來你應該想到了就是遍歷groupMap,生成方法中對應的代碼陳述句,那下麵接著看parseRoutes()原始碼:

 

//遍歷groupMap,將其中的每個group組添加初始化代碼
for (Map.Entry<StringSet> entry : groupMap.entrySet()) {
    String groupName = entry.getKey();

//迴圈遍歷group對應的每個Set中儲存的元素,為每個元素添加一行加載的代碼
Set groupData = entry.getValue();
for (RouteMeta routeMeta : groupData) {
。。。。。。
loadIntoMethodOfGroupBuilder.addStatement(
        "atlas.put($S, $T.build($T." + routeMeta.getType() + ", $T.class, $S, $S, " + (StringUtils.isEmpty(mapBody) ? null : ("new java.util.HashMap(){{" + mapBodyBuilder.toString() + "}}")) + ", " + routeMeta.getPriority() + ", " + routeMeta.getExtra() + "))",
        routeMeta.getPath(),
        routeMetaCn,
        routeTypeCn,
        className,
        routeMeta.getPath().toLowerCase(),
        routeMeta.getGroup().toLowerCase());
}

//儲存每個group和對應的檔案名
    String groupFileName = NAME_OF_GROUP + groupName;
    rootMap.put(groupName, groupFileName); //rootMap儲存每個組對應生成的檔案類名
}

//遍歷rootMap在root類中的loadInto()方法中添加每個組的執行陳述句
if (MapUtils.isNotEmpty(rootMap)) {
    for (Map.Entry<StringString> entry : rootMap.entrySet()) {
//添加每個group對應loadInto()方法中的代碼  routes.put("app", ARouter$$Group$$app.class);
        loadIntoMethodOfRootBuilder.addStatement("routes.put($S, $T.class)", entry.getKey(), ClassName.get(PACKAGE_OF_GENERATE_FILE, entry.getValue()));//儲存每個Group組類
    }
}

上面的代碼是從原始碼中抽取出來的部分主要代碼,短短的代碼中出現了三個for迴圈,這裡每個迴圈就是在添加代碼陳述句:

 

1、第一個迴圈從groupMap中獲取每個group組對應的Set集合

2、從Set集合中遍歷每個RouteMeta,並創建loadInto()方法中的陳述句,並將每個group生成的類儲存在rootMap中

3、遍歷root Map中的元素,添加Root類的loadInto()方法中的陳述句

到這裡我們按照瞭解一個框架的順序,分析了整個框架的編寫和執行過程,上面所提出的第二個問題也找到了答案,這裡總結一下:

 

1、在使用時為標的的Activity添加@Route註解

2、編譯時使用APT根據註解信息生成Root和Group類及其中的方法體

3、在初始化時反射將root類中的所有group信息,加載到Warehouse中

4、在使用navigation中導航時,從Warehouse中加載並獲取註解信息

5、從註解信息中獲取標的Activity,從而呼叫startActivity實現界面跳轉

5、深入框架細節

上面從整體的角度瞭解了框架的原始碼和執行,這個過程對於你瞭解、使用和學習框架來說至關重要,相信走到這一步的人很多,但相信停在這一步的更多;到此已經可以說你熟悉或掌握了這個框架的原理,但學習去沒有結束,如果想真正成為開發框架的人,可能更重要的兩步是:細節和總結;

 

5.1、攔截器

 

攔截器原始碼生成

 

for (Element element : elements) {
    if (verify(element)) { 
        Interceptor interceptor = element.getAnnotation(Interceptor.class);
        Element lastInterceptor = interceptors.get(interceptor.priority());
        if (null != lastInterceptor) { 
            throw new IllegalArgumentException( //這裡當兩個攔截起設置相同的優先級時回觸發異常(在哪理按照優先級運算?)
                    String.format(Locale.getDefault(), "More than one interceptors use same priority [%d], They are [%s] and [%s].",
                            interceptor.priority(),
                            lastInterceptor.getSimpleName(),
                            element.getSimpleName())
            );
        }
        interceptors.put(interceptor.priority(), element); //儲存資料
    } 
}

攔截起原始碼的生成和上面Root、Group的流程一樣,儲存每個攔截器的註解,然後編譯生成類檔案,值得註意的是攔截器的優先級不能相同否則丟擲異常,因為儲存註解的鍵就是設置的優先級;

 

攔截器的初始化:在ARouter初始化時將所有的信息儲存在Warehouse.interceptorsIndex中,然後遍歷初始化所有的攔截器並快取在Warehouse.interceptors中

 

IInterceptor iInterceptor = interceptorClass.getConstructor().newInstance();
iInterceptor.init(context); //初始化每個IInterceptor
Warehouse.interceptors.add(iInterceptor);

攔截器執行

 

CancelableCountDownLatch interceptorCounter = new CancelableCountDownLatch(Warehouse.interceptors.size());
interceptorCounter.await(postcard.getTimeout(), TimeUnit.SECONDS);//呼叫鎖鎖住當前執行緒

if (index             IInterceptor iInterceptor = Warehouse.interceptors.get(index);
            iInterceptor.process(postcard, new InterceptorCallback() {//執行每個執行緒的process()
                @Override
                public void onContinue(Postcard postcard{
                    counter.countDown(); //呼叫鎖 -1
                    _excute(index + 1, counter, postcard);  //迴圈遞迴呼叫
                }
                @Override
                public void onInterrupt(Throwable exception{
                    postcard.setTag(null == exception ? new HandlerException("No message.") : exception.getMessage());
                    counter.cancel();//攔截事件
                }
            });
        }

使用CountDownLatch鎖住當前執行緒,然後使用執行緒池遞迴執行所有攔截器的process()方法,當所有攔截器執行完畢後繼續執行呼叫執行緒;

 

5.2、Autowired引數解析

 

在使用使用方法提到ARouter攜帶引數跳轉時,只需要在標的Activity的屬性中添加@Autowired註解,即可實現屬性的自動賦值,在原始碼中關於@Autowired的註解編譯過程和@Route一樣,具體細節在原始碼中查看,這裡直接給出生成的類:

 

public class WebActivity$$ARouter$$Autowired implements ISyringe {
  private SerializationService serializationService;

  @Override
  public void inject(Object target) {
    serializationService = ARouter.getInstance().navigation(SerializationService.class);
    WebActivity substitute = (WebActivity)target;
    substitute.url = substitute.getIntent().getStringExtra("url”);  //呼叫getIntent()為屬性負值
  }
}

從類中的inject()直接看出資料的賦值也是使用getIntent()實現的,那麼此方法在何時被呼叫的呢?其實在使用指南中介紹,使用引數註解時要在onCreate中添加:ARouter.getInstance().inject(this);正是這個初始化了資料的複製;在_ARouter.inject()中直接呼叫了AutowiredService的實現類:

 

static void inject(Object thiz{
    AutowiredService autowiredService = ((AutowiredService) ARouter.getInstance().build("/arouter/service/autowired").navigation());
    if (null != autowiredService) {
        autowiredService.autowire(thiz);//呼叫autowire方法
    }
}

看到這是不是感覺有點意思,在框架中就使用框架!作者的設計巧妙啊!下麵根據路徑找到實現類的autowire方法:

 

String className = instance.getClass().getName();  //獲取當前類名 
ISyringe autowiredHelper = classCache.get(className); //判斷快取是否含有
if (null == autowiredHelper) { 
 autowiredHelper = (ISyringe) Class.forName(instance.getClass().getName() + SUFFIX_AUTOWIRED).getConstructor().newInstance();//按照規則生成編譯檔案名,並反射創建實體}
autowiredHelper.inject(instance); //呼叫inject()傳入Activity實體
classCache.put(className, autowiredHelper);  //快取反射的實體

autowire方法根據傳入的Activity,獲取生成的檔案類,反射呼叫其中的inject()進行資料的賦值,這個有沒有給你點啟發呢?有沒有想到ButterKnife呢?

 

5.3、PathReplaceService

 

PathReplaceService用於在程式執行過程中動態的修改路由或實現重定向功能,它的使用也很簡單直接實現PathReplaceService接口重寫其中方法即可,其實在_ARouter.build()方法有幾句代碼上面沒有貼出,首先會使用路由獲取實現接口的子類,呼叫其中方法修改傳遞的path,後面所有的過程都是在新的路徑上執行:

 

PathReplaceService pService = ARouter.getInstance().navigation(PathReplaceService.class);
if (null != pService) {
    path = pService.forString(path);
}

 

5.4、DegradeService

 

在路由執行過程中,可能會因為路由地址錯誤而找不到標的,從而引起整個跳轉的失敗,如果我們想所有的失敗都顯示固定的界面,此時就可以使用DegradeService實現頁面的降級問題,其實也是一種完全意義的重定向:

 

try {
    LogisticsCenter.completion(postcard);
} catch (NoRouteFoundException ex) {

    if (null != callback) {
        callback.onLost(postcard);  //如果設置回呼呼叫回呼方法
    } else { 
        DegradeService degradeService = ARouter.getInstance().navigation(DegradeService.class); //獲取設置的重定向實體
        if (null != degradeService) {
            degradeService.onLost(context, postcard); // 呼叫重定向的方法
        }
    }
    return null;
}

在呼叫navigation()時,如果沒有找到Route註解對應的類,則會丟擲異常,捕獲到異常後執行兩個選擇:

 

1、如果設置跳轉監聽,則會掉callback.onLost()

2、如果未設置回呼,使用路由獲取DegradeService的實現並呼叫onLost()重新執行跳轉

6、總結收穫

分析完整個原始碼執行和編寫後,有沒有自己的收穫和心得呢?

如果讓你來寫或者以後會遇到同樣的需求是否能實現同樣的功能呢?

哪些細節實現值得我們借鑒呢?

 

下麵我們就總結一下本篇原始碼的收穫與思考,細節都在原始碼當中這裡只列出幾點:

 

如何使用APT和javapoet技術編寫原始碼

相信很多人都已經掌握此項技術,上面的連接也提供學習內容

如何掃描指定包下的檔案

生成的類屬於不同的包和類,如何集中管理他們?如何初始化?(本條也是回答上面的問題)

1、答案就是分別實現了IRouteGroup或IRouteRoot接口,這樣所有的生成類就都是接口的實現類

2、初始化時只需根據類名反射獲取接口實體,反射呼叫方法即可

如何避免初始化問題?

 

1、採用按需加載的方式,避免初始化過於繁重;ARouter執行如下:

2、這裡將每個group組的所有路由信息儲存在一個類中,比如類A、B、C分別對應3個組

3、將group生成的類A、B、C,分別以鍵值對形式儲存在Map中

4、當第一次使用某個group時,找到Map中儲存的類,呼叫類中方法快取同組的資料

攔截器處理

1、使用CountDownLatch阻塞呼叫執行緒,然後遞迴呼叫所有的攔截器方法,最後喚醒執行緒

2、此處有沒有想到okhttp的攔截器呢?它是如何讓實現呢?

重定向和降級

這裡使用實現接口的方式,通過路由獲取實體,在程式執行時統一管理,是不是有點類似AOP?如果使用AOP如何實現呢?

相信每一篇原始碼中都會有很多優秀的細節,如果我們能一點點積累起來,相信一定能更快的提升自己,這是筆者重新審視原始碼學習的第一篇,後面有時間會針對過去學過的開源框架,從不同的角度對比分析細節的實現,希望可以提高自己開發框架的能力!

赞(0)

分享創造快樂