在開始之前，我們首先申明一個非常重要的問題：我們並不討論那些在執行時（Runtime）通過反射機制執行處理的註解，而是討論在編譯時（Compile time）處理的註解。註解處理器是一個在javac中的，用來編譯時掃描和處理的註解的工具。可以為特定的註解，註冊自己的註解處理器。

一個註解的註解處理器，以Java程式碼（或者編譯過的位元組碼）作為輸入，生成檔案（通常是.java檔案）作為輸出。可以生成Java程式碼，這些生成的Java程式碼是在生成的.java檔案中，所以不能修改已經存在的Java類，例如向已有的類中新增方法。這些生成的Java檔案，會同其他普通的手動編寫的Java原始碼一樣被javac編譯。

虛處理器AbstractProcessor

我們首先看一下處理器的API。每一個處理器都是繼承於AbstractProcessor，如下所示：

public class MyProcessor extends AbstractProcessor {

    @Override
    public synchronized void init(ProcessingEnvironment env){ }

    @Override
    public boolean process(Set<? extends TypeElement> annoations, RoundEnvironment env) { }

    @Override
    public Set<String> getSupportedAnnotationTypes() { }

    @Override
    public SourceVersion getSupportedSourceVersion() { }

}
 

• init(ProcessingEnvironment env): 每一個註解處理器類都必須有一個空的建構函式。然而，這裡有一個特殊的init()方法，它會被註解處理工具呼叫，並輸入ProcessingEnviroment引數。ProcessingEnviroment提供很多有用的工具類Elements,Types和Filer。
• process(Set<? extends TypeElement> annotations, RoundEnvironment env): 這相當於每個處理器的主函式main()。 在這裡寫掃描、評估和處理註解的程式碼，以及生成Java檔案。輸入引數RoundEnviroment，可以讓查詢出包含特定註解的被註解元素。
• getSupportedAnnotationTypes(): 這裡必須指定，這個註解處理器是註冊給哪個註解的。注意，它的返回值是一個字串的集合，包含本處理器想要處理的註解型別的合法全稱。換句話說，在這裡定義你的註解處理器註冊到哪些註解上。
• getSupportedSourceVersion(): 用來指定你使用的Java版本。通常這裡返回SourceVersion.latestSupported()。然而，如果有足夠的理由只支援Java 6的話，也可以返回SourceVersion.RELEASE_6。推薦使用前者。

舉一個簡單例子

自動生成一個bean的結構檔案

把
public class Student {
	public String stu_name;
	public String stu_id;
	public int stu_age;
}
轉換為
{class:"com.robert.processor.Student",  
 fields:  
 {  
  stu_name:"java.lang.String",  
  stu_id:"java.lang.String",
  stu_age:"java.lang.Integer"
 }  
} 

package com.robert.processor;

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

@Target({ ElementType.FIELD, ElementType.TYPE })
@Retention(RetentionPolicy.CLASS)
public @interface Serialize {

}

定義自己的解析器

package com.robert.processor;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import javax.annotation.processing.AbstractProcessor;
import javax.annotation.processing.ProcessingEnvironment;
import javax.annotation.processing.RoundEnvironment;
import javax.lang.model.element.Element;
import javax.lang.model.element.ElementKind;
import javax.lang.model.element.TypeElement;
import javax.lang.model.element.VariableElement;
import javax.lang.model.util.ElementFilter;
import javax.lang.model.util.Elements;

public class MyProcessor extends AbstractProcessor {

	// 元素操作的輔助類
	Elements elementUtils;

	@Override
	public synchronized void init(ProcessingEnvironment processingEnv) {
		super.init(processingEnv);
		elementUtils = processingEnv.getElementUtils();
	}

	@Override
	public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
		// 獲得被該註解宣告的元素
		Set<? extends Element> elememts = roundEnv.getElementsAnnotatedWith(Serialize.class);
		TypeElement classElement = null;// 宣告類元素
		List<VariableElement> fields = null;// 宣告一個存放成員變數的列表
		// 存放二者
		Map<String, List<VariableElement>> maps = new HashMap<String, List<VariableElement>>();
		// 遍歷
		for (Element ele : elememts) {
			// 判斷該元素是否為類
			if (ele.getKind() == ElementKind.CLASS) {
				classElement = (TypeElement) ele;
				maps.put(classElement.getQualifiedName().toString(), fields = new ArrayList<VariableElement>());

			} else if (ele.getKind() == ElementKind.FIELD) // 判斷該元素是否為成員變數
			{
				VariableElement varELe = (VariableElement) ele;
				// 獲取該元素封裝型別
				TypeElement enclosingElement = (TypeElement) varELe.getEnclosingElement();
				// 拿到key
				String key = enclosingElement.getQualifiedName().toString();
				fields = maps.get(key);
				if (fields == null) {
					maps.put(key, fields = new ArrayList<VariableElement>());
				}
				fields.add(varELe);
			}
		}

		for (String key : maps.keySet()) {
			if (maps.get(key).size() == 0) {
				TypeElement typeElement = elementUtils.getTypeElement(key);
				List<? extends Element> allMembers = elementUtils.getAllMembers(typeElement);
				if (allMembers.size() > 0) {
					maps.get(key).addAll(ElementFilter.fieldsIn(allMembers));
				}
			}
		}
		generateFile(maps);
		return true;
	}

	private void generateFile(Map<String, List<VariableElement>> maps) {
		File dir = new File(MyProcessor.class.getResource("/").getPath());
		if (!dir.exists())
			dir.mkdirs();
		// 遍歷map
		for (String key : maps.keySet()) {

			// 建立檔案
			File file = new File(dir, key.replaceAll("\\.", "_") + ".txt");
			try {
				/**
				 * 編寫檔案內容
				 */
				FileWriter fw = new FileWriter(file);
				fw.append("{").append("class:").append("\"" + key + "\"").append(",\n ");
				fw.append("fields:\n {\n");
				List<VariableElement> fields = maps.get(key);

				for (int i = 0; i < fields.size(); i++) {
					VariableElement field = fields.get(i);
					fw.append("  ").append(field.getSimpleName()).append(":")
							.append("\"" + field.asType().toString() + "\"");
					if (i < fields.size() - 1) {
						fw.append(",");
						fw.append("\n");
					}
				}
				fw.append("\n }\n");
				fw.append("}");
				fw.flush();
				fw.close();

			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

	@Override
	public Set<String> getSupportedAnnotationTypes() {
		Set<String> set = super.getSupportedAnnotationTypes();
		if (set == null) {
			set = new HashSet<>();
		}
		set.add("com.robert.processor.Serialize");
		return set;
	}
}

我們經常使用的ButterKnife這個框架就很好的使用了AbstractProcessor

Butter Knife 是 Android 檢視欄位和方法繫結，使用註解處理來生成樣板程式碼。後面做詳細說明。

歡迎掃描二維碼，關注個人公眾號