Java-注解(Annotation)的使用（详解）

秒速五厘米 2023-09-24 13:30 52阅读 0赞

### 注解(Annotation） ###

*  前言
 *  一、 注解(Annotation)概述
 *  二、 常见的Annotation示例
 *   *  1、示例一：生成文档相关的注解
     *  2、示例二：在编译时进行格式检查
     *   *  2.1 JDK内置的三个基本注解
         *  2.2 代码演示
     *  3、示例三：跟踪代码依赖性，实现替代配置文件功能
 *  三、 自定义Annotation
 *   *  1、特性
     *  2、代码演示
 *  四、 JDK中的元注解
 *   *  1、概述
     *  2、@Retention
     *  3、@Target
     *  4、@Documented
     *  5、@Inherited
 *  五、 利用反射获取注解信息
 *  六、 JDK 8中注解的新特性
 *   *  1、概述
     *  2. 示例
     *   *  2.1 可重复注解示例
         *  2.2 类型注解

--------------------

# 前言 #

本博主将用CSDN记录软件开发求学之路上亲身所得与所学的心得与知识，有兴趣的小伙伴可以关注博主！  
也许一个人独行，可以走的很快，但是一群人结伴而行，才能走的更远！让我们在成长的道路上互相学习，欢迎关注！

# 一、 注解(Annotation)概述 #

> ⭕ 从 `JDK 5.0` 开始, Java 增加了对元数据(`MetaData`) 的支持, 也就是 `Annotation`(注解)。

> ⭕ `Annotation` 其实就是代码里的特殊标记, 这些标记可以在编译, 类加载, 运行时被读取, 并执行相应的处理。通过使用`Annotation`, 程序员可以在不改变原有逻辑的情况下, 在源文件中嵌入一些补充信息。  
> 代码分析工具、开发工具和部署工具可以通过这些补充信息进行验证或者进行部署。

> ⭕ `Annotation` 可以像修饰符一样被使用, 可用于修饰包,类, 构造器, 方 法, 成员变量, 参数, 局部变量的声明, 这些信息被保存在 `Annotation` 的 `"name=value"` 对中。

> ⭕ 在`JavaSE`中，注解的使用目的比较简单，  
> 例如标记过时的功能，忽略警告等。在`JavaEE/Android`中注解占据了更重要的角色。  
> 例如用来配置应用程序的任何切面，代替`JavaEE`旧版中所遗留的繁冗代码和`XML`配置等。

> ⭕ 未来的开发模式都是基于注解的，`JPA`是基于注解的，`Spring2.5`以上都是基于注解的，`Hibernate3.x`以后也是基于注解的，现在的 `Struts2`有一部分也是基于注解的了，注解是一种趋势，一定程度上可以说：框架 = 注解 + 反射 + 设计模式。

# 二、 常见的Annotation示例 #

> 使用 `Annotation` 时要在其前面增加 `@` 符号, 并把该 `Annotation` 当成 一个修饰符使用。用于修饰它支持的程序元素。

## 1、示例一：生成文档相关的注解 ##

<table> 
 <thead> 
  <tr> 
   <th>注解</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>@author</code></td> 
   <td>标明开发该类模块的作者，多个作者之间使用,分割</td> 
  </tr> 
  <tr> 
   <td><code>@version</code></td> 
   <td>标明该类模块的版本</td> 
  </tr> 
  <tr> 
   <td><code>@see</code></td> 
   <td>参考转向，也就是相关主题</td> 
  </tr> 
  <tr> 
   <td><code>@since</code></td> 
   <td>从哪个版本开始增加的</td> 
  </tr> 
  <tr> 
   <td><code>@param</code></td> 
   <td>对方法中某参数的说明，如果没有参数就不能写</td> 
  </tr> 
  <tr> 
   <td><code>@return</code></td> 
   <td>对方法返回值的说明，如果方法的返回值类型是<code>void</code>就不能写</td> 
  </tr> 
  <tr> 
   <td><code>@exception</code></td> 
   <td>对方法可能抛出的异常进行说明 ，如果方法没有用<code>throws</code>显式抛出的异常就不能写</td> 
  </tr> 
 </tbody> 
</table>

> 注意：  
> `@param` `@return` 和 `@exception`这三个标记都是只用于方法的：  
> ⭕ `@param`的格式要求：`@param 形参名 形参类型 形参说明`  
> ⭕ `@return` 的格式要求：`@return 返回值类型 返回值说明`  
> ⭕ `@exception`的格式要求：`@exception 异常类型 异常说明`
> 
> ⭕ `@param`和`@exception`可以并列多个

**代码演示：**

package com.annotation.javadoc;
         /**
         * @author shkstart
         * @version 1.0
         * @see Math.java
         */
    public class JavadocTest {
         
         /**
         * 程序的主方法，程序的入口
         * @param args String[] 命令行参数
         */
         public static void main(String[] args) {
         
         }
         /**
         * 求圆面积的方法
         * @param radius double 半径值
         * @return double 圆的面积
         */
         public static double getArea(double radius){
         
         return Math.PI * radius * radius; 
         } 
    }

## 2、示例二：在编译时进行格式检查 ##

### 2.1 JDK内置的三个基本注解 ###

<table> 
 <thead> 
  <tr> 
   <th>注解</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>@Override</code></td> 
   <td>限定重写父类方法, 该注解只能用于方法</td> 
  </tr> 
  <tr> 
   <td><code>@Deprecated</code></td> 
   <td>用于表示所修饰的元素(类, 方法等)已过时。通常是因为 所修饰的结构危险或存在更好的选择</td> 
  </tr> 
  <tr> 
   <td><code>@SuppressWarnings</code></td> 
   <td>抑制编译器警告</td> 
  </tr> 
 </tbody> 
</table>

### 2.2 代码演示 ###

package com.annotation.javadoc;
    public class AnnotationTest{
         
         public static void main(String[] args) {
         
              @SuppressWarnings("unused")
              int a = 10;
         }
         @Deprecated
         public void print(){
         
              System.out.println("过时的方法");
         }
         @Override
         public String toString() {
         
              return "重写的toString方法()"; 
         } 
    }

## 3、示例三：跟踪代码依赖性，实现替代配置文件功能 ##

> `Servlet3.0`提供了注解`@annotation`,使得不再需要在`web.xml`文件中进行`Servlet`的部署。

@WebServlet("/login")
    public class LoginServlet extends HttpServlet {
         
         private static final long serialVersionUID = 1L;
         protected void doGet(HttpServletRequest request, HttpServletResponse response) throws
    ServletException, IOException {
          }
         protected void doPost(HttpServletRequest request, HttpServletResponse response) throws
    ServletException, IOException {
         
    doGet(request, response);
    } }

<servlet> 
          <servlet-name>LoginServlet</servlet-name> <servlet-class>com.servlet.LoginServlet</servlet-class>
    </servlet> 
    
    <servlet-mapping> 
          <servlet-name>LoginServlet</servlet-name> <url-pattern>/login</url-pattern>
    </servlet-mapping>

# 三、 自定义Annotation #

## 1、特性 ##

> ⭕ 定义新的 `Annotation` 类型使用 `@interface` 关键字。

> ⭕ 自定义注解自动继承了`java.lang.annotation.Annotation`接口。

> ⭕ `Annotation` 的成员变量在 `Annotation`定义中以无参数方法的形式来声明。其方法名和返回值定义了该成员的名字和类型。我们称为配置参数。类型只能是八种基本数据类型、`String`类型、`Class`类型、`enum`类型、`Annotation`类型、以上所有类型的数组。

> ⭕ 可以在定义 `Annotation` 的成员变量时为其指定初始值, 指定成员变量的初始值可使用 `default` 关键字。

> ⭕ 如果只有一个参数成员，建议使用参数名为`value`。

> ⭕ 如果定义的注解含有配置参数，那么使用时必须指定参数值，除非它有默认值。格式是“`参数名 = 参数值`”，如果只有一个参数成员，且名称为`value`，可以省略“`value=`” 。

> ⭕ 没有成员定义的 `Annotation` 称为标记; 包含成员变量的 `Annotation` 称为元数据 `Annotation`。

> ⭕ 自定义注解必须配上注解的信息处理流程才有意义。

## 2、代码演示 ##

@Inherited
    @Repeatable(MyAnnotations.class)
    @Retention(RetentionPolicy.RUNTIME)
    @Target({
         TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE,TYPE_PARAMETER,TYPE_USE})
    public @interface MyAnnotation {
         
        String value() default "hello";
    }

# 四、 JDK中的元注解 #

## 1、概述 ##

> ⭕ `JDK` 的元 `Annotation` 用于修饰其他 `Annotation` 定义。  
> ⭕ `JDK5.0`提供了4个标准的`meta-annotation`类型，分别是：  
> `Retention`、`Target`、`Documented`、`Inherited`。

## 2、@Retention ##

> ⭕ 只能用于修饰一个 `Annotation` 定义, 用于指定该 `Annotation` 的生命周期

> ⭕ `@Rentention` 包含一个 `RetentionPolicy` 类型的成员变量, 使用 `@Rentention` 时必须为该`value`成员变量指定值:  
> ● `RetentionPolicy.SOURCE`:在源文件中有效（即源文件保留），编译器直接丢弃这种策略的注释。
> 
> ● `RetentionPolicy.CLASS`:在class文件中有效（即class保留） ， 当运行 Java 程序时, JVM不会保留注解，这是默认值。
> 
> ● `RetentionPolicy.RUNTIME`:在运行时有效（即运行时保留），当运行 Java 程序时, JVM会保留注释。程序可以通过反射获取该注释。  
> ![在这里插入图片描述][3071bc8eea2e468a82f5992085586a3d.png]

**代码演示：**

public enum RetentionPolicy{
         
        SOURCE,
        CLASS,
        RUNTIME
    }
    @Retention(RetentionPolicy.SOURCE)
    @interface MyAnnotation1{
          }
    @Retention(RetentionPolicy.RUNTIME) 
    @interface MyAnnotation2{
          }

## 3、@Target ##

> ⭕ 用于修饰 `Annotation` 定义, 用于指定被修饰的 `Annotation` 能用于修饰哪些程序元素。  
> ⭕ `@Target`也包含一个名为`value`的成员变量。

![在这里插入图片描述][bfbab6e804be4462bab19bbb99b1d67a.png]

## 4、@Documented ##

> ⭕ 用于指定被该元 `Annotation` 修饰的 `Annotation` 类将被`javadoc`工具提取成文档，默认情况下，`javadoc`是不包括注解的。  
> ⭕ 定义为`Documented`的注解必须设置`Retention`值为`RUNTIME`。

## 5、@Inherited ##

> ⭕ 被它修饰的 `Annotation` 将具有继承性。如果某个类使用了被`@Inherited` 修饰的`Annotation`, 则其子类将自动具有该注解。
> 
> 比如：如果把标有`@Inherited`注解的自定义的注解标注在类级别上，子类则可以继承父类类级别的注解。

# 五、 利用反射获取注解信息 #

> ⭕ JDK 5.0 在 `java.lang.reflect` 包下新增了 `AnnotatedElement` 接口,该接口代表程序中可以接受注解的程序元素

> ⭕ 当一个 `Annotation` 类型被定义为运行时 `Annotation` 后, 该注解才是运行时可见, 当 `class`文件被载入时保存在 `class` 文件中的 `Annotation` 才会被虚拟机读取

> ⭕ 程序可以调用 `AnnotatedElement`对象的如下方法来访问 `Annotation` 信息

![在这里插入图片描述][2644b7b08ff043d18eefb4c45f827da6.png]

# 六、 JDK 8中注解的新特性 #

## 1、概述 ##

> `Java8`对注解处理提供了两点改进：  
> ⭕ **可重复的注解及可用于类型的注解**。  
> ⭕ 反射也得到了加强，在Java8中能够得到方法参数的名称。这会简化标注在方法参数上的注解。

## 2. 示例 ##

### 2.1 可重复注解示例 ###

![在这里插入图片描述][423ec13508c044efa8c28d2e395034a0.png]![在这里插入图片描述][072794dc31f24ac0a65043239001215f.png]

### 2.2 类型注解 ###

> ⭕ `JDK1.8`之后，关于元注解`@Target`的参数类型`ElementType`枚举值多了两个：`TYPE_PARAMETER,TYPE_USE`。  
> ⭕ 在`Java 8`之前，注解只能是在声明的地方所使用，`Java8`开始，注解可以应用在任何地方。
> 
> 1.  `ElementType.TYPE_PARAMETER` 表示该注解能写在类型变量的声明语句中。如：泛型声明
> 2.  `ElementType.TYPE_USE` 表示该注解能写在使用类型的任何语句中。

**代码演示1：**

public class TestTypeDefine<@TypeDefine() U> {
         
        private U u;
        public <@TypeDefine() T> void test(T t){
         
        }
    }
    @Target({
         ElementType.TYPE_PARAMETER})
    @interface TypeDefine{
         
    }

**代码演示2：**

@MyAnnotation
    public class AnnotationTest<U> {
         
        @MyAnnotation
        private String name;
        public static void main(String[] args) {
         
            AnnotationTest<@MyAnnotation String> t = null;
            int a = (@MyAnnotation int) 2L;
            @MyAnnotation
        int b = 10;
        }
        public static <@MyAnnotation T> void method(T t) {
         
        }
        public static void test(@MyAnnotation String arg) throws @MyAnnotation Exception {
         
        }
    }
    @Target(ElementType.TYPE_USE)
    @interface MyAnnotation {
         
    }

[3071bc8eea2e468a82f5992085586a3d.png]: https://img-blog.csdnimg.cn/3071bc8eea2e468a82f5992085586a3d.png
[bfbab6e804be4462bab19bbb99b1d67a.png]: https://img-blog.csdnimg.cn/bfbab6e804be4462bab19bbb99b1d67a.png
[2644b7b08ff043d18eefb4c45f827da6.png]: https://img-blog.csdnimg.cn/2644b7b08ff043d18eefb4c45f827da6.png
[423ec13508c044efa8c28d2e395034a0.png]: https://img-blog.csdnimg.cn/423ec13508c044efa8c28d2e395034a0.png
[072794dc31f24ac0a65043239001215f.png]: https://img-blog.csdnimg.cn/072794dc31f24ac0a65043239001215f.png