介绍

自 Java 5 以来，Java 注解已成为 Java 语言的一部分。它们提供了一种向 Java 代码添加元数据的强大方法，从而使代码更具可读性、可维护性和无样板代码。

了解注解并学习如何创建自定义注解可以极大地提高您的 Java 开发技能。在本文中，我们将探索 Java 注解的世界：它们的工作原理、类型以及创建自己的注解的分步过程。

什么是 Java 注解？

Java 注解是现代 Java 开发的基石功能之一，提供了一种描述和控制代码元素行为的强大方法。注解在 Java 5 到 JSR 175 中引入，为开发人员提供了一种以形式化方式将元数据附加到代码的方法。然后，该元数据可用于各种目的，从指示 Java 编译器、指导代码生成工具，甚至影响运行时行为。

Java 注解剖析

注解是 Java 中一种特殊的接口。它们是使用@interface关键字定义的，但不是传统意义上的接口。它们是 Java 编译器或可能处理它们的工具的接口。

当用注解修饰一段代码时，实际上是将元数据附加到该代码。此元数据不会直接更改编译代码的操作。

以下是一个注解结构的简单细分：

• 注解声明：就像声明一个接口，但在关键字前面加上@符号。在代码中，可以定义使用注解可以配置的元素。
• Elements：它们的声明方式非常类似于方法，但它们的作用类似于字段。注解中定义的每个元素都可以有一个默认值，或者留给用户在使用注解提供。
• Retention Policy：只是用于编译时 ( RetentionPolicy.SOURCE)、类文件 ( RetentionPolicy.CLASS)，还是应该通过反射在运行时可用 ( RetentionPolicy.RUNTIME)？
• 目标Target：这定义了可以使用注解的位置（例如，在类、方法、字段等上）。

Java 中注解的作用

注解在 Java 编程中扮演着多种角色：

编译器指令

注解可以向编译器发出指令。例如，@Override告诉编译器检查某个方法是否确实是超类中方法的重写。如果不是，编译器会抛出错误。

代码分析

静态代码分析工具使用注解来检测问题或潜在问题、强制执行编码标准或查找代码异常。

运行时行为

注解可以影响程序在运行时的行为。例如，@Deprecated注解可以在运行时与反射结合使用，以不同的方式处理已弃用的功能。

简化 XML 配置

在使用注解之前，Java 开发人员严重依赖 XML 来配置应用程序，尤其是在 Java EE 生态系统中。注解在很大程度上取代了 XML，用于在代码中指定配置详细信息，例如定义 servlet 映射或事务管理。

促进框架的发展

Spring 和 Hibernate 等框架广泛使用注解来减少对样板代码的需求。例如，Spring中的@Autowired注解自动注入依赖项，Hibernate中的@Entity注解将类标记为数据库实体。

使用注解的最佳实践

虽然注解非常有用，但应谨慎使用它们：

• 不要过度使用：添加太多注解会使代码变得混乱并降低可读性。
• 文档：就像方法和类一样，记录注解的用途至关重要，尤其是对于自定义注解。
• 清晰：注解应该有清晰、简洁的名称，并且应该只做预期的事情。
• 避免冗余：如果可以推断元数据或已在其他地方声明元数据，则注解可能是多余的。

Java 注解是每个 Java 开发人员都应该理解的语言的基本方面。它们有助于使代码更加健壮、不易出错并且更易于维护。它们还充当我们编写的代码与我们依赖的工具和框架之间的桥梁，有助于自动化和简化开发过程的许多方面。

关键内置注解概述

@Override

@Override用在方法上以确保它们重写超类中的方法。这是针对简单错误（例如方法名称中的拼写错误或不正确的方法参数）的一种“保险”形式。

这是一个简单的例子：

class  SuperClass { 
    public  void  display () { 
        System.out.println( "SuperClass 显示方法" ); 
    } 
} 

class  SubClass  extends  SuperClass { 
    @Override 
    public  void  display () { 
        System.out.println( "子类显示方法" ); 
    } 
}

如果 SubClass中的方法没有正确覆盖SuperClass中的display方法（可能是由于方法签名不匹配），编译器将通过注解@Override标记错误。

@Deprecated

@Deprecated表示不应再使用某个类、方法或字段。它向其他开发人员发出警告，带注解的元素可能会在软件的未来版本中删除。

用法示例：

@Deprecated 
public  void  oldMethod () { 
    // ...
 }

当其他开发人员看到@Deprecated或使用已弃用的元素时，他们将在 IDE 中或编译期间收到警告。

@SuppressWarnings

此注解告诉编译器抑制否则会生成的特定警告。抑制多类别警告的示例：

@SuppressWarnings({"unchecked", "deprecation"}) 
void  myMethod () { 
    // ...
 }

@FunctionalInterface

Java 8 中引入的@FunctionalInterface注解表明类型声明在成为 Java 语言规范所定义的函数式接口。函数式接口是只有一个抽象方法的接口，用作 Java 中 lambda 表达式的基础。

例如：

@FunctionalInterface
public interface SimpleFunctionalInterface { 
    void execute() ; 
}

元注解

元注解是应用于其他注解的注解。它们定义编译器和运行时应如何处理带注解的元素。

@Retention

@Retention指定带有注解类型的注解要保留多长时间。它需要一个RetentionPolicy参数，可以是SOURCE、CLASS或 之一RUNTIME。

例如，@Retention(RetentionPolicy.RUNTIME)意味着注解应该由 JVM 保留，以便可以在运行时反射性地使用。

@Target

@Target注解指定注解类型适用的程序元素的种类。一些可能的ElementType值包括TYPE、FIELD、METHOD、PARAMETER等。

例如，@Target(ElementType.METHOD)限制对方法声明使用注解。

@Inherited

@Inherited注解表示注解类型被自动继承。如果一个类被标注了@Inherited，那么它的子类也会继承该注解。

@Documented

注解@Documented表示每当使用指定的注解时，都应该由 javadoc 工具记录。

了解内置注解的影响

Java 中的内置注解不仅仅是代码中的元数据或注解；它们具有真正的影响：

• 它们可以改变编译器处理某些代码片段的方式（@Override、@SuppressWarnings）。
• 他们可以提供有关其注解的元素的预期用途的信息，这对于维护和理解代码至关重要（@Deprecated，@FunctionalInterface）。
• @Retention它们可以在运行时控制注解的可见性，这对于依赖运行时反射（ @Inherite ）的框架至关重要。

在现代 Java 开发中，理解并有效使用这些内置注解至关重要。它们构成了许多 Java 编程实践和框架的支柱，确保代码安全、干净且文档齐全。

注解如何工作

Java 中的注解提供了一种元数据形式，可以附加到代码元素，例如类、方法、变量、参数和包。要了解注解的工作原理，必须掌握其生命周期，包括声明、处理和应用阶段。

注解声明

注解是使用一种特殊形式的接口来声明的，即注解类型，用关键字@interface定义。注解的结构如下：

import java.lang.annotation.*; 

@Retention(RetentionPolicy.RUNTIME) 
@Target(ElementType.METHOD) 
public  @interface MyCustomAnnotation { 
    String writer () default "John Doe" ; 
    String date() ; 
    int  version () default 1；
}

在上面的示例中，MyCustomAnnotation是一个具有三个元素的注解：author、date和version。@Retention和@Target是元注解，指定Java 编译器和 JVM 应如何处理MyCustomAnnotation。

注解的元素

注解元素可以被认为是没有参数和返回类型的方法。返回类型必须是与常量表达式类型以及这些类型的数组兼容的类型之一。有效的返回类型包括：

• 所有原始类型（int、long、float等）
• String
• Class
• 枚举
• 注解
• 上面的数组类型

元素可以有默认值，如上面version和writer示例所示

使用注解

在 Java 中应用注解非常简单。您可以将它们直接放置在它们应注解的代码元素的声明前面。例如：

public  class  MyAnnotatedClass { 

    @MyCustomAnnotation(date = "2023-11-01") 
    public  void  myMethod () { 
        // 方法体
    } 
}

现在在myMethod方法上使用@MyCustomAnnotation注解，并且该date元素设置为“2023-11-01”。由于author和version具有默认值，因此不需要显式设置它们。

如何处理注解

注解可以分两个主要阶段进行处理：

编译时处理

在编译时，注解可以由注解处理器处理 - 这些是特殊的类，可以读取注解信息并生成附加源代码、文档或其他资源。注解处理器是 Java 注解处理工具 (APT) 的一部分。

编译时处理的一个示例是@Override注解，Java 编译器使用它来验证某个方法确实覆盖了超类中的方法。

运行时处理

保留策略为RUNTIME 的注解在运行时可供 JVM 使用。这允许运行时反射——代码可以检查自己的注解，并根据这些注解的存在和配置执行不同步骤。

这是使用反射的运行时处理的简单示例：

import java.lang.reflect.*; 

public  class AnnotationRuntimeProcessor {
    public static void  processAnnotations (Object obj) 抛出异常 { 
        Class<?> objClass = obj.getClass(); 
        for (Method method : objClass.getDeclaredMethods()) { 
            if (method.isAnnotationPresent(MyCustomAnnotation.class)) { 
                MyCustomAnnotation annotations = method.getAnnotation(MyCustomAnnotation.class); } 
                System.out.println( "找到一个用MyCustomAnnotation注解的方法：" ); 
                System.out.println( "作者：" + comment.author()); 
                System.out.println( "日期：" + comment.date()); 
                System.out.println( "版本：" + 注解.version()); 
            } 
        } 
    } 

    public  static  void  main (String[] args)  throws Exception { 
        MyAnnotatedClass  myObj  =  new  MyAnnotatedClass (); 
        processAnnotations(myObj); 
    } 
}

上面代码中的processAnnotations方法使用反射来迭代对象的所有方法。如果它找到用 MyCustomAnnotation注解的方法，它将检索注解并打印出详细信息。

了解注解的内部结构

Java 中的注解是通过动态代理和接口实现的。当您查询元素上的注解时，返回的不是注解接口的直接实例，而是实现注解接口的代理。

该代理由 JVM 在运行时创建，它从代码中的注解或注解接口中定义的默认值提供注解元素的值。

注解是 Java 的一个强大部分，可以影响编译时行为和运行时行为。它们对于现代 Java 编程至关重要，可以实现更简单、更清晰的代码，并支持 Java 开发人员所依赖的庞大的工具和框架生态系统。对于任何希望充分利用该语言功能的 Java 开发人员来说，了解注解的声明、处理和应用方式至关重要。

创建自定义注解

在 Java 中创建自定义注解是一个多步骤的过程，可以显着增强代码的功能和可读性。自定义注解可用于多种目的，包括配置、验证甚至文档。

第 1 步：定义注解

要创建自定义注解，从@interface关键字开始。这向 Java 编译器发出信号，表明正在声明注解。以下是定义基本自定义注解的方法：

import java.lang.annotation.ElementType; 
import java.lang.annotation.Retention；
import java.lang.annotation.RetentionPolicy; 
import java.lang.annotation.Target；

@Retention(RetentionPolicy.RUNTIME) 
@Target({ElementType.METHOD, ElementType.TYPE}) 
public  @interface MyCustomAnnotation { 
    String writer () default "N/A" ; 
    String date() ; 
    int  version () default 1；
}

在这个定义中：

• @Retention(RetentionPolicy.RUNTIME)指定该注解在运行时可用于反射。
• @Target({ElementType.METHOD, ElementType.TYPE})表明该注解既可以用于类声明，也可以用于方法声明。
• 注解中的author、date和version元素可用于存储有关代码的信息。

第 2 步：应用注解

定义注解后，您可以将其应用到代码中。例如：

@MyCustomAnnotation(date = "2023-11-07") 
public  class  SomeClass { 
    @MyCustomAnnotation(author = "Jane Doe", date = "2023-11-07", version = 2) 
    public  void  someMethod () { 
        // . ..
     } 
}

在 中SomeClass，MyCustomAnnotation注解既应用于类本身又应用于someMethod方法。该date元素是为类提供的，所有三个元素（author、date和version）都是为方法提供的。

第 3 步：处理注解

自定义注解可以通过两种方式处理：在编译时使用注解处理器或在运行时使用反射。

编译时处理

要在编译时处理注解，通常会使用 Java 注解处理 API。注解处理器是一种检查和处理 Java 代码中注解类型的工具。这是注解处理器的骨架结构：

import javax.annotation.processing.AbstractProcessor; 
import javax.annotation.processing.RoundEnvironment；
import javax.lang.model.element.TypeElement; 
import javax.lang.model.element.Element; 
import java.util.Set；

public  class  MyAnnotationProcessor  extends  AbstractProcessor { 

    @Override 
    public  boolean  process (Set<? extends TypeElement> comments, RoundEnvironment roundEnv) { 
        for (TypeElement comment : comments) { 
            for (Element element : roundEnv.getElementsAnnotatedWith(annotation)) { 
                // 处理
            } 
        }
        返回 true；
    } 
}

运行时处理

对于运行时处理，您将使用反射，如上一节所示。这是一个重点关注我们的自定义注解的简短示例：

import java.lang.reflect.Method；

public  class  AnnotationRuntimeProcessor { 

    public  static  void  processAnnotations (Class<?> clazz)  throws Exception { 
        if (clazz.isAnnotationPresent(MyCustomAnnotation.class)) { 
            // 类级注解
            MyCustomAnnotation  classAnnotation  = clazz.getAnnotation(MyCustomAnnotation.class); } 
            System.out.println( "Class " + clazz.getSimpleName() + " 注解为： " + classAnnotation.author()); 
        } 

        for (Method method : clazz.getDeclaredMethods()) { 
            if (method.isAnnotationPresent(MyCustomAnnotation.class)) { 
                // 方法级注解
                MyCustomAnnotation  methodAnnotation  = method.getAnnotation(MyCustomAnnotation.class); 
                System.out.println( "方法 " + method.getName() + " 注解为： " + methodAnnotation.author()); 
            } 
        } 
    } 

    public  static  void  main (String[] args)  throws Exception { 
        processAnnotations(SomeClass.class); 
    } 
}

在此示例中，该processAnnotations方法用于打印author类和方法（如果存在）。

在 Java 中创建和使用自定义注解是增强代码的有效方法。它允许更清晰、更具描述性的代码，并在编译时和运行时实现某些任务的自动化。通过定义、应用和处理自定义注解，您可以创建更具可读性、可维护性和表现力的 Java 应用程序。

结论

注解是 Java 中的一项强大功能，它允许开发人员编写更清晰、更具表现力的代码。它们可用于多种目的，从向编译器提供提示，到启用复杂的运行时基于反射的逻辑。通过理解和利用自定义注解，Java 开发人员可以创建更健壮、可维护且防错的应用程序。

创建自定义注解涉及使用关键字定义注解、指定任何默认元素值以及使用和元注解@Retention，@Target，确定可以应用注解的位置。定义后，自定义注解可以在编译时或运行时使用反射进行处理，从而提供强大的机制来扩展 Java 语言的功能。

如果喜欢这篇文章，点赞支持一下，微信搜索：京城小人物，关注我第一时间查看更多内容！感谢支持！