Android组件化架构 – 3. 组件间跳转 & ARouter路由

组件间跳转 & 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)
    }
}
//清单文件注册
 
    
        
        
    

//使用隐式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 {
...
}

//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 json2Object(String text, Class 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等等，可以根据自己的项目实际情况进行技术选型