Java常用注解

miku

一、Java基础注解

1. @Override

• 用于注解方法，表示当前的方法定义将覆盖超类中的方法（重写）。如果方法签名不正确或者拼写错误，编译器会报错。

  class Parent {
    void display() {
        System.out.println("父类方法");
    }
  }
  
  class Child extends Parent {
    @Override
    void display() {
        System.out.println("子类重写父类方法");
    }
  }

2. @Deprecated

• 用于标记类、方法或字段，表示不再推荐使用，通常会在调用时出现删除线。不过，仍可以使用，但建议使用替代方法

  class DeprecatedExample {
    @Deprecated
    void oldMethod() {
        System.out.println("这是一个过时的方法");
    }
  
    void newMethod() {
        System.out.println("这是一个新方法");
    }
  }

3. @SuppressWarnings

• @SuppressWarnings 注解用于抑制编译器产生警告信息。在某些情况下，编译器会发出警告，通常是因为代码中存在潜在的问题或不安全的操作，但开发者知道这些警告是安全的，可以通过 @SuppressWarnings 注解来告诉编译器不要产生这些警告。

• 通常与特定的警告类型一起使用，如@SuppressWarnings("unchecked")。

  @SuppressWarnings("unchecked")
  // 右侧的 ArrayList 不带泛型类型参数。这种情况下，编译器会发出 "unchecked" 警告，
  // 因为泛型信息可能在运行时丢失，导致潜在的类型不安全性。
  List<String> list = new ArrayList();

  在上面的例子中，@SuppressWarnings注解抑制了编译器警告，List<String> list = new ArrayList()语句不再发出警告信息。

4. @SafeVarargs

• @SafeVarargs 注解用于标识泛型可变参数构造器或方法声明中的泛型类型是安全的，这意味着在使用该方法或构造器时不会引发类型安全问题。通常，泛型可变参数在Java中可能会引发警告信息，因为泛型和可变参数的组合可能会导致潜在的类型安全问题。

@SafeVarargs
public final <T> void doSomething(T... args) {
    // ...
}

在这种情况下，编译器可能会警告说使用了非安全的可变参数。但是，如果你确定你的泛型可变参数使用是安全的，可以使用 @SafeVarargs 注解来告诉编译器不要生成这种警告。

5. @FunctionalInterface

• 用来标识接口是函数式接口，即只包含一个抽象方法的接口。

@FunctionalInterface
public interface GreetingService {
    void greet(String name);
}

在上面的例子中，@FunctionalInterface注解标识接口GreetingService是一个函数式接口，只包含一个抽象方法greet。

二、元注解（Meta-Annotations）

1. @Target

• 用于注解注解类本身，指定了注解可以应用于的位置，包括构造器声明、域声明、局部变量声明、方法声明、包声明、参数声明、类、接口或枚举声明。可以同时指定多个位置。

2. @Retention

• 用于指定注解的保留策略，指定在什么级别保存注解信息。有三个可选的策略：
• SOURCE（注解只在源代码中存在，编译时丢弃）
• CLASS（注解在编译后的 class 文件中存在，但在运行时丢弃，默认值）
• RUNTIME（注解在运行时保留，可以通过反射获取）

3. @Documented

• 用于注解注解类本身，表示此注解应包含在Java文档中（javadoc），这样文档工具会将其信息提取到文档中，有助于文档的可读性。

4. @Inherited

• 用于注解注解类本身，允许子类继承父类中的注解。这意味着如果一个类使用了带有@Inherited注解的注解，那么它的子类也会继承这个注解。

三、MyBatis常用注解

// @Mapper：标记Mapper接口
@Mapper
public interface UserMapper {

    // @Select：定义查询语句
    @Select("SELECT * FROM users WHERE id = #{id}")
    User getUserById(int id);

    // @Insert：定义插入语句
    @Insert("INSERT INTO users (name, email) VALUES (#{name}, #{email})")
    int insertUser(User user);

    // @Update：定义更新语句
    @Update("UPDATE users SET name = #{name}, email = #{email} WHERE id = #{id}")
    int updateUser(User user);

    // @Delete：定义删除语句
    @Delete("DELETE FROM users WHERE id = #{id}")
    int deleteUser(int id);

    // @Results：定义结果映射规则
    @Results(id = "userResultMap", value = {
        @Result(property = "id", column = "user_id"),
        @Result(property = "name", column = "user_name"),
        @Result(property = "email", column = "user_email")
    })

    // @Result：定义单个字段的映射规则
    @Result(property = "email", column = "user_email")
    List<User> getAllUsers();

    // @Param：定义方法参数名称
    int updateUserEmail(@Param("id") int userId, @Param("email") String newEmail);

    // @Options：配置选项，如生成主键
    @Options(useGeneratedKeys = true, keyProperty = "id")
    @Insert("INSERT INTO users (name, email) VALUES (#{name}, #{email})")
    int insertUserWithGeneratedKey(User user);
}

四、MyBaits-Plus常用注解

1. @TableName

   : 用于指定实体类对应的数据库表名。

   • value: 指定表名。

2. @TableId

   : 用于指定实体类中作为主键的字段。

   • value: 指定主键字段在数据库表中的列名。
   • type: 指定主键策略（如自增、UUID等）。

3. @TableField

   : 用于配置实体类属性和数据库表字段的映射关系。

   • value: 指定属性对应的数据库字段名。
   • exist: 指示字段在数据库中是否存在，默认为 true。
   • 其他属性用于处理更复杂的映射关系。

4. @TableLogic

   : 用于标记逻辑删除属性。

   • 在逻辑删除的字段上使用，与数据库中的逻辑删除字段相对应。

5. @Version: 用于乐观锁控制，标记乐观锁版本号字段。

6. @EnumValue: 用于标识实体类中枚举类的字段，该字段的值将被保存到数据库中。

7. @KeySequence: 用于设置序列名，主要用于Oracle数据库。

8. @FieldName: 指定复杂映射关系中数据库字段的名称。

@TableName(value = "employee") // 指定实体类对应的数据库表名
@KeySequence(value = "seq_employee") // 用于Oracle数据库的序列名
public class Employee {
    @TableId(value = "id", type = IdType.AUTO) // 指定主键字段及其生成策略（这里为自增）
    private Long id;

    @TableField(value = "name") // 映射数据库字段 name
    private String name;

    @TableField(exist = false) // 表示这个字段在数据库表中不存在
    private String transientField; // 临时字段，不映射到数据库

    @TableField("email") // 映射数据库字段 email
    private String email;

    @TableLogic // 标记为逻辑删除字段
    @TableField("is_deleted") // 映射数据库中的逻辑删除字段
    private Boolean deleted;

    @Version // 标记为乐观锁版本号字段
    @TableField("version")
    private Integer version;

    @EnumValue // 标记枚举类字段，其值将被保存到数据库
    @TableField("role")
    private Role role;

    // 省略 getter 和 setter 方法

    public enum Role {
        ADMIN, USER, GUEST
    }
}

@TableField 注解

该注解用于标识非主键的字段，用于将数据库列与 JavaBean 中的属性进行映射。

属性名称	类型	默认值	描述
value	String	“”	数据库字段名
el	String	“”	映射为原生 #{ … } 逻辑，相当于写在 xml 里的 #{ … } 部分
exist	boolean	true	是否为数据库表字段
condition	String	“”	字段 where 实体查询比较条件，有值设置则按设置的值为准
update	String	“”	字段 update set 部分注入，例如：update=“%s+1” 表示更新时会 set 该字段为原值加1
insertStrategy	Enum	DEFAULT	插入策略，具体见官方文档
updateStrategy	Enum	DEFAULT	更新策略，具体见官方文档
whereStrategy	Enum	DEFAULT	where 条件策略，具体见官方文档
fill	Enum	FieldFill.DEFAULT	字段自动填充策略
select	boolean	true	是否进行 select 查询
keepGlobalFormat	boolean	false	是否保持使用全局的 format 进行处理
jdbcType	JdbcType	JdbcType.UNDEFINED	JDBC 类型，该默认值不代表会按照该值生效
typeHandler	Class<? extends TypeHandler>	UnknownTypeHandler.class	类型处理器，该默认值不代表会按照该值生效
numericScale	String	“”	指定小数点后保留的位数

@TableId 注解

描述主键的注解。

属性名称	类型	必须指定	默认值	描述
value	String	否	“”	主键字段名
type	Enum	否	IdType.NONE	主键类型，具体取值请参考官方文档

主键类型的取值及描述如下：

• AUTO：数据库ID自增
• NONE：无状态，未设置主键类型
• INPUT：插入前自行设置主键值
• ASSIGN_ID：分配ID（主键类型为Number(Long和Integer)或String）
• ASSIGN_UUID：分配UUID（主键类型为String）
• ID_WORKER：分布式全局唯一ID（长整型类型）
• UUID：32位UUID字符串
• ID_WORKER_STR：分布式全局唯一ID（字符串类型）

@TableLogic 注解

用于添加逻辑删除功能的注解，加在属性字段上。

属性名称	类型	默认值	描述
value	String	“”	逻辑删除的原值
delval	String	“”	逻辑删除的改值

@TableName 注解

用于标识表名的注解。

属性名称	类型	默认值	描述
value	String	“”	表名
schema	String	“”	schema
keepGlobalPrefix	boolean	false	是否保持使用全局的 tablePrefix 的值
resultMap	String	“”	XML 中 resultMap 的 id
autoResultMap	boolean	false	是否自动构建 resultMap 并使用（如果设置 resultMap，则不会进行 resultMap 的自动构建）

五、Spring常用注解

1. @Bean注解

• 用途与应用：@Bean注解用于在Java配置类中声明一个Spring容器管理的bean。它标记在方法上，方法的返回值是一个对象，该对象被注册为Spring应用上下文中的bean。这个注解通常与@Configuration注解一起使用，定义在配置类的方法上。@Bean注解的方法可以接受参数，这些参数对应于其他bean的依赖，Spring会自动为这些参数注入合适的bean。

  • 当没有设置name属性时，bean名称是方法名
  • 当设置了name属性，只能通过name属性对应的值来获取，使用方法名就获取不到

  @Configuration
  public class AppConfig {
    // @Bean注解用于将myBean方法返回的对象注册为Spring容器中的bean
    @Bean
    // @Bean(name = "myBean2")
    public MyBean myBean() {
        return new MyBean();
    }
  }

  如果容器中有多个与属性的类型匹配的bean，你需要使用bean的名称来指定要注入哪个bean。你可以使用@Qualifier注解来指定bean的名称。

  @Autowired
  @Qualifier("userServiceA")
  private UserService userService; // 使用@Qualifier指定要注入的bean名称

2. @Service注解

• 用途与应用：@Service注解标记在服务层（业务层）的类上，表示这是一个提供业务逻辑服务的类。Spring通过类路径扫描来发现这些服务，并将它们注册为bean，从而可以在应用中通过依赖注入的方式使用这些服务。这样可以将业务逻辑层的实现自动注册到Spring容器中，减少配置和管理的负担。

  @Service
  public class MyService {
    // @Service注解表示这是一个业务逻辑服务类，Spring会自动扫描并注册它
  }

3. @Component注解

• 用途与应用：@Component注解是一个泛用型注解，用于任何Spring管理的组件。当一个类不明确属于任何其他层（如服务层、控制层）时使用。它是其他三个注解（@Repository, @Service, @Controller）的通用形式，用于标记Spring容器自动扫描和配置的组件。

  @Component
  public class MyComponent {
    // @Component注解用于将这个类注册为Spring容器中的通用组件
  }

4. @Repository注解

• 用途与应用：@Repository注解标记在DAO层类上，用于访问数据库。Spring会对使用@Repository注解的类进行异常翻译，将数据库访问过程中出现的原生异常转换为Spring的数据访问异常，从而简化了错误处理。

  @Repository
  public class MyRepository {
    // @Repository注解标识这是一个用于数据库访问的类，Spring提供异常翻译
  }

5. @Controller注解

• 用途与应用：@Controller注解标记在Web层的控制器类上，用于处理Web请求。Spring MVC会自动检测使用@Controller注解的类，并将其注册为Web控制器，这些控制器类负责处理通过HTTP请求映射到的方法。

  @Controller
  public class MyController {
    // @Controller注解用于将这个类标记为Spring MVC中的控制器，处理Web请求
    @RequestMapping("/hello")
    public String hello() {
        // 处理Web请求并返回视图名
        return "hello";
    }
  }

6. @Configuration注解

• 用途与应用：@Configuration注解用于定义配置类，可以替代传统的XML配置文件。在这个类中，可以使用@Bean注解定义多个方法，每个方法返回一个对象，这些对象被注册为Spring应用上下文中的bean。这种方式允许更加灵活和强大的配置方式，尤其是在构建复杂的bean依赖关系时。

  @Configuration
  public class AppConfig {
    // @Configuration注解用于定义配置类，通常与@Bean一起使用，定义Spring容器中的bean
    @Bean
    public MyBean myBean() {
        return new MyBean();
    }
  }

7. @Autowired注解

• 用途与应用：@Autowired注解用于实现自动依赖注入。它可以用于类的成员变量、方法及构造函数上，自动注入所需的依赖。默认情况下，Spring会按类型进行自动装配。如果存在多个相同类型的bean，则可以结合@Qualifier注解来指定具体的bean。

  @Service
  public class MyService {
    @Autowired
    private MyRepository myRepository;
    // @Autowired注解用于自动注入依赖，将myRepository赋值为一个已注册的bean
  }

8. @Resource注解

• 用途与应用：@Resource注解也用于实现依赖注入，但它默认按名称进行自动装配。如果没有指定名称，则会回退到按类型装配。@Resource注解提供了更细粒度的控制，允许通过指定的名称或类型来注入特定的bean。

  @Service
  public class MyService {
    @Resource
    private MyRepository myRepository;
    // @Resource注解用于自动注入依赖，按名称匹配已注册的bean
  }

9. @ComponentScan注解

• 用途与应用：@ComponentScan注解用于指定Spring在初始化时应该扫描哪些包来发现带有@Component, @Service, @Repository, @Controller等注解的类，并将它们注册为bean。这个注解通常用在配置类上，指定基础包，从而避免手动注册每个组件。

  @Configuration
  @ComponentScan(basePackages = "com.example")
  public class AppConfig {
    // @ComponentScan注解用于指定Spring扫描的包，自动注册标有@Component的类
  }

10. @PropertySource注解

• @PropertySource注解用于将properties配置文件的内容加载到Spring的Environment中。这允许应用读取配置文件中的值，例如数据库配置或任何自定义配置。这些值可以通过@Value注解注入到bean的字段中。

  注意，在Spring Boot 中，你通常不需要使用 @PropertySource 注解来加载配置文件，因为 Spring Boot 会默认加载一些常见的配置文件，例如 application.properties 或 application.yml

  @Configuration
  @PropertySource("classpath:config.properties")
  public class AppConfig {
    @Value("${my.property}")
    private String myProperty;
    // @Value注解用于注入配置属性值，从配置文件中读取my.property的值
  }

11. @ImportResource注解和@Import注解

• @Import注解用于导入其他配置类。@ImportResource注解用于导入传统的XML配置文件。这两个注解通常用于将不同的配置模块组合在一起，使得配置更加模块化。

  @Configuration
  @ImportResource("classpath:applicationContext.xml")
  @Import({AnotherConfig.class, YetAnotherConfig.class})
  public class AppConfig {
    // @ImportResource注解用于导入XML配置文件，@Import注解用于导入其他配置类
  }

12. @Value注解

• @Value注解用于将一个值注入到bean的字段中。这个值可以是硬编码的字符串，也可以是从配置文件中解析出来的。例如，@Value(“${property.name}”)会读取配置文件中名为property.name的属性值。

  @Component
  public class MyComponent {
    @Value("${my.property}")
    private String myProperty;
    // @Value注解用于注入配置属性值，从配置文件中读取my.property的值
  }

13. @Scope注解

• 声明 Spring Bean 的作用域，这个注解可以放在方法级别，也可以放在类级别:

  @Bean
  @Scope("singleton")
  public Person personSingleton() {
    return new Person();
  }

  四种常见的 Spring Bean 的作用域：

  • singleton : 唯一 bean 实例，Spring 中的 bean 默认都是单例的。
  • prototype : 每次请求都会创建一个新的 bean 实例。
  • request : 每一次 HTTP 请求都会产request 生一个新的 bean，该 bean 仅在当前 HTTP request 内有效。
  • session : 每一次 HTTP 请求都会产生一个新的 bean，该 bean 仅在当前 HTTP session 内有效。

14. @ConfigurationProperties注解

• @ConfigurationProperties 是 Spring Framework 中的一个注解，它的主要作用是将外部配置文件中的属性值映射到 Java 对象的属性上。这个注解通常与 @Configuration 配合使用，以实现将配置文件中的属性值注入到 Spring Bean 中。

• @ConfigurationProperties 支持从不同的数据源中读取属性，包括 properties 文件、YAML 文件、环境变量等。

• 前缀设置：可以通过设置 prefix 属性来指定配置属性的前缀，这有助于区分不同的配置属性集。

  application.yml 示例:

  app:
  database:
    url: jdbc:mysql://localhost:3306/mydb
    username: myuser
    password: secret
  

  接下来，我们创建一个 Java 类来映射这些配置属性。使用 @ConfigurationProperties 注解来指定配置的前缀，这样 Spring 就能自动将配置文件中相应的属性映射到这个类的属性上。

  @Configuration
  @Data
  @ConfigurationProperties(prefix = "app.database")
  public class DatabaseConfig {
    private String url;
    private String username;
    private String password;
  }

  这样，你就可以在应用程序中通过注入 DatabaseConfig 类的实例来访问数据库配置了。这种方式简化了配置管理，使得代码更清晰、更易于维护。

15. @Transactional注解

在要开启事务的方法上使用@Transactional注解即可!

我们知道 Exception 分为运行时异常 RuntimeException 和非运行时异常。在@Transactional注解中如果不配置rollbackFor属性,那么事物只会在遇到RuntimeException的时候才会回滚,加上rollbackFor=Exception.class,可以让事物在遇到非运行时异常时也回滚。

@Transactional 注解一般用在可以作用在类或者方法上。

• 作用于类：当把@Transactional 注解放在类上时，表示所有该类的public 方法都配置相同的事务属性信息。
• 作用于方法：当类配置了@Transactional，方法也配置了@Transactional，方法的事务会覆盖类的事务配置信息。

@Transactional(rollbackFor = Exception.class)
public void save() {
  ......
}

16. @EnableScheduling注解

• 这个注解用于在 Spring 应用程序中启用定时任务的支持。它通常被放置在配置类上，允许 Spring 查找和注册所有的 @Scheduled 注解的方法作为定时任务。
• 在 Spring Boot 中，您只需要在一个配置类上添加此注解，Spring Boot 会自动扫描和注册所有 @Scheduled 注解的方法

@Configuration
@EnableScheduling // 启用定时任务
public class SchedulerConfig {
    // 这里可以定义其他的Bean
}

17. @Scheduled注解

• @Scheduled 注解用于在指定的时间间隔执行特定的方法。它支持多种调度选项，包括固定延迟（fixedDelay）、固定速率（fixedRate）和 cron 表达式（cron）。
• 在 Spring Boot 中，使用 @Scheduled 注解创建定时任务非常直接。您可以在任何被 Spring 管理的 bean 的方法上使用此注解来定义定时任务。

@Component
public class ScheduledTasks {

    @Scheduled(fixedRate = 5000) // 每5000毫秒（5秒）执行一次
    public void performTask() {
        // 需要定期执行的任务代码
    }
}

18. @Schedules注解

@Schedules 注解用于在一个方法上定义多个不同的定时任务。这适用于需要多种调度策略的情况。

@Component
public class MultipleScheduledTasks {

    @Schedules({
        @Scheduled(fixedDelay = 10000), // 每10000毫秒（10秒）执行一次
        @Scheduled(cron = "0 15 10 * * ?") // 每天上午10:15执行
    })
    public void performMultipleTasks() {
        // 需要定期执行的任务代码
    }
}

19. @EnableAsync 注解

• @EnableAsync 注解开启 Spring 的异步方法执行能力，允许使用 @Async 注解的方法异步执行。这通常在配置类中使用，使得整个 Spring 应用程序中的异步方法得以执行。
• 在 Spring Boot 中，您只需在一个配置类上添加此注解，Spring Boot 会自动配置异步方法的支持

@Configuration
@EnableAsync // 开启异步方法执行的支持
public class AsyncConfig {
    // 配置异步执行相关的设置
}

20. @Async 注解

@Async 注解用于声明一个方法是异步执行的，即该方法将在不同的线程中运行，而非调用者的线程中。这对于执行耗时较长的任务特别有用，例如发送邮件、执行数据库长操作等。

public class AsyncService {

    @Async // 标记该方法为异步执行
    public void executeAsyncTask() {
        // 在异步线程中执行的代码
    }
}

六、SpringMVC常用注解

1. @RestController

• @RestController 是一个复合注解，它是在 Spring Framework中对 @Controller 和 @ResponseBody 进行了整合的注解。@Controller 注解用于标记类

• @RestController 注解默认将方法返回的对象转换为 JSON 或 XML 格式，并作为响应体返回给客户端。

  @RestController // @RestController = @Controller + @ResponseBody
  public class HelloController {
  
    @GetMapping("/hello") 
    public String sayHello() {
        return "你好，世界！"; 
    }
  }

2. @RequestMapping

• @RequestMapping是Spring MVC中用于建立请求URL和处理器方法之间映射关系的注解。当它用于类上时，它指定了一个基础的请求路径，该类中的所有方法都将继承这个路径。而当它用于方法上时，它指定了处理特定请求的方法。这个注解可以处理不同类型的HTTP方法（如GET, POST等），并支持自定义请求头、参数等。

@RequestMapping注解拥有以下的六个配置属性：

• value:映射的请求URL或者其别名
• method:兼容HTTP的方法名
• params:根据HTTP参数的存在、缺省或值对请求进行过滤
• header:根据HTTP Header的存在、缺省或值对请求进行过滤
• consume:设定在HTTP请求正文中允许使用的媒体类型
• product:在HTTP响应体中允许使用的媒体类型

@Controller
@RequestMapping("/users")
public class UserController {

    // 使用@RequestMapping处理特定的URL。
    // 在这个例子中，处理形如 "/users/{userId}" 的GET请求。
    @RequestMapping(value = "/{userId}", method = RequestMethod.GET)
    public String getUser(@PathVariable String userId, Model model) {
        // @PathVariable用于从URL获取参数，这里的userId对应于/users/{userId}中的{userId}。
        // ... 获取用户信息的逻辑
        model.addAttribute("userId", userId);
        // 返回视图名称，与模板文件对应。
        return "userProfile";
    }
}

3. @RequestParam

• 有时候, 前端传过来的参数, 不符合后端的命名规则时, 这时候就要用到后端参数重命名了.

• @RequestParam 注解在 Spring MVC 中通常用于从 URL 的查询参数中提取值。它默认是从请求的查询字符串（URL 中 ? 后面的部分）中获取参数值。。它非常适合处理简单类型的参数，并支持设置默认值和标记参数为必需或可选。例如，当你需要从查询字符串中提取值时，@RequestParam使得这一过程变得简单直接。

• 如果我们的实际业务前端的参数是⼀个非必传的参数,我们可以通过设置 @RequestParam 中的 required=false 来避免不传递时报错, 默认是 required=true.

  对于 HTTP POST 或 PUT 请求中的请求体（body），如果请求体是 application/x-www-form-urlencoded 类型（这是 HTML 表单提交的默认类型），@RequestParam 也可以用来获取其中的参数。这是因为 application/x-www-form-urlencoded 请求体的格式和 URL 查询字符串的格式相同。

  @Controller
  public class UserController {
  
    // 使用@RequestParam获取查询参数。
    // 例如，处理 "/search?name=xxx" 的请求。
    @RequestMapping(value = "/search", method = RequestMethod.GET)
    public String searchUser(@RequestParam(name = "name",required=false) String userName, Model model) {
        // @RequestParam将请求中的name参数值赋给userName变量。
        // ... 根据userName进行搜索的逻辑
        model.addAttribute("userName", userName);
        return "searchResult";
    }
  }

4. @PathVariable

• @PathVariable用于接受前端URL路径参数，通过路径参数作为接口接受的参数。这对于RESTful风格的URL非常有用，其中URL的一部分是动态的，比如在URL路径中嵌入ID。

  @Controller
  @RequestMapping("/users")
  public class UserController {
  
    // 使用@PathVariable从URL路径中提取变量。
    // 例如，处理 "/users/123" 的请求，其中123是用户ID。
    @RequestMapping(value = "/{userId}", method = RequestMethod.GET)
    public String getUser(@PathVariable String userId, Model model) {
        // userId将匹配/users/{userId}路径中的{userId}部分。
        // ... 根据userId获取用户信息的逻辑
        model.addAttribute("userId", userId);
        return "userProfile";
    }
  }

5. @ModelAttribute

• @ModelAttribute有两种用法。当它用于方法参数上时，它表示请求参数应该被绑定到这个参数上。当它用于方法上时，它表示该方法会在控制器的请求处理方法执行之前执行，其目的是为模型对象添加属性。这在需要预先设置一些模型属性（如下拉列表的内容）时非常有用。

  @Controller
  @RequestMapping("/users")
  public class UserController {
  
    // @ModelAttribute用于方法，表示在处理请求之前，先执行这个方法。
    @ModelAttribute
    public void addUserAttributes(Model model) {
        // 这里可以添加一些通用模型属性，例如下拉列表的选项。
        model.addAttribute("commonAttribute", "value");
    }
  
    // 处理具体的请求。
    @RequestMapping(value = "/{userId}", method = RequestMethod.GET)
    public String getUser(@PathVariable String userId, Model model) {
        // 这里的model已经包含了addUserAttributes方法中添加的属性。
        // ... 根据userId获取用户信息的逻辑
        return "userProfile";
    }
  }

6. @SessionAttributes

• @SessionAttributes用于声明某些模型属性应该被透明地存储在会话中，这在需要在多个请求之间保持模型属性时非常有用。这可以帮助在一个用户会话中保持用户的特定状态，但应谨慎使用，以避免在会话中存储过多的数据。

  @Controller
  @SessionAttributes("user")
  public class UserController {
  
    @RequestMapping(value = "/login", method = RequestMethod.POST)
    public String loginUser(@RequestParam String userName, Model model) {
        // 假设用户验证成功后，将用户信息添加到模型中。
        model.addAttribute("user", userName);
        // 这里的"user"属性会被存储在会话中，可在多个请求间共享。
        return "userDashboard";
    }
  }

7. @ResponseBody

• @ResponseBody会自动将控制器中方法的返回值写入到HTTP响应中。特别的，@ResponseBody注解只能用在被@Controller注解标记的类中。如果在被@RestController标记的类中，则方法不需要使用@ResponseBody注解进行标注。@RestController相当于是@Controller和@ResponseBody的组合注解。

• @ResponseBody返回的对象会自动转换为JSON

  @Controller
  public class MyController {
  
    @GetMapping("/get-data")
    @ResponseBody
    public MyData getData() {
        MyData data = new MyData();
        data.setName("Example");
        data.setValue(123);
        // 返回的对象会自动转换为JSON
        return data;
    }
  }

8. @RequestBody

• @RequestBody用于将HTTP请求body的内容绑定到控制器方法的参数上。它使用合适的HttpMessageConverter自动反序列化请求体内容到Java对象。这在处理JSON或XML数据时特别有用，允许你直接在方法参数中使用复杂类型。(换句话就是：用于接收前端请求的Json参数，并且封装到对应的JavaBean)

• 一个请求方法只可以有一个@RequestBody，但是可以有多个@RequestParam和@PathVariable。

• 此外，还可以通过@Valid注解对请求主体中的参数进行校验。

  @RestController
  public class MyController {
  
    @PostMapping("/submit-data")
    public ResponseEntity<String> submitData(@Valid @RequestBody MyData data) {
        // 这里，data对象将包含JSON请求体中的数据
        // 如果data对象不符合校验规则，将抛出异常
        // 执行一些操作...
        return ResponseEntity.ok("Data processed");
    }
  }

9. 常见的 HTTP 请求类型

• GET ：请求从服务器获取特定资源。举个例子：GET /users（获取所有学生）

@GetMapping("users") 等价于
@RequestMapping(value="/users",method=RequestMethod.GET)

• POST ：在服务器上创建一个新的资源。举个例子：POST /users（创建学生）

@PostMapping("users") 等价于
@RequestMapping(value="/users",method=RequestMethod.POST)

• PUT ：更新服务器上的资源（客户端提供更新后的整个资源）。举个例子：PUT /users/12（更新编号为 12 的学生）

@PutMapping("/users/{userId}") 等价于
@RequestMapping(value="/users/{userId}",method=RequestMethod.PUT)

• DELETE ：从服务器删除特定的资源。举个例子：DELETE /users/12（删除编号为 12 的学生）

@DeleteMapping("/users/{userId}")等价于
@RequestMapping(value="/users/{userId}",method=RequestMethod.DELETE)

• PATCH ：更新服务器上的资源（客户端提供更改的属性，可以看做作是部分更新），使用的比较少，这里就不举例子了。

七、SpringBoot常用注解

1. @SpringBootApplication

包含@Configuration、@EnableAutoConfiguration、@ComponentScan通常用在主类上；

相关注解	说明
@ComponentScan	用来自动扫描被这些注解标识的类，最终生成ioc容器里的bean，默认扫描范围是@ComponentScan注解所在配置类包及子包的类（可以通过basePackages属性指定扫描范围）
@SpringBootConfiguration	这个注解继承自@Configuration，与@Configuration作用相同，都是用来声明当前类是一个配置类，这里表明是springboot主类使用的配置类
@EnableAutoConfiguration	是springboot实现自动化配置的核心注解，通过这个注解把spring应用所需的bean注入容器中

2. @Valid注解（参数校验）

数据的校验的重要性就不用说了，即使在前端对数据进行校验的情况下，我们还是要对传入后端的数据再进行一遍校验，避免用户绕过浏览器直接通过一些 HTTP 工具直接向后端请求一些违法数据。

Java Bean Validation API中的注解通常通过在Spring框架中的Controller层使用@Valid注解来触发。这意味着当客户端提交表单或JSON数据到Controller时，Spring会自动应用这些校验规则，并在校验失败时生成错误。

@RestController
public class UserController {

    @PostMapping("/users")
    public ResponseEntity<String> createUser(@Valid @RequestBody User user) {
        // 处理用户数据...
        return ResponseEntity.ok("User created successfully");
    }
}

• Java Bean Validation API 提供了一系列用于数据校验的注解，在Spring Boot项目中，通常不需要显式地导入Bean Validation API（如Hibernate Validator）的依赖，因为spring-boot-starter-web依赖已经包含了所需的校验库。
• 需要注意的是：所有的注解，推荐使用 JSR 注解，即javax.validation.constraints，而不是org.hibernate.validator.constraints

import javax.validation.constraints.*;

public class User {

    // 确保字段值不为 null
    @NotNull(message = "该字段不能为null")
    private String id;

    // 确保字符串不为空且至少包含一个非空白字符
    @NotBlank(message = "姓名不能为空")
    private String name;

    // 确保字符串是有效的电子邮件地址
    @Email(message = "电子邮件应该有效")
    private String email;

    // 确保数值至少为指定的最小值
    @Min(value = 10, message = "值至少为10")
    private int minNumber;

    // 确保数值不大于指定的最大值
    @Max(value = 100, message = "值不得超过100")
    private int maxNumber;

    // 确保字符串或集合的大小在指定范围内
    @Size(min = 2, max = 5, message = "用户名大小必须在2到5之间")
    private String username;

    // 确保字符串符合指定的正则表达式
    @Pattern(regexp = "^[a-zA-Z0-9]+$", message = "只允许字母和数字")
    private String alphanumeric;

    // 确保数值是正数
    @Positive(message = "数字必须是正数")
    private int positiveNumber;

    // 确保数值是非负数
    @PositiveOrZero(message = "数字必须是正数或零")
    private int positiveOrZeroNumber;

    // 确保数值是负数
    @Negative(message = "数字必须是负数")
    private int negativeNumber;

    // 确保数值是非正数
    @NegativeOrZero(message = "数字必须是负数或零")
    private int negativeOrZeroNumber;

    // Getters and Setters...
}

八、lombok常用注解

1. @Data

• 作用范围：注在类上

• 使用位置：通常用在实体类上，等同于同时添加了@Getter、@Setter、@EqualsAndHashCode、@ToString注解。它会自动生成类的getter、setter方法，equals方法，hashCode方法和toString方法。

  @Data
  public class User {
    private String name;
    private int age;
    // 自动生成getter、setter、equals、hashCode和toString
  }

2. @AllArgsConstructor

• 作用范围：注在类上

• 使用位置：用在实体类上，生成一个包含所有参数的构造函数。这个构造函数可以用于初始化对象时设置所有字段的值。

  @AllArgsConstructor
  public class User {
    private String name;
    private int age;
    // 自动生成包含所有字段的构造函数
  }

3. @NoArgsConstructor

• 作用范围：注在类上

• 使用位置：用在实体类上，生成一个无参构造函数。这个构造函数可以用于创建对象时不需要传入任何参数。

  @NoArgsConstructor
  public class User {
    private String name;
    private int age;
    // 自动生成无参构造函数
  }

4. @Setter

• 作用范围：注在属性上

• 使用位置：用在实体类的字段上，生成setter方法。通过注解在字段上，可以避免手动编写setter方法。

  public class User {
    @Setter
    private String name;
    // 自动生成setName()方法
  }

5. @Getter

• 作用范围：注在属性上

• 使用位置：用在实体类的字段上，生成getter方法。通过注解在字段上，可以避免手动编写getter方法。

  public class User {
    @Getter
    private String name;
    // 自动生成getName()方法
  }

6. @EqualsAndHashCode

• 作用范围：注在类上

• 使用位置：用在实体类上，自动生成equals方法和hashCode方法。这些方法用于比较对象的相等性和计算对象的哈希值。

  @EqualsAndHashCode
  public class User {
    private String name;
    private int age;
    // 自动生成equals()和hashCode()方法
  }

7. @Log4j / @Slf4j

• 作用范围：注在类上

• 使用位置：用于自动生成日志记录器对象，变量名通常为"log"。@Log4j和@Slf4j是两种常用的日志记录器生成注解，可以根据项目的日志框架选择使用其中一种。

  在没有 Lombok 插件的情况下，如果您需要在一个类中记录日志，通常会手动创建一个日志对象，如果不想每次都写private final Logger logger = LoggerFactory.getLogger(当前类名.class); 可以使用此注解

  @Slf4j
  public class LogExample {
    public void performSomeTask() {
        log.info("执行了一些任务");
        // 使用log变量记录日志
    }
  }

8. @Builder 注解

• @Builder提供了一种比较推崇的构建值对象的方式; 非常推荐的一种构建值对象的方式。

• 标注@Builder的类, 会在类内部生成一个内部类,用于生成值对象

  注意，当使用 Lombok 的 @Builder 注解时，如果您的类有继承关系（即存在父类和子类），默认情况下，子类的 builder 不会包含父类的属性。这意味着您不能使用子类的 builder 来设置父类的属性，而只能设置子类自身的属性

  @Builder
  public class User {
    private String name;
    private String email;
    private String phoneNumber;
    // 更多字段...
  
    // 无需编写构造函数和setter方法
  }

  如何使用生成的 Builder:

  User.builder() 创建了一个 User 对象的 builder 实例。然后，你可以链式调用 builder 提供的方法来设置属性，最后调用 build() 方法构造最终的 User 对象。

  public class App {
    public static void main(String[] args) {
        User user = User.builder()
                        .name("John Doe")
                        .email("john.doe@example.com")
                        .build();
  
        // 使用 user 对象...
    }
  }

九、Swagger注解API

1. @ApiModelProperty

• 作用范围：对象属性
• 使用位置：通常用在请求和响应对象的字段上，用于描述字段的含义和约束条件。这个注解允许开发者为每个属性添加详细的说明和示例值，以生成具有清晰文档的API。

2. @Api

• 作用范围：协议集描述
• 使用位置：通常用在Controller类上，用于描述整个API的信息，如API的标题、描述、版本等。这个注解定义了一个API的全局信息，可以帮助生成API文档。

3. @ApiOperation

• 作用范围：协议描述
• 使用位置：通常用在Controller的方法上，用于描述单个API操作的信息，包括操作的HTTP方法、路径、摘要、响应等。这个注解提供了对API操作的详细描述。

4. @ApiResponses

• 作用范围：Response集
• 使用位置：通常用在Controller的方法上，用于定义多个API操作的响应集。每个@ApiResponses注解包含多个@ApiResponse注解，用于描述不同的响应情况。

5. @ApiResponse

• 作用范围：Response
• 使用位置：通常用在@ApiResponses注解内部，用于描述单个API操作的响应情况，包括HTTP状态码、描述信息和响应模型等。

6. @ApiImplicitParams

• 作用范围：非对象参数集
• 使用位置：通常用在Controller的方法上，用于定义多个非对象参数的集合。这些参数可以是请求头、查询参数、路径参数等。@ApiImplicitParams注解包含多个@ApiImplicitParam注解。

7. @ApiImplicitParam

• 作用范围：非对象参数描述
• 使用位置：通常用在@ApiImplicitParams注解内部，用于描述单个非对象参数的信息，包括参数名、参数位置、数据类型、是否必需等。这个注解用于为非对象参数添加详细说明。

8. @ApiModel

• 作用范围：描述返回对象的意义
• 使用位置：通常用在返回对象的类上，用于描述返回对象的含义和用途。@ApiModel注解可以帮助生成API文档中的模型定义。

版权声明

1、转载或引用本网站内容(Java常用注解)须注明原网址及作者(miku)，并标明本网站网址(https://pixtech.cc/)。

2、对于不当转载或引用本网站内容而引起的民事纷争、行政处理或其他损失，本网站不承担责任。

3、对不遵守本声明或其他违法、恶意使用本网站内容者，本网站保留追究其法律责任的权利。

本文地址: https://pixtech.cc/thread-649-1-1.html