注解的详细入门

一、什么是注解

　　Annotation（注解）就是Java提供了一种为程序元素关联任何信息或任何元数据（metadata）的途径和方法。Annotion(注解)是一个接口，

程序可以通过反射来获取指定程序元素的Annotion对象，然后通过Annotion对象来获取注解里面的元数据。说白点就是我们自定义的注解绝大

部分都是用来存放配置数据的，和XML的作用差不多，但是注解可以提供更大的便捷性，易于维护修改，但耦合度高，而 XML 相对于注解则是相反的，所以

是使用注解还是XML就看自己的需求了吧。

1、注解出现的位置

　　Annotation(注解)是JDK1.5及以后版本引入的。它可以用于创建文档，跟踪代码中的依赖性，甚至执行基本编译时检查。从某些方面看，

annotation就像修饰符一样被使用，并应用于包、类型、构造方法、方法、成员变量、参数、本地变量的声明中。

这些信息被存储在Annotation的“name=value”结构对中。

2 注解的成员提供了程序元素的关联信息（成员称注解属性）

3 Annotation中声明属性

　　Annotation的成员在Annotation类型中以无参数的方法的形式被声明。其方法名和返回值定义了该成员的名字和类型。

在此有一个特定的默认 语法：允许声明任何Annotation成员的默认值。一个Annotation可以将name=value对作为没有定义默认值的Annotation 成员的值，

当然也可以使用name=value对来覆盖其它成员默认值。这一点有些近似类的继承特性，父类的构造函数可以作为子类的默认构造函数，

但是也 可以被子类覆盖。

4注解不会影响程序代码的执行 

Annotation能被用来为某个程序元素（类、方法、成员变量等）关联任何的信息。需要注意的是，

　　这里存在着一个基本的规则：Annotation不能影响程序代码的执行，无论增加、删除 Annotation，代码都始终如一的执行。

另外，尽管一些annotation通过java的反射api方法在运行时被访问，而java语言解释器在工作时忽略了这些annotation。

正是由于java虚拟机忽略了Annotation，导致了annotation类型在代码中是“不起作用”的；

只有通过某种配套的工具才会对annotation类型中的信息进行访问和处理

5注解的作用是什么

　　注解（Annotation） 为我们在代码中添加信息提供了一种形式化的方法，是我们可以在稍后某个时刻方便地使用这些数据（通过 解析注解 来使用这些数据），

常见的作用有以下几种：

　　(1).生成文档。这是最常见的，也是java 最早提供的注解。常用的有@see @param @return 等；

　　(2).在编译时进行格式检查。如@Override放在方法前，如果你这个方法并不是覆盖了超类方法，则编译时就能检查出；

　　(3).跟踪代码依赖性，实现替代配置文件功能。比较常见的是spring 2.5 开始的基于注解配置。作用就是减少配置。现在的框架基本都使用了这种配置来减少配置文件的数量；

二、JDK中的注解：

1、@Override 表示当前方法覆盖了父类的方法

此注释只适用于修辞方法，表示一个方法声明打算重写超类中的另一个方法声明。如果方法利用此注释类型进行注解但没有重写超类方法，则编译器
会生成一条错误消息

1     /**
2      * 覆盖重写父类的方法
3      * @return
4      */
5     @Override
6     public String tostring() {    //正确的应该是为toString，  而这里写tostring是会报错的
7         return super.toString();
8     }

2 、@Deprecated 表示方法已经过时,方法上有横线，使用时会有警告。

此注释可用于修辞方法、属性、类，表示不鼓励程序员使用这样的元素，

通常是因为它很危险或存在更好的选择。在使用不被赞成的程序元素或在不被赞成的代码中执行重写时，

编译器会发出警告

事例：

 1 public class Test1 {
 2     public static void main(String[] args) {        
 3         test_01();
 4     }
 5     
 6     /**
 7      * 这个方法是被弃用了，因为使用了@Deprecated注解，则一般是不推荐使用这个方法了
 8      */
 9     @Deprecated
10     private static void test_01() {
11         System.out.println("这个方法被弃用了");
12     }
13 }

3 @SuppressWarings 表示关闭一些警告信息(通知java编译器忽略特定的编译警告)

用来抑制编译时的警告信息。与前两个注释有所不同，你需要添加一个参数才能正确使用，

这些参数值都是已经定义好了的，我们选择性的使用就好了，

1     @SuppressWarnings({"all"})
2     public static void main(String[] args) {        
3         test_01();
4         
5         Scanner scanner=new Scanner(System.in);   //本来这样是会报警告信息的，因为我们没有关闭，但是我们用了@SuppressWarrings的注解
6     }

 

                              

                                 

三、开发自定义注解

1 自定义注解的语法规则

(1).使用@interface关键字定义注解，注意关键字的位置使用@interface自定义注解时，自动继承了java.lang.annotation.Annotation接口，由编译程序自动完成其他细节。在定义注解时，不能继承其他的注解或接口。

(2).成员以无参数无异常的方式声明，注意区别一般类成员变量的声明其中的每一个方法实际上是声明了一个配置参数。方法的名称就是参数的名称

(3).可以使用default为成员指定一个默认值

(4).成员类型是受限的，合法的类型包括原始类型以及String、Class、Annotation、Enumeration （JAVA的基本数据类型有8种：byte(字节)、short(短整型)、int(整数型)、long(长整型)、float(单精度浮点数类型)、double(双精度浮点数类型)、char(字符类型)、boolean(布尔类型）

(5).注解类可以没有成员，没有成员的注解称为标识注解，例如JDK注解中的@Override、@Deprecation

(6).如果注解只有一个成员，并且把成员取名为value()，则在使用时可以忽略成员名和赋值号“=” ,例如JDK注解的@SuppviseWarnings ；如果成员名   不为value，则使用时需指明成员名和赋值号"="，

创建一个简单的自定义注解

1 //使用了@interface关键字来定义这个是一个注解
2 public @interface AnnoationDemo {
3     
4     //变量名的命名规则和方法名一样，但是注意，这个不是方法
5     String userName();   
6     int age();
7 }

在其他类中使用这个注解了

1 public class AnnotationTest {
2 
3     //下面就是使用了一个我们刚刚定义的注解，我们可以在这里为其属性赋值
4     @AnnoationDemo(userName="turtle",age=10)
5     public static void main(String[] args) {
6                 
7     }
8 }

有个特殊情况，如果我们自定义的注解中的属性名是value的话，那么我们就可以在使用的时候为属性赋值的时候直接写属性值就行了：

 1 public @interface AnnotationDemo2 {
 2     String value();
 3 }
 4 
 5 
 6 public class AnnotationTest2 {
 7 
 8     @AnnotationDemo2("turtle")
 9     public static void main(String[] args) {
10 
11     }
12 }

2 元注解：

　　何为元注解？就是注解的注解，就是给你自己定义的注解添加注解，你自己定义了一个注解，但你想要你的注解有什么样的功能，此时就需要用元注解对你的注解进行说明了。

Java5.0定义了4个标准的meta-annotation类型，它们被用来提供对其它 annotation类型作说明。

a、 @Target

@Target说明了Annotation所修饰的对象范围：

即注解的作用域，用于说明注解的使用范围（即注解可以用在什么地方，比如类的注解，方法注解，成员变量注解等等）
注意:如果Target元注解没有出现，那么定义的注解可以应用于程序的任何元素。

取值是在java.lang.annotation.ElementType这个枚举中规定的：

1.  CONSTRUCTOR:用于描述构造器
2. FIELD:用于描述域
3. LOCAL_VARIABLE:用于描述局部变量
4. METHOD:用于描述方法
5. PACKAGE:用于描述包
6. PARAMETER:用于描述参数
7. TYPE:用于描述类、接口(包括注解类型) 或enum声明

 创建一个用了元注解，指定了注解的使用范围

 1 import java.lang.annotation.ElementType;
 2 import java.lang.annotation.Target;
 3 
 4 //下面定义的注解使用元注解 @Target，则需要注意参数中ElementType指定该注解所能使用的范围了
 5 //下面是定义了该注解只能在方法和包上面使用
 6 @Target({ElementType.METHOD,ElementType.PACKAGE})
 7 public @interface AnnotationDmmo2 {
 8     String userName();
 9     int age();
10 }

我们使用：

 1 //下面的注解使用会报错，没有按照注解的使用范围来使用
 2 //@AnnotationDmmo2(userName="turtle",age=10)
 3 public class AnnotationTest3 {
 4 
 5     //下面的注解使用正确，满足在方法上面使用该注解
 6     @AnnotationDmmo2(userName="turtle",age=10)
 7     public static void main(String[] args) {
 8         
 9 
10     }
11 }

 

b、.@Retention

@Retention定义了该Annotation被保留的时间长短：
　　(1)某些Annotation仅出现在源代码中，而被编译器丢弃；
　　(2)而另一些却被编译在class文件中；编译在class文件中的Annotation可能会被虚拟机忽略，
　　(3)而另一些在class被装载时将被读取（请注意并不影响class的执行，因为Annotation与class在使用上是被分离的）。
　　使用这个meta-Annotation可以对 Annotation的“生命周期”限制。

@Retention的取值是在RetentionPoicy这个枚举中规定的

1. SOURCE:在源文件中有效（即源文件保留）
2. CLASS:在class文件中有效（即class保留）
3. RUNTIME:在运行时有效（即运行时保留）

创建一个带@Retention元注解的注解

 1 import java.lang.annotation.ElementType;
 2 import java.lang.annotation.Retention;
 3 import java.lang.annotation.RetentionPolicy;
 4 import java.lang.annotation.Target;
 5 
 6 @Target({ElementType.METHOD})  //指定该注解的使用范围
 7 //指定该注解的生存时间，当前是在运行时有效
 8 @Retention(RetentionPolicy.RUNTIME) 
 9 
10 public @interface AnnotationDemo4 {
11 
12     String userName();
13     int age();
14 }

 我们使用这个注解：

1 public class AnnotationTest4 {
2 
3     @AnnotationDemo4(userName="turtle",age=10)
4     public static void main(String[] args) {
5         
6 
7     }
8 
9 }

 

 注意:注解的的RetentionPolicy的属性值是RUTIME,这样注解处理器可以通过反射，获取到该注解的属性值，从而去做一些运行时的逻辑处理

c、@Documented

@Documented用于描述其它类型的annotation应该被作为被标注的程序成员的公共API，因此可以被例如javadoc此类的工具文档化。

Documented是一个标记注解，没有成员。

d. @Inherited

@Inherited 元注解是一个标记注解，@Inherited阐述了某个被标注的类型是被继承的。如果一个使用了@Inherited修饰的annotation类型被用于一个class，

则这个annotation将被用于该class的子类。

注意：@Inherited annotation类型是被标注过的class的子类所继承。类并不从它所实现的接口继承annotation，方法并不从它所重载的方法继承annotation。

当@Inherited annotation类型标注的annotation的Retention是RetentionPolicy.RUNTIME，则反射API增强了这种继 承性。

如果我们使用java.lang.reflect去查询一个@Inherited annotation类型的annotation时，反射代码检查将展开工作：检查class和其父类，

直到发现指定的annotation类型被发现， 或者到达类继承结构的顶层。

四、注解开发实例:通过注解来创建数据库表

1、创建Column注解,表示数据库中的字段信息

 1 import java.lang.annotation.ElementType;
 2 import java.lang.annotation.Retention;
 3 import java.lang.annotation.RetentionPolicy;
 4 import java.lang.annotation.Target;
 5 
 6 /**
 7  * 一个用来保存数据表中字段信息的注解
 8  * @author TurtleZhang
 9  *
10  */
11 @Target({ElementType.FIELD})  //表示该注解只能在字段上使用
12 @Retention(RetentionPolicy.RUNTIME) //表示该注解在运行时保留
13 public @interface Column {
14 
15     String columnName();   //字段名字
16     String columnType();   //字段的数据类型
17     int columnLength();     //字段的类型长度
18     String columnConstraint() default "";  //字段上面的约束，默认是无约束
19 }

2、创建Table注解,表示数据库中的表

 1 import java.lang.annotation.ElementType;
 2 import java.lang.annotation.Retention;
 3 import java.lang.annotation.RetentionPolicy;
 4 import java.lang.annotation.Target;
 5 
 6 /**
 7  * 一个用来保存表名信息的注解
 8  * @author TurtleZhang
 9  *
10  */
11 @Target({ElementType.TYPE})   //用在类名上面
12 @Retention(RetentionPolicy.RUNTIME)  //运时时有效
13 public @interface Table {
14     String tableName();   //
15 }

3、创建JavaBen类,使用定义的注解

 1 import java.io.Serializable;
 2 
 3 @Table(tableName="user")   //设置表名为user
 4 //推荐实现Serializable
 5 public class JavaBean  implements Serializable {
 6     
 7     /**
 8      * 推荐创建一个UID
 9      */
10     private static final long serialVersionUID = 4171803733957608693L;
11 
12     //通过注解来保存数据  列名为id，类型为int,   长度为4 ， 约束：主键约束
13     @Column(columnName="ID",columnType="INT",columnLength=4,columnConstraint="PRIMARY KEY")
14     private int id;   //该列为id
15     
16     //通过注解来保存数据  列名为name，类型为varchar,   长度为50 
17     @Column(columnName="NAME",columnType="VARCHAR",columnLength=50)
18     private String name;  //该列为naem
19     
20     //通过注解来保存数据  列名为password，类型为varchar,   长度为50 
21     @Column(columnName="PASSWROD",columnType="VARCHAR",columnLength=50)
22     private String password;  //该列为password
23 }

 4、创建Main方法,读取JavaBen类中的注解信息,根据注解信息自动生成DDL语句

 1 import java.lang.reflect.Field;
 2 
 3 /**
 4  * 这个是我们用来读取注解中的信息，然后组合成SQL语句的。
 5  * @author Administrator
 6  *
 7  */
 8 public class Main {
 9 
10     public static void main(String[] args) throws ClassNotFoundException {
11 
12         builderSql();
13     }
14 
15     
16     //构建我们的SQL语句
17     @SuppressWarnings("all")
18     private static void builderSql() throws ClassNotFoundException {
19         StringBuilder stringBuilder=new StringBuilder("create table");
20 
21         //通过反射来取得JavaBean类
22         Class javaBean= Class.forName("annotaion.JavaBean");
23         
24         //查找表
25         Table table=(Table) javaBean.getAnnotation(Table.class);
26         stringBuilder.append(table.tableName()+"(");
27 
28         //查找字段
29         Field[] fields=javaBean.getDeclaredFields();
30 
31         for(int i=0;i<fields.length;i++) {
32             if(fields[i].isAnnotationPresent(Column.class)) {
33                 Column column=(Column)fields[i].getAnnotation(Column.class);
34 
35                 //得到字段名字
36                 String columnName=column.columnName();
37 
38                 //得到字段类型
39                 String columnType=column.columnType();
40 
41                 //得到字段的长度
42                 int columnLength=column.columnLength();
43 
44                 //得到字段的约束
45                 String columnContraint=column.columnConstraint();
46 
47                 stringBuilder.append(columnName);
48                 stringBuilder.append(" ");
49                 stringBuilder.append(columnType);
50                 stringBuilder.append(" ");
51                 stringBuilder.append("(");
52                 stringBuilder.append(columnLength);
53                 stringBuilder.append(")");
54                 stringBuilder.append(columnContraint);
55                 stringBuilder.append(",");
56             }
57         }
58 
59         String sql=stringBuilder.substring(0, stringBuilder.length()-1)+")";
60         System.out.println("我们创建出来的SQL语句为"+sql);
61     }
62 }

 

 

 总结：

上面的是一个通过注解来保存信息，我们在主类中通过注解来取得值。要注意的是，注解在后面的框架中的使用率很高的，

我这个也就是注解的简单入门而已，如果要精深的话，自己多看看书，然后多看看博客，再加上自己的领悟。

 　　                                          2019-03-09-17:20:27