安卓AOP三剑客之AndroidAPT技术浅谈

通过学习与使用square公司的开源项目Javapoet，来实现仓库层动态生成代码

创新互联主营思礼网站建设的网络公司,主营网站建设方案,手机APP定制开发,思礼h5小程序定制开发搭建,思礼网站营销推广欢迎思礼等地区企业咨询

安卓AOP三剑客: APT, AspectJ, Javassist

Android APT

APT(Annotation Processing Tool 的简称)，可以在代码编译期解析注解，并且生成新的 Java 文件，减少手动的代码输入。现在有很多主流库都用上了 APT，比如 Dagger2, ButterKnife, EventBus3 等

代表框架：

  • DataBinding
  • Dagger2
  • ButterKnife
  • EventBus3
  • DBFlow
  • AndroidAnnotation

使用姿势

1，在android工程中，创建一个java的Module，写一个类继承AbstractProcessor

 
 
 
 
    
  
  
  
  
  1. @AutoService(Processor.class) // javax.annotation.processing.IProcessor
    2. 
  
  
  
  
  2. @SupportedSourceVersion(SourceVersion.RELEASE_7) //java
    3. 
  
  
  
  
  3. @SupportedAnnotationTypes({ // 标注注解处理器支持的注解类型
    4. 
  
  
  
  
  4.     "com.annotation.SingleDelegate",
    5. 
  
  
  
  
  5.     "com.annotation.MultiDelegate"
    6. 
  
  
  
  
  6. })
    7. 
  
  
  
  
  7. public class AnnotationProcessor extends AbstractProcessor {
    8. 
  
  
  
  
  8. 
  
  
  
  
  9. public static final String PACKAGE = "com.poet.delegate";
    10. 
  
  
  
  
  10. public static final String CLASS_DESC = "From poet compiler";
    11. 
  
  
  
  
  11. 
  
  
  
  
  12. public Filer filer; //文件相关的辅助类
    13. 
  
  
  
  
  13. public Elements elements; //元素相关的辅助类
    14. 
  
  
  
  
  14. public Messager messager; //日志相关的辅助类
    15. 
  
  
  
  
  15. public Types types;
    16. 
  
  
  
  
  16. 
  
  
  
  
  17. @Override
    18. 
  
  
  
  
  18. public boolean process(Set set, RoundEnvironment roundEnvironment) {
    19. 
  
  
  
  
  19.     filer = processingEnv.getFiler();
    20. 
  
  
  
  
  20.     elements = processingEnv.getElementUtils();
    21. 
  
  
  
  
  21.     messager = processingEnv.getMessager();
    22. 
  
  
  
  
  22.     types = processingEnv.getTypeUtils();
    23. 
  
  
  
  
  23. 
  
  
  
  
  24.     new SingleDelegateProcessor().process(set, roundEnvironment, this);
    25. 
  
  
  
  
  25.     new MultiDelegateProcessor().process(set, roundEnvironment, this);
    26. 
  
  
  
  
  26. 
  
  
  
  
  27.     return true;
    28. 
  
  
  
  
  28. }
    29. 
  
  
  
  
  29. }
    30.

2，在继承AbstractProcessor类中的process方法，处理我们自定义的注解，生成代码：

 
 
 
 
    
  
  
  
  
  1. public class SingleDelegateProcessor implements IProcessor { 
    2. 
  
  
  
  
  2. @Override
    3. 
  
  
  
  
  3. public void process(Set set, RoundEnvironment roundEnv,
    4. 
  
  
  
  
  4.                 AnnotationProcessor abstractProcessor) {
    5. 
  
  
  
  
  5. // 查询注解是否存在
    6. 
  
  
  
  
  6. Set elementSet =
    7. 
  
  
  
  
  7.         roundEnv.getElementsAnnotatedWith(SingleDelegate.class);
    8. 
  
  
  
  
  8. Set typeElementSet = ElementFilter.typesIn(elementSet);
    9. 
  
  
  
  
  9. if (typeElementSet == null || typeElementSet.isEmpty()) {
    10. 
  
  
  
  
  10.     return;
    11. 
  
  
  
  
  11. } 
    12. 
  
  
  
  
  12. // 循环处理注解
    13. 
  
  
  
  
  13. for (TypeElement typeElement : typeElementSet) {
    14. 
  
  
  
  
  14.     if (!(typeElement.getKind() == ElementKind.INTERFACE)) { // 只处理接口类型
    15. 
  
  
  
  
  15.         continue;
    16. 
  
  
  
  
  16.     }
    17. 
  
  
  
  
  17. 
  
  
  
  
  18.     // 处理 SingleDelegate，只处理 annotation.classNameImpl() 不为空的注解
    19. 
  
  
  
  
  19.     SingleDelegate annotation = typeElement.getAnnotation(SingleDelegate.class);
    20. 
  
  
  
  
  20.     if ("".equals(annotation.classNameImpl())) {
    21. 
  
  
  
  
  21.         continue;
    22. 
  
  
  
  
  22.     }
    23. 
  
  
  
  
  23.     Delegate delegate = annotation.delegate();
    24. 
  
  
  
  
  24. 
  
  
  
  
  25.     // 添加构造器
    26. 
  
  
  
  
  26.     MethodSpec.Builder constructorBuilder = MethodSpec.constructorBuilder()
    27. 
  
  
  
  
  27.             .addModifiers(Modifier.PUBLIC);
    28. 
  
  
  
  
  28. 
  
  
  
  
  29.     // 创建类名相关 class builder
    30. 
  
  
  
  
  30.     TypeSpec.Builder builder =
    31. 
  
  
  
  
  31.             ProcessUtils.createTypeSpecBuilder(typeElement, annotation.classNameImpl());
    32. 
  
  
  
  
  32. 
  
  
  
  
  33.     // 处理 delegate
    34. 
  
  
  
  
  34.     builder = ProcessUtils.processDelegate(typeElement, builder,
    35. 
  
  
  
  
  35.             constructorBuilder, delegate);
    36. 
  
  
  
  
  36. 
  
  
  
  
  37.     // 检查是否继承其它接口
    38. 
  
  
  
  
  38.     builder = processSuperSingleDelegate(abstractProcessor, builder, constructorBuilder, typeElement);
    39. 
  
  
  
  
  39. 
  
  
  
  
  40.     // 完成构造器
    41. 
  
  
  
  
  41.     builder.addMethod(constructorBuilder.build());
    42. 
  
  
  
  
  42. 
  
  
  
  
  43.     // 创建 JavaFile
    44. 
  
  
  
  
  44.     JavaFile javaFile = JavaFile.builder(AnnotationProcessor.PACKAGE, builder.build()).build();
    45. 
  
  
  
  
  45.     try {
    46. 
  
  
  
  
  46.         javaFile.writeTo(abstractProcessor.filer);
    47. 
  
  
  
  
  47.     } catch (IOException e) {
    48. 
  
  
  
  
  48.         e.printStackTrace();
    49. 
  
  
  
  
  49.     }
    50. 
  
  
  
  
  50. }
    51. 
  
  
  
  
  51. }
    52.

3，在项目Gradle中添加 annotationProcessor project 引用

 
 
 
 
    
  
  
  
  
  1. compile project(':apt-delegate-annotation') 
    2. 
  
  
  
  
  2. annotationProcessor project(':apt-delegate-compiler')
    3.

4，如果有自定义注解的话，创建一个java的Module，专门放入自定义注解。项目与apt Module都需引用自定义注解Module

4-1，主工程：

 
 
 
 
    
  
  
  
  
  1. compile project(':apt-delegate-annotation') 
    2. 
  
  
  
  
  2. annotationProcessor project(':apt-delegate-compiler')
    3.

4-2，apt Module：

 
 
 
 
    
  
  
  
  
  1. compile project(':apt-delegate-annotation') 
    2. 
  
  
  
  
  2. compile 'com.google.auto.service:auto-service:1.0-rc2'
    3. 
  
  
  
  
  3. compile 'com.squareup:javapoet:1.4.0'
    4.

5，生成的源代码在build/generated/source/apt下可以看到

难点

就apt本身来说没有任何难点可言，难点一在于设计模式和解耦思想的灵活应用，二在与代码生成的繁琐，你可以手动字符串拼接，当然有更高级的玩法用squareup的javapoet，用建造者的模式构建出任何你想要的源代码

优点

它的强大之处无需多言，看代表框架的源码，你可以学到很多新姿势。总的一句话：它可以做任何你不想做的繁杂的工作，它可以帮你写任何你不想重复代码。懒人福利，老司机必备神技，可以提高车速，让你以任何姿势漂移。它可以生成任何源代码供你在任何地方使用，就像剑客的剑，快疾如风，无所不及

我想稍微研究一下,APT还可以在哪些地方使用，比如：Repository层?

APT在Repository层的尝试

了解APT与简单学习之后，搭建Repository层时，发现有一些简单，重复模版的代码

每一次添加新接口都需要简单地修改很多地方，能不能把一部分代码自动生成，减少改动的次数呢?

Repository层

IRemoteDataSource， RemoteDataSourceImpl

远程数据源，属于网络请求相关

ILocalDataSource， LocalDataSourceImpl

本地数据源，属于本地数据持久化相关

IRepository，RepositoryImpl

仓库代理类，代理远程数据源与本地数据源

Repository层APT设计思路

发现在具体实现类中，大多都是以代理类的形式调用：方法中调用代理对象，方法名称与参数，返回值类型都相同。显然可以进行APT的尝试

  • 简单的情况，具体实现类中只有一个代理对象
  • 复杂的情况，有多个代理对象，方法内并有一些变化

期望结果：

  • 把RemoteDataSourceImpl自动化生成
  • 把LocalDataSourceImpl自动化生成
  • 把RepositoryImpl自动化生成

自定义注解设计

要想具体实现类自动生成，首先要知道需要什么：

  • 方便自动生成java文件的类库
  • 自动生成类名字是什么
  • 需要注入的代理对象
  • 让代理对象代理的方法集

自动生成java文件的类库，可以使用 squareup javapoet

自动生成类名字，代理对象，方法集需要通过自定义注解配置参数的形成，在AbstractProcessor中获取

Delegate

 
 
 
 
    
  
  
  
  
  1. @Retention(RetentionPolicy.SOURCE)
    2. 
  
  
  
  
  2. @Target(ElementType.TYPE)
    3. 
  
  
  
  
  3. public @interface Delegate {
    4. 
  
  
  
  
  4. 
  
  
  
  
  5. /**
    6. 
  
  
  
  
  6.  * delegate class package
    7. 
  
  
  
  
  7.  */
    8. 
  
  
  
  
  8. String delegatePackage();
    9. 
  
  
  
  
  9. 
  
  
  
  
  10. /**
    11. 
  
  
  
  
  11.  * delegate class name
    12. 
  
  
  
  
  12.  */
    13. 
  
  
  
  
  13. String delegateClassName();
    14. 
  
  
  
  
  14. 
  
  
  
  
  15. /**
    16. 
  
  
  
  
  16.  * delegate simple name
    17. 
  
  
  
  
  17.  */
    18. 
  
  
  
  
  18. String delegateSimpleName();
    19. 
  
  
  
  
  19. }
    20.

SingleDelegate

 
 
 
 
    
  
  
  
  
  1. @Retention(RetentionPolicy.SOURCE)
    2. 
  
  
  
  
  2. @Target(ElementType.TYPE)
    3. 
  
  
  
  
  3. public @interface SingleDelegate {
    4. 
  
  
  
  
  4. 
  
  
  
  
  5. /**
    6. 
  
  
  
  
  6.  * impl class name
    7. 
  
  
  
  
  7.  */
    8. 
  
  
  
  
  8. String classNameImpl();
    9. 
  
  
  
  
  9. 
  
  
  
  
  10. /**
    11. 
  
  
  
  
  11.  * delegate data
    12. 
  
  
  
  
  12.  */
    13. 
  
  
  
  
  13. Delegate delegate();
    14. 
  
  
  
  
  14. }
    15.

MultiDelegate

 
 
 
 
    
  
  
  
  
  1. @Retention(RetentionPolicy.SOURCE)
    2. 
  
  
  
  
  2. @Target(ElementType.TYPE)
    3. 
  
  
  
  
  3. public @interface MultiDelegate { 
    4. 
  
  
  
  
  4. /**
    5. 
  
  
  
  
  5.  * impl class name
    6. 
  
  
  
  
  6.  */
    7. 
  
  
  
  
  7. String classNameImpl(); 
    8. 
  
  
  
  
  8. /**
    9. 
  
  
  
  
  9.  * delegate list
    10. 
  
  
  
  
  10.  */
    11. 
  
  
  
  
  11. Delegate[] Delegates();
    12. 
  
  
  
  
  12. }
    13.

处理自定义的注解、生成代码

AnnotationProcessor

 
 
 
 
    
  
  
  
  
  1. @AutoService(Processor.class) // javax.annotation.processing.IProcessor
    2. 
  
  
  
  
  2. @SupportedSourceVersion(SourceVersion.RELEASE_7) //java
    3. 
  
  
  
  
  3. @SupportedAnnotationTypes({ // 标注注解处理器支持的注解类型
    4. 
  
  
  
  
  4.     "com.annotation.SingleDelegate",
    5. 
  
  
  
  
  5.     "com.annotation.MultiDelegate"
    6. 
  
  
  
  
  6. })
    7. 
  
  
  
  
  7. public class AnnotationProcessor extends AbstractProcessor { 
    8. 
  
  
  
  
  8. public static final String PACKAGE = "com.poet.delegate";
    9. 
  
  
  
  
  9. public static final String CLASS_DESC = "From poet compiler"; 
    10. 
  
  
  
  
  10. public Filer filer; //文件相关的辅助类
    11. 
  
  
  
  
  11. public Elements elements; //元素相关的辅助类
    12. 
  
  
  
  
  12. public Messager messager; //日志相关的辅助类
    13. 
  
  
  
  
  13. public Types types; 
    14. 
  
  
  
  
  14. @Override
    15. 
  
  
  
  
  15. public boolean process(Set set, RoundEnvironment roundEnvironment) {
    16. 
  
  
  
  
  16.     filer = processingEnv.getFiler();
    17. 
  
  
  
  
  17.     elements = processingEnv.getElementUtils();
    18. 
  
  
  
  
  18.     messager = processingEnv.getMessager();
    19. 
  
  
  
  
  19.     types = processingEnv.getTypeUtils();
    20. 
  
  
  
  
  20. 
  
  
  
  
  21.     new SingleDelegateProcessor().process(set, roundEnvironment, this);
    22. 
  
  
  
  
  22.     new MultiDelegateProcessor().process(set, roundEnvironment, this);
    23. 
  
  
  
  
  23. 
  
  
  
  
  24.     return true;
    25. 
  
  
  
  
  25. }
    26. 
  
  
  
  
  26. }
    27.

网页题目：安卓AOP三剑客之AndroidAPT技术浅谈
分享URL：http://www.csdahua.cn/qtweb/news29/41729.html

网站建设、网络推广公司-快上网，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 快上网

成都快上网为您推荐相关内容

动态网站知识

行业网站建设

德阳服务器托管　　 　成都SEO优化　　 　都江堰网站建设　　 　铁科精智测控　　 　网站SEO优化　　 　成都网站建设报价　　 　成都网络营销　　 　商城网站建设公司　　 　zyfdjwx.com　　 　gyruijie.cn　　 　食品包装设计　　 　高防服务器租用　　 　app软件开发公司　　 　绵阳发电机　　 　手机app　　 　卖友情链接　　 　成都广告招牌　　 　广安网站建设　　 　四川晃众门窗　　 　香港主机