Java注解是附加在代码中的一些元信息，用于一些工具在编译、运行时进行解析和使用，起到说明、配置的功能。
注解不会也不能影响代码的实际逻辑，仅仅起到辅助性的作用。包含在 java.lang.annotation 包中。1、元注解
元注解是指注解的注解。包括 @Retention @Inherited四种。
1.1、@Retention: 定义注解的保留策略
@Retention(RetentionPolicy. SOURCE) //注解仅存在于源码中，在class字节码文件中不包含
@Retention(RetentionPolicy. CLASS) // 默认的保留策略，注解会在class字节码文件中存在，但运行时无法获得，
@Retention(RetentionPolicy.RUNTIME) // 注解会在class字节码文件中存在，在运行时可以通过反射获取到
1.2、@Target：定义注解的作用目标
其定义的源码为：
1 @Documented 2 @Retention(RetentionPolicy.RUNTIME) 3 @Target(ElementType.ANNOTATION_TYPE) 4 public @interface Target { 5 ElementType[] value(); 6 } @Target(ElementType.TYPE) //接口、类、枚举、注解
@Target(ElementType.FIELD) // 字段、枚举的常量
@Target(ElementType.METHOD) // 方法
@Target(ElementType.PARAMETER) // 方法参数
@Target(ElementType.CONSTRUCTOR) // 构造函数
@Target(ElementType.LOCAL_VARIABLE) // 局部变量
@Target(ElementType.ANNOTATION_TYPE) // 注解
@Target(ElementType.PACKAGE) / // 包
由以上的源码可以知道，他的elementType 可以有多个，一个注解可以为类的，方法的，字段的等等
1.3、@Document：说明该注解将被包含在javadoc中
1.4、@Inherited：说明子类可以继承父类中的该注解
2、java 注解的自定义
下面是自定义注解的一个例子
@Documented @Target({ElementType.TYPE,ElementType.METHOD}) @Retention(RetentionPolicy.RUNTIME) public @interface Yts { public enum YtsType{util,entity,service,model}; public YtsType classType() default YtsType.util; } 1 @Documented 2 @Retention(RetentionPolicy.RUNTIME) 3 @Target(ElementType.METHOD) 4 @Inherited 5 public @interface HelloWorld { 6 public String name()default ""; 7 } @Retention(RetentionPolicy.RUNTIME)
定义的这个注解是注解会在class字节码文件中存在，在运行时可以通过反射获取到。
@Target({ElementType.TYPE,ElementType.METHOD})
因此这个注解可以是类注解，也可以是方法的注解
这样一个注解就自定义好了，当然注解里面的成员可以为基本的数据类型，也可以为数据，Object等等
3 注解是定义好了，那么怎么来得到，解析注解呢？
java的反射机制可以帮助，得到注解，代码如下：
1 public class ParseAnnotation { 2 3 public void parseMethod(Class clazz) throws IllegalArgumentException, IllegalAccessException, InvocationTargetException, SecurityException, NoSuchMethodException, InstantiationException{ 4 Object obj = clazz.getConstructor(new Class[]{}).newInstance(new Object[]{}); 5 for(Method method : clazz.getDeclaredMethods()){ 6 HelloWorld say = method.getAnnotation(HelloWorld.class); 7 String name = ""; 8 if(say != null){ 9 name = say.name(); 10 method.invoke(obj, name); 11 } 12 Yts yts = (Yts)method.getAnnotation(Yts.class); 13 if(yts != null){ 14 if(YtsType.util.equals(yts.classType())){ 15 System.out.println("this is a util method"); 16 }else{ 17 System.out.println("this is a other method"); 18 } 19 } 20 } 21 } 22 @SuppressWarnings("unchecked") 23 public void parseType(Class clazz) throws IllegalArgumentException, IllegalAccessException, InvocationTargetException{ 24 Yts yts = (Yts) clazz.getAnnotation(Yts.class); 25 if(yts != null){ 26 if(YtsType.util.equals(yts.classType())){ 27 System.out.println("this is a util class"); 28 }else{ 29 System.out.println("this is a other class"); 30 } 31 } 32 } 33 34 } 前一个方法是解析得到方法注解的，后一个方法是得到类注解的
以下是测试方法类
1 @Yts(classType =YtsType.util) 2 public class SayHell { 3 4 @HelloWorld(name = " 小明 ") 5 @Yts 6 public void sayHello(String name){ 7 if(name == null || name.equals("")){ 8 System.out.println("hello world!"); 9 }else{ 10 System.out.println(name + "say hello world!"); 11 } 12 } 13 } 1 public static void main(String[] args) throws IllegalArgumentException, IllegalAccessException, InvocationTargetException, SecurityException, NoSuchMethodException, InstantiationException { 2 ParseAnnotation parse = new ParseAnnotation(); 3 parse.parseMethod(SayHell.class); 4 parse.parseType(SayHell.class); 5 }
1、Annotation的工作原理：
JDK5.0中提供了注解的功能，允许开发者定义和使用自己的注解类型。该功能由一个定义注解类型的语法和描述一个注解声明的语法，读取注解的API，一个使用注解修饰的class文件和一个注解处理工具组成。
Annotation并不直接影响代码的语义，但是他可以被看做是程序的工具或者类库。它会反过来对正在运行的程序语义有所影响。
Annotation可以冲源文件、class文件或者在运行时通过反射机制多种方式被读取。
2、@Override注解：
java.lang注释类型 Override@Target(value=METHOD)@Retention(value=SOURCE)public @interface Override
表示一个方法声明打算重写超类中的另一个方法声明。如果方法利用此注释类型进行注解但没有重写超类方法，则编译器会生成一条错误消息。
@Override注解表示子类要重写父类的对应方法。
Override是一个Marker annotation，用于标识的Annotation，Annotation名称本身表示了要给工具程序的信息。
下面是一个使用@Override注解的例子：
class A { private String id; A(String id){ this.id = id; } @Override public String toString() { return id; }} 3、@Deprecated注解：
java.lang注释类型 Deprecated@Documented@Retention(value=RUNTIME)public @interface Deprecated
用 @Deprecated 注释的程序元素，不鼓励程序员使用这样的元素，通常是因为它很危险或存在更好的选择。在使用不被赞成的程序元素或在不被赞成的代码中执行重写时，编译器会发出警告。
@Deprecated注解表示方法是不被建议使用的。
Deprecated是一个Marker annotation。
下面是一个使用@Deprecated注解的例子：
class A { private String id; A(String id){ this.id = id; } @Deprecated public void execute(){ System.out.println(id); } public static void main(String[] args) { A a = new A("a123"); a.execute(); }} 4、@SuppressWarnings注解：
java.lang注释类型 SuppressWarnings@Target(value={TYPE,FIELD,METHOD,PARAMETER,CONSTRUCTOR,LOCAL_VARIABLE})@Retention(value=SOURCE)public @interface SuppressWarnings 指示应该在注释元素（以及包含在该注释元素中的所有程序元素）中取消显示指定的编译器警告。注意，在给定元素中取消显示的警告集是所有包含元素中取消显示的警告的超集。例如，如果注释一个类来取消显示某个警告，同时注释一个方法来取消显示另一个警告，那么将在此方法中同时取消显示这两个警告。
根据风格不同，程序员应该始终在最里层的嵌套元素上使用此注释，在那里使用才有效。如果要在特定的方法中取消显示某个警告，则应该注释该方法而不是注释它的类。
@SuppressWarnings注解表示抑制警告。
下面是一个使用@SuppressWarnings注解的例子：
@SuppressWarnings("unchecked") public static void main(String[] args) { List list = new ArrayList(); list.add("abc");} 5、自定义注解：
使用@interface自定义注解时，自动继承了java.lang.annotation.Annotation接口，由编译程序自动完成其他细节。在定义注解时，不能继承其他的注解或接口。
自定义最简单的注解：
public @interface MyAnnotation {} 使用自定义注解：
public class AnnotationTest2 { @MyAnnotation public void execute(){ System.out.println("method"); }} 5.1、添加变量：
public @interface MyAnnotation { String value1();} 使用自定义注解：
public class AnnotationTest2 { @MyAnnotation(value1="abc") public void execute(){ System.out.println("method"); }} 当注解中使用的属性名为value时，对其赋值时可以不指定属性的名称而直接写上属性值接口；除了value意外的变量名都需要使用name=value的方式赋值。
5.2、添加默认值：
public @interface MyAnnotation { String value1() default "abc";} 5.3、多变量使用枚举：
public @interface MyAnnotation { String value1() default "abc"; MyEnum value2() default MyEnum.Sunny;}enum MyEnum{ Sunny,Rainy} 使用自定义注解：
public class AnnotationTest2 { @MyAnnotation(value1="a", value2=MyEnum.Sunny) public void execute(){ System.out.println("method"); }} 5.4、数组变量：
public @interface MyAnnotation { String[] value1() default "abc";} 使用自定义注解：
public class AnnotationTest2 { @MyAnnotation(value1={"a","b"}) public void execute(){ System.out.println("method"); }} 6、设置注解的作用范围：
@Documented@Retention(value=RUNTIME)@Target(value=ANNOTATION_TYPE)public @interface Retention
指示注释类型的注释要保留多久。如果注释类型声明中不存在 Retention 注释，则保留策略默认为 RetentionPolicy.CLASS。
只有元注释类型直接用于注释时，Target 元注释才有效。如果元注释类型用作另一种注释类型的成员，则无效。
public enum RetentionPolicy extends Enum
注释保留策略。此枚举类型的常量描述保留注释的不同策略。它们与 Retention 元注释类型一起使用，以指定保留多长的注释。
CLASS 编译器将把注释记录在类文件中，但在运行时 VM 不需要保留注释。 RUNTIME 编译器将把注释记录在类文件中，在运行时 VM 将保留注释，因此可以反射性地读取。 SOURCE 编译器要丢弃的注释。
@Retention注解可以在定义注解时为编译程序提供注解的保留策略。
属于CLASS保留策略的注解有@SuppressWarnings，该注解信息不会存储于.class文件。
6.1、在自定义注解中的使用例子：
@Retention(RetentionPolicy.CLASS) public @interface MyAnnotation { String[] value1() default "abc";} 7、使用反射读取RUNTIME保留策略的Annotation信息的例子：
java.lang.reflect 接口 AnnotatedElement 所有已知实现类： AccessibleObject, Class, Constructor, Field, Method, Package
表示目前正在此 VM 中运行的程序的一个已注释元素。该接口允许反射性地读取注释。由此接口中的方法返回的所有注释都是不可变并且可序列化的。调用者可以修改已赋值数组枚举成员的访问器返回的数组；这不会对其他调用者返回的数组产生任何影响。
如果此接口中的方法返回的注释（直接或间接地）包含一个已赋值的 Class 成员，该成员引用了一个在此 VM 中不可访问的类，则试图通过在返回的注释上调用相关的类返回的方法来读取该类，将导致一个 TypeNotPresentException。
isAnnotationPresentboolean isAnnotationPresent(Class annotationClass)
如果指定类型的注释存在于此元素上，则返回 true，否则返回 false。此方法主要是为了便于访问标记注释而设计的。
参数：
annotationClass - 对应于注释类型的 Class 对象
返回：
如果指定注释类型的注释存在于此对象上，则返回 true，否则返回 false
抛出：
NullPointerException - 如果给定的注释类为 null
从以下版本开始：
1.5
getAnnotationT getAnnotation(Class annotationClass)
如果存在该元素的指定类型的注释，则返回这些注释，否则返回 null。
参数：
annotationClass - 对应于注释类型的 Class 对象
返回：
如果该元素的指定注释类型的注释存在于此对象上，则返回这些注释，否则返回 null
抛出：
NullPointerException - 如果给定的注释类为 null
从以下版本开始：
1.5
getAnnotationsAnnotation[] getAnnotations()
返回此元素上存在的所有注释。（如果此元素没有注释，则返回长度为零的数组。）该方法的调用者可以随意修改返回的数组；这不会对其他调用者返回的数组产生任何影响。
返回：
此元素上存在的所有注释
从以下版本开始：
1.5
getDeclaredAnnotationsAnnotation[] getDeclaredAnnotations()
返回直接存在于此元素上的所有注释。与此接口中的其他方法不同，该方法将忽略继承的注释。（如果没有注释直接存在于此元素上，则返回长度为零的一个数组。）该方法的调用者可以随意修改返回的数组；这不会对其他调用者返回的数组产生任何影响。
返回：
直接存在于此元素上的所有注释
从以下版本开始：
1.5
下面是使用反射读取RUNTIME保留策略的Annotation信息的例子：
自定义注解：@Retention(RetentionPolicy.RUNTIME) public @interface MyAnnotation { String[] value1() default "abc";} 使用自定义注解：
public class AnnotationTest2 { @MyAnnotation(value1={"a","b"}) @Deprecated public void execute(){ System.out.println("method"); }} 读取注解中的信息：
public static void main(String[] args) throws SecurityException, NoSuchMethodException, IllegalArgumentException, IllegalAccessException, InvocationTargetException { AnnotationTest2 annotationTest2 = new AnnotationTest2(); //获取AnnotationTest2的Class实例 Class c = AnnotationTest2.class; //获取需要处理的方法Method实例 Method method = c.getMethod("execute", new Class[]{}); //判断该方法是否包含MyAnnotation注解 if(method.isAnnotationPresent(MyAnnotation.class)){ //获取该方法的MyAnnotation注解实例 MyAnnotation myAnnotation = method.getAnnotation(MyAnnotation.class); //执行该方法 method.invoke(annotationTest2, new Object[]{}); //获取myAnnotation String[] value1 = myAnnotation.value1(); System.out.println(value1[0]); } //获取方法上的所有注解 Annotation[] annotations = method.getAnnotations(); for(Annotation annotation : annotations){ System.out.println(annotation); }} 8、限定注解的使用：
限定注解使用@Target。
@Documented@Retention(value=RUNTIME)@Target(value=ANNOTATION_TYPE)public @interface Target
指示注释类型所适用的程序元素的种类。如果注释类型声明中不存在 Target 元注释，则声明的类型可以用在任一程序元素上。如果存在这样的元注释，则编译器强制实施指定的使用限制。 例如，此元注释指示该声明类型是其自身，即元注释类型。它只能用在注释类型声明上：
@Target(ElementType.ANNOTATION_TYPE) public @interface MetaAnnotationType { ... } 此元注释指示该声明类型只可作为复杂注释类型声明中的成员类型使用。它不能直接用于注释：
@Target({}) public @interface MemberType { ... } 这是一个编译时错误，它表明一个 ElementType 常量在 Target 注释中出现了不只一次。例如，以下元注释是非法的：
@Target({ElementType.FIELD, ElementType.METHOD, ElementType.FIELD}) public @interface Bogus { ... } public enum ElementType extends Enum
程序元素类型。此枚举类型的常量提供了 Java 程序中声明的元素的简单分类。
这些常量与 Target 元注释类型一起使用，以指定在什么情况下使用注释类型是合法的。
ANNOTATION_TYPE 注释类型声明 CONSTRUCTOR 构造方法声明 FIELD 字段声明（包括枚举常量） LOCAL_VARIABLE 局部变量声明 METHOD 方法声明 PACKAGE 包声明 PARAMETER 参数声明 TYPE 类、接口（包括注释类型）或枚举声明
注解的使用限定的例子：
@Target(ElementType.METHOD) public @interface MyAnnotation { String[] value1() default "abc";} 9、在帮助文档中加入注解：
要想在制作JavaDoc文件的同时将注解信息加入到API文件中，可以使用java.lang.annotation.Documented。
在自定义注解中声明构建注解文档：
@Documented public @interface MyAnnotation { String[] value1() default "abc";} 使用自定义注解：
public class AnnotationTest2 { @MyAnnotation(value1={"a","b"}) public void execute(){ System.out.println("method"); }} 10、在注解中使用继承：
默认情况下注解并不会被继承到子类中，可以在自定义注解时加上java.lang.annotation.Inherited注解声明使用继承。
@Documented@Retention(value=RUNTIME)@Target(value=ANNOTATION_TYPE)public @interface Inherited
指示注释类型被自动继承。如果在注释类型声明中存在 Inherited 元注释，并且用户在某一类声明中查询该注释类型，同时该类声明中没有此类型的注释，则将在该类的超类中自动查询该注释类型。此过程会重复进行，直到找到此类型的注释或到达了该类层次结构的顶层 (Object) 为止。如果没有超类具有该类型的注释，则查询将指示当前类没有这样的注释。
注意，如果使用注释类型注释类以外的任何事物，此元注释类型都是无效的。还要注意，此元注释仅促成从超类继承注释；对已实现接口的注释无效。
Annotation在java的世界正铺天盖地展开,有空写这一篇简单的annotations的文章,算是关于Annotation入门的文章吧,希望能各位们能抛砖,共同学习......
不讲废话了,实践才是硬道理. 第一部分:了解一下java1.5起默认的三个annotation类型: 一个是@Override:只能用在方法之上的，用来告诉别人这一个方法是改写父类的。 一个是@Deprecated:建议别人不要使用旧的API的时候用的,编译的时候会用产生警告信息,可以设定在程序里的所有的元素上. 一个是@SuppressWarnings:这一个类型可以来暂时把一些警告信息消息关闭. 如果不清楚上面三个类型的具体用法，各位可以baidu或google一下的,很简单的。 第二部分:讲一下annotation的概念先，再来讲一下怎样设计自己的annotation. 首先在jdk自带的java.lang.annotation包里,打开如下几个源文件: 1、源文件Target.java Java代码
- @Documented
- @Retention(RetentionPolicy.RUNTIME)
- (ElementType.ANNOTATION_TYPE)
- public Target {
- ElementType[] value();
- }
[java]
- @Documented
- @Retention(RetentionPolicy.RUNTIME)
- (ElementType.ANNOTATION_TYPE)
- public Target {
- ElementType[] value();
- }
@Documented @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.ANNOTATION_TYPE) public @interface Target { ElementType[] value(); } 其中的@interface是一个关键字，在设计annotations的时候必须把一个类型定义为 ，而不能用class或interface关键字(会不会觉得sun有点吝啬,偏偏搞得与interface这么像). 2、源文件Retention.java
Java代码
- @Documented
- @Retention(RetentionPolicy.RUNTIME)
- (ElementType.ANNOTATION_TYPE)
- public Retention {
- RetentionPolicy value();
- }
[java]
- @Documented
- @Retention(RetentionPolicy.RUNTIME)
- (ElementType.ANNOTATION_TYPE)
- public Retention {
- RetentionPolicy value();
- }
@Documented @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.ANNOTATION_TYPE) public @interface Retention { RetentionPolicy value(); } 看到这里，大家可能都模糊了,都不知道在说什么，别急，往下看一下. 在上面的文件都用到了RetentionPolicy，ElementType这两个字段,你可能就会猜到这是两个java文件.的确，这两个文件的源代码如下： 3、源文件RetentionPolicy.java
Java代码
- public enum RetentionPolicy {
- SOURCE,
- CLASS,
- RUNTIME
- }
[java]
- public enum RetentionPolicy {
- SOURCE,
- CLASS,
- RUNTIME
- }
public enum RetentionPolicy { SOURCE, CLASS, RUNTIME } 这是一个enum类型,共有三个值，分别是SOURCE,CLASS 和 RUNTIME. SOURCE代表的是这个Annotation类型的信息只会保留在程序源码里，源码如果经过了编译之后，Annotation的数据就会消失,并不会保留在编译好的.class文件里面。 ClASS的意思是这个Annotation类型的信息保留在程序源码里,同时也会保留在编译好的.class文件里面,在执行的时候，并不会把这一些信息加载到虚拟机(JVM)中去.注意一下，当你没有设定一个Annotation类型的Retention值时，系统默认值是CLASS. 第三个,是RUNTIME,表示在源码、编译好的.class文件中保留信息，在执行的时候会把这一些信息加载到JVM中去的． 举一个例子，如@Override里面的Retention设为SOURCE,编译成功了就不要这一些检查的信息;相反,@Deprecated里面的Retention设为RUNTIME,表示除了在编译时会警告我们使用了哪个被Deprecated的方法,在执行的时候也可以查出该方法是否被Deprecated. 4、源文件ElementType.java
Java代码
- public enum ElementType {
- TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR,
- LOCAL_VARIABLE, ANNOTATION_TYPE,PACKAGE
- }
[java]
- public enum ElementType {
- TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR,
- LOCAL_VARIABLE, ANNOTATION_TYPE,PACKAGE
- }
public enum ElementType { TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE, ANNOTATION_TYPE,PACKAGE } ＠Target里面的ElementType是用来指定Annotation类型可以用在哪一些元素上的.说明一下：TYPE(类型), FIELD(属性), METHOD(方法), PARAMETER(参数), CONSTRUCTOR(构造函数),LOCAL_VARIABLE(局部变量), ANNOTATION_TYPE,PACKAGE(包),其中的TYPE(类型)是指可以用在Class,Interface,Enum和Annotation类型上. 另外,从1的源代码可以看出,@Target自己也用了自己来声明自己,只能用在ANNOTATION_TYPE之上. 如果一个Annotation类型没有指明@Target使用在哪些元素上,那么它可以使用在任何元素之上,这里的元素指的是上面的八种类型. 举几个正确的例子: @Target(ElementType.METHOD) @Target(value=ElementType.METHOD) @Target(ElementType.METHOD,ElementType.CONSTRUCTOR) 具体参考一下javadoc文档 上面一下1和2的源文件，它们都使用了@Documented,@Documented的目的就是让这一个Annotation类型的信息能够显示在javaAPI说明文档上;没有添加的话，使用javadoc生成API文档的时候就会找不到这一个类型生成的信息. 另外一点，如果需要把Annotation的数据继承给子类，那么就会用到@Inherited这一个Annotation类型. 第三部分:下面讲的设计一个最简单的Annotation例子,这一例子共用四个文件; 1、Description.java
Java代码
- package lighter.javaeye.com;
- 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;
- (ElementType.TYPE)
- @Retention(RetentionPolicy.RUNTIME)
- @Documented
- public Description {
- String value();
- }
[java]
- package lighter.javaeye.com;
- 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;
- (ElementType.TYPE)
- @Retention(RetentionPolicy.RUNTIME)
- @Documented
- public Description {
- String value();
- }
package lighter.javaeye.com; 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; @Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface Description { String value(); } 说明:所有的Annotation会自动继承java.lang.annotation这一个接口,所以不能再去继承别的类或是接口. 最重要的一点,Annotation类型里面的参数该怎么设定: 第一,只能用public或默认(default)这两个访问权修饰.例如,String value();这里把方法设为defaul默认类型. 第二,参数成员只能用基本类型byte,short,char,int,long,float,double,boolean八种基本数据类型和String,Enum,Class,annotations等数据类型,以及这一些类型的数组.例如,String value();这里的参数成员就为String. 第三,如果只有一个参数成员,最好把参数名称设为"value",后加小括号.例:上面的例子就只有一个参数成员. 2、Name.java
Java代码
- package lighter.javaeye.com;
- 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;
- //注意这里的@Target与@Description里的不同,参数成员也不同
- (ElementType.METHOD)
- @Retention(RetentionPolicy.RUNTIME)
- @Documented
- public Name {
- String originate();
- String community();
- }
[java]
- package lighter.javaeye.com;
- 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;
- //注意这里的@Target与@Description里的不同,参数成员也不同
- (ElementType.METHOD)
- @Retention(RetentionPolicy.RUNTIME)
- @Documented
- public Name {
- String originate();
- String community();
- }
package lighter.javaeye.com; 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; //注意这里的@Target与@Description里的不同,参数成员也不同 @Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface Name { String originate(); String community(); } 3、JavaEyer.java
Java代码
- package lighter.javaeye.com;
- @Description("javaeye,做最棒的软件开发交流社区")
- public class JavaEyer {
- (originate="创始人:robbin",community="javaEye")
- public String getName()
- {
- return null;
- }
- (originate="创始人:江南白衣",community="springside")
- public String getName2()
- {
- return "借用两位的id一用,写这一个例子,请见谅!";
- }
- }
[java]
- package lighter.javaeye.com;
- @Description("javaeye,做最棒的软件开发交流社区")
- public class JavaEyer {
- (originate="创始人:robbin",community="javaEye")
- public String getName()
- {
- return null;
- }
- (originate="创始人:江南白衣",community="springside")
- public String getName2()
- {
- return "借用两位的id一用,写这一个例子,请见谅!";
- }
- }
package lighter.javaeye.com;@Description("javaeye,做最棒的软件开发交流社区")public class JavaEyer { @Name(originate="创始人:robbin",community="javaEye") public String getName() { return null; } @Name(originate="创始人:江南白衣",community="springside") public String getName2() { return "借用两位的id一用,写这一个例子,请见谅!"; }} 4、最后，写一个可以运行提取JavaEyer信息的类TestAnnotation
Java代码
- package lighter.javaeye.com;
- import java.lang.reflect.Method;
- import java.util.HashSet;
- import java.util.Set;
- public class TestAnnotation {
- /**
- * author lighter
- * 说明:具体关天Annotation的API的用法请参见javaDoc文档
- */
- public static void main(String[] args) throws Exception {
- String CLASS_NAME = "lighter.javaeye.com.JavaEyer";
- Class test = Class.forName(CLASS_NAME);
- Method[] method = test.getMethods();
- boolean flag = test.isAnnotationPresent(Description.class);
- if(flag)
- {
- Description des = (Description)test.getAnnotation(Description.class);
- System.out.println("描述:"+des.value());
- System.out.println("-----------------");
- }
- //把JavaEyer这一类有利用到@Name的全部方法保存到Set中去
- Set<Method> set = new HashSet<Method>();
- for(int i=0;i<method.length;i++)
- {
- boolean otherFlag = method[i].isAnnotationPresent(Name.class);
- if(otherFlag) set.add(method[i]);
- }
- for(Method m: set)
- {
- Name name = m.getAnnotation(Name.class);
- System.out.println(name.originate());
- System.out.println("创建的社区:"+name.community());
- }
- }
- }
[java]
- package lighter.javaeye.com;
- import java.lang.reflect.Method;
- import java.util.HashSet;
- import java.util.Set;
- public class TestAnnotation {
- /**
- * author lighter
- * 说明:具体关天Annotation的API的用法请参见javaDoc文档
- */
- public static void main(String[] args) throws Exception {
- String CLASS_NAME = "lighter.javaeye.com.JavaEyer";
- Class test = Class.forName(CLASS_NAME);
- Method[] method = test.getMethods();
- boolean flag = test.isAnnotationPresent(Description.class);
- if(flag)
- {
- Description des = (Description)test.getAnnotation(Description.class);
- System.out.println("描述:"+des.value());
- System.out.println("-----------------");
- }
- //把JavaEyer这一类有利用到@Name的全部方法保存到Set中去
- Set<Method> set = new HashSet<Method>();
- for(int i=0;i<method.length;i++)
- {
- boolean otherFlag = method[i].isAnnotationPresent(Name.class);
- if(otherFlag) set.add(method[i]);
- }
- for(Method m: set)
- {
- Name name = m.getAnnotation(Name.class);
- System.out.println(name.originate());
- System.out.println("创建的社区:"+name.community());
- }
- }
- }
package lighter.javaeye.com; import java.lang.reflect.Method; import java.util.HashSet; import java.util.Set; public class TestAnnotation { /** * author lighter * 说明:具体关天Annotation的API的用法请参见javaDoc文档 */ public static void main(String[] args) throws Exception { String CLASS_NAME = "lighter.javaeye.com.JavaEyer"; Class test = Class.forName(CLASS_NAME); Method[] method = test.getMethods(); boolean flag = test.isAnnotationPresent(Description.class); if(flag) { Description des = (Description)test.getAnnotation(Description.class); System.out.println("描述:"+des.value()); System.out.println("-----------------"); } //把JavaEyer这一类有利用到@Name的全部方法保存到Set中去 Set set = new HashSet (); for(int i=0;i Java注解 1、什么是java注解 注解，顾名思义，注解,就是对某一事物进行添加注释说明，会存放一些信息，这些信息可能对以后某个时段来说是很有用处的。 Java注解又叫java标注，java提供了一套机制，使得我们可以对方法、类、参数、包、域以及变量等添加标准(即附上某些信息)。且在以后某个时段通过反射将标注的信息提取出来以供使用。 2 为什么要自定义注解 Java从1.5版本以后默认内置三个标注： Ø @Override:只能用在方法之上的，用来告诉别人这一个方法是改写父类的。 Ø @Deprecated:建议别人不要使用旧的API的时候用的,编译的时候会用产生警告信息,可以设定在程序里的所有的元素上. Ø @SuppressWarnings:这一个类型可以来暂时把一些警告信息消息关闭. 但是，仅仅这三个标注是不能满足我们开发时一些需求的。所以java允许我们自定义注解来使用。 3 为什么要自定义注解 Java从1.5版本以后默认内置三个标注： Ø @Override:只能用在方法之上的，用来告诉别人这一个方法是改写父类的。 Ø @Deprecated:建议别人不要使用旧的API的时候用的,编译的时候会用产生警告信息,可以设定在程序里的所有的元素上. Ø @SuppressWarnings:这一个类型可以来暂时把一些警告信息消息关闭. 但是，仅仅这三个标注是不能满足我们开发时一些需求的。所以java允许我们自定义注解来使用。 4 如何自定义注解 自定义步骤大致分为两步： 1， 通过@interface关键字(注意，不是interface，是@interace)声明注解名称，以及注解的成员属性或者叫做注解的参数。 2， 使用java内置的四个元注解对这个自定义标注的功能和范围进行一些限制 问题来了，什么是元注解？ 5 什么是元注解 元注解，就是定义注解的注解，也就是说这些元注解是的作用就是专门用来约束其它注解的注解。请区别上面那三个注解，他们也是通过元注解定义而来的。 元注解有哪些呢，主要有四个@Target,@Retention,@Documented,@Inherited？ 注解的应用图 自定义注解 自定义一个类级别的标注Description package lighter.javaeye.com; 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; @Target(ElementType.TYPE)//这个标注应用于类 @Retention(RetentionPolicy.RUNTIME)//标注会一直保留到运行时 @Documented//将此注解包含在javadoc中 public @interface Description { String value(); } 再定义个方法级别的注解Name package lighter.javaeye.com; 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; //注意这里的@Target与@Description里的不同,参数成员也不同 @Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface Name { String originate(); String community(); } 然后使用以上两个注解 package lighter.javaeye.com; @Description(value="javaeye,做最棒的软件开发交流社区") public class JavaEyer { @Name(originate="创始人:robbin",community="javaEye") public String getName() { return null; } @Name(originate="创始人:江南白衣",community="springside") public String getName2() { return "借用两位的id一用,写这一个例子,请见谅!"; } } 说明：其中标注“@Description(value="javaeye,做最棒的软件开发交流社区")”，可以写成“@Description("javaeye,做最棒的软件开发交流社区") ”，结果也是一样的。因为Description标注定义的时候其参数(或者说属性)为value。而value比较特殊，它在被指定参数的时候可以不用显示的写出来。当然如果定义的时候参数名不是value而是其它的比如des，那么使用注解的时候，必须显示写出参数名，然后再赋值：@Description(Des=”xxx”) 提取出注解的信息 package lighter.javaeye.com; import java.lang.reflect.Method; import java.util.HashSet; import java.util.Set; public class TestAnnotation { /** * author lighter * 说明:具体关天Annotation的API的用法请参见javaDoc文档 */ public static void main(String[] args) throws Exception { String CLASS_NAME = "lighter.javaeye.com.JavaEyer"; Class test = Class.forName(CLASS_NAME); Method[] method = test.getMethods(); boolean flag = test.isAnnotationPresent(Description.class); if(flag) { Description des = (Description)test.getAnnotation(Description.class); System.out.println("描述:"+des.value()); System.out.println("-----------------"); } //把JavaEyer这一类有利用到@Name的全部方法保存到Set中去 Set set = new HashSet (); for(int i=0;i