Android路由實現

vcrs0792 8年前發布 | 17K 次閱讀安卓開發 Android開發移動開發

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

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

自己實現一個路由的動機

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

完全自己實現路由, 完全封裝跳轉參數
利用隱式意圖跳轉

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

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

體驗一下

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

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 類的靜態方法 router 方法進行注冊的, 兩個參數, 第一個參數是路由地址(也可以理解成別名), 第二個參數對應的類. 注冊完了, 那接下來就是如何使用了, 我們來看看在商城模塊如何跳轉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事件里, 我們調用了 Router.invoke 方法, 第一個參數是當前Activity, 第二個參數就是我們前面注冊的路由了, 這里都很好理解, 關鍵是看它的返回值, 這里直接返回了一個Intent, 這一點是最棒的~ 返回Intent也就是說明下面的代碼和我們使用原生方式沒有任何區別! 這一點符合上面我們說到的 上手簡單 的目的.

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

/**
 * 路由規則接口<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);

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

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

路由實現代碼

接下來我們開始進入實現代碼環節~ 在來是代碼之前, 還是先來一張圖了解下這個 Router 的結構.

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

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

public class Router {

    /**
     * 添加自定義路由規則
     * @param scheme 路由scheme
     * @param rule 路由規則
     * @return {@code RouterInternal} Router真實調用類
     */
    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真實調用類
     */
    public static <T> RouterInternal router(String pattern, Class<T> klass) {
        return RouterInternal.get().router(pattern, klass);
    }

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

哈, Router的代碼很簡單, 主要就是起到一個類似靜態代理的作用, 主要的代碼還是在 RouterInternal 里, 那來看看 RouterInternal 的結構吧.

public class RouterInternal {

    private static RouterInternal sInstance;

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

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

    /**
     * 添加默認的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 變量用來保存我們的路由規則, 在構造中我們注冊了三個默認的路由規則, 這三個路由規則想都不用想就知道是Activity, Service和BroadcastReceiver的. 接下來看看其他的方法.

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

addRule 方法是添加路由規則的實現, 這里我們是直接向 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 的作用是根據 pattern 來獲取規則, 這是一個私有的方法, 所以在使用的時候不需要關心, 它的原理很簡單, 就是根據你的 pattern 來匹配 scheme 來獲取對應的 Rule .

/**
 * 添加路由
 * @param pattern 路由uri
 * @param klass 路由class
 * @return {@code RouterInternal} Router真實調用類
 */
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 方法就是我們添加路由的實現了, 首先我們根據路由的uri來獲取對應的 Rule , 然后調用該 Rule 的 router 方法, 至于 Rule.router 方法如何實現的, 我們稍后看~

/**
 * 路由調用
 * @param ctx Context
 * @param pattern 路由uri
 * @return {@code V} 返回對應的返回值
 */
/*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 方法就是我們調用的時候執行的代碼的, 返回值 T 是返回的 Rule 范型中指定的類型, 例如前面的 Intent .

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

對于Activity, Service, BroadcastReceiver的調用, 總結了一下, 它們其實都是返回的 Intent 類型, 所以我們可以先構建一個指定返回值是 Intent 的Base類型.

/**
 * 返回Intent的路由規則的基類<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);
    }

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

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

/**
 * activity路由規則<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 , 實現的 throwException 方法也很簡單, 就是拋出了一個 ActivityNotRouteException 異常, 對于這個異常, 大家可以在文章最后的源碼下載部分找到~ 看完 ActivityRule 的實現, 其實其他兩個默認 Rule 的實現都一樣了~ 大家也是自己去看代碼吧.

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

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

本文由用戶 vcrs0792 自行上傳分享，僅供網友學習交流。所有權歸原作者，若您的權利被侵害，請聯系管理員。

轉載本站原創文章，請注明出處，并保留原始鏈接、圖片水印。

本站是一個以用戶分享為主的開源技術平臺，歡迎各類分享！

本文地址：http://www.baiduhome.net/lib/view/open1480318618689.html

安卓開發 Android開發移動開發

Android路由實現

自己實現一個路由的動機

體驗一下

路由實現代碼

相關經驗

相關資訊

相關文檔

目錄