关闭

Android路由实现

标签: android
12513人阅读 评论(46) 收藏 举报
分类:

本文已授权微信公众号:鸿洋(hongyangAndroid)在微信公众号平台原创首发。

前几个月有幸参加了CSDN组织的MDCC移动开发者大会, 一天下来我最大的收获就是了解到了模块化开发, 回来之后我就一直在思考模块化的一些优点, 不说别的, 提供一种可插拔的开发方式就足够我们兴奋一会了~ 接下来自己开始尝试了一些小demo, 发现在模块化开发中最大的问题就是组件间通讯, 例如: 在模块化架构中, 商城和个人中心分别是两个独立的模块, 在开发阶段, 个人中心如何想要跳转商城的某个页面咋办? 这里就需要引入一个路由的概念了. 做过web开发的都知道, 在大部分web框架中url路由也是框架中很重要的组成部分, 如果大家对路由的概念还不是很清楚, 可以先来看一下我这篇go web开发之url路由设计来了解下路由的概念, 这里稍稍解释一下路由就是起到一个转发的作用.
一张图来体会一下路由的作用, 因为我本地没有UML工具, 新的还在下载中… 900M+, 我这网速有点受不了. 所以我选择KolourPaint手动绘制一张具有魔性的图片先来体会一下.

自己实现一个路由的动机

那到了我们Android开发中呢? 如果我们把项目模块化了, 那两个组件间进行通讯或者跳转, 我们一般构建Intent的方式就不再使用了, 很简单, 因为在模块A中根本找不到模块B中的C类, 这就需要我们自定义路由规则, 绕一道弯去进行跳转, 说白了就是给你的类起一个别名, 我们用别用去引用. 其实在我准备自己去实现一个路由的时候我是google了一些解决方案的, 这些方案大致可分为两种.

  1. 完全自己实现路由, 完全封装跳转参数
  2. 利用隐式意图跳转

对于这两种方式我总结了一下, 个人认为第一种方式封装的太多, 甚至有些框架是RESTFul like的, 这样的封装一是学习成本太高, 二是旧项目改动起来太麻烦. 那第二种方式呢? 利用隐式意图是一种不错的选择, 而且Android原生支持, 这也是大家在尝试模块化开发时的一个选择, 不过这种方式仅支持Activity, Service, BroadcastReceiver, 扩展性太差. 综上因素, 我还是决定自己实现一个路由, 参考自上面的局限性, 我们的路由具有一下2个特点.

  1. 上手简单, 目标是与原生方式一行代码之差就能实现Activity, Service, BroadcastReceiver调用.
  2. 扩展性强, 开发者可以任意添加自己的路由实现, 不仅仅局限于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, 然后调用该Rulerouter方法, 至于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方法, 我们通过参数中的patternmIntentRules目标类, 然后构建一个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的实现都一样了~ 大家也是自己去看代码吧.

其实实现一个路由很简单, 原理就是给我们要路由的类定义一个别名, 然后在调用的地方通过别名去调用. 而且在封装的时候尽量要符合现在用户的使用习惯, 不要过多的封装而忽略了使用者的感受.

好了, 这篇文章就到这里了, 文章中的代码大家可以到https://github.com/qibin0506/Module2Module一个模块化开发的小demo中找到~

17
3
查看评论
发表评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场

Android路由框架Router分析

转载自:http://www.jianshu.com/p/f582c3893bed Android路由框架Router的分析 什么是路由?说简单点就是映射页面跳转关系的,当然它也包含跳转相关的一切功能。 路由框架的意义 Android系统已经给我们提供了api来做页面跳转,比...
  • u011404670
  • u011404670
  • 2017-02-05 21:30
  • 9436

Android中路由的实现

本文和大家分享的主要是android开发中路由的实现相关方法,希望通过本文的分享,对大家学习android 有所帮助。 前几个月有幸参加了CSDN组织的MDCC移动开发者大会, 一天下来我最大的收获就是了解到了模块化开发, 回来之后我就一直在思考模块化的一些优点, 不说别的, 提供一种可...
  • qq_32506555
  • qq_32506555
  • 2016-11-30 20:08
  • 2120

Android路由实现

前几个月有幸参加了CSDN组织的MDCC移动开发者大会, 一天下来我最大的收获就是了解到了模块化开发, 回来之后我就一直在思考模块化的一些优点, 不说别的, 提供一种可插拔的开发方式就足够我们兴奋一会了~ 接下来自己开始尝试了一些小demo, 发现在模块化开发中最大的问题就是组件间通讯, 例如: ...
  • qq_27650777
  • qq_27650777
  • 2017-03-20 11:51
  • 752

谈android组件化之ARouter简单使用

本文主要讲解了android组件化下的ARouter基本使用方法
  • vv765947965
  • vv765947965
  • 2017-04-25 16:30
  • 6836

Android 路由框架ARouter最佳实践

转载请标明出处:http://blog.csdn.net/zhaoyanjun6/article/details/76165252 本文出自【赵彦军的博客】 一:什么是路由?说简单点就是映射页面跳转关系的,当然它也包含跳转相关的一切功能。二:为什么需要路由Android系统已经给我们提供了a...
  • zhaoyanjun6
  • zhaoyanjun6
  • 2017-07-27 18:05
  • 2904

Android借用Arouter进行组件化旧城改造。

一、组件化开发须知: 随着项目的发展,业务模块越来越多,各个模块间相互引用,耦合越来越严重,同时有些项目还伴随着影子应用单独发布,整个项目编译速度越来越慢等问题,我们更需要组件化开发。 组件化开发就是将一个app分成多个模块,每个模块都是一个组件(Module),...
  • bin622
  • bin622
  • 2017-06-06 18:12
  • 1702

ARouter--简单且好用的Android路由框架

我们开发时使用最多的就是页面的跳转,现在使用的方案一般是显示Intent和隐式intent.
  • wangzhen17
  • wangzhen17
  • 2017-03-15 00:06
  • 767

Android路由跳转——ARouter使用

前言 模块化开发过程中首要解决的问题是如何进行跨模块交互,由于模块与模块之间不存在类的依赖关系因此类无法直接使用,在软件开发过程中随着业务不断膨胀,模块化开发就凸显得尤为重要。最近在研究组件化/模块化开发过程中突然遇到跨模块交互瓶颈,(例如A模块想要跳转B模块页面,由于AB模块相互独立并不存在依赖关...
  • zcmain
  • zcmain
  • 2017-10-10 11:18
  • 422

[Android]如何做一个崩溃率少于千分之三噶应用app(22)-组件化路由跳转

大家好,我是苍王。以下是我这个系列的相关文章,有兴趣可以参考一下,可以给个喜欢或者关注我的文章。 [Android]如何做一个崩溃率少于千分之三噶应用app--章节列表 大家应该有看完我的第十二编简书的页面跳转会清楚跨module的跳转用Android原生来做是,需要使用...
  • hongchengling2
  • hongchengling2
  • 2017-06-24 12:57
  • 305

翻翻git之---丰富多样的路由跳转开源库 ARouter

转载请注明出处:王亟亟的大牛之路有一段时间没更新博客了,最近也没学什么新东西,正好组里小伙在做路由跳转的一个“公共库“,然后正好最近这样的轮子不少,我也就跟着看看,学习一下人家的思路,然后推荐给大家这个库https://github.com/alibaba/ARouter分析讲解之前先安利:http...
  • ddwhan0123
  • ddwhan0123
  • 2017-01-13 17:43
  • 9937
    个人资料
    • 访问:647559次
    • 积分:6905
    • 等级:
    • 排名:第3917名
    • 原创:80篇
    • 转载:0篇
    • 译文:2篇
    • 评论:625条
    文章分类
    博客专栏
    友情链接

    鸿洋_

    Aggie的博客

    梁肖技术中心

    极客导航

    最新评论