Java注解处理器

发表于 |

注解在Android开发中用得越来越广泛，很多知名的Android库都用注解来实现了，很酷，很方便。在这篇文章将会介绍JAVA注解，并讲解如何编写一个简单的注解处理器。另外，需要注意的是，本篇文章仅仅涉及到编译时注解，不涉及运行时（runtime）注解

一些知识

JAVA注解处理器总的来说是一个javac内置的编译时扫描以及处理注解的工具。在编译阶段，通过注解处理器就可以获取到注解的内容，进而进行一些操作。例如ButterKnife，它通过注解来对View进行绑定，节省了编写绑定事件的代码的时间，其原理就是在编译阶段生成XXX_ViewBinding.java，在新生成的类中进行绑定

开始

接下来，就模仿ButterKnife来实现一个简单的注解处理器

Annotation

以Android项目为例，需要新建module用以定义annotation。

1
2
3
4
5
@Retention(RetentionPolicy.CLASS) //确定为编译时的注解
@Target(ElementType.FIELD) //注解的目标类型
public @interface AAA {
    int value();// 对应R.id.xxxx
}

Processor

Processor部分是对注解处理器的实现部分

AbstractProcessor

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class AAACompiler extends AbstractProcessor {

    @Override public Set<String> getSupportedAnnotationTypes() {
        return Collections.singleton(AAA.class.getCanonicalName());
    }

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

    @Override public synchronized void init(ProcessingEnvironment processingEnvironment) {
        super.init(processingEnvironment);
    }

    @Override public boolean process(Set<? extends TypeElement> set, RoundEnvironment env) {
        return false;
    }
}

AbstractProcessor是处理器的API

init方法内主要是使用processEnv参数，通过processEnv来获取Elements，Types以及Filer

process方法为处理注解的main方法，在这个方法里面你可以查找，处理注解，以及生成java文件，并将其编译到class中

getSupportedAnnotationTypes方法是说明需要处理那些注解

process

我们的目标是生成XXXActivity$$ViewBind.java文件，通过这个类来对View实例化，从而达到不写findViewById的目的。
例如，下面的Activity

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class MainActivity extends AppCompatActivity {

    @AAA(R.id.tv)
    TextView mTV;
    @AAA(R.id.tv_1)
    TextView mTV_1;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        MainActivity$$AAA_ViewBind.bindView(this);

        mTV.setText("AAA");
        mTV_1.setText("AAA_1");
    }
}

期望自动生成的文件为

1
2
3
4
5
6
public final class MainActivity$$AAA_ViewBind extends MainActivity {
  public static void bindView(MainActivity activity) {
    activity.mTV = (android.widget.TextView) activity.findViewById(2131427422);
    activity.mTV_1 = (android.widget.TextView) activity.findViewById(2131427423);
  }
}

因此，后续的操作是：

  • 找到@AAA注解的所有变量，并确定其所在类，记录下来
  • 根据记录，生成XXXActivity$$ViewBind类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
@Override public boolean process(Set<? extends TypeElement> set, RoundEnvironment env) {
       Map<TypeElement, List<? extends Element>> pending;
       Set<? extends Element> elements = env.getElementsAnnotatedWith(AAA.class);
       for (Element e: elements) {
           TypeElement type = (TypeElement) e.getEnclosingElement();
           ArrayList<? extends Element> list = new ArrayList<>(elementsUtils.getAllMembers(type));
           Iterator<? extends Element> it = list.listIterator();
           while (it.hasNext()) {
               Element item = it.next();
               if (item == null
                       || item.getAnnotation(AAA.class) == null) {
                   it.remove();//查找所有AAA注解的变量
               } 
           }
           if (list.size() > 0) {
               pending.put(type, list);
           }
       }

       for (TypeElement element:pending.keySet()) {
           //生成文件
           MethodSpec.Builder bindViewMethodSpecBuilder = MethodSpec.methodBuilder("bindView")
                   .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
                   .returns(TypeName.VOID)
                   .addParameter(ClassName.get(element.asType()), "activity");
           for (Element e: pending.get(element)) {
               bindViewMethodSpecBuilder.addStatement(String.format("activity.%s = (%s) activity.findViewById(%s)",
                       e.getSimpleName(), ClassName.get(e.asType()).toString(), e.getAnnotation(AAA.class).value()));
           }
           TypeSpec typeSpec = TypeSpec.classBuilder(element.getSimpleName() + "$$AAA_ViewBind")
                   .superclass(TypeName.get(element.asType()))
                   .addModifiers(Modifier.PUBLIC,Modifier.FINAL)
                   .addMethod(bindViewMethodSpecBuilder.build())
                   .build();
           JavaFile javaFile = JavaFile.builder(getPackageName(element), typeSpec).build();

           try {
               javaFile.writeTo(processingEnv.getFiler());
           } catch (IOException e) {
               //e.printStackTrace();
             
           }
       }


       return true;
   }

在生成文件的时候，可能会提示recreate file的错误，这是因为process函数会被调用多次，因此因此第一轮已经生成了java文件，而处理器不允许重新生成已经生成的文件，因此第二轮就会报错，可以用boolean进行标记来解决

至此一个简单的注解处理器已经完成了