摘要：跳转完了找到了被拦截了找不到了拦截器在模块的时候讲述的使用，如果本次路由跳转不是走的绿色通道那么则会触发拦截器进行过滤。部分代码省略拦截器的初始化在刚开始初始化的时候，就已经做了这个操作。
目录介绍
01.原生跳转实现
02.实现组件跳转方式
2.1 传统跳转方式
2.2 为何需要路由
03.ARouter配置与优势
04.跨进程组件通信
4.1 URLScheme
4.2 AIDL
4.3 BroadcastReceiver
4.4 路由通信注意要点
05.ARouter的结构
06.ARouter的工作流程
6.1 初始化流程
6.2 跳转页面流程
07.ARouter简单调用api
7.1 最简单调用
7.2 build源码分析
7.3 navigation分析
08.Postcard信息携带
09.LogisticsCenter
10.DegradeService降级容错服务
11.Interceptor拦截器
12.数据传输和自动注入
13.多dex的支持
14.InstantRun支持
15.生成的编译代码
好消息博客笔记大汇总【16年3月到至今】，包括Java基础及深入知识点，Android技术博客，Python学习笔记等等，还包括平时开发中遇到的bug汇总，当然也在工作之余收集了大量的面试题，长期更新维护并且修正，持续完善……开源的文件是markdown格式的！同时也开源了生活博客，从12年起，积累共计N篇[近100万字，陆续搬到网上]，转载请注明出处，谢谢！
链接地址：https://github.com/yangchong2...
如果觉得好，可以star一下，谢谢！当然也欢迎提出建议或者问题，万事起于忽微，量变引起质变！
注解学习小案例注解学习小案例，比较系统性学习注解并且应用实践。简单应用了运行期注解，通过注解实现了setContentView功能；简单应用了编译器注解，通过注解实现了防暴力点击的功能，同时支持设置时间间隔；使用注解替代枚举；使用注解一步步搭建简单路由案例。结合相应的博客，在来一些小案例，从此应该对注解有更加深入的理解……
开源项目地址：https://github.com/yangchong2...
01.原生跳转实现Google提供的原声路由主要是通过intent，可以分成显示和隐式两种。显示的方案会导致类之间的直接依赖问题，耦合严重；隐式intent需要的配置清单中统一声明，首先有个暴露的问题，另外在多模块开发中协作也比较困难。只要调用startActivity后面的环节我们就无法控制了，在出现错误时无能为力。
02.实现组件跳转方式 2.1 传统跳转方式第一种，通过intent跳转
第二种，通过aidl跳转
第三种，通过scheme协议跳转
2.2 为何需要路由显示Intent：项目庞大以后，类依赖耦合太大，不适合组件化拆分
隐式Intent：协作困难，调用时候不知道调什么参数
每个注册了Scheme的Activity都可以直接打开，有安全风险
AndroidMainfest集中式管理比较臃肿
无法动态修改路由，如果页面出错，无法动态降级
无法动态拦截跳转，譬如未登录的情况下，打开登录页面，登录成功后接着打开刚才想打开的页面
H5、Android、iOS地址不一样，不利于统一跳转
03.ARouter配置与优势 3.1 ARouter的优势
如下所示
直接解析URL路由，解析参数并赋值
支持多模块项目
支持InstantRun
允许自定义拦截器
ARouter可以提供IoC容器
映射关系自动注册
灵活的降级策略
3.2 至于配置和使用直接看https://www.jianshu.com/p/fed...
04.跨进程组件通信 4.1 URLScheme【例如：ActivityRouter、ARouter等】
优势有：
基因中自带支持从webview中调用
不用互相注册（不用知道需要调用的app的进程名称等信息）
劣势有:
只能单向地给组件发送信息，适用于启动Activity和发送指令，不适用于获取数据(例如：获取用户组件的当前用户登录信息)
需要有个额外的中转Activity来统一处理URLScheme
如果设备上安装了多个使用相同URLScheme的app，会弹出选择框（多个组件作为app同时安装到设备上时会出现这个问题）
无法进行权限设置，无法进行开关设置，存在安全性风险
4.2 AIDL
优势有：
可以传递Parcelable类型的对象
效率高
可以设置跨app调用的开关
劣势有：
调用组件之前需要提前知道该组件在那个进程，否则无法建立ServiceConnection
组件在作为独立app和作为lib打包到主app时，进程名称不同，维护成本高
4.3 BroadcastReceiverBroadcastReceiver + Service + LocalSocket。该方案是参考cc路由框架！
跨组件间通信实现的同时，应该满足以下条件：
每个app都能给其它app调用
app可以设置是否对外提供跨进程组件调用的支持
组件调用的请求发出去之后，能自动探测当前设备上是否有支持此次调用的app
支持超时、取消
4.4 路由通信注意要点 05.ARouter的结构
ARouter主要由三部分组成，包括对外提供的api调用模块、注解模块以及编译时通过注解生产相关的类模块。
arouter-annotation注解的声明和信息存储类的模块
arouter-compiler编译期解析注解信息并生成相应类以便进行注入的模块
arouter-api核心调用Api功能的模块
annotation模块
Route、Interceptor、Autowired都是在开发是需要的注解。
compiler模块
AutoWiredProcessor、InterceptorProcessor、RouteProcessor分别为annotation模块对应的Autowired、Interceptor、Route在项目编译时产生相关的类文件。
api模块
主要是ARouter具体实现和对外暴露使用的api。
06.ARouter的工作流程 6.1 初始化流程
初始化代码如下所示
/**
*/
public static void init(Application application) {
//如果没有初始化，则
if (!hasInit) {
logger = _ARouter.logger;
_ARouter.logger.info(Consts.TAG, "ARouter init start.");
//做初始化工作
hasInit = _ARouter.init(application);
if (hasInit) {
_ARouter.afterInit();
}
_ARouter.logger.info(Consts.TAG, "ARouter init over.");
}
}
```
之后接着看_ARouter.init(application)这行代码，点击去查看
protected static synchronized boolean init(Application application) {
//赋值上下文
mContext = application;
//初始化LogisticsCenter
LogisticsCenter.init(mContext, executor);
logger.info(Consts.TAG, "ARouter init success!");
hasInit = true;
mHandler = new Handler(Looper.getMainLooper());
return true;
}
接下来看看LogisticsCenter里面做了什么
public class LogisticsCenter {
/**
*/
public synchronized static void init(Context context, ThreadPoolExecutor tpe) throws HandlerException {
mContext = context;
executor = tpe;
try {
long startInit = System.currentTimeMillis();
Set routerMap;
//debug或者版本更新的时候每次都重新加载router信息
// It will rebuild router map every times when debuggable.
if (ARouter.debuggable() || PackageUtils.isNewVersion(context)) {
logger.info(TAG, "Run with debug mode or new install, rebuild router map.");
// These class was generate by arouter-compiler.
//加载alibaba.android.arouter.routes包下载的类
routerMap = ClassUtils.getFileNameByPackageName(mContext, ROUTE_ROOT_PAKCAGE);
if (!routerMap.isEmpty()) {
context.getSharedPreferences(AROUTER_SP_CACHE_KEY, Context.MODE_PRIVATE).edit().putStringSet(AROUTER_SP_KEY_MAP, routerMap).apply();
}
PackageUtils.updateVersion(context); // Save new version name when router map update finish.
} else {
logger.info(TAG, "Load router map from cache.");
routerMap = new HashSet<>(context.getSharedPreferences(AROUTER_SP_CACHE_KEY, Context.MODE_PRIVATE).getStringSet(AROUTER_SP_KEY_MAP, new HashSet()));
}
logger.info(TAG, "Find router map finished, map size = " + routerMap.size() + ", cost " + (System.currentTimeMillis() - startInit) + " ms.");
startInit = System.currentTimeMillis();
for (String className : routerMap) {
if (className.startsWith(ROUTE_ROOT_PAKCAGE + DOT + SDK_NAME + SEPARATOR + SUFFIX_ROOT)) {
// This one of root elements, load root.
//导入ARouter$$Root$$app.java,初始化Warehouse.groupsIndex集合
((IRouteRoot) (Class.forName(className).getConstructor().newInstance())).loadInto(Warehouse.groupsIndex);
} else if (className.startsWith(ROUTE_ROOT_PAKCAGE + DOT + SDK_NAME + SEPARATOR + SUFFIX_INTERCEPTORS)) {
// Load interceptorMeta
//导入ARouter$$Interceptors$$app.java，初始化Warehouse.interceptorsIndex集合
((IInterceptorGroup) (Class.forName(className).getConstructor().newInstance())).loadInto(Warehouse.interceptorsIndex);
} else if (className.startsWith(ROUTE_ROOT_PAKCAGE + DOT + SDK_NAME + SEPARATOR + SUFFIX_PROVIDERS)) {
// Load providerIndex
//导入ARouter$$Providers$$app.java，初始化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() + "]");
}
}
}
```
综上所述，整个初始化的流程大概就是：
初始化运行时的上下文环境
初始化日志logger
寻找router相关的类
解析并且缓存路由相关信息
初始化拦截服务
6.2 跳转页面流程 07.ARouter调用api 7.1 最简单调用
最简单的调用方式
ARouter.getInstance()
.build("/user/UserFragment")
.navigation();
7.2 build源码分析
这个主要是添加跳转的路径
public Postcard build(String path) {
return _ARouter.getInstance().build(path);
}
然后把这个路径添加到默认的组中
/**
*/
protected Postcard build(String path) {
if (TextUtils.isEmpty(path)) {
throw new HandlerException(Consts.TAG + "Parameter is invalid!");
} else {
PathReplaceService pService = ARouter.getInstance().navigation(PathReplaceService.class);
if (null != pService) {
path = pService.forString(path);
}
return build(path, extractGroup(path));
}
}
```
7.3 navigation分析
如下所示
final class _ARouter {
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);
} else { // No callback for this invoke, then we use the global degrade service.
DegradeService degradeService = ARouter.getInstance().navigation(DegradeService.class);
if (null != degradeService) {
degradeService.onLost(context, postcard);
}
}
return null;
}
if (null != callback) {
callback.onFound(postcard);
}
//是否为绿色通道，是否进过拦截器处理
if (!postcard.isGreenChannel()) { // It must be run in async thread, maybe interceptor cost too mush time made ANR.
interceptorService.doInterceptions(postcard, new InterceptorCallback() {
@Override
public void onContinue(Postcard postcard) {
_navigation(context, postcard, requestCode, callback);
}
@Override
public void onInterrupt(Throwable exception) {
//中断处理
if (null != callback) {
callback.onInterrupt(postcard);
}
}
});
} else {
return _navigation(context, postcard, requestCode, callback);
}
return null;
}
private Object _navigation(final Context context, final Postcard postcard, final int requestCode, final NavigationCallback callback) {
//没有上下文环境，就用Application的上下文环境
final Context currentContext = null == context ? mContext : context;
switch (postcard.getType()) {
case ACTIVITY:
// Build intent 构建跳转的intent
final Intent intent = new Intent(currentContext, postcard.getDestination());
intent.putExtras(postcard.getExtras());
// Set flags. 设置flag
int flags = postcard.getFlags();
if (-1 != flags) {
intent.setFlags(flags);
} else if (!(currentContext instanceof Activity)) { // Non activity, need less one flag.
//如果上下文不是Activity，则添加FLAG_ACTIVITY_NEW_TASK的flag
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
}
// Navigation in main looper. 切换到主线程中
new Handler(Looper.getMainLooper()).post(new Runnable() {
@Override
public void run() {
if (requestCode > 0) { // Need start for result
ActivityCompat.startActivityForResult((Activity) currentContext, intent, requestCode, postcard.getOptionsBundle());
} else {
ActivityCompat.startActivity(currentContext, intent, postcard.getOptionsBundle());
}
if ((0 != postcard.getEnterAnim() || 0 != postcard.getExitAnim()) && currentContext instanceof Activity) { // Old version.
((Activity) currentContext).overridePendingTransition(postcard.getEnterAnim(), postcard.getExitAnim());
}
if (null != callback) { // Navigation over.
callback.onArrival(postcard);
}
}
});
break;
case PROVIDER:
return postcard.getProvider();
case BOARDCAST:
case CONTENT_PROVIDER:
case FRAGMENT:
Class fragmentMeta = postcard.getDestination();
try {
Object instance = fragmentMeta.getConstructor().newInstance();
if (instance instanceof Fragment) {
((Fragment) instance).setArguments(postcard.getExtras());
} else if (instance instanceof android.support.v4.app.Fragment) {
((android.support.v4.app.Fragment) instance).setArguments(postcard.getExtras());
}
return instance;
} catch (Exception ex) {
logger.error(Consts.TAG, "Fetch fragment instance error, " + TextUtils.formatStackTrace(ex.getStackTrace()));
}
case METHOD:
case SERVICE:
default:
return null;
}
return null;
}
}
08.Postcard信息携带
Postcard主要为信息的携带者，内容是在构造一次路由信息的时候生产的，其继承于RouteMeta。RouteMeta是在代码编译时生成的内容，主要在初始化WareHouse时对跳转信息做了缓存。
看看代码如下所示
//Postcard继承于RouteMeta public final class Postcard extends RouteMeta //然后看看编译生成的文件 /**
public class ARouter$$Group$$me implements IRouteGroup {
@Override
public void loadInto(Map atlas) {
atlas.put("/me/ExperienceCouponActivity", RouteMeta.build(RouteType.ACTIVITY, ExperienceCouponActivity.class, "/me/experiencecouponactivity", "me", null, -1, -2147483648));
atlas.put("/me/ServiceActivity", RouteMeta.build(RouteType.ACTIVITY, ServiceActivity.class, "/me/serviceactivity", "me", null, -1, -2147483648));
atlas.put("/me/SettingActivity", RouteMeta.build(RouteType.ACTIVITY, SettingActivity.class, "/me/settingactivity", "me", null, -1, -2147483648));
atlas.put("/me/UdeskServiceActivity", RouteMeta.build(RouteType.ACTIVITY, UdeskServiceActivity.class, "/me/udeskserviceactivity", "me", null, -1, -2147483648));
}
}
```
10.DegradeService降级容错服务
首先，自定义一个类，需要继承DegradeService类，如下所示
