使用APT实现Android组件化路由功能

组件化后不同模块之间Activity的跳转

组件化后，只有主工程模块依赖其他业务模块，而各个业务模块之间没有互相依赖关系。一个模块可以调用被依赖模块的类和方法，而被依赖的模块不能引用依赖模块的类（依赖只能单向传递）。所以，单个业务模块无法调用主模块和其他业务模块的类和方法，那么业务间Activity的跳转就需要使用隐式跳转：

直接跳转包名：startActivity(new Intent(“com.example.boost”))
使用manifest中的action、category、data进行隐式跳转：startActivity(new Intent(Intent.ACTION_VIEW, Uri.prase("xxxx")))
利用反射

以上这些方法，虽然都能实现不同模块间的Activity跳转。但是，隐式跳转容易被非法应用劫持，反射最大的弊端在于代码结构发生变化后，就需要修改相应的反射路径。

目前比较推荐的方法就是使用一套统一的路由框架，所有的业务模块、主模块都依赖于这个路由模块，路由模块中包含所有Activity的引用，这样，每个模块都可以互相调用不同的模块的Activity。

路由框架

搭建路由模块

路由模块需要包含所有Activity类的引用，并能进行跳转，所有需要建立一个Android Library。

20191006191058

Route路由类的设计：

Route类作为路由需要在每个模块中可以直接调用，那最方便的方法就是使用单例模式
Route中要包含所有Activity的引用，那么就需要使用一个map将Activity和对应的名称关联起来
在使用路由进行页面跳转的时候需要有一个方法，方法要传入待跳转的Activity的名称和需要的参数
Route需要一个方法，将Activity的引用和对应的名称传入路由中

具体的代码如下：

package com.example.route;

import android.app.Activity;
import android.app.Application;
import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import android.text.TextUtils;

import java.util.ArrayList;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import dalvik.system.DexFile;

/**
 * @Description: 路由
 * @Author: jiazhu
 * @Date: 2019-09-19 09:29
 * @ClassName: Route
 */
public class Route {
    private static Route route = new Route();

    private Context mContext;
    private Map<String, Class<? extends Activity>> activityList;

    private Route() {
        activityList = new HashMap<>();
    }

    public static Route getInstance() {
        return route;
    }

    public void init(Application application) {
        mContext = application;
        List<String> classNames = getClassName("com.example.util");
        for (String s : classNames) {
            try {
                Class<?> aClass = Class.forName(s);
                if (IRoute.class.isAssignableFrom(aClass)) {
                    IRoute iRoute = (IRoute) aClass.newInstance();
                    iRoute.putActivity();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    private List<String> getClassName(String packageName) {
        ArrayList<String> classList = new ArrayList<>();
        String path = null;
        try {
            path = mContext.getPackageManager().getApplicationInfo(mContext.getPackageName(), 0).sourceDir;
            DexFile dexFile = new DexFile(path);
            Enumeration<String> entries = dexFile.entries();
            while (entries.hasMoreElements()) {
                String name = entries.nextElement();
                if (name.contains(packageName)) {
                    classList.add(name);
                }
            }
            return classList;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    public void putActivity(String path, Class<? extends Activity> clazz) {
        if (TextUtils.isEmpty(path)) {
            return;
        }
        if (clazz == null) {
            return;
        }
        activityList.put(path, clazz);
    }

    public void jumpActivity(String path, Bundle bundle) {
        Class<? extends Activity> aClass = activityList.get(path);
        if (aClass == null) {
            return;
        }
        Intent intent = new Intent().setClass(mContext, aClass);
        intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
        if (bundle != null) {
            intent.putExtra("bundle", bundle);
        }
        mContext.startActivity(intent);
    }
}

对于init方法，在整个应用启动的时候需要被调用，这样可以获取Application作为以后跳转的context上下文；除此之外，还需要将每一个模块中的Activity获取到，传入Route中。

Route中有一个putActivity()的方法，这个方法可以将Activity的引用和名称传入Route中，那么在每一个模块中如何才能调用这个方法，将本模块的Activity传递给Route呢？

使用APT（注解处理工具）将每一个模块的Activity传入Route路由

APT全名：Annotation Processiong Tool。

使用APT需要有两个部分组成，一个是注解，另一个是处理注解。

1. 注解

这里不需要Android相关的内容，所有新建一个Java Library：

20191006193602

这个模块中只需要创建注解类。

一个注解类主要有以下几个部分构成：

@Target()指定这个注解是针对哪类数据进行注解：TYPE：类；FIELD：元素；METHOD：方法；PARAMETER：参数…
@Retention()指定这个注解的生效阶段：SOURCE：在源码阶段有效；CLASS：在编译期有效；RUNTIME：在运行时有效
@interface xxx{}注解类名称
注解的方法

针对路由框架，实现的注解如下：

/**
 * @author jiazhu
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.CLASS)
public @interface BindPath {
    String value();
}

可以看出：

这个注解类是针对类进行注解的
注解在编译期有效
注解BindPath中有一个方法：value()，这个方法获取一个String类型值

BindPath获取的值作为Activity的名称，Activity的引用可以在后面通过注解处理器进行获取。

2.处理注解

处理注解也是不需要Android相关的内容，所有新建一个Java Library。

做一个注解处理器的类，需要集成AbstractProcessor注解处理器抽象类。

在处理注解之前，需要实现三个方法：

初始化这个注解处理器，并拿到一个创建文件的对象：

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

配置需要处理的注解类

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

设置支持的代码版本

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

然后需要重写父类的process方法，实现注解的处理。处理的步骤如下：

获取需要处理的被注解标注的对象，并获取对象的注解
将对象的名称和注解方法返回的值提取出来（对象名称就是Activity，注解方法的返回值就是Activity的名称）
通过Filer创建每个模块对应的添加路由的类，并用Writer写入刚才通过注解获取的Activity和名称。

最终代码如下：

/**
 * @author jiazhu
 */
@AutoService(Processor.class)
public class AnnotationCompiler extends AbstractProcessor {
    Filer mFiler;

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

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

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

    @Override
    public boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment) {
        Set<? extends Element> elements = roundEnvironment.getElementsAnnotatedWith(BindPath.class);
        HashMap<String, String> map = new HashMap<>();
        String packageName = null;
        for (Element element : elements) {
            if (element instanceof TypeElement) {
                TypeElement typeElement = (TypeElement) element;
                BindPath annotation = typeElement.getAnnotation(BindPath.class);
                String path = annotation.value();
                String activityName = typeElement.getQualifiedName().toString();
                if (packageName == null) {
                    packageName = activityName.substring(0, activityName.lastIndexOf("."));
                    packageName = packageName.replace('.', '_');
                }
                map.put(path, activityName);
            }
        }

        if (map.size() > 0) {

            Writer writer = null;
            String utilName = "ActivityUtil_" + packageName;
            try {
                JavaFileObject javaFileObject = mFiler.createSourceFile("com.example.util." + utilName);
                writer = javaFileObject.openWriter();
                Iterator<String> iterator = map.keySet().iterator();
                writer.write("package com.example.util;\n" +
                        "\n" +
                        "import com.example.route.IRoute;\n" +
                        "import com.example.route.Route;\n" +
                        "\n" +
                        "public class " + utilName + " implements IRoute {\n" +
                        "    @Override\n" +
                        "    public void putActivity() {\n");
                while (iterator.hasNext()) {
                    String path = iterator.next();
                    String value = map.get(path);
                    writer.write("Route.getInstance().putActivity(\"" + path + "\"," + value + ".class);\n");
                }

                writer.write("    }\n" +
                        "}\n");
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (writer != null) {
                    try {
                        writer.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }

        return false;
    }
}

通过注解，将各个模块的Activity添加注解，然后对代码进行一次编译。

在每一个模块生成的代码中会多出来一个类，这个类会将这个模块中的所有已注解的Activity和它们的名称传入Route类中。

当我们跳转某个模块的Activity的时候，只需要如下代码：

1	Route.getInstance().jumpActivity( "mapp/main", null);