一问掌握SpringBoot常见注解，后无压力。

2023-12-16 11:46:50

文章目录

在这里插入图片描述

一、🔎 SpringBoot常用注解大全

🍁🍁 01. @RequestMapping 注解

🍁 1.1. @RequestMapping 是什么？

@RequestMapping 注解是 Spring MVC 框架中的注解，用于将 HTTP 请求映射到对应的处理方法上。它可以用在方法级别或类级别上，用于定义请求映射的路径、HTTP 方法以及其他相关属性。

🍁 1.2. @RequestMapping 特点有哪些？
  • 可以将多个请求映射到同一个处理方法上。
  • 支持多种HTTP请求方法，如 GET、POST、PUT、DELETE 等。
  • 可以使用 Ant 风格的路径模式进行路径匹配。
  • 提供了更细粒度的注解细化映射规则，如 @GetMapping、@PostMapping 等。
  • 支持处理不同的媒体类型。
  • 可以处理 RESTful 风格的 API。
🍁 1.3. @RequestMapping 作用是什么？

@RequestMapping 注解的作用是将请求映射到相应的处理方法上，它可以用于处理不同路径的请求，并将请求参数绑定到方法的参数上。

🍁 1.4. @RequestMapping的注意事项有哪些？
  • 如果在类级别上使用 @RequestMapping 注解，会在方法级别上进行进一步的映射。
  • 可以通过设置 consumes 和 produces 属性来指定请求的媒体类型。
  • 可以使用通配符和正则表达式来匹配路径。
  • 避免在类级别和方法级别同时使用 @RequestMapping 注解，以防止路径冲突。
🍁 1.5. @RequestMapping 的使用案例？

示例1：将一个 GET 请求映射到 “/hello” 路径上的处理方法：

@RequestMapping(value = "/hello", method = RequestMethod.GET)
public String hello() {
	return "Hello, World!";
}

示例2：将一个 POST 请求映射到 “/login” 路径上的处理方法，并绑定请求参数：

@RequestMapping(value = "/login", method = RequestMethod.POST)
public String login(@RequestParam("username") String username, @RequestParam("password") String password) {
	// 处理登录逻辑
}
🍁 1.6. @RequestMapping 接收参数的使用案例？

示例1：接收路径参数

@RequestMapping("/users/{id}")
public String getUserById(@PathVariable("id") int userId) {
	// 根据用户ID获取用户信息
}

在路径 “/users/{id}” 中，{id} 表示路径参数，可以通过 @PathVariable 注解将其绑定到方法参数上。

示例2：接收请求参数

@RequestMapping("/search")
public String searchUsers(@RequestParam("keyword") String keyword, @RequestParam("page") int page) {
	// 根据关键字和页码搜索用户
}

使用 @RequestParam 注解可以将请求中的参数绑定到方法参数上，示例中的 keyword 和 page 分别表示请求中的关键字和页码参数。

🍁 1.7. @RequestMapping 请求头参数的使用案例？

请求头参数可以通过 @RequestHeader 注解将其绑定到方法参数上。以下是一个示例：

@RequestMapping("/header")
public String processHeader(@RequestHeader("User-Agent") String userAgent) {
	// 根据 User-Agent 头信息进行处理
}

在这个示例中，@RequestHeader("User-Agent") 注解用于将 User-Agent 头信息的值绑定到 userAgent 方法参数上。

🍁 1.8. @RequestMapping 接收多个请求参数的使用案例？

如果需要接收多个请求参数，可以使用对象来封装这些参数。以下是一个示例：

@RequestMapping("/user")
public String createUser(User user) {
	// 创建用户
}

在这个示例中，User 对象有多个属性，这些属性会根据请求参数的名称与对象的属性名称进行自动绑定。

🍁 1.9. @RequestMapping 接收 JSON 请求体的使用案例？

如果请求体是 JSON 格式的数据，可以使用 @RequestBody 注解将其绑定到方法参数上。以下是一个示例：

@RequestMapping(value = "/users", method = RequestMethod.POST)
public String createUser(@RequestBody User user) {
	// 创建用户
}

在这个示例中，@RequestBody 注解用于将请求体的 JSON 数据绑定到 User 对象上。

请注意，以上示例仅用于说明，实际的使用可能会有更多的细节和配置。在实际开发中，根据具体的需求和场景，可以灵活应用 @RequestMapping 注解来处理不同类型的请求和参数。

🍁🍁 02. @RequestBody 注解

🍁 2.1. @RequestBody 是什么？

@RequestBody 是 Spring Framework 中的一个注解，用于标记一个方法参数或方法返回值应该绑定到 HTTP 请求的请求体上。

🍁 2.2. @RequestBody 有哪些特点？
  • @RequestBody 注解用于将请求体的内容读取到方法参数或对象中。
  • 它适用于 HTTP 请求的 POST、PUT、PATCH、DELETE 等方法。
  • 请求体的数据可以是 JSON、XML、文本等格式。
🍁 2.3. @RequestBody 作用是什么？

@RequestBody 注解的主要作用是将 HTTP 请求的请求体数据绑定到方法参数或对象上。

🍁 2.4. @RequestBody 注意事项是什么？
  • @RequestBody 注解通常用于处理 POST 或其他请求方法的请求体数据，而不是 GET 请求，因为 GET 请求没有请求体。
  • 需要在方法或控制器类上使用 @RequestMapping 或其他相关注解来指定请求的 URL、请求方法等信息。
🍁 2.5. @RequestBody 示例说明：

  • 添加 @RequestBody 注解到方法参数上，表示该参数应该从请求体中获取数据。

  • 可以将请求体的数据绑定到如字符串、对象、集合等类型的参数上。

  • 可以使用 @RequestMapping 或其他相关注解指定请求的 URL 和请求方法，以及其他必要的配置。

    @PostMapping("/users")
public ResponseEntity<String> createUser(@RequestBody User user) {
	// 处理请求体中的 User 对象，并返回响应
}
🍁 2.6. @RequestBody 接收参数示例说明：

  • 将 @RequestBody 注解添加到方法参数上，Spring MVC 会自动将请求体中的数据转换成对应的参数类型，并传递给方法。

  • 如果请求体是 JSON 格式的数据，Spring 会自动将 JSON 数据转换为对应的参数类型，如对象、Map 或集合。

  • 可以使用 @RequestBody 注解接收多个请求参数，并使用对象来封装这些参数。

    @PostMapping("/users")
public ResponseEntity<String> createUser(@RequestBody User user) {
	// 处理请求体中的 User 对象，并返回响应
}

请注意，@RequestBody 注解需要与其他注解和配置结合使用，具体的使用方式可能因项目环境和需求而有所不同。在实际开发中，可以根据具体情况灵活使用 @RequestBody 注解来处理请求体数据。

🍁🍁 03. @GetMapping 注解

🍁 3.1. @GetMapping 是什么？

@GetMapping 是 Spring Framework 中的一个注解，用于将 HTTP GET 请求映射到特定的处理方法上。

🍁 3.2. @GetMapping 有哪些特点？
  • @GetMapping 注解用于处理 HTTP 请求的 GET 方法。
  • 它是 @RequestMapping 注解的派生注解，专门用于处理 GET 请求。
  • 可以用于类级别或方法级别的注解。
🍁 3.3. @GetMapping 作用是什么？

@GetMapping 注解的主要作用是将特定 URL 的 GET 请求映射到相应的处理方法上。

🍁 3.4. @GetMapping 注意事项是什么？
  • 需要在方法或控制器类上使用 @RequestMapping 或其他相关注解来指定请求的 URL、请求方法等信息。
  • 需要确保所使用的路由路径（URL）与请求方法的映射关系是唯一的，以避免冲突。
🍁 3.5. @GetMapping 代码使用案例？

  • 添加 @GetMapping 注解到处理方法上，指定该方法处理特定 URL 的 GET 请求。

  • 可以在 @GetMapping 注解中指定具体的 URL 路径。

    @GetMapping("/users")
public ResponseEntity<List<User>> getUsers() {
	// 处理获取用户列表的逻辑，并返回响应
}
🍁 3.6. @GetMapping 接收参数代码使用案例？

  • 可以在 @GetMapping 注解中添加占位符 {} 来接收路径参数，并在方法参数中使用 @PathVariable 注解来获取该参数的值。

    @GetMapping("/users/{id}")
public ResponseEntity<User> getUserById(@PathVariable("id") Long id) {
	// 处理获取指定用户的逻辑，并返回响应
}

在上述例子中，我们使用 @GetMapping 注解来处理 GET 请求，并使用 /users/{id} 路径，其中 {id} 是路径参数。然后，我们可以在方法体中使用 @PathVariable 注解来获取该路径参数的值，以执行相应的逻辑。

请注意，@GetMapping 注解需要与其他注解和配置结合使用，具体的使用方式可能因项目环境和需求而有所不同。在实际开发中，可以根据具体情况灵活使用 @GetMapping 注解来处理 GET 请求。

🍁🍁 04. @PostMapping 注解

🍁 4.1. @PostMapping 是什么？

@PostMapping 是 Spring Framework 中的一个注解，用于将 HTTP POST 请求映射到特定的处理方法上。

🍁 4.2. @PostMapping 有哪些特点？
  • @PostMapping 注解用于处理 HTTP 请求的 POST 方法。
  • 它是 @RequestMapping 注解的派生注解，专门用于处理 POST 请求。
  • 可以用于类级别或方法级别的注解。
🍁 4.3. @PostMapping 作用是什么？

@PostMapping 注解的主要作用是将特定 URL 的 POST 请求映射到相应的处理方法上。

🍁 4.4. @PostMapping 注意事项是什么？
  • 需要在方法或控制器类上使用 @RequestMapping 或其他相关注解来指定请求的 URL、请求方法等信息。
  • 需要确保所使用的路由路径（URL）与请求方法的映射关系是唯一的，以避免冲突。
🍁 4.5. @PostMapping 代码使用案例？

  • 添加 @PostMapping 注解到处理方法上，指定该方法处理特定 URL 的 POST 请求。

  • 可以在 @PostMapping 注解中指定具体的 URL 路径。

    @PostMapping("/users")
public ResponseEntity<String> createUser(@RequestBody User user) {
	// 处理创建用户的逻辑，并返回响应
}
🍁 4.6. @PostMapping 接收参数代码使用案例？

  • 可以将 @RequestBody 注解添加到方法参数上，表示该参数应该从请求体中获取数据。

    @PostMapping("/users/{id}")
public ResponseEntity<String> updateUser(@PathVariable("id") Long id, @RequestBody User user) {
	// 处理更新用户的逻辑，并返回响应
}

在上述例子中，我们使用 @PostMapping 注解来处理 POST 请求，并使用 /users/{id} 路径和 {id} 路径参数。然后，我们可以在方法体中将 @RequestBody 注解应用到 User 参数上，以获取请求体中的数据并处理相应的逻辑。

请注意，@PostMapping 注解需要与其他注解和配置结合使用，具体的使用方式可能因项目环境和需求而有所不同。在实际开发中，请根据具体情况灵活使用 @PostMapping 注解来处理 POST 请求。

🍁🍁 05. @PutMapping 注解

🍁 5.1. @PutMapping 是什么？

@PutMapping 是 Spring Framework 中的一个注解，用于将 HTTP PUT 请求映射到特定的处理方法上。

🍁 5.2. @PutMapping 有哪些特点？
  • @PutMapping 注解用于处理 HTTP 请求的 PUT 方法。
  • 它是 @RequestMapping 注解的派生注解，专门用于处理 PUT 请求。
  • 可以用于类级别或方法级别的注解。
🍁 5.3. @PutMapping 作用是什么？

@PutMapping 注解的主要作用是将特定 URL 的 PUT 请求映射到相应的处理方法上。

🍁 5.4. @PutMapping 注意事项是什么？
  • 需要在方法或控制器类上使用 @RequestMapping 或其他相关注解来指定请求的 URL、请求方法等信息。
  • 需要确保所使用的路由路径（URL）与请求方法的映射关系是唯一的，以避免冲突。
🍁 5.5. @PutMapping 代码使用案例？

  • 添加 @PutMapping 注解到处理方法上，指定该方法处理特定 URL 的 PUT 请求。

  • 可以在 @PutMapping 注解中指定具体的 URL 路径。

    @PutMapping("/users/{id}")
public ResponseEntity<String> updateUser(@PathVariable("id") Long id, @RequestBody User user) {
	// 处理更新用户的逻辑，并返回响应
}
🍁 5.6. @PutMapping 接收参数代码使用案例？

  • 可以将 @RequestBody 注解添加到方法参数上，表示该参数应该从请求体中获取数据。

    @PutMapping("/users/{id}")
public ResponseEntity<String> updateUser(@PathVariable("id") Long id, @RequestBody User user) {
	// 处理更新用户的逻辑，并返回响应
}

在上述例子中，我们使用 @PutMapping 注解来处理 PUT 请求，并使用 /users/{id} 路径和 {id} 路径参数。然后，我们可以在方法体中将 @RequestBody 注解应用到 User 参数上，以获取请求体中的数据并处理相应的逻辑。

请注意，@PutMapping 注解需要与其他注解和配置结合使用，具体的使用方式可能因项目环境和需求而有所不同。在实际开发中，请根据具体情况灵活使用 @PutMapping 注解来处理 PUT 请求。

🍁🍁 06. @DeleteMapping 注解

🍁 6.1. @DeleteMapping 是什么？

@DeleteMapping 是 Spring Framework 中的一个注解，用于将 HTTP DELETE 请求映射到特定的处理方法上。

🍁 6.2. @DeleteMapping 有哪些特点？
  • @DeleteMapping 注解用于处理 HTTP 请求的 DELETE 方法。
  • 它是 @RequestMapping 注解的派生注解，专门用于处理 DELETE 请求。
  • 可以用于类级别或方法级别的注解。
🍁 6.3. @DeleteMapping 作用是什么？

@DeleteMapping 注解的主要作用是将特定 URL 的 DELETE 请求映射到相应的处理方法上。

🍁 6.4. @DeleteMapping 注意事项是什么？
  • 需要在方法或控制器类上使用 @RequestMapping 或其他相关注解来指定请求的 URL、请求方法等信息。
  • 需要确保所使用的路由路径（URL）与请求方法的映射关系是唯一的，以避免冲突。
🍁 6.5. @DeleteMapping 代码使用案例？

  • 添加 @DeleteMapping 注解到处理方法上，指定该方法处理特定 URL 的 DELETE 请求。

  • 可以在 @DeleteMapping 注解中指定具体的 URL 路径。

    @DeleteMapping("/users/{id}")
public ResponseEntity<String> deleteUser(@PathVariable("id") Long id) {
	// 处理删除用户的逻辑，并返回响应
}
🍁 6.6. @DeleteMapping 接收参数代码使用案例？

  • 可以使用 @PathVariable 注解将 URL 路径中的参数映射到方法参数上。

    @DeleteMapping("/users/{id}")
public ResponseEntity<String> deleteUser(@PathVariable("id") Long id) {
	// 处理删除用户的逻辑，并返回响应
}

在上述例子中，我们使用 @DeleteMapping 注解来处理 DELETE 请求，并使用 /users/{id} 路径和 {id} 路径参数。然后，我们可以在方法体中将 @PathVariable 注解应用到 id 参数上，以获取 URL 路径中的参数值，并处理相应的逻辑。

请注意，@DeleteMapping 注解需要与其他注解和配置结合使用，具体的使用方式可能因项目环境和需求而有所不同。在实际开发中，请根据具体情况灵活使用 @DeleteMapping 注解来处理 DELETE 请求。

🍁🍁 07. @PatchMapping 注解

🍁 7.1. @PatchMapping 是什么？

@PatchMapping 是 Spring Framework 中的一个注解，用于将 HTTP PATCH 请求映射到特定的处理方法上。

🍁 7.2. @PatchMapping 有哪些特点？
  • @PatchMapping 注解用于处理 HTTP 请求的 PATCH 方法。
  • 它是 @RequestMapping 注解的派生注解，专门用于处理 PATCH 请求。
  • 可以用于类级别或方法级别的注解。
🍁 7.3. @PatchMapping 作用是什么？

@PatchMapping 注解的主要作用是将特定 URL 的 PATCH 请求映射到相应的处理方法上。

🍁 7.4. @PatchMapping 注意事项是什么？
  • 需要在方法或控制器类上使用 @RequestMapping 或其他相关注解来指定请求的 URL、请求方法等信息。
  • 需要确保所使用的路由路径（URL）与请求方法的映射关系是唯一的，以避免冲突。
🍁 7.5. @PatchMapping 代码使用案例？

  • 添加 @PatchMapping 注解到处理方法上，指定该方法处理特定 URL 的 PATCH 请求。

  • 可以在 @PatchMapping 注解中指定具体的 URL 路径。

    @PatchMapping("/users/{id}")
public ResponseEntity<String> updateUser(@PathVariable("id") Long id, @RequestBody User user) {
	// 处理更新用户的逻辑，并返回响应
}
🍁 7.6. @PatchMapping 接收参数代码使用案例？

  • 可以将 @RequestBody 注解添加到方法参数上，表示该参数应该从请求体中获取数据。

    @PatchMapping("/users/{id}")
public ResponseEntity<String> updateUser(@PathVariable("id") Long id, @RequestBody User user) {
	// 处理更新用户的逻辑，并返回响应
}

在上述例子中，我们使用 @PatchMapping 注解来处理 PATCH 请求，并使用 /users/{id} 路径和 {id} 路径参数。然后，我们可以在方法体中将 @RequestBody 注解应用到 User 参数上，以获取请求体中的数据并处理相应的逻辑。

请注意，@PatchMapping 注解需要与其他注解和配置结合使用，具体的使用方式可能因项目环境和需求而有所不同。在实际开发中，请根据具体情况灵活使用 @PatchMapping 注解来处理 PATCH 请求。

🍁🍁 08. @ControllerAdvice 注解

🍁 8.1. @ControllerAdvice 是什么？

@ControllerAdvice 是 Spring Framework 中的一个注解，用于定义全局性的控制器增强器。

🍁 8.2. @ControllerAdvice 有哪些特点？
  • @ControllerAdvice 注解用于在整个应用程序范围内增强控制器的功能。
  • 可以用于类级别注解，该类将充当控制器增强器。
  • 可以用于方法级别注解，用于处理特定的异常或提供全局的错误处理逻辑。
🍁 8.3. @ControllerAdvice 作用是什么？

@ControllerAdvice 注解的主要作用是处理全局性的控制器配置和错误处理逻辑。它可以应用于以下方面：

  • 统一处理异常：可以定义全局的异常处理器，用于捕获和处理应用程序中的异常。
  • 全局数据绑定：可以定义全局的数据绑定配置，用于将某些数据绑定到所有请求中的模型中。
  • 全局数据预处理：可以定义全局的请求数据预处理逻辑，用于预处理请求中的数据。
  • 全局响应处理：可以定义全局的响应处理逻辑，对所有响应进行统一的处理。
🍁 8.4. @ControllerAdvice 注意事项是什么？
  • 需要在应用程序中至少创建一个类并使用 @ControllerAdvice 注解进行标记。
  • 需要使用其他注解和配置来指定具体的处理逻辑，如 @ExceptionHandler、@InitBinder 等。
🍁 8.5. @ControllerAdvice 代码使用案例？

  • 在一个类上添加 @ControllerAdvice 注解，该类将充当全局控制器增强器。

  • 可以使用其他注解（如 @ExceptionHandler、@InitBinder）在该类中定义具体的处理逻辑。

    @ControllerAdvice
public class GlobalControllerAdvice {

	@ExceptionHandler(Exception.class)
	public ResponseEntity<String> handleException(Exception ex) {
		// 处理全局异常的逻辑
	}

	// 其他全局性的配置和处理方法
}
🍁 8.6. @ControllerAdvice 接收参数代码使用案例？

  • 根据具体需求，在 @ExceptionHandler 注解中可以接收不同类型的异常作为参数。

  • 这些异常参数将会根据实际发生的异常类型进行匹配和处理。

    @ControllerAdvice
public class GlobalControllerAdvice {

	@ExceptionHandler(IllegalArgumentException.class)
	public ResponseEntity<String> handleIllegalArgumentException(IllegalArgumentException ex) {
		// 处理 IllegalArgumentException 异常的逻辑
	}

	@ExceptionHandler(NullPointerException.class)
	public ResponseEntity<String> handleNullPointerException(NullPointerException ex) {
		// 处理 NullPointerException 异常的逻辑
	}

	// 其他异常处理方法
}

在上述例子中，我们定义了两个异常处理方法，分别处理 IllegalArgumentException 和 NullPointerException 异常。当应用程序中发生对应的异常时，将会调用相应的处理方法来处理异常。

请注意，@ControllerAdvice 注解的具体使用方式可能因项目环境和需求而有所不同。在实际开发中，请根据具体情况灵活使用 @ControllerAdvice 注解来增强控制器的功能和处理全局性的配置和错误处理逻辑。

🍁🍁 09. @ResponseBody 注解

🍁 9.1. @ResponseBody 是什么？

@ResponseBody 是 Spring Framework 中的一个注解，用于将方法返回值转换成指定格式的响应体，并将其写入 HTTP 响应中返回给客户端。

🍁 9.2. @ResponseBody 有哪些特点？
  • @ResponseBody 注解用于处理方法返回值，将其转换成指定格式的响应体，并写入 HTTP 响应中返回给客户端。
  • 可以用于类、方法等级别的注解。
  • 注解在方法上时，表示该方法的返回值应该直接作为响应体，而不是作为视图名称进行解析。
🍁 9.3. @ResponseBody 作用是什么？

@ResponseBody 注解的主要作用是将方法的返回值作为响应体返回给客户端，可以用于以下方面：

  • 返回 JSON、XML 等格式的数据作为响应体。
  • 处理 Ajax 请求，直接将响应数据发送给客户端，而无需通过页面进行渲染。
🍁 9.4. @ResponseBody 注意事项是什么？
  • 需要在方法上添加 @ResponseBody 注解，该方法的返回值将直接作为响应体返回给客户端。
  • 需要使用特定的消息转换器（如 MappingJackson2HttpMessageConverter）将方法返回值转换为指定的格式。
🍁 9.5. @ResponseBody 代码使用案例？

  • 在方法上添加 @ResponseBody 注解。

  • 使用方法返回类型的数据对象构建响应数据对象。

  • 返回响应数据对象即可。

    @GetMapping("/user/{id}")
@ResponseBody
public User getUser(@PathVariable Long id) {
	User user = userService.getUserById(id);
	return user;
}
🍁 9.6. @ResponseBody 接收参数代码使用案例？

  • @ResponseBody 注解不需要接收参数。它需要的参数是一个被方法返回类型所包装的对象，可以是 Java 内置对象，也可以是自定义对象。

  • 接口实现过程需要根据具体业务需求进行处理，通常在方法内部使用业务逻辑代码获取数据并返回，再将返回值类型对应的对象作为响应体返回给客户端。

    @GetMapping("/user/{id}")
@ResponseBody
public User getUser(@PathVariable Long id) {
	User user = userService.getUserById(id);
	return user;
}

在上述例子中，@ResponseBody 注解将会将 User 对象作为响应体返回给客户端，由 Spring 内置的消息转换器将其转换成指定格式（如 JSON 或 XML 等）。所有客户端就可以接收到相应的数据并进行处理了。

🍁🍁 10. @ExceptionHandler 注解

🍁 10.1. @ExceptionHandler 是什么？

@ExceptionHandler 是 Spring Framework 中的一个注解，用于处理在控制器（Controller）中抛出的异常，提供自定义的异常处理逻辑。

🍁 10.2. @ExceptionHandler 有哪些特点？
  • @ExceptionHandler 注解用于处理特定类型的异常，提供自定义的异常处理逻辑。
  • 可以用于类、方法等级别的注解。
  • 注解在方法上时，表示该方法用于处理指定类型的异常。
🍁 10.3. @ExceptionHandler 作用是什么？

@ExceptionHandler 注解的主要作用是提供自定义的异常处理逻辑，可以用于以下方面：

  • 捕获和处理在控制器中抛出的指定类型的异常。
  • 可以针对不同的异常类型进行不同的处理，例如返回特定的错误信息、跳转到指定的错误页面或进行其他处理动作。
🍁 10.4. @ExceptionHandler 注意事项是什么？
  • 异常处理方法必须被 @ExceptionHandler 注解标记。
  • 异常处理方法的参数中可以使用 Spring 提供的特定类型参数或自定义类型参数，用于接收抛出的异常信息。
  • 需要注意异常处理方法的顺序，先匹配的处理方法会优先执行。
🍁 10.5. @ExceptionHandler 代码使用案例？

  • 在控制器类中的方法上添加 @ExceptionHandler 注解。

  • 在注解的参数中指定异常类型，多个异常类型使用数组表示。

  • 在异常处理方法中编写自定义的异常处理逻辑。

    @RestController
public class UserController {

	@GetMapping("/user/{id}")
	public User getUser(@PathVariable Long id) {
		User user = userService.getUserById(id);
		if (user == null) {
			throw new UserNotFoundException("User not found");
		}
		return user;
	}

	@ExceptionHandler(UserNotFoundException.class)
	public ResponseEntity<String> handleUserNotFoundException(UserNotFoundException ex) {
		return ResponseEntity.status(HttpStatus.NOT_FOUND).body(ex.getMessage());
	}
}
🍁 10.6. @ExceptionHandler 接收参数代码使用案例？

  • @ExceptionHandler 注解需要接收参数，该参数为抛出的异常类型。

  • 接口实现过程需要根据具体业务需求进行处理，可以使用 Spring 提供的特定类型参数（如 Exception，RuntimeException 等）或自定义类型参数来接收抛出的异常信息。

  • 根据实际情况，可以在异常处理方法中编写自定义的异常处理逻辑，例如返回错误信息、跳转到指定的错误页面或进行其他处理动作。

    @ExceptionHandler(UserNotFoundException.class)
public ResponseEntity<String> handleUserNotFoundException(UserNotFoundException ex) {
	return ResponseEntity.status(HttpStatus.NOT_FOUND).body(ex.getMessage());
}

在上述例子中，handleUserNotFoundException 方法接收 UserNotFoundException 异常对象，并使用 ResponseEntity 返回错误信息给客户端。这样客户端就能够接收到相应的错误信息并进行处理了。

🍁🍁 11. @ResponseStatus 注解

🍁 11.1. @ResponseStatus 是什么？

@ResponseStatus 是 Spring Framework 中的一个注解，用于定义控制器的响应状态码和响应消息。

🍁 11.2. @ResponseStatus 有哪些特点？
  • @ResponseStatus 注解用于标记控制器处理请求的方法，用于定义该方法的响应状态码和响应消息。
  • 当使用了 @ResponseStatus 注解时，Spring 框架会直接将注解中定义的状态码和消息设置到响应头中，不需再手动设置。
  • 注解可以用于方法级别或类级别。
🍁 11.3. @ResponseStatus 作用是什么？

@ResponseStatus 注解的主要作用是定义控制器方法的响应状态码和响应消息，以便于客户端处理异常或者其他情况，例如：

  • 根据不同的响应状态码区别处理成功或失败的情况。
  • 提供自定义的响应消息，使得客户端能够更好地理解该请求的响应。
🍁 11.4. @ResponseStatus 注意事项是什么？
  • @ResponseStatus 注解需要放置在类级别或控制器处理请求的方法级别上。
  • 必须同时指定状态码和消息，否则会抛出异常。
  • 如果方法级别和类级别都有 @ResponseStatus 注解，则方法级别的注解会覆盖类级别的注解。
🍁 11.5. @ResponseStatus 代码使用案例？

  • 在控制器类或方法上添加 @ResponseStatus 注解。

  • 在注解的参数中指定状态码和响应消息。

  • 响应头中的状态码和消息会被自动设置并返回给客户端。

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

	@GetMapping("/{id}")
	@ResponseStatus(code = HttpStatus.OK, reason = "Success")
	public User getUser(@PathVariable Long id) {
		User user = userService.getUserById(id);
		if (user == null) {
			throw new UserNotFoundException("User not found");
		}
		return user;
	}
}
🍁 11.6. @ResponseStatus 接收参数代码使用案例？

  • @ResponseStatus 注解无需接收参数，因为状态码和响应消息已经在注解参数中指定。

  • 在控制器方法中引发异常时，Spring 框架会自动将 @ResponseStatus 注解指定的状态码和响应消息设置到响应头中并返回给客户端。

  • 如果没有异常或者没有使用 @ResponseStatus 注解，需要手动设置响应头信息。

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

	@GetMapping("/{id}")
	public User getUser(@PathVariable Long id, HttpServletResponse response) {
		User user = userService.getUserById(id);
		if (user == null) {
			response.setStatus(HttpStatus.NOT_FOUND.value());
			return null;
		}
		return user;
	}
}

在上述例子中，如果没有找到用户，需要手动设置响应状态码为 404 并返回 null 值给客户端。

🍁🍁 12. @SpringBootApplication 注解

🍁 12.1. @SpringBootApplication 是什么？

@SpringBootApplication 是 Spring Boot 的核心注解之一，它是一个组合注解，包含了多个注解的功能。

🍁 12.2. @SpringBootApplication 有哪些特点？
  • @SpringBootApplication 注解是一个组合注解，它包含了 @Configuration、@EnableAutoConfiguration 和 @ComponentScan 注解的功能。
  • @Configuration 注解表示该类是一个配置类，用于定义和组装 Bean。
  • @EnableAutoConfiguration 注解开启自动配置功能，根据项目的依赖和配置，自动配置 Spring Boot 应用程序。
  • @ComponentScan 注解表示扫描指定包及其子包下的组件，将其注册为 Spring Bean。
🍁 12.3. @SpringBootApplication 作用是什么？

@SpringBootApplication 注解的主要作用是简化 Spring Boot 应用程序的配置，具体包括：

  • 将该注解标记的类标识为 Spring Boot 应用程序的入口类。
  • 自动启用 Spring Boot 的自动配置功能。
  • 自动扫描指定包下的组件并注册为 Bean。
🍁 12.4. @SpringBootApplication 注意事项是什么？
  • @SpringBootApplication 注解通常标记在项目的主类上，即包含 public static void main(String[] args) 方法的类。
  • 主类必须位于顶层包下，否则需要显式地指定 scanBasePackages 或 scanBasePackageClasses 属性来指定要扫描的包。
  • 如果你在应用程序中使用了其他扩展注解，例如 @EntityScan 或 @EnableJpaRepositories，则应将它们放置在 @SpringBootApplication 上面。
🍁 12.5. @SpringBootApplication 代码使用案例？

  • 在主类上添加 @SpringBootApplication 注解。

  • 可以使用 @ComponentScan 注解指定要扫描的包。

  • 可以使用 @EnableAutoConfiguration 注解禁用或自定义自动配置的行为。

    @SpringBootApplication
@ComponentScan(basePackages = "com.example.myapp")
public class MyAppApplication {

	public static void main(String[] args) {
		SpringApplication.run(MyAppApplication.class, args);
	}
}
🍁 12.6. @SpringBootApplication 接收参数代码使用案例？

  • @SpringBootApplication 注解不接收参数，因为它是一个标记注解，用于标识 Spring Boot 应用程序的入口类。

  • 你可以在主类中的 main 方法的参数中接收命令行参数或其他参数，并在启动应用程序时传递给 SpringApplication.run() 方法。

    @SpringBootApplication
public class MyAppApplication {

	public static void main(String[] args) {
		SpringApplication.run(MyAppApplication.class, args);
	}
}

在上述例子中，main 方法的 args 参数接收命令行参数，并作为参数传递给 SpringApplication.run() 方法。

🍁🍁 13. @Autowired 注解

🍁 13.1. @Autowired 是什么？

@Autowired 是 Spring 核心注解之一，用于自动注入 Spring 容器中的 Bean 对象。

🍁 13.2. @Autowired 有哪些特点？
  • @Autowired 注解是基于类型的自动注入方式，它可以自动依据类型将 Spring 容器中的 Bean 注入到对应的属性中。
  • 如果需要按名称或按照给定的标识符注入，请使用 @Qualifier 注解进行限定匹配。
  • 如果存在多个与依赖项类型兼容的 Bean，则可以使用 @Primary 注解指定一个 Bean 作为首选注入的 Bean。
🍁 13.3. @Autowired 作用是什么？

@Autowired 注解的主要作用是实现依赖注入，即自动将 Spring 容器中的 Bean 注入到类的属性中，降低了代码的耦合度，提高了代码的可读性和可维护性。

🍁 13.4. @Autowired 注意事项是什么？
  • @Autowired 注解默认要求依赖项必须存在，否则会抛出 NoSuchBeanDefinitionException 异常，可以使用required=false 来避免这种情况。
  • 如果存在多个与依赖项类型兼容的 Bean，则需要使用 @Qualifier 注解进行限定匹配。
  • 建议将 @Autowired 注解标记在属性上而不是 setter 方法上，因为 Spring 会优先使用属性注入。
🍁 13.5. @Autowired 代码使用案例？

  • 在需要进行自动注入的属性上添加 @Autowired 注解。

    @Component
public class MyService {

	@Autowired
	private MyRepository myRepository;

	// other methods
}

在上述例子中，MyService 类中的 myRepository 属性使用 @Autowired 注解自动注入了 MyRepository 类型的 Bean 对象。

🍁 13.6. @Autowired 接收参数代码使用案例？

  • @Autowired 注解不接收参数，它依据类型将 Spring 容器中的 Bean 注入到对应的属性中。

  • 如果需要按名称或按照给定的标识符注入，请使用 @Qualifier 注解进行限定匹配。

  • 如果存在多个与依赖项类型兼容的 Bean，则可以使用 @Primary 注解指定一个 Bean 作为首选注入的 Bean。

    @Service
public class MyService {

	@Autowired
	@Qualifier("myRepository")
	private MyRepository myRepository;
	
	// other methods
}

在上述例子中，使用了 @Qualifier 注解指定了 Bean 的名称为 myRepository，以解决存在多个与依赖项类型兼容的 Bean 的问题。

🍁🍁 14. @Component 注解

🍁 14.1. @Component 是什么？

@Component 是 Spring 核心注解之一，用于将类标识为一个受 Spring 管理的组件。

🍁 14.2. @Component 有哪些特点？
  • @Component 注解是一个通用性的注解，可以用于标记任何类型的类，包括普通的类、接口和枚举等。
  • @Component 注解通常与其他注解一起使用，如 @Controller、@Service 和 @Repository 等。
  • 通过使用 @Component 标记的类，可以将其交给 Spring 容器进行管理，从而实现依赖注入和对象的生命周期管理。
🍁 14.3. @Component 作用是什么？

@Component 注解的主要作用是将类标记为一个受 Spring 容器管理的组件，用于实现依赖注入、AOP 面向切面编程等 Spring 功能。

🍁 14.4. @Component 注意事项是什么？
  • @Component 注解通常建议使用在具有通用性质的类上，比如工具类或通用的领域模型等，而对于具有特定功能的类，可以使用更加具体的注解如 @Controller、@Service 和 @Repository 等。
  • 建议将 @Component 注解与其他更具体的注解一起使用，以提供更详细的语义和更精确的功能。
🍁 14.5. @Component 代码使用案例？

  • 在需要被 Spring 管理的类上添加 @Component 注解。

    @Component
public class MyComponent {
	// class implementation
}

在上述例子中，MyComponent 类被标记为一个受 Spring 管理的组件，可以通过其他注解实现更具体的功能，如 @Controller、@Service 和 @Repository 等。

🍁 14.6. @Component 接收参数代码使用案例？

  • @Component 注解不接收参数，它将类标记为一个受 Spring 容器管理的组件。

  • 如果需要更具体的功能，可以使用其他注解作为补充，如 @Controller、@Service 和 @Repository 等。

    @Component("myComponent")
public class MyComponent {
	// class implementation
}

在上述例子中，使用了 @Component 注解的 value 属性将 Bean 的名称设置为 “myComponent”，并标记了该类为一个受 Spring 容器管理的组件。这样可以在其他地方使用该名称来引用该组件。

🍁🍁 15. @Service 注解

🍁 15.1. @Service 是什么？

@Service 是 Spring 核心注解之一，用于将一个类标识为一个业务逻辑层（Service）的组件。

🍁 15.2. @Service 有哪些特点？
  • @Service 注解是 @Component 注解的扩展，具有相同的功能，并且用于标记业务逻辑层的组件。
  • 通过使用 @Service 标记的类，可以将其交给 Spring 容器进行管理，实现依赖注入和对象的生命周期管理。
🍁 15.3. @Service 作用是什么？

@Service 注解的主要作用是将标记的类标识为一个业务逻辑层的组件，用于实现业务逻辑的封装和处理。

🍁 15.4. @Service 注意事项是什么？
  • @Service 注解通常建议使用在业务逻辑层的类上。
  • 建议将 @Service 注解与其他更具体的注解一起使用，以提供更详细的语义和更精确的功能。
🍁 15.5. @Service 代码使用案例？

  • 在需要被 Spring 管理的业务逻辑层类上添加 @Service 注解。

    @Service
public class MyService {
	// class implementation
}

在上述例子中，MyService 类被标记为一个受 Spring 容器管理的业务逻辑层组件。

🍁 15.6. @Service 接收参数代码使用案例？

  • @Service 注解不接收参数，它将类标记为一个受 Spring 容器管理的业务逻辑层组件。

  • 如果需要更具体的功能，可以使用其他注解作为补充，如 @Transactional 等。

    @Service("myService")
public class MyService {
	// class implementation
}

在上述例子中，使用了 @Service 注解的 value 属性将 Bean 的名称设置为 “myService”，并标记了该类为一个受 Spring 容器管理的业务逻辑层组件。这样可以在其他地方使用该名称来引用该组件。

🍁🍁 16. @Repository 注解

🍁 16.1. @Repository 是什么？

@Repository 是 Spring 核心注解之一，用于将一个类标识为数据访问层（Repository）的组件。

🍁 16.2. @Repository 有哪些特点？
  • @Repository 注解是 @Component 注解的扩展，具有相同的功能，并且用于标记数据访问层的组件。
  • 通过使用 @Repository 标记的类，可以将其交给 Spring 容器进行管理，实现依赖注入和对象的生命周期管理。
🍁 16.3. @Repository 作用是什么？

@Repository 注解的主要作用是将标记的类标识为一个数据访问层的组件，用于实现数据访问的封装和处理。

🍁 16.4. @Repository 注意事项是什么？
  • @Repository 注解通常建议使用在数据访问层的类上。
  • 建议将 @Repository 注解与其他更具体的注解一起使用，以提供更详细的语义和更精确的功能。
🍁 16.5. @Repository 代码使用案例？

  • 在需要被 Spring 管理的数据访问层类上添加 @Repository 注解。

    @Repository
public class MyRepository {
	// class implementation
}

在上述例子中，MyRepository 类被标记为一个受 Spring 容器管理的数据访问层组件。

🍁 16.6. @Repository 接收参数代码使用案例？

  • @Repository 注解不接收参数，它将类标记为一个受 Spring 容器管理的数据访问层组件。

  • 如果需要更具体的功能，可以使用其他注解作为补充，如 @Transactional 等。

    @Repository("myRepository")
public class MyRepository {
	// class implementation
}

在上述例子中，使用了 @Repository 注解的 value 属性将 Bean 的名称设置为 “myRepository”，并标记了该类为一个受 Spring 容器管理的数据访问层组件。这样可以在其他地方使用该名称来引用该组件。

🍁🍁 17. @Controller 注解

🍁 17.1. @Controller 是什么？

@Controller 是 Spring 核心注解之一，用于将一个类标识为控制器（Controller）的组件。

🍁 17.2. @Controller 有哪些特点？
  • @Controller 注解是 @Component 注解的扩展，具有相同的功能，并且用于标记控制器层的组件。
  • 通过使用 @Controller 标记的类，可以将其交给 Spring 容器进行管理，实现依赖注入和对象的生命周期管理。
🍁 17.3. @Controller 作用是什么？

@Controller 注解的主要作用是将标记的类标识为一个控制器组件，用于接收用户请求并处理相应逻辑。

🍁 17.4. @Controller 注意事项是什么？
  • @Controller 注解通常建议使用在控制器层的类上。
  • 建议将 @Controller 注解与其他更具体的注解一起使用，如 @RequestMapping 等。
🍁 17.5. @Controller 代码使用案例？

  • 在需要被 Spring 管理的控制器类上添加 @Controller 注解。

    @Controller
public class MyController {
	// class implementation
}

在上述例子中，MyController 类被标记为一个受 Spring 容器管理的控制器组件。

🍁 17.6. @Controller 接收参数代码使用案例？

  • @Controller 注解不接收参数，它将类标记为一个受 Spring 容器管理的控制器组件。

  • 如果需要更具体的功能，可以使用其他注解作为补充，如 @RequestMapping、@RequestParam 等。

    @Controller("myController")
public class MyController {
	// class implementation
}

在上述例子中，使用了 @Controller 注解的 value 属性将 Bean 的名称设置为 “myController”，并标记了该类为一个受 Spring 容器管理的控制器组件。这样可以在其他地方使用该名称来引用该组件。

🍁🍁 18. @Configuration 注解

🍁 18.1. @Configuration 是什么？

@Configuration 是 Spring 核心注解之一，用于将一个类标识为配置类（Configuration）。

🍁 18.2. @Configuration 有哪些特点？
  • @Configuration 注解是 @Component 注解的扩展，具有相同的功能，并且用于标记配置类。
  • 通过使用 @Configuration 标记的类，可以将其交给 Spring 容器进行管理，并在其中定义和组织 Bean 的配置信息。
🍁 18.3. @Configuration 作用是什么？

@Configuration 注解的主要作用是将标记的类标识为一个配置类，用于定义和组织 Bean 的配置信息，类似于传统的 XML 配置。

🍁 18.4. @Configuration 注意事项是什么？
  • @Configuration 注解通常建议使用在配置类上。
  • 配置类可以包含用 @Bean 注解标记的方法，用于定义 Bean 的创建和配置。
  • 建议将 @Configuration 注解与其他组件扫描注解一起使用，如 @ComponentScan，以确保配置类被正确识别和加载。
🍁 18.5. @Configuration 代码使用案例？

  • 在需要被 Spring 管理的配置类上添加 @Configuration 注解。

    @Configuration
public class AppConfig {
	// configuration methods using @Bean
}

在上述例子中，AppConfig 类被标记为一个受 Spring 容器管理的配置类。

🍁 18.6. @Configuration 接收参数代码使用案例？

  • @Configuration 注解不接收参数，它将类标记为一个受 Spring 容器管理的配置类。

  • 如果需要更具体的功能，可以使用其他注解作为补充，如 @Profile、@Import 等。

    @Configuration("myConfig")
public class AppConfig {
	// configuration methods using @Bean
}

在上述例子中，使用了 @Configuration 注解的 value 属性将 Bean 的名称设置为 “myConfig”，并标记了该类为一个受 Spring 容器管理的配置类。这样可以在其他地方使用该名称来引用该组件。

🍁🍁 19. @PathVariable 注解

🍁 19.1. @PathVariable 是什么？

@PathVariable 是 Spring MVC 注解之一，用于将 URL 中的路径变量映射到控制器方法的参数上。

🍁 19.2. @PathVariable 有哪些特点？
  • @PathVariable 注解可以将 URL 中的路径变量映射到方法的参数上，方便获取和处理请求中的动态参数信息。
  • 通过使用 @PathVariable 注解，可以将请求中的路径变量动态地传递到控制器方法中，从而简化了编写控制器方法的过程。
🍁 19.3. @PathVariable 作用是什么？

@PathVariable 注解主要作用是将 URL 中的路径变量映射到控制器方法的参数上，用于接收和处理请求中的动态参数信息。

🍁 19.4. @PathVariable 注意事项是什么？
  • @PathVariable 注解通常建议使用在控制器方法的参数上。
  • 在将请求中的参数映射到方法参数时，需要确保变量名称和 URL 上的参数名称一致。
  • 如果请求中没有指定参数值，则控制器方法中使用 @PathVariable 的变量将为 null。
🍁 19.5. @PathVariable 代码使用案例？

  • 添加 @PathVariable 注解到控制器方法的参数上，以将 URL 中的路径变量映射到方法参数上。

    @GetMapping("/users/{id}")
public User getUserById(@PathVariable Long id) {
	// implementation
}

在上述例子中，使用 @PathVariable 注解将 URL 中的 “id” 变量映射到控制器方法的 id 参数上。

🍁 19.6. @PathVariable 接收参数代码使用案例？

  • @PathVariable 注解接收一个 String 类型的参数，用于指定 URL 中的变量名。

  • 在控制器方法中，使用与 @PathVariable 注解中指定的变量名相同的参数名来接收请求参数。

  • 如果请求中没有指定该参数，则方法中使用 @PathVariable 的变量将为 null。

    @GetMapping("/users/{id}")
public User getUserById(@PathVariable("id") Long userId) {
	// implementation
}

在上述例子中，使用 @PathVariable 注解显式指定了 URL 中的变量名为 “id”，并将其映射到控制器方法的 userId 参数上。

🍁🍁 20. @RequestParam 注解

🍁 20.1. @RequestParam 是什么？

@RequestParam 是 Spring MVC 注解之一，用于将请求参数映射到控制器方法的参数上。

🍁 20.2. @RequestParam 有哪些特点？
  • @RequestParam 注解可以将请求参数映射到方法的参数上，方便获取和处理请求中的静态参数信息。
  • 通过使用 @RequestParam 注解，可以在控制器方法中直接获取请求中的参数值，而无需手动解析和提取参数。
🍁 20.3. @RequestParam 作用是什么？

@RequestParam 注解的主要作用是将请求中的参数映射到控制器方法的参数上，用于接收和处理请求中的静态参数信息。

🍁 20.4. @RequestParam 注意事项是什么？
  • @RequestParam 注解通常建议使用在控制器方法的参数上。
  • 如果请求中没有指定参数值，则控制器方法中使用 @RequestParam 的参数将根据类型的默认值进行初始化。
  • 如果请求中的参数名与方法参数名不一致，需要使用 value 或 name 属性显式指定参数名进行映射。
🍁 20.5. @RequestParam 代码使用案例？

  • 添加 @RequestParam 注解到控制器方法的参数上，以将请求参数映射到方法参数上。

    @GetMapping("/users")
public User getUserById(@RequestParam Long id) {
	// implementation
}

在上述例子中，通过 @RequestParam 注解将请求中的 “id” 参数映射到控制器方法的 id 参数上。

🍁 20.6. @RequestParam 接收参数代码使用案例？

  • @RequestParam 注解接收多个可选参数，用于配置请求参数映射的相关信息，如参数名、默认值、是否必需等。

  • 在控制器方法中，使用与 @RequestParam 注解中指定的参数名相同的参数名来接收请求参数。

  • 如果请求中没有指定该参数，且未设置默认值，则方法中使用 @RequestParam 的参数将为 null。

    @GetMapping("/users")
public User getUserById(@RequestParam("id") Long userId, @RequestParam(defaultValue = "John") String name) {
	// implementation
}

在上述例子中，使用 @RequestParam 注解显式指定了请求参数名为 “id”，并将其映射到控制器方法的 userId 参数上。另外，通过 defaultValue 属性设置了参数 “name” 的默认值为 “John”。

🍁🍁 21. @value 注解

🍁 21.1. @value 是什么？

@Value 是 Spring 注解之一，用于从配置文件中读取属性值，并将其注入到类中的字段或方法参数中。

🍁 21.2. @value 有哪些特点？
  • @Value 注解可以用于注入简单类型的属性值，如字符串、整数、布尔值等。
  • 通过使用 @Value 注解，可以方便地配置和管理应用程序中的属性值。
🍁 21.3. @value 作用是什么？

@Value 注解的主要作用是从配置文件中读取属性值，并将其注入到类中的字段或方法参数中，用于配置和管理应用程序中的属性。

🍁 21.4. @value 注意事项是什么？
  • @Value 注解通常使用在类的字段上，以注入属性值。
  • 在使用 @Value 注解时，需要在 Spring 的配置文件中定义相应的属性值。
  • @Value 注解支持以下格式的属性值注入：
    • 直接注入简单类型的属性值，如 @Value("Hello")。
    • 使用占位符注入属性值，如 @Value("${app.name}")。
    • 使用 SpEL 表达式注入属性值，如 @Value("#{systemProperties['user.language']}")。
🍁 21.5. @value 代码使用案例？

  • 添加 @Value 注解到类的字段或方法参数上，以从配置文件中读取属性值并注入。

    @Component
public class MyBean {
	@Value("${app.name}")
	private String appName;

	// 其他代码...
}

在上述例子中，使用 @Value 注解将配置文件中名为 “app.name” 的属性值注入到 appName 字段中。

🍁 21.6. @value 接收参数代码使用案例？

  • @Value 注解支持多种属性值注入方式，可以直接注入简单类型的属性值，也可以使用占位符和 SpEL 表达式进行注入。

  • 当使用占位符注入属性值时，需要在 Spring 的配置文件中定义相应的属性值。

    @Component
public class MyBean {
	@Value("${app.name}")
	private String appName;

	@Value("#{systemProperties['user.language']}")
	private String userLanguage;

	// 其他代码...
}

在上述例子中，使用 @Value 注解注入了两个属性值：一个使用占位符注入名为 “app.name” 的属性值，另一个使用 SpEL 表达式注入系统属性 “user.language” 的属性值。

🍁🍁 22. @ConfigurationProperties 注解

🍁 22.1. @ConfigurationProperties 是什么？

@ConfigurationProperties 是 Spring Boot 注解之一，用于将配置文件中的属性值注入到 Java 对象中。

🍁 22.2. @ConfigurationProperties 有哪些特点？
  • @ConfigurationProperties 注解可以用于注入复杂类型的属性值，如 Map、List 等。
  • 通过使用 @ConfigurationProperties 注解，可以方便地配置和管理应用程序中的属性值。
  • @ConfigurationProperties 注解可以与 @Component 注解结合使用，将配置文件中的属性值注入到类的实例中。
🍁 22.3. @ConfigurationProperties 作用是什么？

@ConfigurationProperties 注解的主要作用是从配置文件中读取属性值，并将其注入到 Java 对象中，用于配置和管理应用程序中的属性。

🍁 22.4. @ConfigurationProperties 注意事项是什么？
  • @ConfigurationProperties 注解应用于类级别，该注解所注释的类必须被 @Component 所注释，并且在 Spring 容器中进行注册。
  • 在使用 @ConfigurationProperties 注解时，需要在 Spring 的配置文件中定义相应的属性值。
  • @ConfigurationProperties 注解支持以下格式的属性值注入：
    • 直接注入简单类型的属性值，如 my.name=John。
    • 使用嵌套属性注入属性值，如 my.address.city=New York。
    • 使用 @Value 注解注入属性值，如 my.age=${app.age}。
🍁 22.5. @ConfigurationProperties 代码使用案例？

  • 添加 @ConfigurationProperties 注解到类上，以从配置文件中读取属性值。

    @Component
@ConfigurationProperties(prefix = "my")
public class MyProperties {
	private String name;
	private int age;

	// 其他代码...
}

在上述例子中，使用 @Component 注解将 MyProperties 类注册到 Spring 容器中，并使用 @ConfigurationProperties 注解将配置文件中以 “my” 为前缀的属性值注入到 MyProperties 类的实例中。

🍁 22.6. @ConfigurationProperties 接收参数代码使用案例？

  • @ConfigurationProperties 注解支持多种属性值注入方式，可以直接注入简单类型的属性值，也可以使用嵌套属性、列表、Map 等注入复杂类型的属性值。

  • 当使用嵌套属性注入属性值时，需要在配置文件中使用点号 “.” 进行分隔。

    @Component
@ConfigurationProperties(prefix = "my")
public class MyProperties {
	private String name;
	private int age;
	private Address address;

	// 其他代码...

	public static class Address {
		private String city;
		private String street;

		// 其他代码...
	}
}

在上述例子中，MyProperties 类中声明了一个内部类 Address，用于表示一个包含城市和街道信息的地址。使用 @ConfigurationProperties 注解将配置文件中以 “my” 为前缀的属性值注入到 MyProperties 类的实例中。具体使用时，可以声明一个 Address 类型的字段，并在配置文件中使用点号 “.” 将嵌套属性注入到 Address 类型的字段中。

🍁🍁 23. @Resource 注解

🍁 23.1. @Resource 是什么？

@Resource 是一个由标准 J2EE 提供的注解，用于注入某个对象，它可以自动从 Spring 容器中查找需要的 bean，并注入到指定的变量中。

🍁 23.2. @Resource 有哪些特点？
  • @Resource 注解是 J2EE 标准注解，不依赖于 Spring 框架，可以在其他 J2EE 环境中使用。
  • @Resource 注解可以注入任何由 Spring 托管的 bean 对象。
  • @Resource 注解可以根据名称进行匹配注入。
🍁 23.3. @Resource 作用是什么？

@Resource 注解的主要作用是注入某个对象实例，它可以自动从 Spring 容器中查找需要的 bean，并注入到指定的变量中。

🍁 23.4. @Resource 注意事项是什么？
  • @Resource 注解不是 Spring 框架提供的注解，它是 J2EE 标准注解，因此需要在类路径下添加 javax.annotation-api 才能使用。
  • 在使用 @Resource 注解时，需要保证被注入的 bean 名称在 Spring 容器中是唯一的。
  • @Resource 注解默认使用名称进行匹配，也可以通过 name 属性指定名称。
  • @Resource 注解不支持 @Primary 和 @Qualifier 注解。
🍁 23.5. @Resource 代码使用案例？

  • 使用 @Resource 注解注入其他 bean。

    @Component
public class MyComponent {
	@Resource
	private MyService myService;

	public void doSomething() {
		myService.doSomething();
	}
}

在上述例子中，使用 @Resource 注解将名为 “myService” 的 bean 注入到 MyComponent 中的 myService 字段中。

🍁 23.6. @Resource 接收参数代码使用案例？

  • @Resource 注解可以通过 name 属性指定 bean 的名称，这个名称就是在 Spring 容器中注册的 bean 名称。

    @Component
public class MyComponent {
	@Resource(name = "helloService")
	private HelloService helloService;

	public void doSomething() {
		helloService.sayHello();
	}
}

在上述例子中，使用 @Resource 注解将名为 “helloService” 的 bean 注入到 MyComponent 中的 helloService 字段中。

🍁🍁 24. @JsonIgnoreProperties 注解

🍁 24.1. @JsonIgnoreProperties 是什么？

@JsonIgnoreProperties 是 Jackson JSON 库提供的一个注解，用于在序列化和反序列化过程中忽略特定的属性。它可以应用于类级别或属性级别。

🍁 24.2. @JsonIgnoreProperties 有哪些特点？
  • @JsonIgnoreProperties 注解可以用于控制 JSON 反序列化过程中要忽略的属性。
  • @JsonIgnoreProperties 注解可以在类级别和属性级别上使用。
  • 在类级别上使用时，所有指定的属性都将被忽略。
  • 在属性级别上使用时，仅指定的属性将被忽略。
🍁 24.3. @JsonIgnoreProperties 作用是什么？

@JsonIgnoreProperties 注解的主要作用是在 JSON 序列化和反序列化过程中忽略指定的属性，避免将它们包含在生成的 JSON 字符串中或解析过程中。

🍁 24.4. @JsonIgnoreProperties 注意事项是什么？
  • 在使用 @JsonIgnoreProperties 注解时应小心，确保不会忽略需要保留或使用的重要属性。
  • 如果同时使用 @JsonIgnore 注解和 @JsonIgnoreProperties 注解，在序列化和反序列化过程中，@JsonIgnore 注解优先级更高。
🍁 24.5. @JsonIgnoreProperties 代码使用案例？

  • 在类级别上使用 @JsonIgnoreProperties 注解。

    @JsonIgnoreProperties({"password", "creditCardNumber"})
public class User {
	private String username;
	private String password;
	private String email;
	private String creditCardNumber;

	// Getters and setters
}

在上述例子中，@JsonIgnoreProperties 注解应用于 User 类级别，忽略了 password 和 creditCardNumber 属性在序列化和反序列化过程中的处理。

🍁 24.6. @JsonIgnoreProperties 接收参数代码使用案例？

  • @JsonIgnoreProperties 注解可以接收一个字符串数组作为参数，每个字符串表示要忽略的属性。

    @JsonIgnoreProperties({"field1", "field2"})
public class MyClass {
	// class members
}

在上述例子中，MyClass 类中的 field1 和 field2 属性将在 JSON 序列化和反序列化过程中被忽略。

🍁🍁 25. @RestController 注解

🍁 25.1. @RestController 是什么？

@RestController 是 Spring 框架提供的一个注解，用于标记一个类为 RESTful Web 服务的控制器。该注解结合了 @Controller 和 @ResponseBody 注解的功能。

🍁 25.2. @RestController 有哪些特点？
  • @RestController 注解可以应用于类级别。
  • 在被 @RestController 注解标记的类中，所有的方法都将自动具备 @ResponseBody 注解的功能，返回的数据将直接写入 HTTP 响应体中。
  • @RestController 注解可以与其他注解（例如 @RequestMapping、@GetMapping 等）一起使用，来定义 RESTful API 的路由和请求处理。
🍁 25.3. @RestController 作用是什么？

@RestController 注解的主要作用是将类标记为 RESTful Web 服务的控制器，用于处理 HTTP 请求并返回数据。

🍁 25.4. @RestController 注意事项是什么？
  • @RestController 注解适用于纯粹的 RESTful Web 服务，即返回的数据通常为 JSON 或 XML 格式，而不是用于渲染视图。
  • 需要确保在项目的依赖中引入 Spring Web 相关的库，以使 @RestController 注解生效。
🍁 25.5. @RestController 代码使用案例？

  • 基本的 @RestController 使用示例：

    @RestController
@RequestMapping("/api")
public class UserController {
	@GetMapping("/users")
	public List<User> getUsers() {
		// 返回用户列表
	}

	@PostMapping("/users")
	public void addUser(@RequestBody User user) {
		// 添加新用户
	}
}

在上述例子中，UserController 类被标记为 @RestController，并使用 @RequestMapping 注解指定了基础路由路径为 “/api”。然后，getUsers 和 addUser 方法分别使用了 @GetMapping 和 @PostMapping 注解来处理对应的 GET 和 POST 请求。

🍁 25.6. @RestController 接收参数代码使用案例？
  • @RestController 注解不直接接收参数。它主要用于标记一个类为 RESTful Web 服务的控制器，方法内部使用其他注解来接收参数，如 @RequestParam、@PathVariable、@RequestBody 等。详细的参数接收方式可以参考 Spring MVC 的文档和其他注解的使用说明。

🍁🍁 26. @CrossOrigin 注解

🍁 26.1. @CrossOrigin 是什么？

@CrossOrigin 是 Spring 框架提供的一个注解，用于处理跨域资源共享（CORS）问题。CORS 是一种机制，用于允许在不同的域之间进行安全的数据交互。

🍁 26.2. @CrossOrigin 有哪些特点？
  • @CrossOrigin 注解可以应用于方法级别或类级别。
  • 在被 @CrossOrigin 注解标记的方法或类中，可以设置允许的跨域请求的源、请求方法、允许的请求头、预检请求等。
  • @CrossOrigin 注解提供了灵活的配置选项，以满足不同的跨域需求。
🍁 26.3. @CrossOrigin 作用是什么？

@CrossOrigin 注解的主要作用是解决浏览器的跨域请求限制问题，允许在不同的域之间安全地进行数据交互。

🍁 26.4. @CrossOrigin 注意事项是什么？
  • 在使用 @CrossOrigin 注解时，需要注意安全性。允许跨域请求可能会带来安全风险，因此要确保只允许预期的跨域请求来源。
  • 需要确保在项目的依赖中引入 Spring Web 相关的库，以使 @CrossOrigin 注解生效。
🍁 26.5. @CrossOrigin 代码使用案例？

  • 基本的 @CrossOrigin 使用示例：

    @RestController
@RequestMapping("/api")
@CrossOrigin(origins = "http://localhost:8080")
public class UserController {
	@GetMapping("/users")
	public List<User> getUsers() {
		// 返回用户列表
	}
}

在上述例子中，UserController 类被标记为 @RestController，并使用 @RequestMapping 注解指定了基础路由路径为 “/api”。然后，在类级别使用了 @CrossOrigin 注解来允许来自 “http://localhost:8080” 域的跨域请求。

🍁 26.6. @CrossOrigin 接收参数代码使用案例？
  • @CrossOrigin 注解不直接接收参数。它主要用于标记一个方法或类为允许跨域请求的处理器，方法内部没有参数与之关联。如果需要在方法中接收参数，可以使用其他注解，如 @RequestParam、@PathVariable 等。详细的参数接收方式可以参考 Spring MVC 的文档和其他注解的使用说明。

🍁🍁 27. @ComponentScan 注解

🍁 27.1. @ComponentScan 是什么？

@ComponentScan 是 Spring 框架提供的一个注解，用于自动扫描指定基础包及其子包下的类，并把这些类注册成 Spring 容器中的 bean。

🍁 27.2. @ComponentScan 有哪些特点？
  • @ComponentScan 注解可以应用于类级别。
  • 在被 @ComponentScan 注解标记的类中，可以设置扫描的基础包路径、过滤规则等，以控制 bean 注册的范围和方式。
  • @ComponentScan 注解提供了自动装配和依赖注入的功能，可以简化应用程序的开发。
🍁 27.3. @ComponentScan 作用是什么？

@ComponentScan 注解的主要作用是为应用程序中的 bean 提供自动注册和自动装配的能力，从而简化应用程序的开发过程。

🍁 27.4. @ComponentScan 注意事项是什么？
  • 在使用 @ComponentScan 注解时，需要注意被扫描到的类必须被 Spring 框架所管理，即它们必须带有相应的注解，如 @Service、@Controller、@Repository 等。
  • 过多的自动扫描容易引起性能问题，因此需要谨慎配置扫描范围和过滤规则。
🍁 27.5. @ComponentScan 代码使用案例？

  • 基本的 @ComponentScan 使用示例：

    @SpringBootApplication
@ComponentScan("com.example")
public class MyApplication {
	public static void main(String[] args) {
		SpringApplication.run(MyApplication.class, args);
	}
}

在上述例子中，MyApplication 类被标记为 @SpringBootApplication，并同时使用了 @ComponentScan 注解来扫描 “com.example” 包及其子包下的所有组件，自动注册为 Spring 容器中的 bean。

🍁 27.6. @ComponentScan 接收参数代码使用案例？
  • @ComponentScan 注解的参数是一个字符串数组，用于指定要扫描的包路径。如果要扫描多个包，可以使用逗号分隔。例如：@ComponentScan({"com.example.service", "com.example.controller"})。
  • @ComponentScan 注解还支持其他参数，如 basePackages、basePackageClasses、includeFilters、excludeFilters 等，可以通过这些参数来更灵活地控制扫描的范围和方式。详细的参数说明可以参考 Spring 官方文档。

🍁🍁 28. @Component 注解

🍁 28.1. @Component 是什么？

@Component 是 Spring 框架提供的一个通用注解，用于将一个类标记为 Spring 容器中的一个组件。@Component 注解可以被没有其他更具体的注解的 POJO 类使用。

🍁 28.2. @Component 有哪些特点？
  • @Component 注解可以应用于类级别。
  • 在被 @Component 注解标记的类中，需要使用 @Autowired 或其他注解来进行依赖注入，以便让 Spring 自动管理组件之间的依赖关系。
  • @Component 注解的具体实现可以是 @Service、@Controller、@Repository 或其他注解。
🍁 28.3. @Component 作用是什么？

@Component 注解的主要作用是将一个普通的 Java 类标记为 Spring 容器中的一个组件，使该类可以被 Spring 自动管理和装配。

🍁 28.4. @Component 注意事项是什么？
  • 在使用 @Component 注解时，需要保证被标记的类确实是一个 POJO 类，并且没有其他更具体的注解可以使用。
  • 在被 @Component 注解标记的类中，需要使用其他有意义的注解（如 @Service、@Controller、@Repository 等）来表示该组件的具体作用。
🍁 28.5. @Component 代码使用案例？

  • 基本的 @Component 使用示例：

    @Component
public class MyComponent {
	public void doSomething() {
		// do something
	}
}

在上述例子中，MyComponent 类被标记为 @Component，表示它是一个 Spring 容器中的组件，可以通过 @Autowired 或其他注解来进行依赖注入。

🍁 28.6. @Component 接收参数代码使用案例？
  • @Component 注解不直接接收参数。如果需要进一步细化组件的作用和用途，可以使用其他更具体的注解，如 @Service、@Controller、@Repository 等。例如：@Service("userService") 表示将该组件标记为一个服务类，并设置服务名称为 “userService”。

🍁🍁 29. @Qualifier 注解

🍁 29.1. @Qualifier 是什么？

@Qualifier 是 Spring 框架提供的一个注解，用于指定在多个相同类型并且实现类不同的 bean 中，具体要注入哪个 bean。

🍁 29.2. @Qualifier 有哪些特点？
  • @Qualifier 注解可以应用于构造方法、setter 方法和域变量。
  • @Qualifier 注解结合 @Autowired 注解使用，用于指定具体要注入哪个 bean。
  • @Qualifier 注解可以同时指定 bean 的名称和 bean 的类型。
🍁 29.3. @Qualifier 作用是什么？

@Qualifier 注解的主要作用是解决由于多个相同类型不同实现的 bean 造成的注入歧义问题，使得注入行为更明确、可控。

🍁 29.4. @Qualifier 注意事项是什么？
  • 在使用 @Qualifier 注解时，需要保证对应的 bean 已经被定义到 Spring 容器中，并且在不同的 bean 中使用的 @Qualifier 值唯一。
  • 如果使用了 @Qualifier 注解，但没有为对应的 bean 命名，即在 @Component 或其他注解中没有设置 value 或 name 属性，那么 @Qualifier 会自动使用 bean 的类名称作为其限定符。
🍁 29.5. @Qualifier 代码使用案例？

  • 使用 @Qualifier 注解指定注入的 bean：

    public class MyController {
	private UserService userService;

	@Autowired
	public void setUserService(@Qualifier("userServiceImpl") UserService userService) {
		this.userService = userService;
	}
}

在上述例子中，@Qualifier 注解指定了 userServiceImpl bean 的名称，因此在自动注入 UserService 类型的 bean 时，Spring 容器会优先选择名称为 userServiceImpl 的 bean 进行注入。

🍁 29.6. @Qualifier 接收参数代码使用案例？
  • @Qualifier 注解的参数是一个字符串，用于指定要注入的 bean。参数值通常是限定符，也可以是 bean 的名称或其他属性的值。例如：@Qualifier("userServiceImpl")。

🍁🍁 30. @Transactional 注解

🍁 30.1. @Transactional 是什么？

@Transactional 是 Spring 框架提供的一个注解，用于声明事务的属性和行为。

🍁 30.2. @Transactional 有哪些特点？
  • @Transactional 注解可以应用于方法级别和类级别。
  • @Transactional 注解可以用于控制事务的传播行为、隔离级别、超时时间、只读属性等。
  • @Transactional 注解可以配置在接口、类、方法上。配置在接口上，会被所有实现类继承；配置在类上，会被该类的全部方法继承；配置在方法上，仅作用于该方法。
🍁 30.3. @Transactional 作用是什么？

@Transactional 注解的主要作用是声明当前方法或类需要在事务管理下执行。它可以确保方法在执行过程中遵循事务的 ACID 特性，并将其与其他事务隔离开来。

🍁 30.4. @Transactional 注意事项是什么？
  • 在使用 @Transactional 注解时，需要确保 Spring 配置中启用了事务管理器，以便使注解生效。
  • 方法或类上的 @Transactional 注解可以被继承，但继承关系可能会出现一些意外行为，因此要小心使用。
🍁 30.5. @Transactional 代码使用案例？

  • 基本的 @Transactional 使用示例：

    @Transactional
public void doSomethingTransactional() {
	// 事务内的代码逻辑
}

在上述例子中，doSomethingTransactional 方法被标记为 @Transactional，表示该方法需要在事务管理下执行。方法内的代码逻辑将受事务的管理保护。

🍁 30.6. @Transactional 接收参数代码使用案例？
  • @Transactional 注解接收多个参数来配置事务的属性。
  • 常用的参数包括：propagation（事务传播行为）、isolation（事务隔离级别）、timeout（事务超时时间）、readOnly（事务只读属性）等。例如：@Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.DEFAULT, timeout = 10, readOnly = false)。不同的参数可以根据实际需求来进行配置。

在这里插入图片描述

文章来源:https://blog.csdn.net/m0_50308467/article/details/135025582
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。