假设一个类定义了一个常量字段:

public class Foo {
  public static final int CONSTANT_FIELD = 3;
}

假设注解接口(interface)声明如下:

public @interface Something {
  int value();
}

最后，假设注解使用如下:

@Something(Foo.CONSTANT_FIELD)

问题:在注解处理器中，如何通过设置@Something 的值来获取CONSTANT_FIELD 的元素？

编辑:在问题本身中包含一个具体示例。

我有一个像这样使用的注释:

@RuleDependency(recognizer = BQLParser.class,
                rule = BQLParser.RULE_statement,
                version = 0)

注释处理器需要知道 RULE_statement 是 BQLParser 类中定义的常量。如果我可以通过设置注释的 rule 属性直接访问 BQLParser.RULE_statement 的 Element，那么就不需要 识别器 属性。此注释在实际应用程序中使用了数千次，识别器始终只是规则常量的声明类型。解决这个问题会将注释的使用简化为:

@RuleDependency(rule = BQLParser.RULE_statement, version = 0)

最佳答案

我能够使用 Compiler Trees API 实现此功能。

1. 更新 pom.xml 以包含以下配置文件，以确保 tools.jar 在默认情况下未被引用的系统上被引用。

   <profiles>
       <profile>
           <!-- Java 6 and earlier have java.vendor set to "Sun Microsystems Inc." -->
           <id>default-tools-6.jar</id>
           <activation>
               <property>
                   <name>java.vendor</name>
                   <value>Sun Microsystems Inc.</value>
               </property>
           </activation>
           <dependencies>
               <dependency>
                   <groupId>com.sun</groupId>
                   <artifactId>tools</artifactId>
                   <version>1.6</version>
                   <scope>system</scope>
                   <systemPath>${java.home}/../lib/tools.jar</systemPath>
               </dependency>
           </dependencies>
       </profile>
   
       <profile>
           <!-- Java 7 and later have java.vendor set to "Oracle Corporation" -->
           <id>default-tools.jar</id>
           <activation>
               <property>
                   <name>java.vendor</name>
                   <value>Oracle Corporation</value>
               </property>
           </activation>
           <dependencies>
               <dependency>
                   <groupId>com.sun</groupId>
                   <artifactId>tools</artifactId>
                   <version>1.6</version>
                   <scope>system</scope>
                   <systemPath>${java.home}/../lib/tools.jar</systemPath>
               </dependency>
           </dependencies>
       </profile>
   </profiles>
   

2. 覆盖 Processor.init获取 Trees 的实例.

   @Override
   public void init(ProcessingEnvironment processingEnv) {
       super.init(processingEnv);
       this.trees = Trees.instance(processingEnv);
   }
   

3. 实现 TreePathScanner<TypeMirror, Void> , 用于获取 TypeMirror分配给 rule 的声明类型注释中的属性。

   private class AnnotationVisitor extends TreePathScanner<TypeMirror, Void> {
       @Override
       public TypeMirror visitAnnotation(AnnotationTree node, Void p) {
           for (ExpressionTree expressionTree : node.getArguments()) {
               if (!(expressionTree instanceof AssignmentTree)) {
                   continue;
               }
   
               AssignmentTree assignmentTree = (AssignmentTree)expressionTree;
               ExpressionTree variable = assignmentTree.getVariable();
               if (!(variable instanceof IdentifierTree) || !((IdentifierTree)variable).getName().contentEquals("rule")) {
                   continue;
               }
   
               return scan(expressionTree, p);
           }
   
           return null;
       }
   
       @Override
       public TypeMirror visitAssignment(AssignmentTree at, Void p) {
           return scan(at.getExpression(), p);
       }
   
       @Override
       public TypeMirror visitMemberSelect(MemberSelectTree mst, Void p) {
           return scan(mst.getExpression(), p);
       }
   
       @Override
       public TypeMirror visitIdentifier(IdentifierTree it, Void p) {
           return trees.getTypeMirror(this.getCurrentPath());
       }
   }
   

4. 为 recognizer 提供默认值属性(property)。我希望这可以是 null但是 Java 明确禁止...

   /**
    * Gets the recognizer class where the dependent parser rules are defined.
    * This may reference the generated parser class directly, or for simplicity
    * in certain cases, any class derived from it.
    * <p>
    * If this value is not specified, the default value {@link Parser}
    * indicates that the declaring type of the constant value specified for
    * {@link #rule} should be used as the recognizer type.
    * </p>
    */
   Class<? extends Recognizer<?, ?>> recognizer() default Parser.class;
   

5. 更新收集有关 RuleDependency 信息的代码应用于特定 Element 的注释代码中的实例首先尝试访问 recognizer属性，如果未指定，则使用 rule 中常量的声明类型属性(property)代替。为简洁起见，此代码示例中省略了错误处理。

   RuleDependency dependency = element.getAnnotation(RuleDependency.class);
   
   // first try to get the parser type from the annotation
   TypeMirror recognizerType = getRecognizerType(dependency);
   if (recognizerType != null && !recognizerType.toString().equals(Parser.class.getName())) {
       result.add(new Triple<RuleDependency, TypeMirror, Element>(dependency, recognizerType, element));
       continue;
   }
   
   // fallback to compiler tree API
   AnnotationMirror annotationMirror = null;
   for (AnnotationMirror mirror : element.getAnnotationMirrors()) {
       if (processingEnv.getTypeUtils().isSameType(ruleDependencyTypeElement.asType(), mirror.getAnnotationType())) {
           annotationMirror = mirror;
           break;
       }
   }
   
   AnnotationValue annotationValue = null;
   for (Map.Entry<? extends ExecutableElement, ? extends AnnotationValue> entry : annotationMirror.getElementValues().entrySet()) {
       if (entry.getKey().getSimpleName().contentEquals("rule")) {
           annotationValue = entry.getValue();
           break;
       }
   }
   
   TreePath treePath = trees.getPath(element, annotationMirror, annotationValue);
   AnnotationVisitor visitor = new AnnotationVisitor();
   recognizerType = visitor.scan(treePath, null);
   
   result.add(new Triple<RuleDependency, TypeMirror, Element>(dependency, recognizerType, element));
   

关于java - 访问注释处理器中的常量字段，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/22360058/