好了, 下面進(jìn)入今天的主題, 前幾個月有幸參加了CSDN組織的MDCC移動開發(fā)者大會, 一天下來我最大的收獲就是了解到了模塊化開發(fā), 回來之后我就一直在思考模塊化的一些優(yōu)點, 不說別的, 提供一種可插拔的開發(fā)方式就足夠我們興奮一會了~ 接下來自己開始嘗試了一些小demo, 發(fā)現(xiàn)在模塊化開發(fā)中最大的問題就是組件間通訊, 例如: 在模塊化架構(gòu)中, 商城和個人中心分別是兩個獨立的模塊, 在開發(fā)階段, 個人中心如何想要跳轉(zhuǎn)商城的某個頁面咋辦? 這里就需要引入一個路由的概念了. 做過web開發(fā)的都知道, 在大部分web框架中url路由也是框架中很重要的組成部分, 如果大家對路由的概念還不是很清楚, 可以先來看一下我這篇 go web開發(fā)之url路由設(shè)計來了解下路由的概念, 這里稍稍解釋一下路由就是起到一個轉(zhuǎn)發(fā)的作用.

一張圖來體會一下路由的作用, 因為我本地沒有UML工具, 新的還在下載中… 900M+, 我這網(wǎng)速有點受不了. 所以我選擇KolourPaint手動繪制一張具有魔性的圖片先來體會一下.

自己實現(xiàn)一個路由的動機

那到了我們Android開發(fā)中呢? 如果我們把項目模塊化了, 那兩個組件間進(jìn)行通訊或者跳轉(zhuǎn), 我們一般構(gòu)建Intent的方式就不再使用了, 很簡單, 因為在模塊A中根本找不到模塊B中的C類, 這就需要我們自定義路由規(guī)則, 繞一道彎去進(jìn)行跳轉(zhuǎn), 說白了就是給你的類起一個別名, 我們用別用去引用. 其實在我準(zhǔn)備自己去實現(xiàn)一個路由的時候我是google了一些解決方案的, 這些方案大致可分為兩種.

1. 完全自己實現(xiàn)路由, 完全封裝跳轉(zhuǎn)參數(shù)
2. 利用隱式意圖跳轉(zhuǎn)

對于這兩種方式我總結(jié)了一下, 個人認(rèn)為第一種方式封裝的太多, 甚至有些框架是RESTFul like的, 這樣的封裝一是學(xué)習(xí)成本太高, 二是舊項目改動起來太麻煩. 那第二種方式呢? 利用隱式意圖是一種不錯的選擇, 而且Android原生支持, 這也是大家在嘗試模塊化開發(fā)時的一個選擇, 不過這種方式僅支持Activity, Service, BroadcastReceiver, 擴展性太差. 綜上因素, 我還是決定自己實現(xiàn)一個路由, 參考自上面的局限性, 我們的路由具有一下2個特點.

1. 上手簡單, 目標(biāo)是與原生方式一行代碼之差就能實現(xiàn)Activity, Service, BroadcastReceiver調(diào)用.
2. 擴展性強, 開發(fā)者可以任意添加自己的路由實現(xiàn), 不僅僅局限于Activity, Service, BroadcastReceiver.

體驗一下

在了解具體實現(xiàn)代碼之前, 我們先來了解一下新的路由怎么使用, 使用起來是不是符合上面兩點, 首先我們先建立三個moduler, 分別是殼app, 商城模塊shoplib, bbs模塊bbslib. app模塊就是我們的殼了, 我們需要利用app模塊去打包, 而且app也是依賴shoplib和bbslib的, 所以我們可以在app的application里進(jìn)行路由的注冊.

public class App extends Application {

    @Override
    public void onCreate() {
        super.onCreate();
        setupRouter();
    }

    private void setupRouter() {
        Router.router(ActivityRule.ACTIVITY_SCHEME + "shop.main", ShopActivity.class);
        Router.router(ActivityRule.ACTIVITY_SCHEME + "bbs.main", BBSActivity.class);
    }
}

這里注冊了兩個路由, 分別是商城模塊的的ShopActivity和bbs模塊的BBSActivity, 它們都是通過 Router 類的靜態(tài)方法 router 方法進(jìn)行注冊的, 兩個參數(shù), 第一個參數(shù)是路由地址(也可以理解成別名), 第二個參數(shù)對應(yīng)的類. 注冊完了, 那接下來就是如何使用了, 我們來看看在商城模塊如何跳轉(zhuǎn)BBS模塊吧.

public class ShopActivity extends AppCompatActivity {

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        TextView tv = new TextView(this);
        tv.setTextSize(50);
        tv.setText("SHOP!!!");
        setContentView(tv);

        tv.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent it = Router.invoke(ShopActivity.this, ActivityRule.ACTIVITY_SCHEME + "bbs.main");
                startActivity(it);
            }
        });
    }
}

主要代碼是在click事件里, 我們調(diào)用了 Router.invoke 方法, 第一個參數(shù)是當(dāng)前Activity, 第二個參數(shù)就是我們前面注冊的路由了, 這里都很好理解, 關(guān)鍵是看它的返回值, 這里直接返回了一個Intent, 這一點是最棒的~ 返回Intent也就是說明下面的代碼和我們使用原生方式?jīng)]有任何區(qū)別! 這一點符合上面我們說到的 上手簡單 的目的.

至于第二點目標(biāo), 高擴展性 , 大家可以實現(xiàn) Rule 接口自定義路由Rule, 然后調(diào)用 Router.addRule(String scheme, Rule rule) 方法進(jìn)行路由規(guī)則的注冊. Rule接口的定義如下,

/**
 * 路由規(guī)則接口<br/>
 * Created by qibin on 2016/10/8.
 */

public interface Rule<T, V> {
    /**
     * 添加路由
     * @param pattern 路由uri
     * @param klass 路由class
     */
    void router(String pattern, Class<T> klass);

    /**
     * 路由調(diào)用
     * @param ctx Context
     * @param pattern 路由uri
     * @return {@code V} 返回對應(yīng)的返回值
     */
    V invoke(Context ctx, String pattern);
}

解釋一下, 首先是Rule接口的兩個范型, 第一個T是我們注冊的路由類型, 例如前面使用的Activity類型, 第二個V是 invoke 方法的返回值類型, 例如前面使用的Intent類型.至于自定義的代碼, 這里我賴了~, 沒有提供demo~~~ 大家可以嘗試自定義一下.

路由實現(xiàn)代碼

接下來我們開始進(jìn)入實現(xiàn)代碼環(huán)節(jié)~ 在來是代碼之前, 還是先來一張圖了解下這個 Router 的結(jié)構(gòu).

帶著上面的圖片, 我們來看代碼, 首先我們來看看Router類, 畢竟我們在使用的時候都是在和Router打交道.

/**
 * Usage: <br />
 * <pre>
 * step 1. 調(diào)用Router.router方法添加路由
 * step 2. 調(diào)用Router.invoke方法根據(jù)pattern調(diào)用路由
 * </pre>
 * Created by qibin on 2016/10/9.
 */

public class Router {

    /**
     * 添加自定義路由規(guī)則
     * @param scheme 路由scheme
     * @param rule 路由規(guī)則
     * @return {@code RouterInternal} Router真實調(diào)用類
     */
    public static RouterInternal addRule(String scheme, Rule rule) {
        RouterInternal router = RouterInternal.get();
        router.addRule(scheme, rule);
        return router;
    }

    /**
     * 添加路由
     * @param pattern 路由uri
     * @param klass 路由class
     * @return {@code RouterInternal} Router真實調(diào)用類
     */
    public static <T> RouterInternal router(String pattern, Class<T> klass) {
        return RouterInternal.get().router(pattern, klass);
    }

    /**
     * 路由調(diào)用
     * @param ctx Context
     * @param pattern 路由uri
     * @return {@code V} 返回對應(yīng)的返回值
     */
    public static <V> V invoke(Context ctx, String pattern) {
        return RouterInternal.get().invoke(ctx, pattern);
    }
}

哈, Router的代碼很簡單, 主要就是起到一個類似靜態(tài)代理的作用, 主要的代碼還是在 RouterInternal 里, 那來看看 RouterInternal 的結(jié)構(gòu)吧.

public class RouterInternal {

    private static RouterInternal sInstance;

    /** scheme->路由規(guī)則 */
    private HashMap<String, Rule> mRules;

    private RouterInternal() {
        mRules = new HashMap<>();
        initDefaultRouter();
    }

    /**
     * 添加默認(rèn)的Activity，Service，Receiver路由
     */
    private void initDefaultRouter() {
        addRule(ActivityRule.ACTIVITY_SCHEME, new ActivityRule());
        addRule(ServiceRule.SERVICE_SCHEME, new ServiceRule());
        addRule(ReceiverRule.RECEIVER_SCHEME, new ReceiverRule());
    }

    /*package */ static RouterInternal get() {
        if (sInstance == null) {
            synchronized (RouterInternal.class) {
                if (sInstance == null) {
                    sInstance = new RouterInternal();
                }
            }
        }

        return sInstance;
    }
}

首先 RouterInternal 是一個單例, 一個 mRules 變量用來保存我們的路由規(guī)則, 在構(gòu)造中我們注冊了三個默認(rèn)的路由規(guī)則, 這三個路由規(guī)則想都不用想就知道是Activity, Service和BroadcastReceiver的. 接下來看看其他的方法.

/**
 * 添加自定義路由規(guī)則
 * @param scheme 路由scheme
 * @param rule 路由規(guī)則
 * @return {@code RouterInternal} Router真實調(diào)用類
 */
public final RouterInternal addRule(String scheme, Rule rule) {
    mRules.put(scheme, rule);
    return this;
}

addRule 方法是添加路由規(guī)則的實現(xiàn), 這里我們是直接向 mRules 這個 HashMap 中添加的.

private <T, V> Rule<T, V> getRule(String pattern) {
    HashMap<String, Rule> rules = mRules;
    Set<String> keySet = rules.keySet();
    Rule<T, V> rule = null;
    for (String scheme : keySet) {
        if (pattern.startsWith(scheme)) {
            rule = rules.get(scheme);
            break;
        }
    }

    return rule;
}

getRule 的作用是根據(jù) pattern 來獲取規(guī)則, 這是一個私有的方法, 所以在使用的時候不需要關(guān)心, 它的原理很簡單, 就是根據(jù)你的 pattern 來匹配 scheme 來獲取對應(yīng)的 Rule .

/**
 * 添加路由
 * @param pattern 路由uri
 * @param klass 路由class
 * @return {@code RouterInternal} Router真實調(diào)用類
 */
public final <T> RouterInternal router(String pattern, Class<T> klass) {
    Rule<T, ?> rule = getRule(pattern);
    if (rule == null) {
        throw new NotRouteException("unknown", pattern);
    }

    rule.router(pattern, klass);
    return this;
}

這個 router 方法就是我們添加路由的實現(xiàn)了, 首先我們根據(jù)路由的uri來獲取對應(yīng)的 Rule , 然后調(diào)用該 Rule 的 router 方法, 至于 Rule.router 方法如何實現(xiàn)的, 我們稍后看~

/**
 * 路由調(diào)用
 * @param ctx Context
 * @param pattern 路由uri
 * @return {@code V} 返回對應(yīng)的返回值
 */
/*package*/ final <V> V invoke(Context ctx, String pattern) {
    Rule<?, V> rule = getRule(pattern);
    if (rule == null) {
        throw new NotRouteException("unknown", pattern);
    }

    return rule.invoke(ctx, pattern);
}

invoke 方法就是我們調(diào)用的時候執(zhí)行的代碼的, 返回值 T 是返回的 Rule 范型中指定的類型, 例如前面的 Intent .

綜上代碼, 我們發(fā)現(xiàn) RouterInternal 其實就是一個管理 Rule 的類, 具體的調(diào)用還是在各個 Rule 中實現(xiàn), 上面提到過, Rule 是一個接口, 它具有兩個范型, 分別對應(yīng)的調(diào)用 invoke 的返回值類型和我們要路由的類的類型. 解析來我們就來看看默認(rèn)的幾個路由規(guī)則是如何實現(xiàn)的.

對于Activity, Service, BroadcastReceiver的調(diào)用, 總結(jié)了一下, 它們其實都是返回的 Intent 類型, 所以我們可以先構(gòu)建一個指定返回值是 Intent 的Base類型.

/**
 * 返回Intent的路由規(guī)則的基類<br />
 * Created by qibin on 2016/10/9.
 */

public abstract class BaseIntentRule<T> implements Rule<T, Intent> {

    private HashMap<String, Class<T>> mIntentRules;

    public BaseIntentRule() {
        mIntentRules = new HashMap<>();
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public void router(String pattern, Class<T> klass) {
        mIntentRules.put(pattern, klass);
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public Intent invoke(Context ctx, String pattern) {
        Class<T> klass = mIntentRules.get(pattern);
        if (klass == null) { throwException(pattern);}
        return new Intent(ctx, klass);
    }

    /**
     * 當(dāng)找不到路由規(guī)則時拋出異常
     * @param pattern 路由pattern
     */
    public abstract void throwException(String pattern);
}

router 方法不多說, 還是向 Map 中添加鍵值對, invoke 方法, 我們通過參數(shù)中的 pattern 從 mIntentRules 目標(biāo)類, 然后構(gòu)建一個 Intent 返回, 最后一個 throwException 是一個抽象方法, 用來在調(diào)用沒有 router 的類時拋出異常用~, 可以發(fā)現(xiàn), 其實大部分的實現(xiàn)在這里都實現(xiàn)了, 對于Activity繼承這個 BaseIntentRule ,并且指定要路由類的類型是Activity, 并且實現(xiàn) throwException 方法就可以了.

/**
 * activity路由規(guī)則<br />
 * Created by qibin on 2016/10/8.
 */

public class ActivityRule extends BaseIntentRule<Activity> {

    /** activity路由scheme*/
    public static final String ACTIVITY_SCHEME = "activity://";

    /**
     * {@inheritDoc}
     */
    @Override
    public void throwException(String pattern) {
        throw new ActivityNotRouteException(pattern);
    }
}

ActivityRule 首先繼承了 BaseIntentRule 并指定了范型是 Activity , 實現(xiàn)的 throwException 方法也很簡單, 就是拋出了一個 ActivityNotRouteException 異常, 對于這個異常, 大家可以在文章最后的源碼下載部分找到~ 看完 ActivityRule 的實現(xiàn), 其實其他兩個默認(rèn) Rule 的實現(xiàn)都一樣了~ 大家也是自己去看代碼吧.

其實實現(xiàn)一個路由很簡單, 原理就是給我們要路由的類定義一個別名, 然后在調(diào)用的地方通過別名去調(diào)用. 而且在封裝的時候盡量要符合現(xiàn)在用戶的使用習(xí)慣, 不要過多的封裝而忽略了使用者的感受.

 

來自：http://blog.csdn.net/qibin0506/article/details/53373412

 

標(biāo)簽： Google 代碼 開發(fā)者

版權(quán)申明：本站文章部分自網(wǎng)絡(luò)，如有侵權(quán)，請聯(lián)系：west999com@outlook.com
特別注意：本站所有轉(zhuǎn)載文章言論不代表本站觀點！
本站所提供的圖片等素材，版權(quán)歸原作者所有，如需使用，請與原作者聯(lián)系。