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

我是今阳,如果想要进阶和了解更多的干货,欢迎关注公众号”今阳说“接收我的最新文章

你可能感兴趣的:(Android组件化架构 - 3. 组件间跳转 & ARouter路由)