public enum RetentionPolicy {
    /**
     * Annotations are to be discarded by the compiler.
       注解将被编译器丢弃
     */
    SOURCE,

    /**
     * Annotations are to be recorded in the class file by the compiler
     * but need not be retained by the VM at run time.  This is the default
     * behavior.
       注解在class文件中可用，但会被VM丢弃
     */
    CLASS,

    /**
     * Annotations are to be recorded in the class file by the compiler and
     * retained by the VM at run time, so they may be read reflectively.
     *  VM将在运行期也保留注释，因此可以通过反射机制读取注解的信息
     * @see java.lang.reflect.AnnotatedElement 
     */
    RUNTIME
}

public enum ElementType {
    /** Class, interface (including annotation type), or enum declaration 
        类，接口(包括注解类型)或enum声明*/
    TYPE,

    /** Field declaration (includes enum constants) 
        域声明(包括 enum 实例)*/
    FIELD,

    /** Method declaration 方法声明*/
    METHOD,

    /** Formal parameter declaration 参数声明*/
    PARAMETER,

    /** Constructor declaration 构造器声明*/
    CONSTRUCTOR,

    /** Local variable declaration 局部变量声明*/
    LOCAL_VARIABLE,

    /** Annotation type declaration 注解类型声明*/
    ANNOTATION_TYPE,

    /** Package declaration 包声明*/
    PACKAGE,

    /**
     * Type parameter declaration
     *
     * @since 1.8
     */
    TYPE_PARAMETER,

    /**
     * Use of a type
     *
     * @since 1.8
     */
    TYPE_USE
}

@Documented
@Target({ElementType.TYPE, ElementType.CONSTRUCTOR, ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER})
@Inherited
@Retention(RetentionPolicy.RUNTIME)
public @interface CustomAnnotation {

	public String name() default "";
	public String value() default "";
}

/**
 * @author dgm
 * @describe ""
 */
@CustomAnnotation(name="Class Annotation",  value = " 类上的注解")
public class SampleClass {
	@CustomAnnotation(name = "field Annotation", value = "字段上的注解")
	public String sampleField;

	@CustomAnnotation(name = "constructor  Annotation", value = "构造器上的注解")
	public SampleClass(String sampleField) {
		super();
		this.sampleField = sampleField;
	}

	@CustomAnnotation(name = "Method Annotation getSampleField", value = "getSampleField无参方法上的注解")
	public String getSampleField() {
		System.out.println("getSampleField");
		return sampleField;
	}

	@CustomAnnotation(name = "Method Annotation setSampleField", value = "setSampleField方法上的注解")
	public void setSampleField(String sampleField) {
		System.out.println("setSampleField=" + sampleField);
		this.sampleField = sampleField;
	}

	@CustomAnnotation(name = "Method Annotation getSampleField hava param", value = "getSampleField有参方法上的注解")
	private String getSampleField(String sampleField) {
		return sampleField;
	}
}

/**
 * 
 * @author dgm
 * @describe ""
 */
public class CustomAnnotationTest {

	 public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
		Class c0 = SampleClass.class;
		Class c1 = Class.forName("spring.annotation.SampleClass");
		Object o = null;
		try {
			o = Class.forName("spring.annotation.SampleClass").getConstructor(String.class).newInstance("dongguangming");
		} catch (NoSuchMethodException | SecurityException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		Class c2 = o.getClass();
		System.out.println(c0 == c1);
		System.out.println(c0 == c2);
		System.out.println(c1 == c2);

		// 获取类的所有注解
		Annotation[] classAnnotation = c0.getAnnotations();
		for (Annotation ca : classAnnotation) {
			if (ca instanceof CustomAnnotation) {
				CustomAnnotation customAnnotation = (CustomAnnotation) ca;
				System.out.println("class name: " + customAnnotation.name());
				System.out.println("class value: " + customAnnotation.value());
			}
		}

		// 获取类的公有field
		Field[] fields = c0.getFields();
		for (Field field : fields) {
			Annotation[] fieldAnnotation = field.getAnnotations();
			for (Annotation fa : fieldAnnotation) {
				if (fa instanceof CustomAnnotation) {
					CustomAnnotation customAnnotation = (CustomAnnotation) fa;
					System.out
							.println("field name: " + customAnnotation.name());
					System.out.println("field value: "
							+ customAnnotation.value());

				}
			}
		}

		// 获取构造器的所有注解
		// 获取类的构造器
	    Constructor<?>[] publicConstructors = c0.getConstructors();//getDeclaredConstructors

	    for (Constructor constructor : publicConstructors) {
			Annotation[] methodAnnotation = constructor.getAnnotations();
			for (Annotation ma : methodAnnotation) {
				if (ma instanceof CustomAnnotation) {
					CustomAnnotation customAnnotation = (CustomAnnotation) ma;
					System.out.println("构造器 name: "
							+ customAnnotation.name());
					System.out.println("构造器 value: "
							+ customAnnotation.value());

				}
			}
	    }
	    
		// 获取类的公有方法
		Method[] methods = c0.getMethods();
		// Annotation annotation =
		// methods[1].getAnnotation(CustomAnnotation.class);
		for (Method method : methods) {
			Annotation[] methodAnnotation = method.getAnnotations();
			for (Annotation ma : methodAnnotation) {
				if (ma instanceof CustomAnnotation) {
					CustomAnnotation customAnnotation = (CustomAnnotation) ma;
					System.out.println("method name: "
							+ customAnnotation.name());
					System.out.println("method value: "
							+ customAnnotation.value());

				}
			}
 // 获取方法上的所有参数注解 
            Annotation[][] parameterAnnotations = method.getParameterAnnotations();
            for(Annotation[] pa : parameterAnnotations){
                for(Annotation a:pa){
                    if(a instanceof CustomAnnotation){
                        System.out.println("method param name: "
    							+ ((CustomAnnotation) a).name());
    					System.out.println("method param value: "
    							+ ((CustomAnnotation) a).value());
                    }
                }
            }

		}
	   }
}