java编译时生成代码_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代码

创建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就介绍到这里了，希望这篇文章对你有所帮助。

谢谢支持哈~~~