Java注解和注解处理器

FileObject sourceFile = processingEnv.getFiler().createSourceFile(beanClassName);

process() method takes 2 arguments:

Set<? extends TypeElement> annotations  
– the annotation types requested to be processed  
– subset of the supported annotations  

RoundEnvironment roundenv  
– environment for information about the current and prior round  
– supplies elements annotated with a given annotation or all root elements in the source  

@SupportedAnnotationTypes({"Property"})
@SupportedSourceVersion(SourceVersion.RELEASE_6)
public class PropertyAnnotationProcessor extends AbstractProcessor {
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment env) {
        // process the source file elements using the mirror API
    }
}

package com.example;	    // PackageElement
public class Foo {		    // TypeElement
    private int a;          // VariableElement
    private Foo other;      // VariableElement
    public Foo () {}        // ExecuteableElement

}

// ./Name.java  
// ./  表示当前命令行文件夹,后面所有的javc命令都以这个文件夹为准
package java.interview.annotation;

public class Name {

	private final String first;
	private final String last;

	public Name(String f, String l) {
		first = f;
		last = l;
	}

	@Comparator("NameByFirstNameComparator")
	public int compareToByFirstName(Name other) {
		if (this == other)
			return 0;
		int result;
		if ((result = this.first.compareTo(other.first)) != 0)
			return result;
		return this.last.compareTo(other.last);
	}
}

// ./angus/initerview/annotation/NameByFirstNameComparator.java

public class NameByFirstNameComparator implements java.util.Comparator<Name> {
	public int compare(Name o1, Name o2) {
		return o1.compareToByFirstName(o2);
	}

	public boolean equals(Object other) {
		return this.getClass() == other.getClass();
	}
}

// ./Comparator.java 
package angus.interview.annotation;

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

@Documented
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.SOURCE)
public @interface Comparator {
	String value();

}

package angus.interview.annotation;

import java.io.IOException;
import java.io.PrintWriter;
import java.util.Set;

import javax.annotation.processing.AbstractProcessor;
import javax.annotation.processing.RoundEnvironment;
import javax.annotation.processing.SupportedAnnotationTypes;
import javax.annotation.processing.SupportedSourceVersion;
import javax.lang.model.SourceVersion;
import javax.lang.model.element.Element;
import javax.lang.model.element.ExecutableElement;
import javax.lang.model.element.TypeElement;
import javax.lang.model.type.PrimitiveType;
import javax.lang.model.type.TypeKind;
import javax.lang.model.type.TypeMirror;
import javax.tools.Diagnostic;
import javax.tools.FileObject;

@SupportedAnnotationTypes({ "angus.interview.annotation.Comparator" })
@SupportedSourceVersion(SourceVersion.RELEASE_8)
public class MyProcessor extends AbstractProcessor {

	@Override
	public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
		
		
		for( final Element element: roundEnv.getElementsAnnotatedWith( Comparator.class ) ) {
			if(element instanceof ExecutableElement){
				ExecutableElement m = (ExecutableElement) element;
				TypeElement className = (TypeElement)m.getEnclosingElement();
				Comparator a = m.getAnnotation(Comparator.class);
				if (a != null) {

					TypeMirror returnType = m.getReturnType();

					if (!(returnType instanceof PrimitiveType)
							|| ((PrimitiveType) returnType).getKind() != TypeKind.INT) {
						processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR,
								"@Comparator can only be applied to methods that return int");
						continue;
					}
					// prepare for java file generation
					// t m a mean ?
					String comparatorClassName = a.value();
					String comparetoMethodName = m.getSimpleName().toString();
					String theProcessedClassesName = className.getQualifiedName().toString();
					try {
						writeComparatorFile(theProcessedClassesName, comparatorClassName, comparetoMethodName);
					} catch (IOException e) {
						e.printStackTrace();
						
					}

				}
			}
			
		}

		return true;// claimed now,no need next processor
	}

	/*
	 * 
	 * public class NameByFirstNameComparator implements java.util.Comparator<Name> { 
     *   public int compare(Name o1, Nameo2) { return o1.compareToByFirstName(o2); }
	 * 
	 *   public boolean equals(Object other) { return this.getClass() == other.getClass(); } }
	 */

	//!!!careful with spaces and ";"!!!
	private void writeComparatorFile(String fullClassName, String comparatorClassName, String compareToMethodName)
			throws IOException {
		int i = fullClassName.lastIndexOf(".");
		String packageName = fullClassName.substring(0, i);
		FileObject sourceFile = processingEnv.getFiler().createSourceFile(packageName + "." + comparatorClassName);
		if (sourceFile == null) {
			System.out.println("create source file failed");
		}
		PrintWriter out = new PrintWriter(sourceFile.openWriter());

		if (i > 0) {
			out.println("package " + packageName + ";");
		}
		String parametrizedType = fullClassName.substring(i + 1);//!!
		out.println(
				"public class " + comparatorClassName + " implements java.util.Comparator<" + parametrizedType + "> {");
		out.println();
		out.println("public int compare( " + parametrizedType + " o1 , " + parametrizedType + " o2 ){");
		out.println("return o1." + compareToMethodName + "(o2);");
		out.println("}");
		
		out.println();
		out.println();
		out.println("public boolean equals(Object other) {");
		out.println("return this.getClass() == other.getClass();");
		out.println("}");

		out.println("}");

		out.close();
	}

}