路由存在的意义

模块间解耦,不需要再类中明确跳转目标的类名
动态配置,业务需求原因,部分诸如banner页等地方的地址需要动态可配的,这个时候就不方便写死类名,路由是一个比较好的解决方式。

前言

本文会讲解一下如何编写一个简单的路由。在讲解路由之前,需要先了解一下android下的注解(annotation),注解不单单是路由的重要组成部分,目前主流的各大框架都有注解的成分在。

实际上我们通过一个注解就能完成的譬如绑定控件,路由跳转等操作,都是因为注解处理器帮我们生成了对应代码来帮我们实现上述的操作。

下面就来讲解下路由跳转的实现，另外注解的相关知识，可参考浅谈Android下的注解

路由跳转

正常情况下Activity之间的跳转如下

Intent intent=new Intent(this,TestActivity.class);
startActivity(intent);

而路由跳转的原理实际上执行的也是类似的代码,只不过路由执行的是注解生成的逻辑代码。项目下所有注解的Activity会以Map的形式保存下来,类似于下面这样的逻辑.

public static void initActivityMap(HashMap<String, Class> activityMap) {
	activityMap.put("test", TestActivity1.class);
	activityMap.put("test2", TestActivity2.class);
}

然后在传入test这样的字符串,通过遍历map找到对应的TestActivity1这样的目标Activity。最后执行startActivity()实现跳转,上述就是一个简单的路由的跳转。

具体实现

在工程下建立如下几个module

--app                   (主工程)
--route_annotation      (java module 自定义注解)
--route-api             (Android module)
--route_compiler        (java module 注解处理器逻辑)

route_annotation 定义注解

一个很简单的注解接口

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.CLASS)
public @interface Route {
    String [] value();
}

route_compiler 注解处理器逻辑

新建一个注解处理器的类RouteProcessor 继承自AbstractProcessor

具体实现

@AutoService(Processor.class)
public class RouteProcessor extends AbstractProcessor {

    private Messager mMessager;
    private Filer mFiler;

    @Override
    public synchronized void init(ProcessingEnvironment processingEnvironment) {
        super.init(processingEnvironment);
        mMessager = processingEnv.getMessager();
        mFiler = processingEnv.getFiler();
    }

    @Override
    public boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment) {
        Set<? extends Element> routeElements = roundEnvironment.getElementsAnnotatedWith(Route.class);
        try {
            TypeSpec typeSpec = processRouterTable(routeElements);
            if (typeSpec != null) {
                JavaFile.builder("com.dly.routeDemo", typeSpec).build().writeTo(mFiler);
            }
        } catch (Exception e) {
            e.printStackTrace();
            error(e.getMessage());
        }
        return true;
    }

    private TypeSpec processRouterTable(Set<? extends Element> elements) {
        //注意这里一定要做判空处理,因为apt会多次扫描项目所有文件包括javaPoet生成的文件.
        //不做这步处理的话,第一次生成你需要的文件,第二次再进行扫描的时候,又会去生成文件,那时系统就会报一个异常,提示不能生成相同的文件
        if (elements == null || elements.size() == 0) {
            return null;
        }
        ParameterizedTypeName mapTypeName = ParameterizedTypeName
                .get(ClassName.get(HashMap.class), ClassName.get(String.class),
                        ClassName.get(Class.class));
        ParameterSpec mapParameterSpec = ParameterSpec.builder(mapTypeName, "activityMap")
                .build();
        MethodSpec.Builder routerInitBuilder = MethodSpec.methodBuilder("initActivityMap")
                .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
                .addParameter(mapParameterSpec);

        for (Element element : elements) {
            Route route = element.getAnnotation(Route.class);
            String[] routerUrls = route.value();
            for (String url : routerUrls) {
                //核心逻辑  将字符与类做映射关联
                routerInitBuilder.addStatement("activityMap.put($S, $T.class)", url, ClassName.get((TypeElement) element));
            }
        }

        return TypeSpec.classBuilder("AutoCreateModuleActivityMap_app")
                .addModifiers(Modifier.PUBLIC)
                .addMethod(routerInitBuilder.build())
                .build();
    }


    @Override
    public Set<String> getSupportedAnnotationTypes() {
        Set<String> ret = new HashSet<>();
        ret.add(Route.class.getCanonicalName());
        return ret;
    }

    @Override
    public SourceVersion getSupportedSourceVersion() {
        return SourceVersion.latestSupported();
    }

    private void error(String error) {
        mMessager.printMessage(Diagnostic.Kind.ERROR, error);
    }
}

上述RouteProcessor类会在AS编译完成之后,会在目录app/build/generated/source/apt/debug/项目名下生产一个java文件。

public class AutoCreateModuleActivityMap_app {
  public static void initActivityMap(HashMap<String, Class> activityMap) {
    activityMap.put("test", TestActivity1.class);
    activityMap.put("test2", TestActivity2.class);
  }
}

这个java文件会保存你注解过的类以及对于字符串之间的映射关系。

route_api 需要执行具体的跳转逻辑即我们熟悉的startActivity

新建RouteDemo.class

public class RouteDemo {

    private static HashMap<String, Class> activityMap = new HashMap<>();
    private static Application mApplication;

    public static void init(Application application) {
        mApplication = application;
        try {
            //通过反射调用AutoCreateModuleActivityMap_app类的方法,并给activityMap赋值
            Class clazz = Class.forName("com.dly.routeDemo.AutoCreateModuleActivityMap_app");
            Method method = clazz.getMethod("initActivityMap", HashMap.class);
            method.invoke(null, activityMap);
            for (String key : activityMap.keySet()) {
                System.out.println("activityMap = " + activityMap.get(key));
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void open(String url) {
        for (String key : activityMap.keySet()) {
            if (url.equals(key)) {
                Intent intent = new Intent(mApplication, activityMap.get(key));
                intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK );
                mApplication.startActivity(intent);
            }
        }
    }

}

一个简单的反射调用给我们自己定义的ActivityMap赋值.这样的话我们就拥有了ActivityMap的集合了。

app 主工程

定义一个MyApplication用来初始化路由

public class MyApplication extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
        RouteDemo.init(this);
    }
}

然后MainActivity下执行路由跳转即可。

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        Intent intent=new Intent(this,TestActivity.class);
        startActivity(intent);
    }

    public void onClick(View v) {
        switch (v.getId()) {
            case R.id.text1:
                RouteDemo.open("test");
                break;
            case R.id.text2:
                RouteDemo.open("test2");
                break;
        }
    }
}

对应的TestActivity1

@Route("test")
public class TestActivity1 extends AppCompatActivity {

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_test);
    }
}

上述几个流程就完成了一个最为简单的路由跳转,当然我们需要的可不仅仅只是一个跳转,还需要携带参数跳转,,或者跳转拦截等等需求.

而这些需求会在之后的文章中慢慢讲解。

github 地址

RouteDemo