SpringBoot常用注解详解含使用示例（值得珍藏）
1. 启动注解
1.1 @SpringBootApplication
@SpringBootApplication 是一个组合注解，它结合了 @SpringBootConfiguration、@EnableAutoConfiguration 和 @ComponentScan。这个注解用于简化 Spring Boot 应用的初始化和开发过程。
具体来说，@SpringBootConfiguration 表明该类是一个 Spring Boot 配置类，用于定义和注册 Spring Beans。@EnableAutoConfiguration 启用了 Spring Boot 的自动配置功能，根据项目中的依赖关系自动配置应用程序。@ComponentScan 则指示 Spring Boot 在指定的包及其子包中查找组件、配置和服务。
使用 @SpringBootApplication 注解可以简化 Spring Boot 应用的开发过程，使得开发人员能够快速构建独立、生产级别的 Spring 应用。同时，它还提供了一些便利的特性，如嵌入式容器、自动化配置、简化 Maven 配置等，使得应用更加易于部署和管理。
以下是一个简单的 Spring Boot 应用程序示例，其中使用了 @SpringBootApplication 注解：
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class MySpringBootApplication {
public static void main(String[] args) {
SpringApplication.run(MySpringBootApplication.class, args);
}
}
在上面的示例中，@SpringBootApplication 注解将 MySpringBootApplication 类标记为一个 Spring Boot 应用程序的入口点。当运行该应用程序时，Spring Boot 会自动配置和启动应用程序。
你可以在 MySpringBootApplication 类中添加更多的组件和配置，以满足你的应用程序需求。例如，你可以添加控制器、服务、数据访问对象等，并使用 Spring Boot 的自动配置功能来简化配置过程。
1.2 @SpringBootConfiguration
@SpringBootConfiguration 是 Spring Boot 框架提供的注解，用于将普通的 Java 类标记为配置类。该注解的作用是将类作为一个 Spring 配置类，从而使其能够定义和注册 Spring Beans。
与传统的 XML 配置方式相比，使用 @SpringBootConfiguration 注解可以将配置信息直接写在 Java 类中，使得代码更加简洁、易于维护。同时，该注解还提供了自动配置和组件扫描等功能，进一步简化了 Spring Boot 应用的初始化和开发过程。
使用 @SpringBootConfiguration 注解的类通常包含一些用于定义 Spring Beans 的方法，这些方法上可以标注其他注解（如 @Bean、@Component、@Service 等），以便于创建和注册不同的 Spring 组件。通过在主类上使用 @SpringBootApplication 注解，可以将多个配置类组合在一起，从而实现更加灵活和复杂的配置功能。
它继承@Configuration注解，主要用于加载配置文件，二者功能一致，标注当前类为配置类， 将当前类内声明的一个或多个以@Bean注解标记的方法的实例纳入到spring容器中，且实例名为方法名。
1.3 @EnableAutoConfiguration
@EnableAutoConfiguration 是 Spring Boot 的一个核心特性，它根据项目中的依赖关系自动配置应用程序。通过 @EnableAutoConfiguration 注解，Spring Boot 能够根据添加的 jar 依赖自动配置 Spring 应用程序的 IOC 容器。
在 Spring Boot 项目中，只需要在主类上添加 @EnableAutoConfiguration 注解，就可以开启自动配置功能。Spring Boot 会根据项目中的依赖项，自动扫描并配置相应的 Bean。这个过程是自动完成的，不需要手动编写大量的配置文件和注解。
@EnableAutoConfiguration 通过读取 classpath 中的 jar 依赖，判断需要创建哪些 Bean，并自动注册到 Spring 容器中。这样可以大大简化 Spring 应用的初始化和配置过程，提高开发效率。
1.4 @ComponentScan
@ComponentScan 是 Spring 框架中的一个注解，用于指定 Spring 容器扫描组件的路径。通过使用 @ComponentScan，可以将 Spring 容器中的组件注册到指定的路径下。
具体来说，@ComponentScan 注解可以定义在类或接口上，用于指定扫描路径。Spring 容器会将指定路径下带有指定注解的类注册到 IOC 容器中。默认情况下，@ComponentScan 会扫描带有 @Component、@Service、@Repository 和 @Controller 等注解的类。
使用 @ComponentScan 可以简化 Spring 应用的初始化和配置过程。通过指定扫描路径，可以自动将相关的组件注册到 Spring 容器中，而不需要手动创建和配置每个 Bean。这使得代码更加简洁、易于维护，并且减少了出错的可能性。
需要注意的是，在使用 @ComponentScan 时，需要确保扫描路径的正确性。如果扫描路径不正确，可能会导致组件无法被注册到 Spring 容器中，从而导致异常或错误。因此，在实际开发中，需要根据具体情况选择合适的扫描路径，并进行充分的测试和验证。
2. 配置文件相关注解
2.1 @Configuration
@Configuration 是 Spring 框架中的一个注解，用于将普通的 Java 类标记为配置类。当一个类上标注了 @Configuration 注解时，这个类就被视为一个配置类，用于替代传统的 XML 配置方式。
在配置类中，可以使用 @Bean 注解来定义 Spring Beans。这些 Beans 可以是普通的 Java 类，也可以是其他配置类。通过使用 @Configuration 和 @Bean 注解，可以将配置信息直接写在 Java 类中，使得代码更加简洁、易于维护。
与传统的 XML 配置方式相比，使用 @Configuration 和 @Bean 注解可以提供更加灵活和强大的配置功能。例如，可以在配置类中使用 Java 表达式来定义 Beans 的属性和依赖关系，还可以通过继承和组合配置类来实现更加复杂的配置逻辑。
此外，@Configuration 注解的类本身也是一个普通的 Java 类，可以包含普通的属性和方法。这使得配置类更加易于测试和维护。
需要注意的是，虽然使用 @Configuration 和 @Bean 注解可以简化 Spring 的配置过程，但并不是所有的配置都需要使用这种方式。在一些简单的情况下，使用传统的 XML 配置方式可能更加方便和直观。因此，在实际开发中，需要根据具体情况选择合适的配置方式。
以下是一个使用 @Configuration 注解的示例：
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class AppConfig {
@Bean
public MyBean myBean() {
return new MyBean();
}
}
在上面的示例中，@Configuration 注解将 AppConfig 类标记为一个 Spring 配置类。在该类中，我们使用 @Bean 注解定义了一个名为 myBean 的 Bean，该 Bean 返回一个 MyBean 实例。
通过在配置类中使用 @Bean 注解，我们可以将对象实例化并将其注册为 Spring 容器中的 Bean。这样，在应用程序的其他部分中，我们可以使用 @Autowired 或 @Inject 注解来注入这些 Bean，以便使用它们的功能。
3. Controller 相关注解
3.1 @Controller
@Controller 是一个用于标识一个 Java 类为 Spring MVC 控制器的注解。使用 @Controller 注解的类将负责处理请求并返回响应。在 Spring MVC 中，控制器是与视图层进行交互的重要组件，负责处理用户请求并返回相应的视图或数据。
当一个类上标注了 @Controller 注解，Spring MVC 会自动扫描该类，并将其注册为一个控制器。这意味着该类的方法将用于处理请求，并返回响应。方法的返回值可以是一个视图页面、数据对象或模型。
@Controller 注解的作用是将一个类标记为控制器，使 Spring MVC 能够自动扫描和注册该类。与 @Component 注解类似，@Controller 注解也是将一个类标记为 Spring 的组件。但是，@Controller 注解还有以下特性：
- 自动映射 URL：@Controller 注解可以将请求映射到控制器的方法上。这意味着当用户访问特定的 URL 时，Spring MVC 会自动调用相应的控制器方法来处理请求。
- 解析返回值：@Controller 注解可以将方法的返回值解析为视图，并将其渲染到客户端。这意味着方法的返回值可以是一个视图页面的路径、一个模型对象或一个数据集合等。
需要注意的是，在实际开发中，使用 @Controller 注解时需要结合其他注解（如 @RequestMapping）来指定请求的 URL 映射和请求方法（如 GET、POST）。此外，根据实际需求选择合适的控制器注解（如 @Controller、@RestController）也是很重要的。
以下是一个使用 @Controller 注解的示例：
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
@Controller
@RequestMapping("/hello")
public class HelloController {
@GetMapping
public String sayHello() {
return "Hello, World!";
}
}
在上面的示例中，@Controller 注解将 HelloController 类标记为一个 Spring MVC 控制器。@RequestMapping("/hello") 注解指定了该控制器处理的基础 URL 路径为 /hello。
在控制器类中，我们定义了一个名为 sayHello 的方法，该方法使用 @GetMapping 注解指定处理 GET 请求。当用户访问 /hello URL 时，Spring MVC 会自动调用 sayHello 方法，并返回一个名为 “Hello, World!” 的字符串作为响应。
注意，@Controller 注解通常与 @RequestMapping 或 @GetMapping 等注解一起使用，以定义控制器类和控制器方法的映射关系。
3.2 @RestController
@RestController 是一个 Spring Framework 中的注解，用于标识一个类是一个控制器，并且该控制器中的方法返回的数据不是视图页面，而是直接作为响应内容发送到客户端，通常是以 JSON 格式返回数据。
与 @Controller 注解相比，@RestController 注解更加适合创建 RESTful 风格的控制器。使用 @RestController 注解的类通常处理 HTTP 请求并返回 JSON 或其他格式的响应数据，而不是视图页面。
@RestController 注解的主要特点包括：
- 自动转换为 JSON 或其他格式：使用 @RestController 注解的控制器方法可以直接返回数据对象，不需要手动将其转换为 JSON 或其他格式。Spring 会自动将返回值转换为相应的格式，并将其作为响应内容发送给客户端。
- 简化代码：使用 @RestController 注解可以大大简化 RESTful Web 服务的开发，减少代码量和冗余操作。开发者只需要关注数据模型和业务逻辑，而不需要关心请求映射和响应格式转换等细节。
- 自动映射 URL：与 @Controller 注解类似，@RestController 注解也可以将请求映射到控制器的方法上。开发者可以使用 @RequestMapping 或其他相关注解来指定请求的 URL 映射和请求方法。
需要注意的是，@RestController 注解通常用于创建 API 或 Web 服务，而不是用于构建完整的 Web 应用程序。在这些场景下，使用 @RestController 可以简化开发过程，提高开发效率。
以下是一个使用 @RestController 注解的示例：
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("/api/users")
public class UserController {
@GetMapping("/{id}")
public String getUserById(@PathVariable String id) {
// 在这里实现获取用户信息的逻辑...
return "User ID: " + id;
}
}
在上面的示例中，@RestController 注解将 UserController 类标记为一个 RESTful 控制器。@RequestMapping("/api/users") 注解指定了该控制器处理的基础 URL 路径为 /api/users。
在控制器类中，我们定义了一个名为 getUserById 的方法，该方法使用 @GetMapping("/{id}") 注解指定处理 GET 请求，并使用 @PathVariable 注解将 URL 中的 {id} 参数绑定到方法的参数上。当用户访问 /api/users/{id} URL 时，Spring MVC 会自动调用 getUserById 方法，并返回一个字符串作为响应。
由于 @RestController 注解会自动将方法的返回值转换为 JSON 或其他适当的响应格式，因此我们只需要返回一个简单的字符串作为响应。在这个示例中，我们返回了一个包含用户 ID 的字符串。
3.3 @RequestBody
@RequestBody 是 Spring 框架中的一个注解，主要用于将 HTTP 请求的内容（如 JSON、XML 等）绑定到方法的参数上。具体来说，当一个方法参数上标注了 @RequestBody 注解时，Spring 会自动将请求体中的数据解析为对应类型的对象，并将其传递给方法参数。这个过程是自动完成的，不需要手动解析请求体中的数据。
@RequestBody主要特点包括：
- 自动绑定请求体：
@RequestBody能够自动将 HTTP 请求体中的数据绑定到方法的参数上，简化了数据的解析过程。 - 数据格式化：
@RequestBody支持多种数据格式，如 JSON、XML 等，可以根据请求体的内容自动进行格式化。 - 数据校验：通过
@RequestBody注解，Spring 会对绑定到参数的对象进行数据校验，确保数据的完整性和有效性。
假设我们有一个 RESTful API，用于接收用户信息并保存到数据库中。这里我们使用 JSON 作为请求体的格式。
- 首先，创建一个
User类来表示用户信息：
public class User {
private String name;
private int age;
// getters and setters
}
- 创建一个
UserController类，使用@RestController注解标记为一个控制器：
import org.springframework.web.bind.annotation.*;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class UserController {
// ...其他代码...
}
- 在
UserController类中创建一个处理 POST 请求的方法，使用@RequestMapping注解指定 URL 路径，并使用@RequestBody注解将请求体中的数据绑定到方法的参数上：
import org.springframework.web.bind.annotation.*;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
@RestController
public class UserController {
@RequestMapping(value = "/user", method = RequestMethod.POST)
public void createUser(@RequestBody User user) {
// 在这里处理用户数据的保存逻辑...
}
}
在这个示例中，当客户端发送一个 POST 请求到 /user URL 时，Spring 会自动将请求体中的 JSON 数据解析为 User 对象，并将其传递给 createUser 方法。这样，开发者就不需要手动解析请求体中的数据了。
3.4 @ResponseBody
@ResponseBody 是一个 Spring MVC 注解，用于指示控制器方法的返回值应该直接写入 HTTP 响应体中，而不是被视为视图名称。这通常用于返回 JSON、XML 或其他数据格式的响应。
使用 @ResponseBody 注解的方法可以返回任何对象，Spring MVC 会自动将其序列化为适当的格式，并将其写入 HTTP 响应体中。常用的序列化方式包括 JSON（通过 Jackson 库）和 XML（通过 JAXB 或 XStream）。
下面是一个使用 @ResponseBody 的示例：
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("/api/users")
public class UserController {
@GetMapping("/{id}")
@ResponseBody
public User getUserById(@PathVariable String id) {
// 在这里实现获取用户信息的逻辑...
User user = new User();
user.setId(id);
user.setName("John Doe");
return user;
}
}
class User {
private String id;
private String name;
// getters and setters...
}
在上面的示例中，getUserById 方法使用了 @ResponseBody 注解，表示该方法的返回值应该直接写入 HTTP 响应体中。返回的 User 对象会被自动序列化为 JSON 格式，并作为 HTTP 响应的主体返回给客户端。客户端可以通过 HTTP GET 请求访问 /api/users/{id} 来获取用户信息。
3.5 @RequestMapping
@RequestMapping 是一个 Spring MVC 注解，用于将 HTTP 请求映射到特定的控制器方法。它可以用于类级别和方法级别，用于指定请求的 URL 路径、HTTP 方法和其他属性。
在类级别上使用 @RequestMapping 注解时，它将应用于该类中的所有方法。在方法级别上使用时，它将只应用于该方法。
@RequestMapping 注解可以接受多个参数，例如 value、method、consumes 和 produces。其中：
value指定请求的 URL 路径，可以包含路径变量。method指定请求的 HTTP 方法，例如GET、POST等。consumes指定请求的内容类型，例如application/json。produces指定响应的内容类型，例如application/json。
下面是一个使用 @RequestMapping 的示例：
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("/api/users")
public class UserController {
@RequestMapping(value = "/{id}", method = RequestMethod.GET)
public User getUserById(@PathVariable String id) {
// 在这里实现获取用户信息的逻辑...
User user = new User();
user.setId(id);
user.setName("John Doe");
return user;
}
}
class User {
private String id;
private String name;
// getters and setters...
}
在上面的示例中，UserController 类使用了 @RequestMapping("/api/users") 注解，将所有方法映射到 /api/users URL 路径下。然后，在 getUserById 方法上使用了 @RequestMapping(value = "/{id}", method = RequestMethod.GET) 注解，将该方法映射到 /api/users/{id} URL 路径下，并指定只处理 GET 请求。当客户端发送 GET 请求到 /api/users/{id} 时，Spring MVC 会自动调用 getUserById 方法，并返回一个 User 对象作为响应。
3.6 @GetMapping
@GetMapping 是 Spring 5 中引入的一个新注解，它是 @RequestMapping 的一个特化版本，专门用于处理 HTTP GET 请求。使用 @GetMapping 可以更简洁地指定处理 GET 请求的方法。
下面是一个使用 @GetMapping 的示例：
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class UserController {
@GetMapping("/users")
public List<User> getUsers() {
// 在这里实现获取用户列表的逻辑...
List<User> users = new ArrayList<>();
users.add(new User("1", "Alice"));
users.add(new User("2", "Bob"));
return users;
}
}
class User {
private String id;
private String name;
// getters and setters...
}
在上面的示例中，UserController 类使用了 @RestController 注解，表示该类是一个 RESTful 控制器。然后，在 getUsers 方法上使用了 @GetMapping("/users") 注解，将该方法映射到 /users URL 路径下，并指定只处理 GET 请求。当客户端发送 GET 请求到 /users 时，Spring MVC 会自动调用 getUsers 方法，并返回一个 User 对象列表作为响应。
3.7 @PostMapping
@PostMapping 是 Spring 5 中引入的一个注解，它是 @RequestMapping 的特化版本，专门用于处理 POST 请求。由于它的用途更加明确，因此在大多数情况下，推荐使用 @PostMapping 代替 @RequestMapping 并指定 method = RequestMethod.POST。
下面是一个使用 @PostMapping 的示例：
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class UserController {
@PostMapping("/api/users")
public User createUser(@RequestBody User user) {
// 在这里实现创建用户的逻辑...
user.setId(UUID.randomUUID().toString());
user.setName(user.getName().toUpperCase());
return user;
}
}
class User {
private String id;
private String name;
// getters and setters...
}
在上面的示例中，UserController 类中的 createUser 方法使用了 @PostMapping("/api/users") 注解，将该方法映射到 /api/users URL 路径下，并指定只处理 POST 请求。该方法接受一个 User 类型的参数，通过 @RequestBody 注解将请求体中的 JSON 数据绑定到 User 对象上。当客户端发送 POST 请求到 /api/users 时，Spring MVC 会自动调用 createUser 方法，并返回一个 User 对象作为响应。
3.8 @RequestMapping 和 @GetMapping @PostMapping 区别
@GetMapping是组合注解，是@RequestMapping(method = RequestMethod.GET)的缩写。
@PostMapping是组合注解，是@RequestMapping(method = RequestMethod.POST)的缩写。
4. 取请求参数值
4.1 @PathVariable
@PathVariable是Spring框架中的一个注解，用于将URL路径中的参数绑定到控制器方法的参数上。它通常用于处理RESTful Web服务的请求。使用@PathVariable注解可以将URL路径中的参数值注入到方法的参数中，使得在处理请求时可以方便地获取这些参数值。
例如，假设有一个URL路径"/user/{userId}/profile"，其中"{userId}"是一个路径参数。在控制器方法中，可以使用@PathVariable注解将这个参数值绑定到一个方法的参数上，如下所示：
@GetMapping("/user/{userId}/profile")
public UserProfile getUserProfile(@PathVariable String userId) {
// 在这里可以使用userId参数值进行相应的处理
// ...
}
在上面的例子中，@PathVariable注解将URL路径中的"{userId}“参数值绑定到了方法参数"userId"上。当用户访问一个特定的URL时，例如”/user/123/profile"，Spring框架会自动将"123"作为"userId"参数的值注入到方法中。
除了将路径参数绑定到字符串类型的参数上，@PathVariable注解还可以用于绑定其他类型的参数，例如整数、自定义对象等。只需要在方法的参数上使用相应的类型声明即可。
需要注意的是，如果URL路径中的参数没有提供对应的值，或者提供的值无法匹配到方法的参数类型，那么Spring框架将会抛出一个异常。因此，在使用@PathVariable注解时，需要确保URL路径中的参数值能够正确地匹配到方法的参数类型。
4.2 @Value
@Value 是 Spring 框架中的一个注解，用于注入属性值。它通常用于将值注入到 JavaBean 属性、构造函数参数或方法参数中。
使用 @Value 注解时，需要指定要注入的值或表达式的占位符。占位符可以是 ${...} 或 #{...}，其中 ${...} 表示直接属性值，#{...} 表示 SpEL（Spring Expression Language）表达式。
示例1
下面是一个使用 @Value 的示例：
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
@Component
public class MyComponent {
@Value("Hello, World!")
private String message;
public String getMessage() {
return message;
}
}
在上面的示例中，MyComponent 类使用 @Value("Hello, World!") 注解将字符串 “Hello, World!” 注入到 message 属性中。@Component 注解将该类标记为一个 Spring 组件，Spring 容器会自动扫描并实例化该类。然后，可以通过 getMessage() 方法获取注入的 message 属性的值。
除了在属性上使用 @Value 注解外，还可以在构造函数参数或方法参数上使用它，以注入值。例如：
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
@Component
public class MyComponent {
private String message;
public MyComponent(@Value("Hello, World!") String message) {
this.message = message;
}
public String getMessage() {
return message;
}
}
在上面的示例中，MyComponent 类使用 @Value("Hello, World!") 注解在构造函数参数上注入字符串 “Hello, World!”。Spring 容器会自动调用构造函数，并将注入的值传递给 message 参数。
示例2
以下是一个使用 @Value 读取配置文件中数据的示例：
首先，在 Spring 的配置文件（例如 application.properties）中定义一个属性：
my.config.value=Hello, World!
然后，在 Java 类中使用 @Value 注解将该属性注入到字段或方法参数中：
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
@Component
public class MyComponent {
@Value("${my.config.value}")
private String myConfigValue;
public String getMyConfigValue() {
return myConfigValue;
}
}
在上面的示例中，@Value("${my.config.value}") 注解将 my.config.value 属性的值注入到 myConfigValue 字段中。Spring 容器会自动扫描并实例化 MyComponent 类，并将 my.config.value 属性的值注入到 myConfigValue 字段中。然后，可以通过 getMyConfigValue() 方法获取注入的 myConfigValue 字段的值。
4.3 @RequestParam
@RequestParam 是 Spring MVC 框架中的一个注解，用于将请求参数绑定到控制器方法的参数上。它通常用于处理 HTTP GET 或 POST 请求中的参数。
使用 @RequestParam 注解时，需要指定参数的名称和可选的默认值。当请求中包含与参数名称匹配的参数时，该参数的值将被绑定到方法参数上。如果请求中没有该参数，方法参数将使用默认值（如果有提供的话）。
下面是一个使用 @RequestParam 的示例：
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class MyController {
@GetMapping("/greet")
public String greet(@RequestParam(value = "name", defaultValue = "World") String name) {
return "Hello, " + name + "!";
}
}
在上面的示例中，greet 方法使用 @RequestParam 注解将请求参数 name 绑定到 name 方法参数上。如果请求中包含名为 name 的参数，其值将被传递给 name 参数。如果没有提供 name 参数，将使用默认值 World。方法返回一个简单的问候语字符串。
当客户端发送 GET 请求到 /greet?name=John 时，请求参数 name 的值为 John，因此方法将返回 Hello, John!。如果客户端发送 GET 请求到 /greet（没有 name 参数），方法将返回 Hello, World!，因为使用了默认值 World。
4.4 @RequestHeader
@RequestHeader 是 Spring MVC 框架中的一个注解，用于将 HTTP 请求头中的值绑定到控制器方法的参数上。它通常用于处理带有请求头的 HTTP 请求。
使用 @RequestHeader 注解时，需要指定请求头的名称和可选的默认值。当请求中包含与请求头名称匹配的请求头时，该请求头的值将被绑定到方法参数上。如果请求中没有该请求头，方法参数将使用默认值（如果有提供的话）。
下面是一个使用 @RequestHeader 的示例：
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestHeader;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class MyController {
@GetMapping("/header")
public String getHeaderValue(@RequestHeader(name = "User-Agent", defaultValue = "Unknown") String userAgent) {
return "User-Agent: " + userAgent;
}
}
在上面的示例中，getHeaderValue 方法使用 @RequestHeader 注解将请求头 User-Agent 的值绑定到 userAgent 方法参数上。如果请求中包含名为 User-Agent 的请求头，其值将被传递给 userAgent 参数。如果没有提供 User-Agent 请求头，将使用默认值 Unknown。方法返回一个简单的字符串，其中包含请求头的值。
当客户端发送 GET 请求到 /header，并包含请求头 User-Agent，例如 GET /header HTTP/1.1\r\nUser-Agent: Chrome\r\n\r\n，方法将返回 User-Agent: Chrome。如果客户端发送 GET 请求到 /header（没有 User-Agent 请求头），方法将返回 User-Agent: Unknown，因为使用了默认值 Unknown。
4.5 @CookieValue
@CookieValue 是 Spring MVC 框架中的一个注解，用于将 HTTP 请求中的 cookie 值绑定到控制器方法的参数上。它通常用于处理带有 cookie 的 HTTP 请求。
使用 @CookieValue 注解时，需要指定 cookie 的名称和可选的默认值。当请求中包含与 cookie 名称匹配的 cookie 时，该 cookie 的值将被绑定到方法参数上。如果请求中没有该 cookie，方法参数将使用默认值（如果有提供的话）。
下面是一个使用 @CookieValue 的示例：
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.CookieValue;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class MyController {
@GetMapping("/cookie")
public String getCookieValue(@CookieValue(name = "myCookie", defaultValue = "defaultValue") String cookieValue) {
return "Cookie Value: " + cookieValue;
}
}
在上面的示例中，getCookieValue 方法使用 @CookieValue 注解将 cookie myCookie 的值绑定到 cookieValue 方法参数上。如果请求中包含名为 myCookie 的 cookie，其值将被传递给 cookieValue 参数。如果没有提供 myCookie cookie，将使用默认值 defaultValue。方法返回一个简单的字符串，其中包含 cookie 的值。
当客户端发送 GET 请求到 /cookie，并包含 cookie myCookie，例如 GET /cookie HTTP/1.1\r\nCookie: myCookie=cookieValue\r\n\r\n，方法将返回 Cookie Value: cookieValue。如果客户端发送 GET 请求到 /cookie（没有 myCookie cookie），方法将返回 Cookie Value: defaultValue，因为使用了默认值 defaultValue。
5. 注入bean相关
5.1 @Bean
@Bean 是 Spring 框架中的一个注解，用于声明一个对象作为 Spring 容器中的 bean。使用 @Bean 注解的方法将由 Spring 容器自动实例化，并将其注册为 bean，以便在应用程序中使用。
下面是一个使用 @Bean 的示例：
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class AppConfig {
@Bean
public MyBean myBean() {
return new MyBean();
}
}
在上面的示例中，我们定义了一个名为 AppConfig 的配置类，并使用 @Configuration 注解进行标记。在该类中，我们定义了一个名为 myBean 的方法，并使用 @Bean 注解进行标记。这个方法返回一个 MyBean 类型的实例，并将其注册为 Spring 容器中的 bean。
Spring 容器会自动扫描 AppConfig 类，并发现 myBean 方法上的 @Bean 注解。当应用程序启动时，Spring 容器将自动实例化 MyBean 类，并将其注册为一个 bean。然后，可以在应用程序中的其他地方注入这个 bean，例如：
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Component
public class SomeComponent {
private final MyBean myBean;
@Autowired
public SomeComponent(MyBean myBean) {
this.myBean = myBean;
}
}
在上面的示例中，我们定义了一个名为 SomeComponent 的组件，并使用 @Component 注解进行标记。在该组件中，我们定义了一个私有的 myBean 字段，并通过构造函数注入了一个 MyBean 类型的 bean。由于使用了 @Autowired 注解，Spring 容器会自动将之前注册的 myBean bean 注入到这个组件中。
5.2 @Component
@Component 是 Spring 框架中的一个常用注解，用于将一个类标记为 Spring 容器管理的组件。当 Spring 容器启动时，会自动扫描带有 @Component 注解的类，并将其注册为 Spring 容器中的 bean。
使用 @Component 注解的类可以被其他组件自动装配，也可以通过 @Autowired 注解注入到其他组件中。
下面是一个使用 @Component 的示例：
import org.springframework.stereotype.Component;
@Component
public class MyComponent {
public void doSomething() {
// 实现业务逻辑
}
}
在上面的示例中，我们定义了一个名为 MyComponent 的类，并使用 @Component 注解进行标记。这告诉 Spring 容器将该类作为一个组件进行管理，并注册为一个 bean。
然后，可以在其他组件中注入 MyComponent 的实例，例如：
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Component
public class SomeOtherComponent {
private final MyComponent myComponent;
@Autowired
public SomeOtherComponent(MyComponent myComponent) {
this.myComponent = myComponent;
}
}
在上面的示例中，我们定义了一个名为 SomeOtherComponent 的类，并使用 @Component 注解进行标记。在该类中，我们定义了一个私有的 myComponent 字段，并通过构造函数注入了一个 MyComponent 类型的 bean。由于使用了 @Autowired 注解，Spring 容器会自动将之前注册的 myComponent bean 注入到这个组件中。
5.3 @Service
@Service 是 Spring 框架中的一个注解，用于将一个类标记为 Spring 容器管理的服务层组件。@Service 注解与 @Component 注解类似，都是用于将类标记为 Spring 容器中的 bean，但 @Service 注解通常用于表示服务层组件，如业务逻辑层。
使用 @Service 注解的类将由 Spring 容器自动实例化，并注册为 bean，可以在应用程序中被其他组件注入和使用。
下面是一个使用 @Service 的示例：
import org.springframework.stereotype.Service;
@Service
public class MyService {
public void doSomething() {
// 实现业务逻辑
}
}
在上面的示例中，我们定义了一个名为 MyService 的类，并使用 @Service 注解进行标记。这告诉 Spring 容器将该类作为一个服务层组件进行管理，并注册为一个 bean。
然后，可以在其他组件中注入 MyService 的实例，例如：
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Component
public class SomeComponent {
private final MyService myService;
@Autowired
public SomeComponent(MyService myService) {
this.myService = myService;
}
}
在上面的示例中，我们定义了一个名为 SomeComponent 的类，并使用 @Component 注解进行标记。在该类中，我们定义了一个私有的 myService 字段，并通过构造函数注入了一个 MyService 类型的 bean。由于使用了 @Autowired 注解，Spring 容器会自动将之前注册的 myService bean 注入到这个组件中。
5.4 @Repository
@Repository 是 Spring 框架中的一个注解，用于将一个类标记为数据访问对象（DAO）层组件，通常用于操作数据库。与 @Component 和 @Service 类似，使用 @Repository 注解的类将被 Spring 容器自动管理并注册为 bean。
下面是一个使用 @Repository 的示例：
import org.springframework.stereotype.Repository;
@Repository
public class MyRepository {
public void save(Object entity) {
// 实现数据保存操作
}
public Object findById(Long id) {
// 实现根据ID查找数据操作
return null;
}
}
在上面的示例中，我们定义了一个名为 MyRepository 的类，并使用 @Repository 注解进行标记。这告诉 Spring 容器将该类作为一个数据访问对象组件进行管理，并注册为一个 bean。
然后，可以在其他组件中注入 MyRepository 的实例，例如：
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Component
public class SomeComponent {
private final MyRepository myRepository;
@Autowired
public SomeComponent(MyRepository myRepository) {
this.myRepository = myRepository;
}
}
在上面的示例中，我们定义了一个名为 SomeComponent 的类，并使用 @Component 注解进行标记。在该类中，我们定义了一个私有的 myRepository 字段，并通过构造函数注入了一个 MyRepository 类型的 bean。由于使用了 @Autowired 注解，Spring 容器会自动将之前注册的 myRepository bean 注入到这个组件中。
5.5 @Scope
@Scope 是 Spring 框架中的一个注解，用于指定 bean 的作用域。Spring 容器默认将 bean 实例化为单例（singleton），但在某些情况下，可能需要创建 bean 的原型（prototype）或请求（request）作用域的实例。
-
value
-
singleton 表示该bean是单例的。(默认)
-
prototype 表示该bean是多例的，即每次使用该bean时都会新建一个对象。
-
request 在一次http请求中，一个bean对应一个实例。
-
session 在一个httpSession中，一个bean对应一个实例。
-
-
proxyMode
-
DEFAULT 不使用代理。(默认)
-
NO 不使用代理，等价于DEFAULT。
-
INTERFACES 使用基于接口的代理(jdk dynamic proxy)。
-
TARGET_CLASS 使用基于类的代理(cglib)。
-
下面是一个使用 @Scope 的示例：
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
@Component
@Scope("prototype")
public class MyPrototypeBean {
public void doSomething() {
// 实现业务逻辑
}
}
在上面的示例中，我们定义了一个名为 MyPrototypeBean 的类，并使用 @Component 注解进行标记。我们还使用 @Scope("prototype") 注解指定了该 bean 的作用域为原型（prototype）。这意味着每次请求时都会创建一个新的 MyPrototypeBean 实例。
要使用 @Scope 注解，需要将 Spring 配置文件中的 @Component、@Service、@Repository 和 @Controller 等注解的类，并将其注册为 Spring 容器中的 bean。
5.6 @Autowired
@Autowired 是 Spring 框架中的一个注解，用于自动装配 bean。当 Spring 容器启动时，它会扫描带有 @Autowired 注解的字段、构造函数或方法，并自动注入相应的 bean。
使用 @Autowired 注解可以简化 bean 的装配过程，减少手动创建和注入依赖的代码量。
下面是一个使用 @Autowired 的示例：
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Component
public class SomeComponent {
private final MyService myService;
@Autowired
public SomeComponent(MyService myService) {
this.myService = myService;
}
}
在上面的示例中，我们定义了一个名为 SomeComponent 的类，并使用 @Component 注解进行标记。在该类中，我们定义了一个 myService 字段，并使用 @Autowired 注解在构造函数中自动注入了一个 MyService 类型的 bean。由于使用了 @Autowired 注解，Spring 容器会自动将匹配的 bean 注入到 myService 字段中。
要使用 @Autowired 注解，需要确保 Spring 容器已经启动并扫描到了带有 @Autowired 注解的类。可以通过在配置文件中添加
5.7 @Qualifier
@Qualifier 是 Spring 框架中的一个注解，用于解决自动装配时的歧义问题。当有多个相同类型的 bean 存在于 Spring 容器中时，Spring 默认会选择一个进行注入，这可能导致一些问题。@Qualifier 注解可以指定注入哪个具体的 bean。
使用 @Qualifier 注解的示例：
假设有两个相同类型的 DataSource bean，如下所示：
@Bean
public DataSource dataSource1() {
// 创建并返回第一个 DataSource bean
}
@Bean
public DataSource dataSource2() {
// 创建并返回第二个 DataSource bean
}
现在，我们需要将其中一个 DataSource bean 注入到一个组件中，但由于两个 bean 的类型相同，Spring 默认选择一个进行注入，这可能导致歧义。为了解决这个问题，我们可以在注入时使用 @Qualifier 注解来指定要注入的 bean：
@Autowired
@Qualifier("dataSource1")
private DataSource dataSource;
在上面的示例中，我们使用 @Autowired 注解来自动注入 DataSource bean，并通过 @Qualifier("dataSource1") 指定要注入的是名为 dataSource1 的 bean。这样，Spring 就会将正确的 DataSource bean 注入到该组件中。
6. 导入配置文件
6.1 @PropertySource
@PropertySource 是 Spring 框架中的一个注解，用于将外部属性文件加载到 Spring 容器中。通过使用 @PropertySource 注解，可以将外部的属性文件（如 .properties 文件）加载到 Spring 容器中，并使用这些属性值。
-
引入单个properties文件：
@PropertySource(value = {“classpath : xxxx/xxx.properties”})
-
引入多个properties文件：
@PropertySource(value = {“classpath : xxxx/xxx.properties”，“classpath : xxxx.properties”})
使用 @PropertySource 注解的示例：
假设我们有一个名为 application.properties 的属性文件，其中包含了一些属性值，如下所示：
# application.properties
app.name=My App
app.version=1.0
现在，我们希望将这些属性值加载到 Spring 容器中，并在其他组件中使用它们。为此，我们可以使用 @PropertySource 注解来加载属性文件，如下所示：
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
@Configuration
@PropertySource("classpath:application.properties")
public class AppConfig {
// 配置类中的其他组件和属性
}
在上面的示例中，我们使用了 @Configuration 注解来定义一个配置类，并使用 @PropertySource 注解来加载名为 application.properties 的属性文件。该属性文件将被加载到 Spring 容器中，并可以通过 Spring 的自动装配功能注入到其他组件中。
在配置类中，我们可以定义其他组件和属性，并使用 @Value 注解来注入属性值。例如：
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
@Configuration
@PropertySource("classpath:application.properties")
public class AppConfig {
@Value("${app.name}")
private String appName;
@Value("${app.version}")
private String appVersion;
@Bean
public MyComponent myComponent() {
MyComponent component = new MyComponent();
component.setName(appName);
component.setVersion(appVersion);
return component;
}
}
在上面的示例中，我们使用了 @Value 注解来注入属性值，并使用这些属性值初始化了一个名为 myComponent 的组件。这样，我们就可以在其他组件中使用这些属性值了。
6.2 @ImportResource
@ImportResource 是 Spring 框架中的一个注解，用于导入 Spring 配置文件。它允许你将一个或多个 Spring 配置文件的内容导入到当前的应用程序上下文中。导入xml配置文件，可以额外分为两种模式：相对路径classpath、绝对路径（真实路径）file
注意：单文件可以不写value或locations，value和locations都可用相对路径（classpath）
-
引入单个xml配置文件：@ImportSource(“classpath : xxx/xxxx.xml”)
-
引入多个xml配置文件：@ImportSource(locations={“classpath : xxxx.xml” , “classpath : yyyy.xml”})
-
绝对路径（file）
-
引入单个xml配置文件：@ImportSource(locations= {“file : d:/hellxz/dubbo.xml”})
-
引入多个xml配置文件：@ImportSource(locations= {“file : d:/hellxz/application.xml” , “file : d:/hellxz/dubbo.xml”})
-
使用 @ImportResource 注解的示例：
假设你有一个名为 applicationContext.xml 的 Spring 配置文件，其中定义了一些 bean 和其他配置信息。你可以使用 @ImportResource 注解将该文件导入到当前的应用程序上下文中。
@Configuration
@ImportResource("applicationContext.xml")
public class AppConfig {
// 配置类中的其他代码
}
在上面的示例中，@ImportResource("applicationContext.xml") 将 applicationContext.xml 文件中的内容导入到当前的应用程序上下文中。这样，你就可以在当前的应用程序中使用 applicationContext.xml 文件中定义的 bean 和其他配置信息。
注意，如果你使用了 @ComponentScan 注解来扫描组件，那么在 @ImportResource 中可以省略配置文件的路径。Spring 会自动查找并导入与当前包路径相关的配置文件。
例如，如果你的应用程序在 com.example.app 包下，并且你已经在配置类中使用了 @ComponentScan("com.example.app")，那么你可以直接使用 @ImportResource 注解导入名为 applicationContext.xml 的配置文件，而不需要指定路径。
@Configuration
@ComponentScan("com.example.app")
@ImportResource("applicationContext.xml")
public class AppConfig {
// 配置类中的其他代码
}
6.3 @Import
@Import 是 Spring 框架中的一个注解，用于将一个类导入到 Spring 容器中，作为 Spring 容器中的 bean。通常用于导入其他配置类或组件。
使用 @Import 注解的示例：
假设我们有一个名为 OtherConfiguration 的类，其中定义了一些其他的 bean 配置：
@Configuration
public class OtherConfiguration {
@Bean
public SomeBean someBean() {
// 创建并返回 SomeBean bean
}
}
现在，我们希望将 OtherConfiguration 类中的配置导入到当前的 Spring 容器中。为此，我们可以在当前配置类中添加 @Import 注解，如下所示：
@Configuration
@Import(OtherConfiguration.class)
public class MainConfiguration {
// 当前配置类的其他 bean 定义
}
在上面的示例中，我们使用 @Import 注解将 OtherConfiguration 类导入到当前的 MainConfiguration 类中。这样，OtherConfiguration 类中定义的 someBean() 方法将作为 Spring 容器中的一个 bean 进行管理。