全面剖析java中的注解（Annotation）

@Override
public String toString() {
 return "This is String Representation of current object.";
}

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.SOURCE)
public @interface Override {
}

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@interface Todo {
 public enum Priority {LOW, MEDIUM, HIGH}
 public enum Status {STARTED, NOT_STARTED}
 String author() default "Yash";
 Priority priority() default Priority.LOW;
 Status status() default Status.NOT_STARTED;
}

@Todo(priority = Todo.Priority.MEDIUM, author = "Yashwant", status = Todo.Status.STARTED)
public void incompleteMethod1() {
//Some business logic is written
//But it's not complete yet
}

@interface Author{
String value();
}
@Author("Yashwant")
public void someMethod() {
}

//指定注解保留到运行时
@Retention(RetentionPolicy.RUNTIME)
//指定注解可以修饰类、接口、枚举
@Target(ElementType.TYPE)
@interface MyTag
{
 String name() default "测试";
 int age() default 20;
}

//指定注解保留到运行时
@Retention(RetentionPolicy.RUNTIME)
//指定注解可以修饰类、接口、枚举
@Target(ElementType.TYPE)
@interface MyTags
{
 MyTag[] value();
}

@MyTags({
 @MyTag(name="测试1",age=21),
 @MyTag(name="测试2",age=22)
})
public class Test {
 public static void main(String[] args)
 {
 //通过反射解析注解
 Class testClass= Test.class;
 //获得MyTags注解
 MyTags myTagsAnnotation= (MyTags) testClass.getAnnotation(MyTags.class);
 //获得添加到里面的MyTag注解
 MyTag[] myTags=myTagsAnnotation.value();
 for(MyTag myTag : myTags)
 {
 System.out.println(String.format("name:%1$s,age:%2$d",myTag.name(),myTag.age()));
 }
 }
}

@MyTags({
 @MyTag(name="测试1",age=21),
 @MyTag(name="测试2",age=22)
})

@MyTag(name="测试1",age=21)
@MyTag(name="测试2",age=22)

//指定注解保留到运行时
@Retention(RetentionPolicy.RUNTIME)
//指定该注解只能用于方法
@Target(ElementType.METHOD)
@interface Debug
{
 boolean value() default false;
}

public class DebugTest {
 public static void main(String[] args) {
 Class debugTestClass = DebugTest.class;
 //获得所有的方法
 Method[] methods = debugTestClass.getMethods();
 for (Method method : methods) {
 method.setAccessible(true);//禁用安全机制
 if (method.isAnnotationPresent(Debug.class)) {//检查是否使用了Debug注解
 Debug debug = method.getAnnotation(Debug.class);//获得注解实例
 String name = method.getName();//获得方法名称
 if (debug.value()) {
  System.out.println("method:" + name + " should debug");
 } else {
  System.out.println("method:" + name + " should't debug");
 }
 }
 }
 }
 @Debug(false)
 public void testMethod1() {
 }
 @Debug(true)
 public void testMethod2() {
 }
 @Debug(true)
 public void testMethod3() {
 }
 @Debug(false)
 public void testMethod4() {
 }
 @Debug(true)
 public void testMethod5() {
 }
}

//指定该注解可以修饰类，接口，枚举
@Target(ElementType.TYPE)
//指定该注解保留到编译时
@Retention(RetentionPolicy.SOURCE)
//指定该注解可以被显示在文档中(通过javadoc生成文档，便可以在被该注解修饰的元素上看到该注解信息)
@Documented
public @interface Persistent {
 String table();
}

//指定该注解只能修饰字段
@Target(ElementType.FIELD)
//指定该注解保留到编译时
@Retention(RetentionPolicy.SOURCE)
//指定该注解可以被显示在文档中(通过javadoc生成文档，便可以在被该注解修饰的元素上看到该注解信息)
@Documented
public @interface Id {
 String column();
 String type();
 String generator();
}

//指定该注解只能修饰字段
@Target(ElementType.FIELD)
//指定该注解保留到编译时
@Retention(RetentionPolicy.SOURCE)
//指定该注解可以被显示在文档中(通过javadoc生成文档，便可以在被该注解修饰的元素上看到该注解信息)
@Documented
public @interface Property {
 String column();
 String type();
}

@Persistent(table="personInfo")
public class Person {
 @Id(column="person_id",type="integer",generator="identity")
 private int id;
 @Property(column="person_name",type="string")
 private String name;
 @Property(column="person_age",type="integer")
 private int age;
 
 public Person(){}
 
 public Person(int id,String name,int age)
 {
 this.id=id;
 this.name=name;
 this.age=age;
 }
 //所有属性的setter和getter.....
}

import java.io.File;
import java.io.FileOutputStream;
import java.io.PrintStream;
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.ElementKind;
import javax.lang.model.element.Name;
import javax.lang.model.element.TypeElement;

//指定该注解支持java平台的最新版本为6.0
@SupportedSourceVersion(SourceVersion.RELEASE_6)
//指定可以处理Persistent,id,Property注解
@SupportedAnnotationTypes({"Persistent","Id","Property"})
public class HibernateAnnotationProcessor extends AbstractProcessor{
 @Override
 public boolean process(Set<? extends TypeElement> annotations,
 RoundEnvironment roundEnv) {
 //定义文件输出流,用于生成额外的文件
 PrintStream ps=null;
 try{
 for(Element t:roundEnv.getElementsAnnotatedWith(Persistent.class)){
 //获取正在处理的类名称
 Name className=t.getSimpleName();
 //获得类定义前的@Persistent Annotation
 Persistent per= t.getAnnotation(Persistent.class);
 //创建文件输出流
 ps=new PrintStream(new FileOutputStream(new File(className+".hbm.xml")));
 //执行输出
 ps.println("<?xml version=\"1.0\"?>");
 ps.println("");
 ps.println("");
 ps.println("");
 for(Element f:t.getEnclosedElements())
 {
  //只处理成员变量上的Annotation
  if(f.getKind()==ElementKind.FIELD)
  {
  //获取成员变量定义前的@Id Annotation
  Id id=f.getAnnotation(Id.class);
  //但@id注解存在时，输出元素
  if(id!=null)
  {
  ps.println("");
  ps.println("");
  ps.println("");
  continue;
  }
  //获取成员变量前的@Property Annotation
  Property p=f.getAnnotation(Property.class);
  if(p!=null)
  {
  ps.println("");
  continue;
  }
  }
 }
 ps.println("");
 ps.println("");
 }
 }catch(Exception e)
 {
 e.printStackTrace();
 }finally{
 if(ps!=null)
 ps.close();
 }
 return true;
 }
}

javac -processor HibernateAnnotationProcessor Person.java

<?xml version="1.0"?>