阿里arouter框架使用

爱被打了一巴掌 2022-04-02 12:48 609阅读 0赞

官方文档：[https://github.com/alibaba/ARouter/blob/master/README\_CN.md][https_github.com_alibaba_ARouter_blob_master_README_CN.md]

## arouter-compiler报错 ##

官方文档的依赖是这样写的：

dependencies {
        // 替换成最新版本, 需要注意的是api
        // 要与compiler匹配使用，均使用最新版可以保证兼容
        compile 'com.alibaba:arouter-api:x.x.x'
        annotationProcessor 'com.alibaba:arouter-compiler:x.x.x'
        ...
    }

并不意味着api和compiler的版本号是一样的，我的实际依赖是：

compile 'com.alibaba:arouter-api:1.4.1'
        annotationProcessor 'com.alibaba:arouter-compiler:1.2.2'

## 传递参数自动装配 ##

ARouter.getInstance().inject(this);

使用这句之后才能自动装配，如果参数名称相同的话，可直接使用。  
传递：

BeanUser beanUser = new BeanUser();
    beanUser.name = "zs";
    beanUser.age = 11;
    ARouter.getInstance().build("/test/login")
            .withString("name", "zs")
            .withSerializable("bean", beanUser)
            .navigation();

接收

@Autowired
    String name;
    @Autowired
    BeanUser bean;

### 拦截器 ###

声明一个拦截器

@Interceptor(priority = 1, name = "test")
    public class TestInterceptor implements IInterceptor {
        @Override
        public void process(Postcard postcard, InterceptorCallback callback) {
            if (TextUtils.isEmpty(postcard.getExtras().getString("name"))) {
                callback.onInterrupt(new RuntimeException("异常"));
            } else {
                callback.onContinue(postcard);
            }
        }
    
        @Override
        public void init(Context context) {
            Log.e("tag", "TestInterceptor init");
        }
    }

这样就可以了，运行的时候自动初始化拦截器。

12-27 10:01:30.677 6659-6678/com.hy.arouter E/tag: TestInterceptor init

我这个拦截器对登录的用户名做了判断，为空则拦截。  
下面是登录页面代码：

findViewById(R.id.login).setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View view) {
            String name = ((EditText)findViewById(R.id.name)).getText().toString();
            ARouter.getInstance().build("/test/login")
                    .withString("name", name)
                    .navigation(MainActivity.this, new NavigationCallback() {
                        @Override
                        public void onFound(Postcard postcard) {
                            Log.e("tag", "onFound");
                        }
    
                        @Override
                        public void onLost(Postcard postcard) {
                            Log.e("tag", "onLost");
                        }
    
                        @Override
                        public void onArrival(Postcard postcard) {
                            Log.e("tag", "onArrival");
                        }
    
                        @Override
                        public void onInterrupt(Postcard postcard) {
                            Log.e("tag", "onInterrupt");
                        }
                    });
        }
    });

携带用户名参数跳转，并且监听跳转结果。  
如果用户名为空：

12-27 10:01:33.838 6659-6659/com.hy.arouter E/tag: onFound
    12-27 10:01:33.841 6659-6700/com.hy.arouter E/tag: onInterrupt

如果用户名不为空：

12-27 10:01:49.178 6659-6659/com.hy.arouter E/tag: onFound
    12-27 10:01:49.204 6659-6659/com.hy.arouter E/tag: onArrival

说明一开始都要进入onFound方法，拦截后，回调onInterrupt，成功则回调onArrival方法。  
使用绿色通道(跳过所有的拦截器)

ARouter.getInstance().build("/home/main").greenChannel().navigation();

### 服务 ###

通过依赖注入解耦:服务管理(一) 暴露服务  
声明接口,其他组件通过接口来调用服务

public interface HelloService extends IProvider {
        String sayHello(String name);
    }

// 实现接口
    @Route(path = "/yourservicegroupname/hello", name = "测试服务")
    public class HelloServiceImpl implements HelloService {
    
        @Override
        public String sayHello(String name) {
        return "hello, " + name;
        }
    
        @Override
        public void init(Context context) {
    
        }
    }

通过依赖注入解耦:服务管理(二) 发现服务

public class Test {
        @Autowired
        HelloService helloService;
    
        @Autowired(name = "/yourservicegroupname/hello")
        HelloService helloService2;
    
        HelloService helloService3;
    
        HelloService helloService4;
    
        public Test() {
        ARouter.getInstance().inject(this);
        }
    
        public void testService() {
        // 1. (推荐)使用依赖注入的方式发现服务,通过注解标注字段,即可使用，无需主动获取
        // Autowired注解中标注name之后，将会使用byName的方式注入对应的字段，不设置name属性，会默认使用byType的方式发现服务(当同一接口有多个实现的时候，必须使用byName的方式发现服务)
        helloService.sayHello("Vergil");
        helloService2.sayHello("Vergil");
    
        // 2. 使用依赖查找的方式发现服务，主动去发现服务并使用，下面两种方式分别是byName和byType
        helloService3 = ARouter.getInstance().navigation(HelloService.class);
        helloService4 = (HelloService) ARouter.getInstance().build("/yourservicegroupname/hello").navigation();
        helloService3.sayHello("Vergil");
        helloService4.sayHello("Vergil");
        }
    }

### 拦截器和服务的异同 ###

*  拦截器和服务所需要实现的接口不同，但是结构类似，都存在 init(Context context) 方法，但是两者的调用时机不同
 *  拦截器因为其特殊性，会被任何一次路由所触发，拦截器会在ARouter初始化的时候异步初始化，如果第一次路由的时候拦截器还没有初始化结束，路由会等待，直到初始化完成。
 *  服务没有该限制，某一服务可能在App整个生命周期中都不会用到，所以服务只有被调用的时候才会触发初始化操作

### 生成路由文档 ###

更新 build.gradle, 添加参数 AROUTER\_GENERATE\_DOC = enable

android {
        defaultConfig {
            ...
            javaCompileOptions {
                annotationProcessorOptions {
                    arguments = [AROUTER_MODULE_NAME: project.getName(), AROUTER_GENERATE_DOC: "enable"]
                }
            }
        }
    }

生成的文档路径 :

build/generated/source/apt/(debug or release)/com/alibaba/android/arouter/docs/arouter-map-of-${moduleName}.json

打开内容：

{
    	"test":[
    		{
    			"group":"test",
    			"path":"/test/login",
    			"className":"com.hy.arouter.LoginActivity",
    			"type":"activity",
    			"mark":-2147483648,
    			"params":[
    				{
    					"key":"name",
    					"type":"string",
    					"required":false
    				},
    				{
    					"key":"bean",
    					"type":"serializable",
    					"required":false
    				}
    			]
    		},
    		{
    			"group":"test",
    			"path":"/test/main",
    			"className":"com.hy.arouter.MainActivity",
    			"type":"activity",
    			"mark":-2147483648
    		}
    	]
    }

是不是对于路由的各项参数就很直观了。

### 分组 ###

我注意上面有一个group的概念。

*  SDK中针对所有的路径(/test/1 /test/2)进行分组，分组只有在分组中的某一个路径第一次被访问的时候，该分组才会被初始化
 *  可以通过 @Route 注解主动指定分组，否则使用路径中第一段字符串(/\*/)作为分组
 *  注意：一旦主动指定分组之后，应用内路由需要使用 ARouter.getInstance().build(path, group) 进行跳转，手动指定分组，否则无法找到

@Route(path = "/test/1", group = "app")

## 异常 ##

1、there’s no route matched  
在组件化项目中，只需要在基础项目中依赖一次arouter-api即可，而arouter-compiler在每个项目都需要需要依赖。  
2、Execution failed for task ‘:app:compileDebugJavaWithJavac’  
在使用@Autowired的时候，修饰的变量不能为private，否则会报错  
3、RuntimeException: ARouter::Compiler >>> No module name  
下面这就话,原文复制到defaultconfig 中即可.

javaCompileOptions {
        annotationProcessorOptions {
            arguments = [ moduleName : project.getName() ]
        }
    }

3、获取fragment为空  
获取方式：

repaymentFragment = (Fragment) ARouter.getInstance().build(ARouterPath.Mine.FRAGMENT_PATH_REPAYMENT).navigation();

原因1：  
结果发现我的path定义重复了

public static class Mine {
            public static final String BASE="/mine/";
            public static final String FRAGMENT_PATH_REPAYMENT = BASE + "repayment"; // 账单
            public static final String ACT_PATH_REPAYMENT = BASE + "repayment"; // 账单
        }

两个path路径一样，导致arouter获取fragment出错。  
原因2：  
app主模块需要把所有的模块引入进去。  
[Arouter报arouter there is no route match the path][Arouter_arouter there is no route match the path]

[https_github.com_alibaba_ARouter_blob_master_README_CN.md]: https://github.com/alibaba/ARouter/blob/master/README_CN.md
[Arouter_arouter there is no route match the path]: https://www.jianshu.com/p/526a7356a027