### 最簡單的處理器 讓我們開始定義我們能想到的最簡單的處理器，只是為了編譯和測試。如下是注解的定義： ```java // annotations/simplest/Simple.java // A bare-bones annotation package annotations.simplest; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; import java.lang.annotation.ElementType; @Retention(RetentionPolicy.SOURCE) @Target({ElementType.TYPE, ElementType.METHOD, ElementType.CONSTRUCTOR, ElementType.ANNOTATION_TYPE, ElementType.PACKAGE, ElementType.FIELD, ElementType.LOCAL_VARIABLE}) public @interface Simple { String value() default "-default-"; } ``` **@Retention** 的參數現在為 **SOURCE**，這意味著注解不會再存留在編譯后的代碼。這在編譯時處理注解是沒有必要的，它只是指出，在這里，**javac** 是唯一有機會處理注解的代理。 **@Target** 聲明了幾乎所有的目標類型（除了 **PACKAGE**） ，同樣是為了演示。下面是一個測試示例。 ```java // annotations/simplest/SimpleTest.java // Test the "Simple" annotation // {java annotations.simplest.SimpleTest} package annotations.simplest; @Simple public class SimpleTest { @Simple int i; @Simple public SimpleTest() {} @Simple public void foo() { System.out.println("SimpleTest.foo()"); } @Simple public void bar(String s, int i, float f) { System.out.println("SimpleTest.bar()"); } @Simple public static void main(String[] args) { @Simple SimpleTest st = new SimpleTest(); st.foo(); } } ``` 輸出為： ```java SimpleTest.foo() ``` 在這里我們使用 **@Simple** 注解了所有 **@Target** 聲明允許的地方。 **SimpleTest.java** 只需要 **Simple.java** 就可以編譯成功。當我們編譯的時候什么都沒有發生。 **javac** 允許 **@Simple** 注解（只要它存在）在我們創建處理器并將其 hook 到編譯器之前，不做任何事情。 如下是一個十分簡單的處理器，其所作的事情就是把注解相關的信息打印出來： ```java // annotations/simplest/SimpleProcessor.java // A bare-bones annotation processor package annotations.simplest; import javax.annotation.processing.*; import javax.lang.model.SourceVersion; import javax.lang.model.element.*; import java.util.*; @SupportedAnnotationTypes( "annotations.simplest.Simple") @SupportedSourceVersion(SourceVersion.RELEASE_8) public class SimpleProcessor extends AbstractProcessor { @Override public boolean process( Set<? extends TypeElement> annotations, RoundEnvironment env) { for(TypeElement t : annotations) System.out.println(t); for(Element el : env.getElementsAnnotatedWith(Simple.class)) display(el); return false; } private void display(Element el) { System.out.println("==== " + el + " ===="); System.out.println(el.getKind() + " : " + el.getModifiers() + " : " + el.getSimpleName() + " : " + el.asType()); if(el.getKind().equals(ElementKind.CLASS)) { TypeElement te = (TypeElement)el; System.out.println(te.getQualifiedName()); System.out.println(te.getSuperclass()); System.out.println(te.getEnclosedElements()); } if(el.getKind().equals(ElementKind.METHOD)) { ExecutableElement ex = (ExecutableElement)el; System.out.print(ex.getReturnType() + " "); System.out.print(ex.getSimpleName() + "("); System.out.println(ex.getParameters() + ")"); } } } ``` （舊的，失效的）**apt** 版本的處理器需要額外的方法來確定支持哪些注解以及支持的 Java 版本。不過，你現在可以簡單的使用 **@SupportedAnnotationTypes** 和 **@SupportedSourceVersion** 注解（這是一個很好的示例關于注解如何簡化你的代碼）。 你唯一需要實現的方法就是 `process()`，這里是所有行為發生的地方。第一個參數告訴你哪個注解是存在的，第二個參數保留了剩余信息。我們所做的事情只是打印了注解（這里只存在一個），可以看 **TypeElement** 文檔中的其他行為。通過使用 `process()` 的第二個操作，我們循環所有被 **@Simple** 注解的元素，并且針對每一個元素調用我們的 `display()` 方法。所有 **Element** 展示了本身的基本信息；例如，`getModifiers()` 告訴你它是否為 **public** 和 **static** 的。 **Element** 只能執行那些編譯器解析的所有基本對象共有的操作，而類和方法之類的東西有額外的信息需要提取。所以（如果你閱讀了正確的文檔，但是我沒有在任何文檔中找到——我不得不通過 StackOverflow 尋找線索）你檢查它是哪種 **ElementKind**，然后將其向下轉換為更具體的元素類型，注入針對 CLASS 的 TypeElement 和 針對 METHOD 的ExecutableElement。此時，可以為這些元素調用其他方法。 動態向下轉型（在編譯期不進行檢查）并不像是 Java 的做事方式，這非常不直觀這也是為什么我從未想過要這樣做事。相反，我花了好幾天的時間，試圖發現你應該如何訪問這些信息，而這些信息至少在某種程度上是用不起作用的恰當方法簡單明了的。我還沒有遇到任何東西說上面是規范的形式，但在我看來是。 如果只是通過平常的方式來編譯 **SimpleTest.java**，你不會得到任何結果。為了得到注解輸出，你必須增加一個 **processor** 標志并且連接注解處理器類 ```shell javac -processor annotations.simplest.SimpleProcessor SimpleTest.java ``` 現在編譯器有了輸出 ```shell annotations.simplest.Simple ==== annotations.simplest.SimpleTest ==== CLASS : [public] : SimpleTest : annotations.simplest.SimpleTest annotations.simplest.SimpleTest java.lang.Object i,SimpleTest(),foo(),bar(java.lang.String,int,float),main(java.lang.String[]) ==== i ==== FIELD : [] : i : int ==== SimpleTest() ==== CONSTRUCTOR : [public] : <init> : ()void ==== foo() ==== METHOD : [public] : foo : ()void void foo() ==== bar(java.lang.String,int,float) ==== METHOD : [public] : bar : (java.lang.String,int,float)void void bar(s,i,f) ==== main(java.lang.String[]) ==== METHOD : [public, static] : main : (java.lang.String[])void void main(args) ``` 這給了你一些可以發現的東西，包括參數名和類型、返回值等。