Android编译时，怎么自动生成代码？
前言
在前面的Android6.0权限处理不再复杂文章中，介绍过一个开源框架PermissionsDispatcher(权限调度者)，在使用这个框架提供的@RuntimePermissions Annotation标签时，Make Project会自动在add -> build -> intermediates -> classes -> debug -> 包名路径 -> 文件名下，会生成一个名字为【文件名 + PermissionsDispatcher】的class文件，图片如下：
ScanQRActivityPermissionsDispatcher
那今天的主要内容就来讲一下，我们实现在编辑器编译时，怎么上述效果去动态生成class文件。
Annotation（注解）
现在越来越多的开源框架使用的是Annotation来进行注解配置，我在前面的一篇文章有过简单的介绍注解的配置与使用，请前往查看Android进阶之Annotation(注解)的使用文章进行了解。
如果了解过Annotation，至少知道有这样的一个知识点，那也可以继续往下看。
我们今天就是更深入的讲一下注解的内容，运用注解APT中的AbstractProcessor来实现我们想要的效果。
1，创建项目名为【myProcessor】的空项目，如下：
创建项目
项目结构
2，在项目路径下，创建名为【processor】的Module，如下：
创建Module
Java Library
PS：
一定要是【Java Library】，后面编译的时候，会直接打成组件jar包，才能提供使用。
项目结构
3，查看processor中的build.gradle文件
apply plugin: 'java'
dependencies {
compile fileTree(dir: 'libs', include: ['*.jar'])
}
sourceCompatibility = "1.7"
targetCompatibility = "1.7"
据了解，目前Android对Java 8的语言特性支持并不完善，所以在编译的时候可能会有问题，这里使用的是1.7的版本，建议使用。
4，模拟PermissionsDispatcher创建注解
在processor模块中，创建名为【RuntimePermissions】的注解，如下：
创建注解
代码如下：
package com.example;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* 运行时权限 2017/4/19 10:55
*/
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.CLASS)
public @interface RuntimePermissions {
}
5，继承AbstractProcessor，创建注解处理器，如下：
注解处理器
代码如下：
package com.example;
import java.util.Set;
import javax.annotation.processing.AbstractProcessor;
import javax.annotation.processing.RoundEnvironment;
import javax.lang.model.element.TypeElement;
/**
* 在编译时生成代码 2017/4/19 11:02
*/
public class PermissionsProcessor extends AbstractProcessor {
@Override
public boolean process(Set<? extends TypeElement> set,
RoundEnvironment roundEnvironment) {
return true;
}
}
6，指定注解处理器处理的注解类型，如下：
package com.example;
import java.util.Set;
import javax.annotation.processing.AbstractProcessor;
import javax.annotation.processing.RoundEnvironment;
import javax.annotation.processing.SupportedAnnotationTypes;
import javax.annotation.processing.SupportedSourceVersion;
import javax.lang.model.SourceVersion;
import javax.lang.model.element.TypeElement;
/**
* 在编译时生成代码 2017/4/19 11:02
*/
@SupportedAnnotationTypes("com.example.RuntimePermissions")
@SupportedSourceVersion(SourceVersion.RELEASE_7)
public class PermissionsProcessor extends AbstractProcessor {
@Override
public boolean process(Set<? extends TypeElement> set,
RoundEnvironment roundEnvironment) {
// 在这里做处理，例如生成Java文件
return true;
}
}
PS：
当编译时，系统会扫描AbstractProcessor下的所有子类，然后回调其中的process方法。
7，在process中，生成Java代码，如下：
package com.example;
import java.io.IOException;
import java.io.Writer;
import java.util.Set;
import javax.annotation.processing.AbstractProcessor;
import javax.annotation.processing.RoundEnvironment;
import javax.annotation.processing.SupportedAnnotationTypes;
import javax.annotation.processing.SupportedSourceVersion;
import javax.lang.model.SourceVersion;
import javax.lang.model.element.Element;
import javax.lang.model.element.TypeElement;
import javax.tools.JavaFileObject;
/**
* 在编译时生成代码 2017/4/19 11:02
*/
@SupportedAnnotationTypes("com.example.RuntimePermissions")
@SupportedSourceVersion(SourceVersion.RELEASE_7)
public class PermissionsProcessor extends AbstractProcessor {
@Override
public boolean process(Set<? extends TypeElement> set,
RoundEnvironment roundEnvironment) {
/**
* 循环有使用@RuntimePermissions的类 2017/4/19 11:10
*/
for (Element element : roundEnvironment.getElementsAnnotatedWith(RuntimePermissions.class)) {
String objectType = element.getSimpleName().toString(); // 类名 2017/4/19 11:11
StringBuilder builder = new StringBuilder()
.append("package com.example.chenchubin.myprocessor;\n\n")
.append("public class " + objectType + "PermissionsDispatcher" + " {\n\n")
.append("\tpublic String withCheck() {\n")
.append("\t\treturn \"");
builder.append(objectType + "PermissionsDispatcher").append(" create successfully!!!\\n");
builder.append("\";\n")
.append("\t}\n")
.append("}\n");
// 写入Java文件 2017/4/19 11:10
try {
JavaFileObject source = processingEnv.getFiler()
.createSourceFile("com.example.chenchubin.myprocessor." + objectType + "PermissionsDispatcher");
Writer writer = source.openWriter();
writer.write(builder.toString());
writer.flush();
writer.close();
} catch (IOException e) {
}
}
return true;
}
}
8，配置注解处理器的资源服务
在processor -> src -> main中，创建resources文件夹，在其中再创建META-INF.services文件夹。
在services文件夹下，创建名字为【javax.annotation.processing.Processor】的文件，内容为注解处理器的绝对路径，因为这样做的目的是为了在编译时，告知注解处理器的位置所在，如下：
Processor文件
processor的最后目录结构如下：
processor目录结构
9，配置APT插件
打开Top-Level的build.gradle文件，配置如下信息：
dependencies {
classpath 'com.neenbedankt.gradle.plugins:android-apt:1.8'
}
打开app:build.gradle文件，配置如下信息：
apply plugin: 'com.neenbedankt.android-apt'
10，编译processor.jar包
编译
processor编译后，在build -> libs下面会生成processor.jar文件，将该jar复制到app -> libs目录，重新编译即可使用。
PS：
或者在app:build.gradle文件，配置如下信息：
// 创建复制jar包的任务 2017/4/19 11:14
task processorTask(type: Exec) {
commandLine 'cp', '../processor/build/libs/processor.jar', 'libs/'
}
// 构建时，执行 2017/4/19 11:14
processorTask.dependsOn(':processor:build')
preBuild.dependsOn(processorTask)
上面的代码就是先将processor.jar包复制到libs目录下后，再编译。
11，使用@RuntimePermissions注解
在MainActivity中，使用@RuntimePermissions注解，重新编译即可，代码如下：
package com.example.chenchubin.myprocessor;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import com.example.MainActivityPermissionsDispatcher;
import com.example.RuntimePermissions;
@RuntimePermissions
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}
}
PS，重新编译后，查看如下：
文件生成
MainActivityPermissionsDispatcher文件代码如下：
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//
package com.example.chenchubin.myprocessor;
public class MainActivityPermissionsDispatcher {
public MainActivityPermissionsDispatcher() {
}
public String withCheck() {
return "MainActivityPermissionsDispatcher create successfully!!!\n";
}
}
在MainActivity.onCreate中使用，如下：
@RuntimePermissions
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
System.out.println("====== " + new MainActivityPermissionsDispatcher().withCheck());
}
}
到这里，所有的配置以及代码就都写好了，如果按照上面的流程，DEMO应该是没问题的，但有另一个问题就是，我们经常会使用到调试，那我们怎么在使用processor.jar的情况下，进入调试状态呢？
12，调试Processor代码
请参考Debugging-an-Annotator-Processor-in-your-project。
创建Remote，选择Edit Configurations，如下：
Edit Configurations
选择【+】-> 【Remote】，如下：
创建Remote
创建【Remote】，配置信息全部默认，如下：
Paste_Image.png
打开Terminal终端，输入./gradlew --stop，先关闭gradle daemon，信息如下：
./gradlew --stop
再启动daemon后台线程，代码如下：
./gradlew --no-daemon -Dorg.gradle.debug=true :app:clean :app:compileDebugJavaWithJavac
运行结果如下：
./gradlew daemon
选择需要调试的【PermissionsProcessor】类，打上断点，如下：
打断点
选择【Processor】后，点击Debug启动，如下：
Debug启动 Processor
成功启动结果如下：
成功启动
稍等10秒左右，会进入调试模式，跳转到打断点处，如下：
进入调试
这样子就可以进行正常的调试了。
总结
到这里，我们就已经正常的模拟出PermissionsDispatcher，在使用@RuntimePermissions注解时，进行编译后，会自动生成【类名 + PermissionsDispatcher】的代码文件了。
其实上面的生成Java代码用的JavaFileObject类是比较简单的，现在比较好用的是JavaPoet这个框架，如果需要生成比较复杂的代码的话，建议使用这个框架。例如在PermissionsDispatcher中，它就是使用该框架生成的类，在如下的目录中：
PermissionsDispatcher
impl/BaseProcessorUnit
有兴趣的朋友可以前往PermissionsDispatcher--processor进行查看源码，不过作者是使用kotlin写这块代码的，所以。。。想读懂的话，那就得去学一下kotlin的基本语法了。
好了，对于注解APT的AbstractProcessor就介绍到这里了，希望这篇文章对你有所帮助。
谢谢支持哈~~~
