Android组件化架构 - 3. 组件间跳转 & ARoute
组件间跳转 & ARouter路由
常见的跳转，对于用户来说就是页面跳转，对应Android中就是activity或fragment间的跳转，那我们肯定第一时间就想到，
用startActivity()发送一个包装好的intent，将intent交给ActivityManagerService完成新的Activity创建。
但是组件化中，两个功能模块是不存在直接依赖关系的（通过baseModule间接依赖），那么包装intent时就会发现引用不了其他module
中的activity类（xxx.class）。
这如何解决呢，灵光一闪，我们Android中的intent跳转可是分为显示和隐式，虽然上面常用的显示跳转行不通，但我们还有隐式跳转；
于是乎，隐式跳转缓缓起身，拍了拍身上积落的灰尘，扶了扶头上的斗笠，稳了稳腰间的佩剑，从墙角向我们款款走来
1. 隐式跳转
//隐式跳转的目的activity
class ImplicitActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_implicit)
}
}
//清单文件注册
<activity android:name=".activity.ImplicitActivity">
<intent-filter>
<action android:name="com.jinyang.implicitAct"/>
<category android:name="android.intent.category.DEFAULT"/>
</intent-filter>
</activity>
//使用隐式acition跳转
fun onBtnClick(view: View) {
when (view.id) {
R.id.button_implicit -> startActivity(Intent("com.jinyang.implicitAct"))
}
}
//隐式跳转还可以通过app包名 + 目标activity全路径跳转
val intent = Intent()
intent.setClassName(packageName, "com.jinyang.mylibrary.Test01Activity")
intent.component = ComponentName(packageName, "com.jinyang.mylibrary.Test01Activity")
if (intent.resolveActivity(packageManager) != null) {
startActivity(intent)
}
这里还有个安全隐患，其他app也可以通过隐式intent跳转到我们的activity，需要清单文件中设置exported=false，确保只有自己的app能启动组件；
隐式跳转是原生的，和广播一样，范围是整个Android系统都能收到，是否有更好的方式呢
2. ARouter路由跳转
原理借用计算机网络中的路由器概念，将各组件看成不同的局域网，通过路由做中转站，这个中转站可以拦截一些不安全的跳转，或者设定一些特定的拦截服务；
路由和原生跳转的对比：
1. 原生显示跳转是直接的类依赖，耦合严重；路由通过URL索引，无需依赖；
2. 原生隐式跳转通过AndroidManifest集中管理，协作开发困难；路由则是分布式管理页面配置；
3. 原生需要在 AndroidManifest中注册，扩展性差；路由用注解来注册，方便扩展；
4. 原生只要调用了startActivity就交由Android系统控制，过程无法干预，失败无法降级；
路由使用AOP切面编程可以进行控制跳转的过滤，有灵活的降级方式；
ARouter是阿里巴巴开源的路由框架；
如何使用：
//1. 在base module中添加依赖
implementation 'com.alibaba:arouter-api:1.4.0'
annotationProcessor 'com.alibaba:arouter-compiler:1.2.1'
//2. 各模块build.gradle的defaultConfig中加入
javaCompileOptions {
annotationProcessorOptions {
arguments = [AROUTER_MODULE_NAME: project.getName()]
}
}
//各模块build.gradle的dependencies中加入
annotationProcessor 'com.alibaba:arouter-compiler:1.2.1'
//3. 在application中初始化ARouter
if (BuildConfig.isDebug){
ARouter.openLog();
ARouter.openDebug();
//需要在init之前配置才有效
}
ARouter.init(MyApplication.this);
//4.在支持路由的页面上添加注解(必选)
// 这里的路径需要注意的是至少需要有两级，/xx/xx
@Route(path = ARouterPath.ACTIVITY_PATH_MAIN)
public class MainActivity extends BaseActivity<IBaseView, MainPresenter> {
...
}
//5.跳转
ARouter.getInstance()
.build(ARouterPath.ACTIVITY_PATH_FRAGMENTSACTIVITY)
.navigation();
//也可以携带参数或用uri跳转
Uri uri = Uri.parse(ARouterPath.ACTIVITY_PATH_AROUTER2);
ARouter.getInstance()
.build(uri)
// .build(ARouterPath.ACTIVITY_PATH_AROUTER2)
.withTransition(R.anim.anim_act_in, R.anim.anim_act_out)
.withInt("key1", 1024)
.withString("key2", "我是ARouter跳转传递的字符串啊")
.navigation();
//所传参数通过在声明变量时添加注解获取
@Autowired
int key1;
@Autowired(name = "key2")
String keyString;
// 如果需要传递自定义对象，新建一个类（并非自定义对象类），
//然后实现 SerializationService,
并使用@Route注解标注(方便用户自行选择序列化方式)，例如：
@Route(path = "/yourservicegroupname/json")
public class JsonServiceImpl implements SerializationService {
@Override
public void init(Context context) {
}
@Override
public <T> T json2Object(String text, Class<T> clazz) {
return JSON.parseObject(text, clazz);
}
@Override
public String object2Json(Object instance) {
return JSON.toJSONString(instance);
}
}
//使用拦截器(拦截跳转过程，面向切面编程)
//1. 要使用拦截器需要向在build.gradle中添加插件
apply plugin: 'com.alibaba.arouter'
buildscript {
repositories {
jcenter()
}
dependencies {
classpath "com.alibaba:arouter-register:?"
}
}
// 比较经典的应用就是在跳转过程中处理登陆事件，这样就不需要在目标页重复做登陆检查
// 拦截器会在跳转之间执行，多个拦截器会按优先级顺序依次执行
@Interceptor(priority = 8, name = "测试用拦截器")
public class TestInterceptor implements IInterceptor {
@Override
public void process(Postcard postcard, InterceptorCallback callback) {
...
callback.onContinue(postcard); // 处理完成，交还控制权
// callback.onInterrupt(new RuntimeException("我觉得有点异常"));
// 觉得有问题，中断路由流程
// 以上两种至少需要调用其中一种，否则不会继续路由
}
@Override
public void init(Context context) {
// 拦截器的初始化，会在sdk初始化的时候调用该方法，仅会调用一次
}
}
// 例如登陆校验:
@Interceptor( priority = 1)
public class LoginInterceptor implements IInterceptor {
private Context context;
private Postcard postcard;
private InterceptorCallback callback;
private static final int CAMERA_PERMISSION_RESULT = 101;
@Override
public void init(Context context) {
Log.d("LJY_LOG", "PermissionInterceptor.init");
this.context = context;
}
@Override
public void process(Postcard postcard, InterceptorCallback callback) {
Log.d("LJY_LOG", "PermissionInterceptor.process");
this.postcard = postcard;
this.callback = callback;
if (postcard.getPath().equals("/jinyang/arouterdemo/DemoActivity")) {
if (MyApplication.isLogin) {
callback.onContinue(postcard);
} else {
Log.d("LJY_LOG", "请先登录");
}
} else {
callback.onContinue(postcard);
}
}
}
//处理跳转结果
// 使用两个参数的navigation方法，可以获取单次跳转的结果
ARouter.getInstance().build("/test/1").navigation(this, new NavigationCallback() {
@Override
public void onFound(Postcard postcard) {
...
}
@Override
public void onLost(Postcard postcard) {
...
}
});
//自定义全局降级策略
// 实现DegradeService接口，并加上一个Path内容任意的注解即可
@Route(path = "/xxx/xxx")
public class DegradeServiceImpl implements DegradeService {
@Override
public void onLost(Context context, Postcard postcard) {
// do something.
}
@Override
public void init(Context context) {
}
}
//以上是一些常用的例子,更多的使用可以去https://github.com/alibaba/ARouter查看
3. ARouter路由原理
调用ARouter.init方法,在LogisticsCenter中通过编译时注解,生成三个文件,Group(IRouteGroup),
Providers(IProviderGroup),Root(IRouteRoot),使用Warehouse将文件保存到三个不同的HashMap中,
Warehouse就相当于路由表,保存着全部模块的跳转关系;
- 通过ARouter.navigation封装postcard对象;
- 通过ARouter索引传递到LogisticsCenter(路由中转站),询问是否存在跳转对象;
- 如果存在则设置绿色通道开关;
- 判断是否绿色通行和是否能通过拦截服务;
- 全部通过就会调用ActivityCompat.startActivity方法来跳转到目的Activity
所以,ARouter实际还是使用原生的Framework机制startActivity,只是通过apt注解的形式制造出跳转规则,并认为的拦截跳转和设置跳转条件;
4. 組件化最佳路由
说了半天路由，那么为什么现在普遍在组件化中使用路由机制作为跳转方案呢，毕竟其底层也是调用startActivity，隐式跳转也可以满足；
考虑如下场景，当移除一些功能module和跳转关系时，使用startActivity将无法跳转，且没有提示，使用路由方案，可设置统一的拦截和提示；
还可以在跳转前进行登录状态的拦截，虽然这点我们也可以通过aop注解实现，如下，但路由方案显然更方便；
//登录校验的接口
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface NeedLogin {
}
// 登录校验的实现
@Around("execution(@NeedLogin * *(..))")
public void isLoginOn(ProceedingJoinPoint joinPoint) throws Throwable {
if (MyApplication.getMyApplication().getAppConfig().isLogged()) {
joinPoint.proceed();
} else {
if (joinPoint.getThis() instanceof BaseActivity) {
ActivityUtils.startActivity(
(BaseActivity) joinPoint.getThis(),
UserLoginActivity.class
);
} else if (joinPoint.getThis() instanceof BaseFragment) {
ActivityUtils.startActivity(
((BaseFragment) joinPoint.getThis()).getActivity(),
UserLoginActivity.class
);
}
}
}
//登录校验的使用
@NeedLogin
private void setJump(BaseJumpModel itemData) {
//todo something
}
还有就是路由表的引入，就不需要在AndroidManifest中声明隐式跳转；
除了阿里的ARouter，现在的开源路由框架还有很多，如ActivityRouter，天猫统跳协议，DeepLinkDispatch，OkDeepLink等等，可以根据自己的项目实际情况进行技术选型
