动手撸一个路由框架

2019-05-02

前言

最近在对项目大刀阔斧的组件化改造，路由框架将是组件化开发中必不可少的，阿里的Arouter诚然是一个非常优秀的路由框架，但是Arouter确实也存在一些问题，比如初始化的时候会去扫描私有的dex，还有缓存机制，作为一个有追求的程序员，我们今天就来借鉴阿里Arouter的思想自己动手实现一个路由框架AwesomeRouter。我将从以下几个方面展开：

使用和原理
框架的整体架构
注解处理器APT处理自定义注解
优雅的生成路由Group类—JavaPoet的使用
Activity的跳转实现
接口化通信IProvider的实现

使用和原理

首先我们先来看看如何使用和其中的原理

如何使用

//定义注解，并设置path的值
@Router(path = "/user/LoginActivity")
public class LoginActivity extends AppCompatActivity {
			...
}

//通过path地址跳转
public void jumpLogin(View view) {
    AwesomeRouter.getInstance().build("/user/LoginActivity")
           .navigation(this);
}

可以看到用法基本和ARouter一样，接着我们看实现原理

实现原理

路由框架会在项目的编译期间扫描所有添加@Router注解的Activity类，然后将Router注解中的path地址和Activity.class文件一一对应保存在map中，我们直接看apt生成的路由Group类：

public class AwesomeRouter$$Group$$user implements IRouteGroup {
  @Override
  public Map<String, RouteMeta> loadPath() {
    Map<String, RouteMeta> pathMap = new HashMap<>();
    pathMap.put("/user/LoginActivity", RouteMeta.build(RouteMeta.Type.ACTIVITY, LoginActivity.class, "/user/LoginActivity", "user"));
    return pathMap;
  }
}

RouteMeta就是路由表的封装类，里面包含了路由的类型（包括Activity，Provider）, 路由组地址，路由地址，目标class文件。可以看到路由地址和路由表的映射map就是在AwesomeRouter$$Group$$user里面保存着，我们在跳转的时候就可以通过传入的路由地址的组地址，通过Class.forName方式找到AwesomeRouter$$Group$$userclass文件，并通过newInstance的方式得到该类的对象，再调用loadPath方法就能拿到map，然后再根据路由地址得到目标class文件，这样就能完成一次Activity跳转了，这个其实就是路由框架的核心逻辑所在。

整体架构

话不多说，直接上图：

mmap

可以看到主要分为三个moudle：

router-annotation : java的Library，自定义注解所在的库，比如定义Router注解
router-compiler：java的 Library，注解处理器所在的库，用于处理自定义注解，生成路由组代码
router-api：Android的 Library，路由框架核心逻辑代码，之所以是Android的Library，是因为里面有activity跳转的逻辑

APT处理自定义注解

APT 全称Annotation Process Tool ，也就是注解处理器，主要作用就是在编译期间处理注解，生成我们期望的代码，例如ButterKnife，EventBus都用到了APT技术，下面我们就用APT技术生成路由组代码。

自定义注解Router

新建一个java Library,在其中新建Router注解

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.CLASS)
public @interface Router {
    /**
     * 路由的详细路径，如/app/MainActivity
     */
    String path();

    /**
     * 路由组名，可以不写，从path中截取
     */
    String group() default "";
}

注解处理器的实现

通过Google的AutoService来注册注解处理器
指定注解处理器支持的java版本，参数选项，以及支持的注解类型
在init方法中获取操作Element工具类，type(类信息)工具类，以及文件生成器
process方法是在扫描到支持的注解类型时会调用的，所以我们将处理注解的逻辑写在该方法中。

下面我们看具体代码，注释写的很清楚：

# 抽象出来的BaseProcessor类
public abstract class BaseProcessor extends AbstractProcessor {

    // 操作Element工具类 (类、函数、属性都是Element)
    Elements elementUtils;

    // type(类信息)工具类，包含用于操作TypeMirror的工具方法
    Types typeUtils;

    // 文件生成器 类/资源，Filter用来创建新的类文件，class文件以及辅助文件
    Filer filer;

    Logger logger;

    /**
     * 支持的java版本
     */
    @Override
    public SourceVersion getSupportedSourceVersion() {
        return SourceVersion.latestSupported();
    }

    /**
     * 支持的参数选项
     */
    @Override
    public Set<String> getSupportedOptions() {
        return new HashSet<String>() {{
            this.add(Consts.KEY_MODULE_NAME);
        }};
    }

    @Override
    public synchronized void init(ProcessingEnvironment processingEnvironment) {
        super.init(processingEnvironment);
        elementUtils = processingEnvironment.getElementUtils();
        typeUtils = processingEnvironment.getTypeUtils();
        filer = processingEnvironment.getFiler();
        logger = new Logger(processingEnvironment.getMessager());

        String name = processingEnvironment.getOptions().get(Consts.KEY_MODULE_NAME);
        logger.info("模块的名称：" + name);
    }

}

#具体的Router注解处理类RouterProcessor
@AutoService(Processor.class)
@SupportedAnnotationTypes(Consts.ANNOTATION_TYPE_ROUTER)
public class RouterProcessor extends BaseProcessor {

    private Map<String, List<RouteMeta>> tempPathMap = new HashMap<>();

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

    @Override
    public boolean process(Set<? extends TypeElement> set, RoundEnvironment 		roundEnvironment) {
        // 有类之上使用@Router注解
        if (CollectionUtils.isNotEmpty(set)) {
            // 获取所有被 @Router 注解的 元素集合
            Set<? extends Element> elements = roundEnvironment.getElementsAnnotatedWith(Router.class);

            if (CollectionUtils.isNotEmpty(elements)) {
                // 解析元素
                try {
                    parseElements(elements);
                    return true;
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            // 返回true表示处理@Router注解完成
            return true;
        }
        return false;

    }
}

其中parseElements方法主要是根据被Router注解的elements，去生成path地址对应的RouteMeta对象：

private void parseElements(Set<? extends Element> elements) throws IOException {

    // 通过Element工具类，获取Activity、Provider类型
    TypeElement activityType = elementUtils.getTypeElement(Consts.ACTIVITY);
    TypeElement providerType = elementUtils.getTypeElement(Consts.IPROVIDER);

    // 显示类信息（获取被注解节点，类节点）这里也叫自描述 Mirror
    TypeMirror activityMirror = activityType.asType();
    TypeMirror providerMirror = providerType.asType();

    // 遍历节点
    for (Element element : elements) {
        // 获取每个元素类信息，用于比较
        TypeMirror elementMirror = element.asType();

        // 获取每个类上的@ARouter注解中的注解值
        Router router = element.getAnnotation(Router.class);

        // 路由详细信息，最终实体封装类
        RouteMeta bean = new RouteMeta.Builder()
                .setGroup(router.group())
                .setPath(router.path())
                .setElement(element)
                .build();

        // 高级判断：ARouter注解仅能用在类之上，并且是规定的Activity
        // 类型工具类方法isSubtype，相当于instance一样
        if (typeUtils.isSubtype(elementMirror, activityMirror)) {
            bean.setType(RouteMeta.Type.ACTIVITY);
        } else if (typeUtils.isSubtype(elementMirror, providerMirror)) {
            bean.setType(RouteMeta.Type.PROVIDER);
        } else {
            // 不匹配抛出异常，这里谨慎使用！考虑维护问题
            throw new RuntimeException("@ARouter注解目前仅限用于Activity类之上或者实现了IProvider接口的类之上");
        }

        // 赋值临时map存储，用来存放路由组Group对应的详细Path类对象集合
        valueOfPathMap(bean);
    }

    // (生成类文件需要实现的接口）
    TypeElement groupType = elementUtils.getTypeElement(Consts.AROUTE_GROUP); // 路径接口

    createGroupFile(groupType);
}

JavaPoet生成路由Group类

我们接着看根据注解生成Group类的过程，其实生成类文件的过程，我们也是可以采用字符串拼接的方法，但是字符串拼接的方法容易出错且不是那么的高大上（能装逼），所以我们采用更加牛逼的方式JavaPoet来生成类文件。首先我们来熟悉下一些常用的类，以及字符串的格式化规则，然后再来实践生成Group类文件。

常用类

ClassName：用来包装一个类，例如ClassName.get(Map.class)
TypeName：类型，例如返回值类型void可以使用TypeName.VOID

ParameterizedTypeName：参数化类型，TypeName的子类，例如返回值Map 可以这样写

TypeName inputMapTypeOfRoot = ParameterizedTypeName.get(
                ClassName.get(Map.class), // Map
                ClassName.get(String.class), // Map<String,
                ClassName.get(RouteMeta.class) // Map<String, RouteMeta>
        );

ParametarSpec：用来创建参数，例如（Map map）,可以这样写：

1	ParameterSpec rootParamSpec = ParameterSpec.builder(inputMapTypeOfRoot, "map").build();

MethodSpec：用来创建方法
TypeSpec：用来创建类
FieldSpec：用来创建一个成员变量

字符串格式化规则

$T: 类，接口，例如：$T , MainActivity
$S: 字符串，例如：$S , “Hello”
$N: 变量，例如：user.$N , name
$L: 字面量，例如： int value = $L , 10

具体实现

这里有一个小技巧，我们可以先把我们需要生成的类先自己手动敲出来，这样我们在写javaPoet代码的时候就不会那么抽象了。

private void createGroupFile(TypeElement groupType) throws IOException {
    // 判断是否有需要生成的类文件
    if (MapUtils.isEmpty(tempPathMap)) return;

    //返回值类型
    TypeName methodReturns = ParameterizedTypeName.get(
            ClassName.get(Map.class), // Map
            ClassName.get(String.class), // Map<String,
            ClassName.get(RouteMeta.class) // Map<String, RouteMeta>
    );

    // 遍历分组，每一个分组创建一个路径类文件，如：AwesomeRouter$$Group$$app
    for (Map.Entry<String, List<RouteMeta>> entry : tempPathMap.entrySet()) {
        // 方法配置：public Map<String, RouteMeta> loadPath() {
        MethodSpec.Builder methodBuidler = MethodSpec.methodBuilder(Consts.METHOD_LOAD_PATH) // 方法名
                .addAnnotation(Override.class) // 重写注解
                .addModifiers(Modifier.PUBLIC) // public修饰符
                .returns(methodReturns); // 返回值类型

        // 遍历之前：Map<String, RouterBean> pathMap = new HashMap<>();
        methodBuidler.addStatement("$T<$T, $T> $N = new $T<>()",
                ClassName.get(Map.class),
                ClassName.get(String.class),
                ClassName.get(RouteMeta.class),
                Consts.PATH_PARAMETER_NAME,
                HashMap.class);

        List<RouteMeta> pathList = entry.getValue();
        // 方法内容配置（遍历每个分组中每个路由详细路径）
        for (RouteMeta bean : pathList) {
            // pathMap.put("/app/MainActivity", RouteMeta.build(
            //        RouteMeta.Type.ACTIVITY, MainActivity.class, "/app/MainActivity", "app"));
            methodBuidler.addStatement(
                    "$N.put($S, $T.build($T.$L, $T.class, $S, $S))",
                    Consts.PATH_PARAMETER_NAME,
                    bean.getPath(), // "/app/MainActivity"
                    ClassName.get(RouteMeta.class), // RouteMeta
                    ClassName.get(RouteMeta.Type.class), // RouteMeta.Type
                    bean.getType(), // 枚举类型：ACTIVITY
                    ClassName.get((TypeElement) bean.getElement()), // MainActivity.class
                    bean.getPath(), // 路径名
                    bean.getGroup() // 组名
            );
        }

        // 遍历之后：return pathMap;
        methodBuidler.addStatement("return $N", Consts.PATH_PARAMETER_NAME);

        // 最终生成的类文件名
        String finalClassName = Consts.GROUP_FILE_NAME + entry.getKey();
        logger.info("APT生成路由Group类文件：" +
                Consts.PACKAGE_OF_GENERATE_FILE + "." + finalClassName);

        // 生成类文件：Router$$Group$$app
        JavaFile.builder(Consts.PACKAGE_OF_GENERATE_FILE, // 包名
                TypeSpec.classBuilder(finalClassName) // 类名
                        .addSuperinterface(ClassName.get(groupType)) // 实现IRouteGroup接口
                        .addModifiers(Modifier.PUBLIC) // public修饰符
                        .addMethod(methodBuidler.build()) // 方法的构建（方法参数 + 方法体）
                        .build()) // 类构建完成
                .build() // JavaFile构建完成
                .writeTo(filer); // 文件生成器开始生成类文件

    }
}

Activity的跳转实现

Activity跳转的代码是这样的

public void jumpLogin(View view) {
    AwesomeRouter.getInstance().build("/user/LoginActivity")
            .navigation(this);
}

首先AwesomeRouter的build方法主要是返回了一个Postcard对象，Postcard对象主要是封装的是activity跳转的参数以及动画，接着Postcard的navigation方法其实就是调用的AwesomeRouter的navigation方法，接下来我们主要看navigation方法，注释写的很清楚，应该看得懂：

Object navigation(@NonNull final Context context, final PostCard postCard) {

    //根据path地址从缓存里拿RouteMeta对象
    RouteMeta routeMeta = pathCache.get(path);

    //如果缓存里没有对应的RouteMeta对象
    if (null == routeMeta) {
        //对应的group类的全路径
        String groupClassName = Consts.PACKAGE_OF_GENERATE_FILE + Consts.GROUP_FILE_PREFIX_NAME + group;
        //根据group从缓存里拿IRouteGroup对象
        IRouteGroup routeGroup = groupCache.get(group);
        //如果缓存中没有拿到IRouteGroup对象，就通过group的全路径去加载类，并将IRouteGroup对象加入到缓存中
        if (routeGroup == null) {
            Class<?> clazz = null;
            try {
                clazz = Class.forName(groupClassName);
                routeGroup = (IRouteGroup) clazz.newInstance();
            } catch (Exception e) {
                e.printStackTrace();
                throw new RuntimeException("路由路径加载失败" + e.getMessage());
            }
            groupCache.put(group, routeGroup);
        }
        //通过IRouteGroup对象的loadPath方法拿到path地址和RouteMeta对象的映射map
        Map<String, RouteMeta> routeMetaMap = routeGroup.loadPath();
        if (routeMetaMap.isEmpty() || routeMetaMap.get(path) == null) {
            throw new RuntimeException("路由路径加载失败,没有找到对应的class文件");
        } else {
            //根据path地址，从map取出RouteMeta对象
            routeMeta = routeMetaMap.get(path);
            //加入缓存
            for (RouteMeta meta : routeMetaMap.values()) {
                pathCache.put(meta.getPath(), meta);
            }
        }
    }

    if (routeMeta != null) {
        switch (routeMeta.getType()) {
            case ACTIVITY:
                final Intent intent = new Intent(context, routeMeta.getClazz());
                intent.putExtras(postCard.getBundle());
                runInMainThread(new Runnable() {
                    @Override
                    public void run() {
                        ActivityCompat.startActivity(context, intent, null);
                        if ((-1 != postCard.getEnterAnim() && -1 != postCard.getExitAnim()) && context instanceof Activity) {    // Old version.
                            ((Activity) context).overridePendingTransition(postCard.getEnterAnim(), postCard.getExitAnim());
                        }
                    }
                });
                break;
            case PROVIDER:
                //根据path地址从provider缓存中拿到IProvider对象
                IProvider instance = iProviderCache.get(routeMeta.getPath());
                //如果从缓存中没有拿到IProvider对象，就通过newInstance的方式获取对象，并加入缓存
                if (instance == null) {
                    try {
                        instance = (IProvider) routeMeta.getClazz().newInstance();
                        instance.init(context);
                        iProviderCache.put(routeMeta.getPath(), instance);
                    } catch (Exception e) {
                        throw new RuntimeException("Init provider failed! " + e.getMessage());
                    }
                }
                return instance;
        }
    }

    return null;
}

navigation方法是整个路由跳转的核心所在，也是本路由框架和ARouter的差异所在，ARouter是通过初始化的时候异步扫描私有dex，去找到路由group class的，这种方式会存在机型适配问题，并且拖慢启动速度，虽然在后来的ARouter版本中，ARouter改为了使用gradle插件去扫描IRouterRoot实现类，实现路由表自动注册，但是在项目比较庞大，分组过多的时候还是会拖慢启动速度，然而本框架的路由加载是懒加载，是在跳转的时候才会去加载路由表。可能有人会说，因为加载的时候调用了Class.forName方法了，可能会影响页面的跳转，这个可以不需要担心，因为调用一次Class.forName方法的耗时几乎很少，而且我们再其中加入了LRU缓存机制，这样可以避免每次都要去调用forName方法。

接口化通信IProvider的实现

IProvider的实现其实和Activity的跳转实现大同小异。在注解处理器中封装RouteMeta对象的时候，会根据被Router注解的类是Activity的子类还是IProvider的子类去设置RouteMeta的类型，接着在navigation方法中会去判断RouteMeta的类型，如果是PROVIDER类型的话，就会通过newInstance的方式返回目标class的对象，这样我们就可以实现跨模块通信了。