从0到1实现跨模块路由框架的基本原理

读完本篇能够了解的内容
1、注解的一些基本使用;
2、gradle 5.4.1版本中如何正确的导入com.google.auto.service:auto-service:1.0-rc7
类库;
3、利用javapoet编写java文件;
4、如何在编译期生成代码;
5、利用反射执行编译时生成的java类文件。
复制代码

起因

项目中看到中台编写的router路由框架可以利用注解注释后的值进行跳转,于是产生了兴趣,探究了里面实现的基本原理。

具体表现如下代码:

// 注解注释某个activity
@Route(path = "/module_mall/my_points_activity")
public class MyPointsActivity 

// 跳转
ARouter.getInstance().build("/module_mall/my_points_activity")
.navigation();
复制代码

主要实现过程如下图:

从0到1实现跨模块路由框架的基本原理

实现过程

自定义Annotation注解

新建一个java library模块,用来编写注解相关的代码 @Target(ElementType.TYPE) 表示该注解只能作用于类,@Retention(RetentionPolicy.CLASS)表示该注解作用的生命周期为编译期间。

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.CLASS)
public @interface Router {
   String value();
}
复制代码

自定义AbstractProcessor的子类

接着,新建另一个java library模块,用来编写AbstractProcessor的子类。该模块的gradle文件定义如下:

apply plugin: 'java-library'

dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar'])
    annotationProcessor 'com.google.auto.service:auto-service:1.0-rc7' // 需要引入auto-service中的注解,这里要这样写。要不然不能正确生成
    compileOnly 'com.google.auto.service:auto-service:1.0-rc7' 
    implementation 'com.squareup:javapoet:1.13.0' // 方便生成java类
    implementation project(':my_annotation') // 这是自定义的模块
    implementation project(path: ':apt') // 这是自定义的模块

}

sourceCompatibility = "7"
targetCompatibility = "7"
复制代码

注意点: 要用annotationProcessor来引入com.google.auto.service:auto-service:1.0-rc7,这样才能保证正确生成代码 ,这里对应第二个问题。

getSupportedAnnotationTypes方法返回一个set集合,用来保存编译器支持扫描的注解类型。

@Override
public Set<String> getSupportedAnnotationTypes() {
    LinkedHashSet<String> types = new LinkedHashSet<>();
    types.add(Router.class.getCanonicalName());
    return types;
}
复制代码

process方法,在编译期间会被调用,此时我们可以利用javapoet来生成相应的java代码。具体的解释在代码中写的已经很清楚,可以对照着看。

@Override
public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
        // 得到所有被router注解的类
    Set<? extends Element> annotatedElement = roundEnv.getElementsAnnotatedWith(Router.class);
    /**
     *   public void handle(Map<String, Class<?>> routeMap) {
     *   }
     *
     *   构建map类型的参数,Map<String, Class<?>>类型
     */
    ParameterizedTypeName typeName = ParameterizedTypeName.get(
            ClassName.get(Map.class),
            ClassName.get(String.class),
            ParameterizedTypeName.get(
                    ClassName.get(Class.class),
                    WildcardTypeName.subtypeOf(Object.class)
            )
    );

    // 方法名 handle
    MethodSpec.Builder methodSpec = MethodSpec.methodBuilder("handle")
            .addAnnotation(Override.class) // 给方法添加override注解
            .addModifiers(Modifier.PUBLIC) // public类型的方法
            .returns(void.class) // 返回值为void
            .addParameter(ParameterSpec.builder(typeName, "routeMap").build()); // 方法参数名 routeMap

    for (Element element : annotatedElement) {
        // 1、ElementKind.CLASS表示注解注解的类型是class
        // 2、ElementKind.FIELD表示注解的类型是类的属性
        if (element.getKind() == ElementKind.CLASS) {
            TypeElement typeElement = (TypeElement) element;
            // 获取注解类的包名信息
            PackageElement packageElement = (PackageElement) element.getEnclosingElement();
            // 通过类的全名获取注解类的classname对象
            ClassName className = ClassName.get(packageElement.getQualifiedName().toString(), typeElement.getSimpleName().toString());
            // 获取该注解
            Router annotation = element.getAnnotation(Router.class);
            // 1、annotation.value()注解的值
            // 2、$N.put($S,$T.class) 这里有三个占位符$N、$S、$T
            // 3、$N 可代表方法,变量等等;$S表示字符串;$T表示类,并且会自动import该类
            methodSpec.addStatement("$N.put($S,$T.class)", "routeMap", annotation.value(), className);
        }
    }

    ClassName interfaceName = ClassName.get(RouteTable.class);

    // 动态生成类,类名目前是写死的,其实可以利用包名生成特定的Java类
    TypeSpec helloWorld = TypeSpec.classBuilder("PerryRouteTable")
            .addModifiers(Modifier.PUBLIC) // public类型的类
            .addSuperinterface(interfaceName) // 实现的接口
            .addMethod(methodSpec.build()) // 实现的方法
            .build();
    
    // 动态生成文件
    JavaFile javaFile = JavaFile.builder(AptManager.PACKAGE_NAME, helloWorld)
            .build();
    try {
        //来自javapoet  动态生成方法
        javaFile.writeTo(processingEnv.getFiler());
    } catch (IOException e) {
        e.printStackTrace();
    }

    return true;
}
复制代码

此时,build一下我们的代码,就会在如下路径中

从0到1实现跨模块路由框架的基本原理

自动生成如下代码内容:

public class PerryRouteTable implements RouteTable {
  @Override
  public void handle(Map<String, Class<?>> routeMap) {
    routeMap.put("third_activity",ThirdActivity.class);
  }
}
复制代码

利用反射调用build中的代码

把字符串与类之间的关系写入到map集合中去。

public class AptManager {
    public static final String PACKAGE_NAME = "com.perry.router";
    private static Map<String, Class<?>> sRouteTable = new HashMap<>();

    public static void registerModule(String moduleName) {
        String routeTableName = PACKAGE_NAME + "." + moduleName;
        try {
            Class<?> clazz = Class.forName(routeTableName);
            Constructor constructor = clazz.getConstructor();
            RouteTable instance = (RouteTable) constructor.newInstance();
            instance.handle(sRouteTable);

        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

    public static Class<?> getClazzFromKey(String routerKey) {
        if (sRouteTable.isEmpty()) return null;
        return sRouteTable.get(routerKey);
    }
}

复制代码

在我们的主模块中利用反射调用handle方法,我这边为了简单起见,就默认只生成了一个java文件,按理说,不同的模块就会生成一份不同的java文件,然后循环遍历并且利用反射调用handle方法就可以了。

public class MainActivity extends AppCompatActivity {

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

    }
}
复制代码

以上就是整个实现过程,如有问题,欢迎讨论。


很遗憾的说,推酷将在这个月底关闭。人生海海,几度秋凉,感谢那些有你的时光。

原文 

https://juejin.im/post/5f180e795188252e955a7b49

本站部分文章源于互联网,本着传播知识、有益学习和研究的目的进行的转载,为网友免费提供。如有著作权人或出版方提出异议,本站将立即删除。如果您对文章转载有任何疑问请告之我们,以便我们及时纠正。

PS:推荐一个微信公众号: askHarries 或者qq群:474807195,里面会分享一些资深架构师录制的视频录像:有Spring,MyBatis,Netty源码分析,高并发、高性能、分布式、微服务架构的原理,JVM性能优化这些成为架构师必备的知识体系。还能领取免费的学习资源,目前受益良多

转载请注明原文出处:Harries Blog™ » 从0到1实现跨模块路由框架的基本原理

赞 (0)
分享到:更多 ()

评论 0

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址