java中符号@的作用及用法举例详解_Java

前言

在java中，@ 符号用来表示注解（annotation）。注解是java 5.0版本引入的一个特性，它提供了一种安全的为程序元素（类、方法、变量等）添加元数据的方式。注解本身不会直接影响程序的逻辑，但是它们可以被编译器、工具或运行时环境用来处理代码，从而实现特定的功能。

注解通常用于以下几个方面：

编译时检查：某些注解可以帮助编译器验证代码的正确性，例如 @override 注解可以确保你重写的方法确实存在于父类中。
编译时处理：一些注解可以在编译时被处理，生成额外的源文件或者修改字节码，例如使用注解处理器来自动生成代码。
运行时处理：部分注解可以在运行时通过反射机制来读取，并据此执行特定的逻辑，比如spring框架中的 @autowired 注解用于自动装配依赖。
文档生成：注解也可以用来生成文档，如 @deprecated 注解表示某个程序元素已经过时，不应该再使用。

常见的内置注解包括：

@override：用于标记方法覆盖的情况。
@deprecated：标记已弃用的方法或类。
@suppresswarnings：用于抑制编译器警告。

自定义注解可以通过 @interface 关键字来创建，自定义注解可以带有成员，这些成员在使用注解时提供必要的信息。

示例：

public @interface myannotation {
    string value() default "default value";
}

@myannotation(value = "hello, world!")
public class myclass {
    // 类的内容
}

在这个例子中，myannotation 是一个自定义注解，它有一个名为 value 的成员，默认值为 "default value"。myclass 类上应用了这个注解，并指定了 value 成员的具体值。

1. 定义注解

注解本质上是一个接口，但它的声明方式与普通接口不同。定义注解使用 @interface 关键字。注解可以有成员，这些成员类似于接口的方法，但有一些限制，例如成员类型只能是基本类型、字符串、类、枚举、注解或上述类型的数组。

示例：定义一个简单的注解

public @interface myannotation {
    string value() default "";  // 默认值为空字符串
    int count() default 1;      // 默认值为1
}

2. 注解的元注解

元注解是用于修饰注解的注解。java 提供了一些标准的元注解：

@retention：指定注解的保留策略。
@target：指定注解可以应用的目标类型。
@documented：指定注解是否应该包含在 javadoc 中。
@inherited：指定注解是否可以被子类继承。

示例：使用元注解

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)         // 注解可以应用于方法
public @interface myannotation {
    string value() default "";
    int count() default 1;
}

3. 注解的保留策略

@retention 元注解用于指定注解的保留策略，即注解在哪个阶段有效。主要有三种保留策略：

retentionpolicy.source：注解仅保留在源代码级别，编译时会被忽略。
retentionpolicy.class：注解保留在类文件中，但不会被加载到 jvm 中。
retentionpolicy.runtime：注解保留在 jvm 中，可以在运行时通过反射获取。

4. 注解的应用目标

@target 元注解用于指定注解可以应用的目标类型。常见的目标类型包括：

elementtype.type：类、接口（包括注解类型）或枚举声明。
elementtype.field：字段、枚举常量。
elementtype.method：方法。
elementtype.parameter：参数。
elementtype.constructor：构造方法。
elementtype.local_variable：局部变量。
elementtype.annotation_type：注解类型。
elementtype.package：包声明。

5. 运行时处理注解

在运行时处理注解通常需要使用反射机制。通过反射，可以获取类、方法、字段等上的注解，并读取注解的成员值。

示例：运行时处理注解

import java.lang.annotation.retention;
import java.lang.annotation.retentionpolicy;
import java.lang.annotation.target;
import java.lang.reflect.method;

@retention(retentionpolicy.runtime)
@target(elementtype.method)
public @interface myannotation {
    string value() default "";
    int count() default 1;
}

public class myclass {
    @myannotation(value = "hello", count = 5)
    public void mymethod() {
        system.out.println("this is my method.");
    }
}

public class main {
    public static void main(string[] args) throws exception {
        method method = myclass.class.getmethod("mymethod");
        if (method.isannotationpresent(myannotation.class)) {
            myannotation annotation = method.getannotation(myannotation.class);
            system.out.println("value: " + annotation.value());
            system.out.println("count: " + annotation.count());
        }
    }
}

6. 内置注解

java 提供了一些内置注解，用于常见的编程场景：

@override：表示方法覆盖。
@deprecated：表示方法或类已弃用。
@suppresswarnings：用于抑制编译器警告。

7. 自定义注解处理器

注解处理器是一种在编译时处理注解的工具。通过注解处理器，可以在编译时生成额外的源代码或进行其他操作。java 提供了 javax.annotation.processing 包来支持注解处理器的开发。

示例：定义一个简单的注解处理器

import javax.annotation.processing.abstractprocessor;
import javax.annotation.processing.roundenvironment;
import javax.annotation.processing.supportedannotationtypes;
import javax.annotation.processing.supportedsourceversion;
import javax.lang.model.sourceversion;
import javax.lang.model.element.typeelement;
import java.io.ioexception;
import java.io.printwriter;
import java.util.set;

@supportedannotationtypes("com.example.myannotation")
@supportedsourceversion(sourceversion.release_8)
public class myannotationprocessor extends abstractprocessor {
    @override
    public boolean process(set<? extends typeelement> annotations, roundenvironment roundenv) {
        for (typeelement annotation : annotations) {
            set<? extends element> annotatedelements = roundenv.getelementsannotatedwith(annotation);
            for (element element : annotatedelements) {
                try (printwriter out = new printwriter(processingenv.getfiler().createsourcefile(element.getsimplename() + "generated").openwriter())) {
                    out.println("public class " + element.getsimplename() + "generated {");
                    out.println("    public void generatedmethod() {");
                    out.println("        system.out.println(\"this is a generated method.\");");
                    out.println("    }");
                    out.println("}");
                } catch (ioexception e) {
                    e.printstacktrace();
                }
            }
        }
        return true;
    }
}

8. 注解的应用场景

注解在现代java开发中非常常见，尤其是在框架和库中。以下是一些典型的应用场景：

依赖注入：如spring框架中的 @autowired。
单元测试：如junit中的 @test。
web框架：如spring mvc中的 @requestmapping。
持久化框架：如hibernate中的 @entity 和 @table。
配置管理：如spring boot中的 @configuration 和 @bean。当然可以！我们继续深入探讨java注解的高级特性和应用场景。

9. 注解的组合使用

在实际开发中，注解经常被组合使用，以实现更复杂的功能。例如，spring框架中的 @restcontroller 实际上是一个组合注解，它包含了 @controller 和 @responsebody。

示例：定义一个组合注解

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.type)
public @interface mycustomcontroller {
    @myannotation
    class<?> value();
}

@retention(retentionpolicy.runtime)
@target(elementtype.type)
public @interface myannotation {
    string value() default "";
}

@mycustomcontroller(value = myclass.class)
public class myclass {
    // 类的内容
}

10. 注解的默认值

注解的成员可以有默认值，这使得在使用注解时可以省略这些成员的显式赋值。

示例：带有默认值的注解

@retention(retentionpolicy.runtime)
@target(elementtype.method)
public @interface myannotation {
    string value() default "default value";
    int count() default 1;
}

public class myclass {
    @myannotation
    public void mymethod() {
        system.out.println("this is my method.");
    }
}

11. 重复注解

从java 8开始，引入了重复注解的概念。允许在一个地方多次使用同一个注解。

示例：定义和使用重复注解

import java.lang.annotation.repeatable;
import java.lang.annotation.retention;
import java.lang.annotation.retentionpolicy;
import java.lang.annotation.target;

@retention(retentionpolicy.runtime)
@target(elementtype.method)
public @interface myannotations {
    myannotation[] value();
}

@repeatable(myannotations.class)
@retention(retentionpolicy.runtime)
@target(elementtype.method)
public @interface myannotation {
    string value() default "";
}

public class myclass {
    @myannotation(value = "first")
    @myannotation(value = "second")
    public void mymethod() {
        system.out.println("this is my method.");
    }
}

public class main {
    public static void main(string[] args) throws exception {
        method method = myclass.class.getmethod("mymethod");
        if (method.isannotationpresent(myannotations.class)) {
            myannotations annotations = method.getannotation(myannotations.class);
            for (myannotation annotation : annotations.value()) {
                system.out.println("value: " + annotation.value());
            }
        } else if (method.isannotationpresent(myannotation.class)) {
            myannotation annotation = method.getannotation(myannotation.class);
            system.out.println("value: " + annotation.value());
        }
    }
}

12. 注解的继承

虽然注解本身不能继承，但可以通过 @inherited 元注解使注解具有继承性。这意味着如果一个类使用了某个注解，那么它的子类也会继承该注解。

示例：使用 @inherited 元注解

import java.lang.annotation.inherited;
import java.lang.annotation.retention;
import java.lang.annotation.retentionpolicy;
import java.lang.annotation.target;

@inherited
@retention(retentionpolicy.runtime)
@target(elementtype.type)
public @interface myannotation {
    string value() default "";
}

@myannotation(value = "parent")
public class parentclass {
    // 类的内容
}

public class childclass extends parentclass {
    // 类的内容
}

public class main {
    public static void main(string[] args) {
        class<?> clazz = childclass.class;
        if (clazz.isannotationpresent(myannotation.class)) {
            myannotation annotation = clazz.getannotation(myannotation.class);
            system.out.println("value: " + annotation.value());
        }
    }
}

13. 注解在框架中的应用

注解在许多流行的java框架中广泛使用，以下是一些典型的应用场景：

spring框架：

- @autowired：自动注入依赖。
- @controller / @restcontroller：标识控制器类。
- @service：标识服务层类。
- @repository：标识数据访问层类。
- @transactional：管理事务。

hibernate：

- @entity：标识实体类。
- @table：指定表名。
- @column：指定列名。
- @id：标识主键。

junit：

- @test：标识测试方法。
- @before / @after：标识在每个测试方法前/后执行的方法。
- @beforeclass / @afterclass：标识在所有测试方法前/后执行的方法。

servlet 3.0+：

- @webservlet：标识servlet。
- @webfilter：标识过滤器。
- @weblistener：标识监听器。

14. 注解的性能影响

注解本身不会对程序的性能产生显著影响，因为它们只是元数据。然而，如果在运行时频繁地使用反射来处理注解，可能会对性能产生一定的影响。因此，在设计时应权衡注解的使用频率和性能需求。

15. 最佳实践

简洁明了：注解应该简洁明了，避免过于复杂的逻辑。
合理使用：注解不应替代传统的编程逻辑，而应作为辅助手段。
文档化：注解的使用应该有良好的文档说明，以便其他开发者理解其用途。
性能考虑：避免在性能敏感的代码路径中频繁使用反射来处理注解。

java注解的最佳实践

java注解的使用非常灵活，但为了确保代码的可维护性和性能，遵循一些最佳实践是非常重要的。以下是一些关于如何有效使用java注解的最佳实践：

1. 保持注解简单和明确

简洁性：注解应该尽量简洁，避免过多的成员和复杂的逻辑。
命名清晰：注解名称应该清晰、有意义，能够一眼看出其用途。

2. 使用元注解

保留策略：使用 @retention 指定注解的保留策略。通常情况下，如果注解只用于编译时检查，可以选择 source；如果需要在运行时处理注解，选择 runtime。
目标类型：使用 @target 指定注解可以应用的目标类型，确保注解在合适的上下文中使用。
文档化：使用 @documented 将注解包含在生成的javadoc中，提高代码的可读性和可维护性。
继承性：使用 @inherited 使注解具有继承性，适用于需要子类继承父类注解的场景。

3. 避免过度使用注解

适度使用：注解不应该替代传统的编程逻辑，而是作为辅助手段。过度使用注解会增加代码的复杂性和维护难度。
避免冗余：不要在没有必要的情况下重复使用相同的注解，避免冗余和混乱。

4. 使用默认值

默认值：为注解成员提供合理的默认值，这样在使用注解时可以省略不必要的参数，使代码更加简洁。

5. 文档化注解

注释：为注解及其成员添加详细的注释，解释其用途和使用方法。
示例：提供注解使用的示例，帮助其他开发者理解如何正确使用注解。

6. 性能考虑

反射使用：避免在性能敏感的代码路径中频繁使用反射来处理注解。可以考虑缓存注解的处理结果，减少重复的反射调用。
编译时处理：如果可能，使用注解处理器在编译时处理注解，生成额外的源代码或进行其他优化。

7. 组合注解

组合使用：合理使用组合注解，将多个相关的注解组合成一个，简化注解的使用。
一致性：确保组合注解的一致性和语义清晰，避免混淆。

8. 测试注解

单元测试：编写单元测试来验证注解的行为和效果，确保注解按预期工作。
集成测试：在集成测试中验证注解在实际应用中的表现，确保没有遗漏或错误。

9. 遵循框架的最佳实践

框架规范：在使用框架提供的注解时，遵循框架的最佳实践和推荐用法。
扩展性：如果需要扩展框架功能，考虑使用自定义注解和注解处理器。

10. 代码审查

代码审查：在代码审查过程中特别关注注解的使用，确保注解的正确性和合理性。
团队共识：与团队成员达成共识，统一注解的使用规范和风格。

示例：遵循最佳实践的注解定义和使用

import java.lang.annotation.elementtype;
import java.lang.annotation.retention;
import java.lang.annotation.retentionpolicy;
import java.lang.annotation.target;
import java.lang.annotation.documented;
import java.lang.annotation.inherited;

// 定义一个注解
@documented
@inherited
@retention(retentionpolicy.runtime)
@target(elementtype.method)
public @interface myannotation {
    string value() default "default value";
    int count() default 1;
}

// 使用注解
public class myclass {
    @myannotation(value = "hello", count = 5)
    public void mymethod() {
        system.out.println("this is my method.");
    }
}

// 处理注解
public class main {
    public static void main(string[] args) throws exception {
        method method = myclass.class.getmethod("mymethod");
        if (method.isannotationpresent(myannotation.class)) {
            myannotation annotation = method.getannotation(myannotation.class);
            system.out.println("value: " + annotation.value());
            system.out.println("count: " + annotation.count());
        }
    }
}

总结

到此这篇关于java中符号@的作用及用法的文章就介绍到这了,更多相关java符号@用法内容请搜索代码网以前的文章或继续浏览下面的相关文章希望大家以后多多支持代码网！


验证码：

java中符号@的作用及用法举例详解

2025年04月12日 • Java •我要评论

前言