安卓AOP三剑客之Android APT技术浅谈

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

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

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

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

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

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

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

4-1，主工程：

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

4-2，apt Module：

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

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. @Target(ElementType.TYPE) 
3. public @interface Delegate { 
4.  
5. /** 
6.  * delegate class package 
7.  */ 
8. String delegatePackage(); 
9.  
10. /** 
11.  * delegate class name 
12.  */ 
13. String delegateClassName(); 
14.  
15. /** 
16.  * delegate simple name 
17.  */ 
18. String delegateSimpleName(); 
19. } 

SingleDelegate

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

MultiDelegate

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

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

AnnotationProcessor

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