android apt编译时期自动生成代码

最近新了一个架构，之前用dagger2时候，每当添加新activity还要修改或者新建component来完成dagger的注入。用了apt以后，在activity上标注一个注解就可以了。

本文章用最简单的方法最直白的话 来搭建一个简单的apt编译时期生成代码

首先是新建一个android项目。就不说了

然后然后是新建立一个java的Module。注意是javalib。这个lib用来专门写注解就好。为啥要单独后面会说。

这个lib里面就先放一个注解，叫TestAnno

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.CLASS)
@Target(ElementType.TYPE)
public @interface TestAnno {
}

RetentionPolicy.CLASS表示编译时候注解。。

你需要关系的就是@Target(ElementType.TYPE)这个type是类的注解，可以有方法的，属性的等等。

然后这个javalib的gradle文件要这么写

apply plugin: 'java'

dependencies {
compile fileTree(dir: 'libs', include: ['*.jar'])
}
sourceCompatibility = "1.7"
targetCompatibility = "1.7"

注解库弄好了，在弄新建一个java lib 叫inject_comiler。这个是就是核心代码了，在编译时候，执行这个个库里面的代码，然后 生成代码。这个工程 三个类。一个是注解注解处理器的核心。一个是定义生成java文件的，方法拼接。还有一个就是常量包名类名了。

先看这个的gradle文件

apply plugin: 'java'
sourceCompatibility = "1.7"
targetCompatibility = "1.7"
dependencies {
compile fileTree(include: ['*.jar'], dir: 'libs')
compile 'com.google.auto.service:auto-service:1.0-rc2'//谷歌的帮助我们快速实现注解处理器
compile project(':inject_annotation')//自己定义的注解的java lib
compile 'com.squareup:javapoet:1.7.0'//用来生成java文件的，避免字符串拼接的尴尬
}

//这个注解是谷歌提供了，快速实现注解处理器，会帮你生成配置文件啥的 。直接用就好
@AutoService(Processor.class)
public class ActivityInjectProcesser extends AbstractProcessor {
private Filer mFiler; //文件相关的辅助类
private Elements mElementUtils; //元素相关的辅助类  许多元素
private Messager mMessager; //日志相关的辅助类

private Map<String, AnnotatedClass> mAnnotatedClassMap;

@Override
public synchronized void init(ProcessingEnvironment processingEnv) {
super.init(processingEnv);
mFiler = processingEnv.getFiler();
mElementUtils = processingEnv.getElementUtils();
mMessager = processingEnv.getMessager();
mAnnotatedClassMap = new TreeMap<>();
}

//这个方法是核心方法，在这里处理的你的业务。检测类别参数，胜场java文件等
@Override
public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
mAnnotatedClassMap.clear();

try {
processActivityCheck(roundEnv);
} catch (Exception e) {
e.printStackTrace();
error(e.getMessage());
}

for (AnnotatedClass annotatedClass : mAnnotatedClassMap.values()) {
try {
annotatedClass.generateActivityFile().writeTo(mFiler);
} catch (Exception e) {
error("Generate file failed, reason: %s", e.getMessage());
}
}
return true;
}

private void processActivityCheck(RoundEnvironment roundEnv) throws IllegalArgumentException, ClassNotFoundException {
//check ruleslass forName(String className
for (Element element : roundEnv.getElementsAnnotatedWith((Class<? extends Annotation>) Class.forName(TypeUtil.ANNOTATION_PATH))) {
if (element.getKind() == ElementKind.CLASS) {
getAnnotatedClass(element);
} else
error("ActivityInject only can use  in ElementKind.CLASS");
}
}

private AnnotatedClass getAnnotatedClass(Element element) {
// tipe . can not use chines  so  ....
// get TypeElement  element is class's --->class  TypeElement typeElement = (TypeElement) element
//  get TypeElement  element is method's ---> TypeElement typeElement = (TypeElement) element.getEnclosingElement();
TypeElement typeElement = (TypeElement) element;
String fullName = typeElement.getQualifiedName().toString();
AnnotatedClass annotatedClass = mAnnotatedClassMap.get(fullName);
if (annotatedClass == null) {
annotatedClass = new AnnotatedClass(typeElement, mElementUtils, mMessager);
mAnnotatedClassMap.put(fullName, annotatedClass);
}
return annotatedClass;
}

@Override
public SourceVersion getSupportedSourceVersion() {
return SourceVersion.latestSupported();
}

//这个个方法返回你要处理注解的类型
@Override
public Set<String> getSupportedAnnotationTypes() {
Set<String> types = new LinkedHashSet<>();
types.add(TypeUtil.ANNOTATION_PATH);
return types;
}

private void error(String msg, Object... args) {
mMessager.printMessage(Diagnostic.Kind.ERROR, String.format(msg, args));
}

private void log(String msg, Object... args) {
mMessager.printMessage(Diagnostic.Kind.NOTE, String.format(msg, args));
}
}

然后是生成java文件的辅助类

public class AnnotatedClass {

private TypeElement mTypeElement;//activity  //fragmemt
private Elements mElements;
private Messager mMessager;//日志打印

public AnnotatedClass(TypeElement typeElement, Elements elements, Messager messager) {
mTypeElement = typeElement;
mElements = elements;
this.mMessager = messager;
}

public JavaFile generateActivityFile() {
// build inject method
MethodSpec.Builder injectMethod = MethodSpec.methodBuilder(TypeUtil.METHOD_NAME)
.addModifiers(Modifier.PUBLIC)
.addParameter(TypeName.get(mTypeElement.asType()), "activity", Modifier.FINAL);
injectMethod.addStatement("android.widget.Toast.makeText" +"(activity, $S,android.widget.Toast.LENGTH_SHORT).show();", "from build");
//generaClass
TypeSpec injectClass = TypeSpec.classBuilder(mTypeElement.getSimpleName() + "$$InjectActivity")
.addModifiers(Modifier.PUBLIC)
.addMethod(injectMethod.build())
.build();
String packgeName = mElements.getPackageOf(mTypeElement).getQualifiedName().toString();
return JavaFile.builder(packgeName, injectClass).build();
}

}

这里就生成了一个 类名+$$的类，有一个方法叫inject参数是这个类本身，弹出一个toast。

最后一个就是一个字符常量类

public class TypeUtil {
public static final String METHOD_NAME = "inject";
public static final String ANNOTATION_PATH = "com.example.TestAnno";
}

好了lib工程完毕。然后是主工程引用

首先是在工程的gradle里面配置下apt

dependencies {
classpath 'com.android.tools.build:gradle:2.3.2'
classpath 'com.neenbedankt.gradle.plugins:android-apt:1.8'
}

然后在app的gradle里面配置如下

apply plugin: 'com.neenbedankt.android-apt'
……
compile project(':inject_annotation')
apt project(':inject_comiler')

这样就行了。

注意是apt 。为什么要新建立javalib。因为javalib不能在引用adnroidlib，。而注解处理器是javalib来完成，app里面，可以这引用这2个，apt如果换成complie 会提示错误，但不会影响啥。

配置都好了，就是最后的使用了

总结构


在我们MainActivity 上面加上注解，使用下

@TestAnno
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
InjectActivity.inject(this);//调用build生成的类
}
}

最后一个类就是我们的使用这个在运行时，调用生成build的类

public class InjectActivity {
private static final ArrayMap<String, Object> injectMap = new ArrayMap<>();

public static void inject(AppCompatActivity activity) {
String className = activity.getClass().getName();
try {

Object inject = injectMap.get(className);

if (inject == null) {
//加载build生成的类
Class<?> aClass = Class.forName(className + "$$InjectActivity");
inject = aClass.newInstance();
injectMap.put(className, inject);
}
//反射执行方法
Method m1 = inject.getClass().getDeclaredMethod("inject", activity.getClass());
m1.invoke(inject, activity);
} catch (Exception e) {
e.printStackTrace();
}
}
}

这个类用了反射的方式查找了指定类执行了指定方法。有一个map来缓存，不用每次都重新反射。

当然你可可以不用反射，在创建build生成类的时候，实现一个接口，这里直接强转为接口，直接调用接口的方法也可以。这里简单一些用的反射

通过一个注解，就自动生成弹出toast的代码看下自动 生成的代码

public class MainActivity$$InjectActivity {
public void inject(final MainActivity activity) {
android.widget.Toast.makeText(activity, "from build",android.widget.Toast.LENGTH_SHORT).show();;
}
}

最后看下运行效果。



demo下载：https://github.com/836154942/aptdemo