3. Android 一步步手写ARouter 3分钟搞定组件化 注解+注解处理器 (APT)

CountDownLatch的使用！系统里面经常用到！

跳转遇到的问题？Arounter需要解决的问题

不能拿到对方的类。你只能通过找到类的路径去反射拿到这个class，那么有没有一种更好的解决办法呢？

Arounter的原理：产生路由表，通过key去找到value

分析：

首先第一步，定义注解：

Target:ElementType.Type

@Target(ElementType.TYPE)
 @Retention(RetentionPolicy.CLASS)
 public @interface Route {
 
 
/**
 
 
 
  
路由的路径 * * @return
 /
 String path(); /*
 
  
将路由节点进行分组，可以实现动态加载 * * @return
 */
 String group() default ""; }
 

为什么需要分组？

Route注解里有path和group，这便是仿照ARouter对路由进行分组。因为当项目变得越来越庞大的时候，为了便于管理和减小首次加载路由表过于耗时的问题

第二步：定义基本的接口

**[图片上传失败...(image-c9e97f-1640330005823)]

IRouteGroup：自定义加载接口。不是自动生成的，自定义的

public interface IRouteGroup {
 void loadInto(Map atlas); }

**

第三步，编写注解处理器。

需要生成的.java文件

[图片上传失败...(image-11f849-1640330005863)]

EaseRouter_Root_app.java: 里面需要是代表有几个模块，组。有2组

EaseRouter_Group_main.java :包含了Main模块里面的跳转

EaseRouter_Group_show.java :包含了show模块里面的跳转

public class EaseRouter_Root_app implements IRouteRoot {
 @Override
 public void loadInto(Map> routes) {
 routes.put("main", EaseRouter_Group_main.class);
 routes.put("show", EaseRouter_Group_show.class);
 }
 }
 

EaseRouter_Group_main.java文件

public class EaseRouter_Group_main implements IRouteGroup {
 @Override
 public void loadInto(Map atlas) {
 atlas.put("/main/main",RouteMeta.build(RouteMeta.Type.ACTIVITY,MainActivity.class,"/main/main","main"));
 atlas.put("/main/main2",RouteMeta.build(RouteMeta.Type.ACTIVITY,Main2Activity.class,"/main/main2","main"));
 }
 }

EaseRouter_Group_show

public class EaseRouter_Group_show implements IRouteGroup {
 @Override
 public void loadInto(Map atlas) {
 atlas.put("/show/info",RouteMeta.build(RouteMeta.Type.ACTIVITY,ShowActivity.class,"/show/info","show"));
 }
 }

通过注解的形式重写几个方法，比butterknife的又强了点！

@AutoService(Processor.class)
/**
  处理器接收的参数 替代 {@link AbstractProcessor#getSupportedOptions()} 函数
 */
@SupportedOptions(Constant.ARGUMENTS_NAME)
/**
 * 注册给哪些注解的  替代 {@link AbstractProcessor#getSupportedAnnotationTypes()} 函数
 */
@SupportedAnnotationTypes(Constant.ANNOTATION_TYPE_ROUTE)

生成文件的方法：

/**
 
 
 
  
 
   
 
    
@param set 使用了支持处理注解的节点集合
 
   
 
  
@param roundEnvironment 表示当前或是之前的运行环境,可以通过该对象查找找到的注解。
 
  
@return true 表示后续处理器不会再处理(已经处理)
 */ @Override public boolean process(Set set, RoundEnvironment roundEnvironment) {
 if (!Utils.isEmpty(set)) {
 //被Route注解的节点集合
 Set rootElements = roundEnvironment.getElementsAnnotatedWith(Route.class);
 if (!Utils.isEmpty(rootElements)) {
 processorRoute(rootElements);
 }
 return true;
 }
 return false; }
 
 
 
 
private void processorRoute(Set rootElements) {
 //获得Activity这个类的节点信息
 TypeElement activity = elementUtils.getTypeElement(Constant.ACTIVITY);
 TypeElement service = elementUtils.getTypeElement(Constant.ISERVICE);
 for (Element element : rootElements) {
 RouteMeta routeMeta;
 //类信息
 TypeMirror typeMirror = element.asType();
 log.i("Route class:" + typeMirror.toString());
 Route route = element.getAnnotation(Route.class);
 if (typeUtils.isSubtype(typeMirror, activity.asType())) {
 routeMeta = new RouteMeta(RouteMeta.Type.ACTIVITY, route, element);
 } else if (typeUtils.isSubtype(typeMirror, service.asType())) {
 routeMeta = new RouteMeta(RouteMeta.Type.ISERVICE, route, element);
 } else {
 throw new RuntimeException("Just support Activity or IService Route: " + element);
 }
 categories(routeMeta);
 }
 TypeElement iRouteGroup = elementUtils.getTypeElement(Constant.IROUTE_GROUP);
 TypeElement iRouteRoot = elementUtils.getTypeElement(Constant.IROUTE_ROOT); //生成Group记录分组表
 generatedGroup(iRouteGroup); //生成Root类 作用：记录<分组，对应的Group类>
 generatedRoot(iRouteRoot, iRouteGroup); }

用2个Map保存信息！

/**
 
 
 
  
key:组名 value:类名 / private Map rootMap = new TreeMap<>(); /*
 
  
分组 key:组名 value:对应组的路由信息 */ private Map> groupMap = new HashMap<>();

生成Group的java文件

private void generatedGroup(TypeElement iRouteGroup) {
 //创建参数类型 Map
 ParameterizedTypeName parameterizedTypeName = ParameterizedTypeName.get(
 ClassName.get(Map.class),
 ClassName.get(String.class),
 ClassName.get(RouteMeta.class));
 ParameterSpec altas = ParameterSpec.builder(parameterizedTypeName, "atlas").build(); for (Map.Entry> entry : groupMap.entrySet()) {
 MethodSpec.Builder methodBuilder = MethodSpec.methodBuilder(Constant.METHOD_LOAD_INTO)
 .addModifiers(Modifier.PUBLIC)
 .addAnnotation(Override.class)
 .addParameter(altas); String groupName = entry.getKey();
 List groupData = entry.getValue();
 for (RouteMeta routeMeta : groupData) {
 //函数体的添加
 methodBuilder.addStatement("atlas.put(T.build(L,S,$S))",
 routeMeta.getPath(),
 ClassName.get(RouteMeta.class),
 ClassName.get(RouteMeta.Type.class),
 routeMeta.getType(),
 ClassName.get(((TypeElement) routeMeta.getElement())),
 routeMeta.getPath(),
 routeMeta.getGroup());
 }
 String groupClassName = Constant.NAME_OF_GROUP + groupName;
 TypeSpec typeSpec = TypeSpec.classBuilder(groupClassName)
 .addSuperinterface(ClassName.get(iRouteGroup))
 .addModifiers(Modifier.PUBLIC)
 .addMethod(methodBuilder.build())
 .build();
 JavaFile javaFile = JavaFile.builder(Constant.PACKAGE_OF_GENERATE_FILE, typeSpec).build();
 try {
 javaFile.writeTo(filerUtils);
 } catch (IOException e) {
 e.printStackTrace();
 }
 rootMap.put(groupName, groupClassName); }
 }

几个类：

TypeElement：元素类型，比如activty,Service

TypeMirror： 类信息

注解处理器的源码：

@AutoService(Processor.class)
 /**
 处理器接收的参数 替代 {@link AbstractProcessor#getSupportedOptions()} 函数
 / @SupportedOptions(Constant.ARGUMENTS_NAME)
 /*
 
 
 
  
指定使用的Java版本 替代 {@link AbstractProcessor#getSupportedSourceVersion()} 函数
 / @SupportedSourceVersion(SourceVersion.RELEASE_7)
 /*
 
  
注册给哪些注解的 替代 {@link AbstractProcessor#getSupportedAnnotationTypes()} 函数
 */ @SupportedAnnotationTypes(Constant.ANNOTATION_TYPE_ROUTE)
 
 
 
 
public class RouterProcessor extends AbstractProcessor {
 /**
 
 
 
  
key:组名 value:类名 / private Map rootMap = new TreeMap<>();
 /*
 
  
分组 key:组名 value:对应组的路由信息 / private Map> groupMap = new HashMap<>(); /*
 
  
节点工具类 (类、函数、属性都是节点) / private Elements elementUtils; /*
 
  
type(类信息)工具类 / private Types typeUtils; /*
 
  
 
文件生成器 类/资源 */ private Filer filerUtils; private String moduleName; private Log log; @Override
 public synchronized void init(ProcessingEnvironment processingEnvironment) {
 super.init(processingEnvironment);
 //获得apt的日志输出
 log = Log.newLog(processingEnvironment.getMessager());
 elementUtils = processingEnvironment.getElementUtils();
 typeUtils = processingEnvironment.getTypeUtils();
 filerUtils = processingEnvironment.getFiler(); //参数是模块名 为了防止多模块/组件化开发的时候 生成相同的 xx文件
 Map options = processingEnvironment.getOptions();
 if (!Utils.isEmpty(options)) {
 moduleName = options.get(Constant.ARGUMENTS_NAME);
 }
 if (Utils.isEmpty(moduleName)) {
 throw new RuntimeException("Not set processor moudleName option !");
 }
 log.i("init RouterProcessor " + moduleName + " success !");
 }
 
/**
 
 
  
 
   
 
    
@param set 使用了支持处理注解的节点集合
 
   
 
  
@param roundEnvironment 表示当前或是之前的运行环境,可以通过该对象查找找到的注解。
 
  
 
@return true 表示后续处理器不会再处理(已经处理)
 */ @Override
 public boolean process(Set set, RoundEnvironment roundEnvironment) {
 if (!Utils.isEmpty(set)) {
 //被Route注解的节点集合
 Set rootElements = roundEnvironment.getElementsAnnotatedWith(Route.class);
 if (!Utils.isEmpty(rootElements)) {
 processorRoute(rootElements);
 }
 return true;
 }
 return false;
 }
 
private void processorRoute(Set rootElements) {
 //获得Activity这个类的节点信息
 TypeElement activity = elementUtils.getTypeElement(Constant.ACTIVITY);
 TypeElement service = elementUtils.getTypeElement(Constant.ISERVICE);
 for (Element element : rootElements) {
 RouteMeta routeMeta;
 //类信息
 TypeMirror typeMirror = element.asType();
 log.i("Route class:" + typeMirror.toString());
 Route route = element.getAnnotation(Route.class);
 if (typeUtils.isSubtype(typeMirror, activity.asType())) {
 routeMeta = new RouteMeta(RouteMeta.Type.ACTIVITY, route, element);
 } else if (typeUtils.isSubtype(typeMirror, service.asType())) {
 routeMeta = new RouteMeta(RouteMeta.Type.ISERVICE, route, element);
 } else {
 throw new RuntimeException("Just support Activity or IService Route: " + element);
 }
 categories(routeMeta);
 }
 TypeElement iRouteGroup = elementUtils.getTypeElement(Constant.IROUTE_GROUP);
 TypeElement iRouteRoot = elementUtils.getTypeElement(Constant.IROUTE_ROOT); //生成Group记录分组表
 generatedGroup(iRouteGroup); //生成Root类 作用：记录<分组，对应的Group类>
 generatedRoot(iRouteRoot, iRouteGroup);
 }
 
/**
 
 
  
生成Root类 作用：记录<分组，对应的Group类>
 
  
@param iRouteRoot
 
  
 
@param iRouteGroup
 */
 private void generatedRoot(TypeElement iRouteRoot, TypeElement iRouteGroup) {
 //创建参数类型 Map> routes>
 //Wildcard 通配符 ParameterizedTypeName parameterizedTypeName = ParameterizedTypeName.get(
 ClassName.get(Map.class),
 ClassName.get(String.class),
 ParameterizedTypeName.get(
 ClassName.get(Class.class),
 WildcardTypeName.subtypeOf(ClassName.get(iRouteGroup))
 ));
 //参数 Map> routes> routes
 ParameterSpec parameter = ParameterSpec.builder(parameterizedTypeName, "routes").build();
 //函数 public void loadInfo(Map> routes> routes)
 MethodSpec.Builder methodBuilder = MethodSpec.methodBuilder(Constant.METHOD_LOAD_INTO)
 .addModifiers(Modifier.PUBLIC)
 .addAnnotation(Override.class)
 .addParameter(parameter);
 //函数体
 for (Map.Entry entry : rootMap.entrySet()) {
 methodBuilder.addStatement("routes.put(T.class)", entry.getKey(), ClassName.get(Constant.PACKAGE_OF_GENERATE_FILE, entry.getValue()));
 }
 //生成类
 String className = Constant.NAME_OF_ROOT + moduleName;
 TypeSpec typeSpec = TypeSpec.classBuilder(className)
 .addSuperinterface(ClassName.get(iRouteRoot))
 .addModifiers(Modifier.PUBLIC)
 .addMethod(methodBuilder.build())
 .build();
 try {
 JavaFile.builder(Constant.PACKAGE_OF_GENERATE_FILE, typeSpec).build().writeTo(filerUtils);
 log.i("Generated RouteRoot：" + Constant.PACKAGE_OF_GENERATE_FILE + "." + className);
 } catch (IOException e) {
 e.printStackTrace();
 }
 }
 
private void generatedGroup(TypeElement iRouteGroup) {
 //创建参数类型 Map
 ParameterizedTypeName parameterizedTypeName = ParameterizedTypeName.get(
 ClassName.get(Map.class),
 ClassName.get(String.class),
 ClassName.get(RouteMeta.class));
 ParameterSpec altas = ParameterSpec.builder(parameterizedTypeName, "atlas").build(); for (Map.Entry> entry : groupMap.entrySet()) {
 MethodSpec.Builder methodBuilder = MethodSpec.methodBuilder(Constant.METHOD_LOAD_INTO)
 .addModifiers(Modifier.PUBLIC)
 .addAnnotation(Override.class)
 .addParameter(altas); String groupName = entry.getKey();
 List groupData = entry.getValue();
 for (RouteMeta routeMeta : groupData) {
 //函数体的添加
 methodBuilder.addStatement("atlas.put(T.build(L,S,$S))",
 routeMeta.getPath(),
 ClassName.get(RouteMeta.class),
 ClassName.get(RouteMeta.Type.class),
 routeMeta.getType(),
 ClassName.get(((TypeElement) routeMeta.getElement())),
 routeMeta.getPath(),
 routeMeta.getGroup());
 }
 String groupClassName = Constant.NAME_OF_GROUP + groupName;
 TypeSpec typeSpec = TypeSpec.classBuilder(groupClassName)
 .addSuperinterface(ClassName.get(iRouteGroup))
 .addModifiers(Modifier.PUBLIC)
 .addMethod(methodBuilder.build())
 .build();
 JavaFile javaFile = JavaFile.builder(Constant.PACKAGE_OF_GENERATE_FILE, typeSpec).build();
 try {
 javaFile.writeTo(filerUtils);
 } catch (IOException e) {
 e.printStackTrace();
 }
 rootMap.put(groupName, groupClassName); }
 }
 
/**
 
 
  
 
检查是否配置 group 如果没有配置 则从path截取出组名 * @param routeMeta
 */
 private void categories(RouteMeta routeMeta) {
 if (routeVerify(routeMeta)) {
 log.i("Group : " + routeMeta.getGroup() + " path=" + routeMeta.getPath());
 //分组与组中的路由信息
 List routeMetas = groupMap.get(routeMeta.getGroup());
 if (Utils.isEmpty(routeMetas)) {
 routeMetas = new ArrayList<>();
 routeMetas.add(routeMeta);
 groupMap.put(routeMeta.getGroup(), routeMetas);
 } else {
 routeMetas.add(routeMeta);
 }
 } else {
 log.i("Group info error:" + routeMeta.getPath());
 }
 }
 
/**
 
 
  
验证path路由地址的合法性 * @param routeMeta
 
  
@return
 */
 private boolean routeVerify(RouteMeta routeMeta) {
 String path = routeMeta.getPath();
 String group = routeMeta.getGroup();
 // 必须以 / 开头来指定路由地址
 if (!path.startsWith("/")) {
 return false;
 }
 //如果group没有设置 我们从path中获得group
 if (Utils.isEmpty(group)) {
 String defaultGroup = path.substring(1, path.indexOf("/", 1));
 //截取出的group还是空
 if (Utils.isEmpty(defaultGroup)) {
 return false;
 }
 routeMeta.setGroup(defaultGroup);
 }
 return true;
 }
 
 
 
 
}
 

第四步： 文件生成后，需要调用，通过反射，需要反射去创建实例！

先模拟调用的代码！

需要2个Map去装载组和类

public void test() {
    EaseRouter_Root_app rootApp = new EaseRouter_Root_app();
    HashMap> rootMap = new HashMap<>();
    rootApp.loadInto(rootMap);

    //得到/main分组
    Class aClass = rootMap.get("main");
    try {
        HashMap groupMap = new HashMap<>();
        aClass.newInstance().loadInto(groupMap);
        //得到MainActivity
        RouteMeta main = groupMap.get("/main/main");
        Class mainActivityClass = main.getDestination();

        Intent intent = new Intent(this, mainActivityClass);
        startActivity(intent);
    } catch (InstantiationException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    }

}

具体：在application的时候去填充map

public class Warehouse {
 
 
// root 映射表 保存分组信息
 
 
static Map> groupsIndex = new HashMap<>(); // group 映射表 保存组中的所有数据
 static Map routes = new HashMap<>(); // group 映射表 保存组中的所有数据
 static Map services = new HashMap<>();
 // TestServiceImpl.class , TestServiceImpl 没有再反射 /**
 
 
 
  
以键值对优先级的方式保存拦截器对象 / public static Map> interceptorsIndex = new UniqueKeyTreeMap<>();
 /*
 
  
以集合的方式保存所有拦截器对象 */ public static List interceptors = new ArrayList<>(); }
 

/**
 
 
 
  
 
分组表制作 */ private static void loadInfo() throws PackageManager.NameNotFoundException, InterruptedException, ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
 //获得所有 apt生成的路由类的全类名 (路由表)
 Set routerMap = ClassUtils.getFileNameByPackageName(mContext, ROUTE_ROOT_PAKCAGE);
 for (String className : routerMap) {
 if (className.startsWith(ROUTE_ROOT_PAKCAGE + "." + SDK_NAME + SEPARATOR + SUFFIX_ROOT)) {
 //root中注册的是分组信息 将分组信息加入仓库中
 ((IRouteRoot) Class.forName(className).getConstructor().newInstance()).loadInto(Warehouse.groupsIndex);
 } else if (className.startsWith(ROUTE_ROOT_PAKCAGE + "." + SDK_NAME + SEPARATOR + SUFFIX_INTERCEPTOR)) {
 
     ((IInterceptorGroup) Class.forName(className).getConstructor().newInstance()).loadInto(Warehouse.interceptorsIndex);
 
 
 
 
 
}
 }
 for (Map.Entry> stringClassEntry : Warehouse.groupsIndex.entrySet()) {
 Log.d(TAG, "Root映射表[ " + stringClassEntry.getKey() + " : " + stringClassEntry.getValue() + "]");
 }
 
 
}

这里用到了CountDownLatch类，会分path一个文件一个文件的检索，等到所有的类文件都找到后便会返回这个Set集合。

注意，Warehouse就是专门用来存放路由映射关系的类，里面保存着存路由信息的map，这在ARouter里面也是一样的。这段代码Warehouse.routes.get(card.getPath())通过path拿到对应的RouteMeta，这个RouteMeta里面保存了activityClass等信息。继续往下看，如果判断拿到的RouteMeta是空，说明这个路由地址还没有加载到map里面(初始化时为了节省性能，只会加载所有的分组信息，而每个分组下的路由映射关系，会使用懒加载，在首次用到的时候去加载)

下面就是用到了反射！！

/**
 
 
 
  
准备卡片 * * @param card
 */ private void prepareCard(Postcard card) {
 RouteMeta routeMeta = Warehouse.routes.get(card.getPath());
 if (null == routeMeta) {
 Class groupMeta = Warehouse.groupsIndex.get(card.getGroup());
 if (null == groupMeta) {
 throw new NoRouteFoundException("没找到对应路由：分组=" + card.getGroup() + " 路径=" + card.getPath());
 }
 IRouteGroup iGroupInstance;
 try {
 iGroupInstance = groupMeta.getConstructor().newInstance();
 } catch (Exception e) {
 throw new RuntimeException("路由分组映射表记录失败.", e);
 }
 iGroupInstance.loadInto(Warehouse.routes);
 //已经准备过了就可以移除了 (不会一直存在内存中)
 Warehouse.groupsIndex.remove(card.getGroup());
 //再次进入 else
 prepareCard(card);
 } else {
 //类 要跳转的activity 或IService实现类
 card.setDestination(routeMeta.getDestination());
 card.setType(routeMeta.getType());
 switch (routeMeta.getType()) {
 case ISERVICE:
 Class destination = routeMeta.getDestination();
 IService service = Warehouse.services.get(destination);
 if (null == service) {
 try {
 service = (IService) destination.getConstructor().newInstance();
 Warehouse.services.put(destination, service);
 } catch (Exception e) {
 e.printStackTrace();
 }
 }
 card.setService(service);
 break; default:
 break;
 }
 }
 }

最好的实现

https://www.jianshu.com/p/857aea5b54a8