SpringBoot中的一些常用注解（总结篇）_springboot启动类上的注解

SpringBoot中有哪些常用注解？

Spring Boot中有很多常用注解，以下是一些常见的注解：

1. @SpringBootApplication：这个注解标记了一个类作为Spring Boot应用程序的入口点。并且这是一个复合注解，包含了 @Configuration、@EnableAutoConfiguration 和 @ComponentScan 三个注解。使用此注解可以标识一个主类，并且会自动配置 Spring Boot 应用程序。
2. @RestController：这个注解表示一个类是Spring MVC控制器，同时它还将所有处理方法都视为返回 JSON 格式数据。
3. @RequestMapping：这个注解用于映射Web请求到相应的处理程序方法，可以用来指定HTTP请求的URL路径和HTTP请求方法。
4. @RequestBody：用于接收HTTP请求体中的数据，并将其转换成Java对象。
5. @ResponseBody：用于将Java对象转换成HTTP响应体中的数据。
6. @Autowired：这个注解是自动装配的核心注解之一，它可以在需要使用某个Bean时，通过类型或名称进行自动装配。它可用于构造器、属性和方法上，通过类型匹配实现依赖注入。
7. @Controller：表示该类是一个控制器，在 Spring MVC 中使用。
8. @Service：这个注解表示一个类是服务层组件，通常用于标注业务逻辑相关的类。
9. @Repository：这个注解表示一个类是数据访问层组件，通常用于标注 DAO 层的类。
10. @Component：这个注解表示一个类是通用组件。表示将该类声明为一个 Bean 并交给 Spring 容器管理。
11. @Value：这个注解用于注入属性值，可以自动从 application.properties 或 application.yml 文件中读取属性值。
12. @Transactional：这个注解用于实现声明式事务管理，可以将一个方法设置成一个事务。
13. @Configuration：用于标识一个类为配置类，通常与@Bean一起使用，提供了一种Java方式的Bean定义替代XML配置文件。
14. @Import：用于导入一个或多个配置类，从而将其注册到Spring容器中。
15. @PropertySource：用于指定属性文件的位置，使得应用程序可以加载和使用该文件中定义的属性值。
16. @SpringBootConfiguration：表示这是一个配置类，用于配置Spring应用程序上下文。
17. @ComponentScan：用于自动扫描指定包及其子包中的组件，并将其注册为Bean。
18. @EnableAutoConfiguration：表示开启 Spring Boot 的自动配置功能。
19. @AutoConfigurationPackage：该注解会根据@SpringBootApplication所在的包设置自动配置包路径，使得Spring Boot能够自动扫描到应用程序下所有的Spring组件。
20. @Conditional ：该注解用于控制 Spring Bean 的创建条件，只有满足指定条件时才会创建对应的 Bean。
21. @AutoConfigureAfter ：该注解用于指定当前自动配置类需要在指定的其他自动配置类之后执行。
22. @AutoConfigureBefore ：该注解用于指定当前自动配置类需要在指定的其他自动配置类之前执行。
23. @AutoConfigureOrder：该注解用于控制自动配置类的执行顺序，值越小的自动配置类越先执行。
24. @ImportResource： 该注解用于将一个或多个传统的 XML 配置文件加载到 Spring Boot 应用中。
25. @ConfigurationProperties：这个注解用于将 application.properties 或 application.yml 文件中的属性值注入到一个Java Bean 中。
26. @Profile：表示当前环境的配置信息，在不同的环境下可以使用不同的配置。

01、底层注解-@SpringBootApplication详解

@SpringBootApplication 是一个复合注解，包含了三个注解的功能：@Configuration、@EnableAutoConfiguration 和 @ComponentScan。

1. @Configuration：声明当前类为 Spring 配置类。
   • 表明该类是一个配置类，可以将其作为 Spring IoC 容器中的一个 Bean 进行管理。通常我们会在该类中通过 @Bean 注解来声明一些配置项或者第三方库的 Bean。
   • 标识该类为 Spring 配置类，它的作用相当于传统 Spring 中的 XML 配置文件。在该类中可以定义一些 Bean，并将其交给 Spring 管理。
2. @EnableAutoConfiguration：自动配置 Spring 应用程序所需的 Bean。
   • 根据应用程序的依赖添加适当的 Bean，并根据类路径中存在的其他Bean、类和各种属性设置对 Spring Boot 应用程序进行自动配置。该注解利用 Spring Boot 的约定大于配置，避免了手动配置大量的 Bean。
   • @EnableAutoConfiguration：Spring Boot 提供了自动配置机制，会根据项目中引入的依赖和配置优先级规则，自动配置应用程序所需的 Bean。@EnableAutoConfiguration 注解就是开启自动配置的功能。
3. @ComponentScan：自动扫描指定 package 下的所有组件，并注册到 Spring 容器中。
   • 扫描当前工程下的所有标有 @Component、@Service、@Repository、@Controller 等注解的类，将它们注册到 Spring IoC 容器中。
   • 扫描指定的 package 下的所有组件并注册到 Spring 容器中。默认情况下，Spring Boot 建议在主应用程序类上面添加该注解。如果没有指定扫描路径，则默认扫描当前类所在的 package 及其子 package。

• 综上所述，@SpringBootApplication 注解是 Spring Boot 应用程序的入口点，在使用时无需再添加其他额外的注解。
• 因此，使用 @SpringBootApplication 可以简化 Spring Boot 应用的配置过程，同时也能够提高应用开发效率。

下面以一个示例来说明 @SpringBootApplication 的用法：

javaCopy Code@SpringBootApplication
    public class Application {

        public static void main(String[] args) {
            SpringApplication.run(Application.class, args);
        }
    }
1
2
3
4
5
6
7

在上述代码中，我们通过 @SpringBootApplication 注解将 Application 类声明为一个 Spring Boot 应用程序的入口点。当然，它还需要一个 main 方法，通过调用 SpringApplication.run() 方法启动 Spring Boot 应用程序。在这里，我们没有任何其他的配置项，因为 @SpringBootApplication 已经帮我们完成了自动配置和自动扫描的工作。实际上，我们可以在应用程序中添加更多的注解和配置项，例如数据库连接、模板引擎等等，这些都会被自动配置和管理。

总之，@SpringBootApplication 是一个非常有用的注解，它能够帮助我们快速构建 Spring Boot 应用程序并简化配置过程。

02、底层注解-@RestController详解

在SpringBoot中，@RestController注解与在Spring MVC中的作用类似，都是用于定义RESTful风格的控制器。但是，相比于原始的Spring MVC，SpringBoot对@RestController注解进行了一些改进，使得开发RESTful Web服务更加简单和高效。

@RestController注解是@Controller和@ResponseBody注解的组合，用于标识一个控制器类。使用这个注解可以直接返回JSON格式的数据。

具体来说，SpringBoot中的@RestController注解：

1. 组合了@EnableWebMvc注解，并自动配置了一系列默认的MVC组件（如HandlerMapping、ContentNegotiationManager等）。

2. 自动使用Jackson库将Java对象转换为JSON或XML格式的数据，无需进行额外的配置。

3. 可以使用基于注解的方式处理HTTP请求，而无需显式地定义@RequestMapping注解。

4. 集成了SpringBoot Actuator组件，可以通过HTTP接口获取应用程序的运行状态信息（如健康状况、指标、日志等）。

因此，在SpringBoot中，使用@RestController注解可以大幅简化RESTful Web服务的开发和部署流程，而且提供了许多便利的功能和特性。

---

在Spring Boot中，@RestController是一个特殊的@Controller注解，它将类标记为控制器，并告诉Spring框架该类中的所有方法都应该返回RESTful风格的数据。

与@Controller不同的是，@RestController默认情况下会将方法返回的对象自动序列化为JSON格式的数据，并将其作为HTTP响应体返回给客户端。这意味着您无需手动编写代码来实现数据序列化和反序列化。同时，@RestController还可以将请求参数绑定到方法参数上，使开发人员更加方便地处理输入参数。

另外，@RestController还可以与其他Spring Boot注解一起使用，例如@RequestMapping、@GetMapping、@PostMapping等。这些注解可用于定义该控制器中的具体Web API操作，并指定相应的HTTP请求方法和请求路径。

总之，@RestController是Spring Boot中非常重要的注解，它简化了实现RESTful Web服务的过程，提高了开发效率，并使得我们可以更加专注于业务逻辑的实现。

举一个简单的例子:

假设我们正在开发一个在线商店，我们需要实现一个API接口来获取所有商品列表。我们可以使用Spring Boot的@RestController注解来实现这个API接口。

首先，在我们的控制器类上添加@RestController注解：

@RestController
public class ProductController {
    // Controller methods will go here
}
1
2
3
4

然后，在该类中定义一个方法来处理请求并返回所有商品列表。为此，我们可以使用@GetMapping注解指定HTTP GET请求的路径：

@RestController
public class ProductController {

    @GetMapping("/products")
    public List<Product> getAllProducts() {
        // Code to retrieve all products from database goes here
        return productList;
    }
}
1
2
3
4
5
6
7
8
9

在上面的代码中，我们使用@GetMapping注解来定义了一个处理GET请求的方法，该方法返回一个Product对象列表。注意，由于我们在控制器类上使用了@RestController注解，因此无需手动将返回值转换为JSON格式，Spring Boot会自动完成这个工作。

最后，当客户端发送HTTP GET请求到==/products路径==时，Spring Boot将会调用getAllProducts()方法并将其返回结果序列化为JSON格式的数据，然后将其作为HTTP响应体返回给客户端。

03、底层注解-@RequestMapping详解

在Spring Boot中，@RequestMapping是非常重要的注解之一，它可以与控制器类或方法一起使用，用于映射HTTP请求到处理程序方法上。具体来说，@RequestMapping是一个通用注解，可用于映射任何类型的请求，包括GET、POST、PUT、DELETE等。

@RequestMapping是一个用于将HTTP请求映射到控制器方法的注释。它可以应用于控制器类和单个方法上。如果你把这个注解放到类级别上，那么这个类下面所有的方法都会遵循这个URL规则，如果你在方法上定义了一个@RequestMapping，那么这个方法的URL就会建立在类级别映射上。例如：

@RestController
@RequestMapping("/api")
public class MyController {

    @RequestMapping(value = "/hello", method = RequestMethod.GET)
    public String sayHello() {
        return "Hello World!";
    }
}
1
2
3
4
5
6
7
8
9

在这个例子中，我们声明了一个控制器类MyController，该类上使用了@RequestMapping注解并指定了**“/api"作为基本URL路径。在sayHello()方法上，我们再次使用@RequestMapping注解，并指定了”/hello"**作为该方法的URL路径，以及GET作为HTTP请求方法。此时，发送GET请求"http://localhost:8080/api/hello"，就可以得到响应==“Hello World!”==。

除了value和method属性外，@RequestMapping还有其他属性，如params和headers，它们可以帮助我们进一步指定处理请求的条件。例如，我们可以使用params属性来指定必须满足的请求参数：

@RequestMapping(value = "/hello", method = RequestMethod.GET, params = "name")
public String sayHello(@RequestParam("name") String name) {
    return "Hello " + name + "!";
}
1
2
3
4

此时，发送GET请求"http://localhost:8080/api/hello?name=John"，就可以得到响应"Hello John!"。

总之，@RequestMapping是Spring Boot中非常重要的注解之一，它可以帮助我们将HTTP请求映射到控制器方法上，并指定处理请求的条件。

扩展注解

在Spring Boot中，@GetMapping、@PostMapping、@PutMapping、@DeleteMapping注解都是Spring MVC中的扩展注解。它们是对@RequestMapping注解的进一步封装和简化，使得使用者可以更加方便地定义RESTful API。

@SpringBootComponentScan注解则是Spring Boot自己提供的注解，用于自动扫描并注册指定包及其子包中的组件（如@Controller, @Service, @Repository等），并生成Bean。

此外，Spring Boot还提供了许多其他的扩展注解，如@Configuration、@Bean、@Autowired等，这些注解使得我们能够更加便捷地配置和管理Spring应用程序中的各个组件与依赖关系。

• @GetMapping：表示 HTTP GET 请求 URL 映射。

• @PostMapping：表示 HTTP POST 请求 URL 映射。

• @PutMapping：表示 HTTP PUT 请求 URL 映射。

• @DeleteMapping：表示 HTTP DELETE 请求 URL 映射。

@GetMapping详解

@GetMapping是Spring Boot中的注解之一，用于将HTTP GET请求映射到指定的处理程序方法上。通过使用该注解，我们可以将一个GET请求映射到一个Controller中的处理程序方法上。

例如，在一个Controller类中定义以下方法：

@RestController
@RequestMapping("/api")
public class MyController {

    @GetMapping("/hello")
    public String sayHello() {
        return "Hello, World!";
    }
}
1
2
3
4
5
6
7
8
9

这里我们使用@RestController注解来表示这个类是一个RESTful风格的Controller，并且使用@RequestMapping注解来指定该Controller处理的请求路径为“/api”。在这个Controller中，我们定义了一个@GetMapping注解的方法，它将会处理访问路径为“/api/hello”的GET请求，并返回“Hello, World!”字符串。

使用@GetMapping注解可以让我们非常方便地将一个HTTP GET请求映射到一个处理程序方法上，同时也可以使代码更加可读和易于维护。

@PostMapping详解

在 Spring Boot 中，@PostMapping 是一个注解，用于将 HTTP POST 请求映射到处理程序方法上。该注解可以应用于类级别和方法级别。

在方法级别，@PostMapping 注解指定了处理程序方法要处理的请求路径。这个路径可以是绝对路径或相对路径，但通常是相对于应用程序的根路径。

例如，如果您在控制器类中使用 @PostMapping("/submit") 注解，则表示该控制器将处理所有通过 HTTP POST 方法发送到 “/submit” 路径的请求。

此外，@PostMapping 还允许您使用 RequestBody 注解将 HTTP 请求正文转换为 Java 对象，并将其作为参数传递给处理程序方法。这很有用，因为它允许您轻松地从表单提交或 AJAX 请求中提取数据。

例如：

@PostMapping("/users")
public void createUser(@RequestBody User user) {
    // 处理创建用户的逻辑
}
1
2
3
4

在这个例子中，当客户端通过 HTTP POST 请求提交 JSON 或 XML 格式的用户数据时，Spring Boot 将自动将请求正文转换为 User 对象，并将其传递给 createUser() 方法。

总之，@PostMapping 注解使得编写处理 HTTP POST 请求的处理程序方法变得非常简单，同时也提高了代码的可读性和可维护性。

@PutMapping详解

在Spring Boot中，@PutMapping是用于处理HTTP PUT请求的注释之一。

PUT请求用于更新或替换目标资源的全部内容。与@PatchMapping不同，@PutMapping要求客户端提供完整的更新信息，而不是仅提供需要更改的部分。

@PutMapping注释可以附加到类或方法上。如果将其附加到类上，则指定该类所有处理程序方法的基本URI。如果将其附加到方法上，则指定该方法的特定URI，并覆盖类级别的任何URI。

例如，以下示例使用@PutMapping将更新一个名为"product"的产品：

@RestController
@RequestMapping("/products")
public class ProductController {

    @PutMapping("/{id}")
    public ResponseEntity<Product> updateProduct(@PathVariable Long id, @RequestBody Product product) {
        // code to update the product
    }
}
1
2
3
4
5
6
7
8
9

在这个例子中，@PutMapping注解指定了URI “/products/{id}”，表示此方法用于处理PUT请求，其中{id}是动态的路径变量，可以在调用方法时进行传递和访问。方法签名中的@PathVariable注解表示将此变量绑定到方法参数中，从而使您可以在方法内部访问该值。

此外，@RequestBody注解表示将请求正文作为Java对象反序列化，并将其绑定到方法参数中。在这种情况下，请求正文应该包含一个JSON对象，其中包括有关产品的所有信息。

最后，方法返回类型为ResponseEntity，这意味着您可以返回一个HTTP响应，其中包含新的或更新的产品。在这种情况下，我们使用ResponseEntity封装Product对象，并设置HTTP状态代码为200 OK。

@DeleteMapping详解

在 Spring Boot 中， @DeleteMapping 是一个注解，用于处理 HTTP DELETE 请求。它是 Spring Web 应用程序中的一种 HTTP 方法映射注解之一。

使用 @DeleteMapping 注解标记的方法将会处理 HTTP DELETE 请求，并能够响应来自客户端的请求。与其他 Spring MVC 注解类似，@DeleteMapping 注解可以添加到控制器类或者具体的请求处理方法上。

通常情况下，@DeleteMapping 注解需要指定一个 URL 路径作为参数，用于指示要处理请求的路径。例如：

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

    @DeleteMapping("/{id}")
    public void deleteUser(@PathVariable Long id) {
        // 删除用户逻辑实现
    }
}
1
2
3
4
5
6
7
8
9

在上面的示例中，@DeleteMapping 注解被用于 UserController 类中的 deleteUser() 方法上。该方法允许根据指定的 ID 删除一个用户，并且使用@PathVariale 注解从 URL 中提取 id 参数。

总之，@DeleteMapping 注解提供了一种简单方便的方式，用于指定如何处理 HTTP Delete请求，并且可以帮助你快速构建强大、灵活的Spring Boot Web 应用程序。

04、底层注解-@RequestBody详解

在Spring Boot中，@RequestBody注解用于绑定HTTP请求体的内容到Controller方法的参数上。当请求的Content-Type为application/json或其他支持消息转换器的格式时，Spring会自动将HTTP请求体中的JSON数据转化为Java对象，并将其绑定到使用@RequestBody注解的方法参数上。

例如：

@PostMapping("/users")
public ResponseEntity<User> createUser(@RequestBody User user) {
    // 保存用户信息
    userService.save(user);
    return new ResponseEntity<>(user, HttpStatus.CREATED);
}
1
2
3
4
5
6

在上述代码中，@RequestBody注解表示将HTTP请求体中的JSON数据转为User对象，然后将其作为参数传递给createUser方法。

需要注意的是，使用@RequestBody注解需要开启消息转换器（MessageConverter），否则会导致无法解析请求体中的内容。此外，如果请求体中的JSON数据类型与Java对象不匹配，则会抛出反序列化异常。因此，在使用@RequestBody注解时，需要确保请求体中的JSON数据与Java对象的属性名以及类型都能正确匹配。

05、底层注解-@ResponseBody详解

在 Spring Boot 中，@ResponseBody 注解用于将返回值直接写入 HTTP 响应正文中，而不是将返回值渲染到视图模板中。使用 @ResponseBody 注解可以使控制器方法返回的数据变成 HTTP 响应体的一部分，通常以 JSON 或 XML 格式呈现给客户端。

举个例子，假设我们有一个返回 JSON 数据的控制器方法：

@GetMapping("/users")
@ResponseBody
public List<User> getAllUsers() {
    List<User> users = userService.getAllUsers();
    return users;
}
1
2
3
4
5
6

在这个例子中，@GetMapping 注解表示这是一个处理 GET 请求的控制器方法，@ResponseBody 注解表示该方法返回的对象会被直接写入 HTTP 响应正文中，而不是经过渲染后输出到视图页面。当客户端发送请求时，该控制器方法返回的 User 对象集合将以 JSON 格式返回给客户端。

使用 @ResponseBody 注解非常方便，因为它可以自动将返回值序列化为所需的格式（例如 JSON 或 XML），并将其直接写入响应正文中。这样可以大大简化代码编写过程，同时也可以提高应用程序的性能和可读性。

06、底层注解-@Autowired详解

在SpringBoot中，@Autowired是一个用于自动装配bean的注解。它可以被应用于构造函数、setter方法、以及直接应用于类字段上。

使用@Autowired标记的字段、构造函数或者setter方法会由Spring容器自动注入相应的bean实例。Spring容器会根据被注入对象的类型，在IOC容器中查找匹配的bean进行注入。

如果有多个bean满足要求，则可以使用@Qualifier注解进一步指定需要注入的bean的名称。例如：

@Autowired
@Qualifier("myBean")
private MyBean myBean;
1
2
3

此外，还可以使用@Primary注解指定默认注入的bean。例如：

@Component
@Primary
public class PrimaryBean implements MyBean {
    ...
}
1
2
3
4
5

当我们在另一个类中使用@Autowired注入MyBean时，如果没有使用@Qualifier指定具体的bean名称，则默认会注入PrimaryBean实例。

总之，@Autowired是SpringBoot中非常常用的注解之一，通过它我们可以很方便地实现bean之间的依赖注入，减少手动配置的工作量，提高代码的可读性和可维护性。

07、底层注解-@Controller详解

在Spring Boot中，@Controller是用来定义一个控制器(Controller)的注解。通过使用@Controller注解标记一个类，该类就可以被Spring框架扫描到，并且将其作为一个控制器来使用。

具体来说，@Controller注解的作用是：

1. 将该类声明为一个控制器。
2. 告诉Spring框架该类中的方法可以响应HTTP请求。
3. 将响应结果返回给客户端。

另外，需要注意的是，@Controller注解通常与@RequestMapping注解一起使用。@RequestMapping注解用于将HTTP请求映射到相应的控制器方法上，从而让Spring框架知道如何调用这些方法来处理请求。例如：

@Controller
@RequestMapping("/hello")
public class HelloController {
    @RequestMapping("/")
    public String hello() {
        return "Hello, World!";
    }
}
1
2
3
4
5
6
7
8

在上面的代码中，@Controller注解用于声明HelloController这个类是一个控制器。@RequestMapping注解用于将/hello路径映射到该控制器下的hello()方法上，当用户访问/hello路径时，就会调用该方法并返回"Hello, World!"字符串作为响应结果。

08、底层注解-@Service详解

在Spring Boot中，@Service是一种用于注释服务类的注释类型。通过将@Service注释添加到类定义中，Spring Boot将自动检测该类并将其实例化为bean。

@Service注释通常与依赖注入（DI）机制一起使用，因为它告诉Spring Boot框架这个类需要被管理和实例化成一个单例的bean，并且将其注册到应用程序上下文中。这样，在整个应用程序生命周期中，您就可以使用@Autowired或@Inject等注入机制来引用这个bean。

与@Component、@Repository和@Controller不同，@Service注释的作用是用于业务逻辑层的组件定义，表明该类是一个服务类，主要处理业务逻辑，并且通常会调用DAO（数据访问对象）或其他服务类来完成具体的任务。

因此，@Service注释通常用于需要进行业务处理的类，例如用户管理、订单管理、邮件发送等服务类。通过使用@Service注释，可以更好地分离应用程序中的关注点，提高代码的可读性和维护性。

---

• 在SpringBoot中，@Service是一种特殊的注解，它用于将一个类标识为服务层组件。通常情况下，在应用程序中，服务层组件用于封装业务逻辑和数据处理操作。
• 使用@Service注解标注的类会被Spring容器所管理，这样可以方便地在其他组件中使用该服务层组件，例如控制器、仓库层组件等等。
• @Service注解通常与@Autowired注解一起使用，以便在需要使用服务层组件时，能够自动从Spring容器中获取该组件的实例，并进行调用。

总的来说，@Service注解的作用就是告诉Spring容器，将被标记的类作为一个服务层组件来管理，并在需要时提供给其他组件使用。

---

==在Spring Boot中，@Service是一种特殊的注解，用于标记服务层的组件。==具体而言，@Service注解通常用于定义业务逻辑层的类，在该类中包含了与数据访问层（DAO）交互的方法，以实现应用程序的业务逻辑。

例如，假设我们有一个名为UserService的服务类，用于处理用户相关的业务逻辑。我们可以使用@Service注解来标记该类，如下所示:

@Service
public class UserService {

    @Autowired
    private UserDao userDao;

    public List<User> findAllUsers() {
        return userDao.findAll();
    }

    public User findUserById(Long id) {
        return userDao.findById(id);
    }

    public void saveUser(User user) {
        userDao.save(user);
    }

    public void deleteUser(Long id) {
        userDao.deleteById(id);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

在以上示例中，UserService类被标记为@Service，并注入了一个名为userDao的UserDao对象。同时，该类包含了findAllUsers、findUserById、saveUser和deleteUser等几个方法，这些方法用于操作用户数据。

通过将@Service注解添加到UserService类上，Spring Boot会自动将其识别为服务层组件，并将其纳入Spring容器的管理范围内，从而使得其他组件可以方便地使用该服务。

09、底层注解-@Repository详解

在Spring Boot中，@Repository 是一个用于定义数据访问对象的注解。该注解通常应该被用于 DAO（数据访问对象）层中，以表明这个类是用于数据库交互的。使用@Repository注解的类将自动被Spring扫描到并注入到相应的控制器或服务中。

@Repository 注解实际上是 Spring 框架中的一种特殊的@Component 注解。它允许 Spring 自动识别这个类作为数据访问对象，并且可以通过 Spring 的依赖注入来注入其它需要使用该对象的组件，如 Service 层和 Controller 层等。

在使用 @Repository 注解的时候，需要确保该注解只标记了数据访问对象（DAO）层的类，而不是其它类型的组件。同时，也需要确保 DAO 层的接口和实现类都被正确地注解，以便 Spring 能够正确地扫描和注入它们。

总体来说，@Repository 注解的存在使得我们在开发过程中更加方便地使用 Spring 进行数据持久化操作。

---

在Spring Boot中，@Repository是一种注解，用于指示一个类表示数据访问层（DAO）。当我们使用@Repository注解来标记一个类时，Spring Boot会将该类识别为数据访问对象，并将其自动注册到应用程序上下文中。

例如，当我们需要从数据库中读取数据时，我们可以编写一个带有@Repository注解的类，这个类可以使用JPA或Hibernate等框架来与数据库进行交互。下面是一个使用@Repository注解的简单示例：

import org.springframework.stereotype.Repository;

@Repository
public class UserRepository {
    // 数据库操作代码
}
1
2
3
4
5
6

在这个例子中，我们使用了@Repository注解将UserRepository类标记为一个数据访问对象。之后，我们可以在代码的其他部分使用UserRepository类来执行数据库操作，如下所示：

@Autowired
private UserRepository userRepository;

public void someMethod() {
    // 使用userRepository执行数据库操作
}
1
2
3
4
5
6

通过使用@Repository注解，我们可以轻松地创建和管理数据访问对象，并将它们集成到我们的Spring Boot应用程序中。

10、底层注解-@Component详解

在Spring Boot中，@Component是一个基本的注解，用于标记一个类作为组件。这个注解表明了一个类将会被自动扫描并注册到应用上下文中，可以使用@Autowired或者@Resource等注解将其注入到其他需要引用该组件的类中。

@Component注解实际上是一个通用的Spring注解，它与Spring Boot应用程序一起使用。除此之外，还有一些其他的注解，如@Repository、@Service、@Controller等，它们都是@Component的派生注解，提供了更具体的语义来描述不同类型的组件。

在Spring Boot中，@Component注解可以和其他注解一起使用，如@Configuration、@Autowired、@Value等，使得这些注解也可以应用到被标记为组件的类上。例如，在@Configuration注解的类中，我们可以使用@ComponentScan注解来扫描特定的包或类路径，以自动注册所有标记为@Component的类。同时，在@Autowired注解的字段或setter方法中，我们也可以使用@Qualifier来选择要注入的具体组件，从而更精确地控制依赖注入的行为。

总之，@Component注解是Spring Boot中最基础的组件注解之一，它可以帮助我们定义和管理应用程序中的各种组件，并且还可以和其他注解一起使用，来实现更加灵活和高效的组件化开发。

---

==这里举一个例子。==假设我们正在编写一个简单的电商网站应用程序，其中需要使用到购物车功能。为了实现购物车的功能，我们可以创建一个名为"ShoppingCart"的组件，并在该类上添加@Component注解。具体代码如下：

@Component
public class ShoppingCart {

    private Map<String, Integer> cartItems = new HashMap<>();

    public void addItem(String productId, int quantity) {
        Integer existingQuantity = cartItems.get(productId);
        if (existingQuantity != null) {
            quantity += existingQuantity;
        }
        cartItems.put(productId, quantity);
    }

    public Map<String, Integer> getItems() {
        return Collections.unmodifiableMap(cartItems);
    }

    public void clear() {
        cartItems.clear();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

在上述代码中，我们定义了一个名为ShoppingCart的类，并将其标记为一个Spring组件，以便能够在应用程序中进行自动扫描和注册。该类包含了一些购物车功能的方法，如addItem()、getItems()和clear()等，可以让用户向购物车中添加或删除商品，并查询当前购物车中的商品列表。

通过使用@Component注解，我们可以保证在Spring Boot应用程序启动时，该类会被正确地自动扫描并注册到应用程序上下文中。然后，在其他需要引用购物车功能的类中，我们可以使用@Autowired注解来将ShoppingCart组件自动注入进去，从而完成依赖注入和组件化开发的过程。

11、底层注解-@Value详解

在Spring Boot中，@Value注解用于将属性值从应用程序的属性文件或环境变量注入到Spring Bean中。这个注解可以用来注入简单的值类型，例如String、int、double等等，也可以用来注入复杂的对象类型。

通常情况下，我们会将应用程序的配置信息存储在属性文件中，例如application.properties或application.yml。通过使用@Value注解，我们可以轻松地将这些配置值注入到我们的Spring Bean中。例如：

@Component
public class MyComponent {

    @Value("${my.property}")
    private String myProperty;
    
    // ...
}
1
2
3
4
5
6
7
8

在上面的示例中，@Value注解将名为**"my.property"的属性值从属性文件中注入到了myProperty**字段中。在默认情况下，Spring Boot会自动加载application.properties文件并读取其中的属性值。如果您想要更改默认的属性文件名，可以在Spring Boot的配置文件（通常是application.yml或application.properties）中设置spring.config.name属性。

除了从属性文件中注入值之外，@Value注解还可以从环境变量中注入值。例如：

@Component
public class MyComponent {

    @Value("${MY_ENV_VAR}")
    private String myEnvVar;

    // ...
}
1
2
3
4
5
6
7
8

在上面的示例中，@Value注解将名为**"MY_ENV_VAR"的环境变量值注入到了myEnvVar**字段中。

总结一下，@Value注解是一个非常方便的工具，可以轻松地将配置信息注入到Spring Bean中，从而使我们的应用程序更加灵活和可配置。

12、底层注解-@Transactional详解

在Spring Boot中，@Transactional注解用于开启事务处理。使用该注解可以确保在执行一系列相关的操作时，要么所有的操作都被成功执行并提交到数据库，要么所有的操作都被撤销。

具体来说，@Transactional注解可以作用于方法和类上。当注解作用于方法上时，它表示该方法是一个事务性方法，也就是说，在该方法内部执行的所有操作都将被包含在同一个事务中，并且如果该方法执行过程中发生了异常，那么该方法所做的所有操作都将被撤销。

当注解作用于类上时，它表示该类中的所有方法都将被视为事务性方法，也就是说，在该类中执行的所有操作都将被包含在同一个事务中。这种情况下，@Transactional注解还可以用于设置事务的隔离级别、超时时间等属性。

需要注意的是，@Transactional注解只能作用于公共方法，因为Spring AOP是基于代理模式实现的，而只有公共方法才可以被代理。

除了使用注解的方式应用事务，Spring Boot还提供了编程式事务管理的方式，开发者可以利用Spring的TransactionTemplate或者PlatformTransactionManager接口来手动管理事务。

---

第一个例子：

假设我们有一个简单的应用程序，如果您想要在一个事务中同时更新用户和余额信息，可以将更新用户和余额信息的这两个方法放在同一个方法中，并在该方法上添加 @Transactional 注解，以确保它们在同一个事务中执行，例如：

@Service
public class UserServiceAndBalanceService {
    @Autowired
    private UserRepository userRepository;

    @Autowired
    private BalanceRepository balanceRepository;

     // 注意：@Transactional注解只能作用于公共方法
    @Transactional
    public void updateUserAndBalance(Long userId, String newUserName, BigDecimal amount) {
        User user = userRepository.findById(userId);
        user.setName(newUserName);
        userRepository.save(user);

        Balance balance = balanceRepository.findByUserId(userId);
        balance.setAmount(balance.getAmount().add(amount));
        balanceRepository.save(balance);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

这样，在调用 updateUserAndBalance 方法时，会在一个事务中同时更新用户和余额信息。以确保更新用户信息和更新用户余额这两个操作都在同一个事务中进行。

如果在执行更新用户和余额信息这两个操作的过程中发生了异常，那么事务管理器会自动回滚所有已经执行的操作，以保证数据库的一致性。

---

第二个例子：

@Transactional 是 Spring Framework 提供的一个注解，用于对带有该注解的方法进行事务管理。在 Spring Boot 中，使用 @Transactional 注解可以将方法调用包装在事务中，以确保数据的一致性和完整性。

举个例子，假设我们有一个服务类 UserService，其中的某个方法需要更新数据库中的多个表格：

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;

    @Autowired
    private AddressRepository addressRepository;

    @Autowired
    private OrderRepository orderRepository;

     // 注意：@Transactional注解只能作用于公共方法
    @Transactional
    public void updateUser(Long userId, String newUserName, String newAddress, String newOrder) {
        User user = userRepository.findById(userId);
        user.setName(newUserName);
        userRepository.save(user);

        Address address = addressRepository.findByUserId(userId);
        address.setAddress(newAddress);
        addressRepository.save(address);

        Order order = orderRepository.findByUserId(userId);
        order.setOrder(newOrder);
        orderRepository.save(order);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

在上面的代码中，我们使用了 @Transactional 注解来标记 updateUser 方法，使其成为一个事务。这个事务会包含对三个不同表格的更新操作，如果其中任意一个操作失败，则整个事务都会回滚，使得所有表格的数据都不会被修改。

总之，通过使用 @Transactional 注解，Spring Boot 可以自动地管理事务的起始、提交和回滚等细节，从而大大简化了事务管理的工作。

13、底层注解-@Configuration详解

在Spring Boot中，@Configuration是一个注解，用于标识一个类是应用程序上下文的Java配置类。它告诉Spring容器这个类将包含一个或多个bean定义。

使用@Configuration注解的类可以使用@Bean注解来定义bean。@Bean告诉Spring容器，它所注释的方法将返回一个对象，该对象应该被注册为一个bean，并由Spring容器管理其生命周期。这个对象可以是任何Java对象。

@Configuration类通常包含多个@Bean方法，每个方法都定义了一个bean。Spring会自动检测@Configuration类中的所有@Bean方法，并将它们注册为bean定义。

除了@Bean方法之外，@Configuration还提供了其他一些有用的功能，例如：

• @Import：允许从另一个@Configuration类中导入bean定义。
• @PropertySource：指定配置文件的位置。
• @ComponentScan：自动扫描包以查找特定的组件（例如@Service和@Repository）并将它们注册为bean定义。

总之，@Configuration注解表明这个类声明了一个或多个bean，使得Spring容器可以获取和管理这些bean。

---

下面是一个简单的示例，说明在Spring Boot中如何使用@Configuration注释：

@Configuration   // 声明这个类为配置类
public class MyConfiguration {

    @Bean         // 定义一个bean
    public MyService myService() {
        return new MyServiceImpl();
    }

    @Bean         // 定义另一个bean，并注入上面定义的myService
    public MyController myController(MyService myService) {
        return new MyControllerImpl(myService);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

在这个例子中，@Configuration注解告诉Spring容器这个类是一个Java配置类。它包含两个@Bean方法，分别定义了MyService和MyController这两个bean。MyController需要依赖于MyService，因此在@Bean方法中将MyService作为参数传递到MyController的构造函数中。

通过这样的方式，Spring容器可以实例化MyService和MyController，并将它们注册为bean定义。其他组件可以使用@Autowired或@Inject注解来获取这些bean的实例并使用它们。

14、底层注解-@Import 导入组件

在SpringBoot中，@Import注解是用来引入其他Java配置类或者导入其他Bean定义的注解。通过@Import注解，我们可以将其他配置类或者组件添加到当前的配置类中，并使它们生效。

@Import注解有以下几种使用方式：

1. 导入配置类：可以通过@Import注解将其他的配置类导入进来，从而实现多个配置类合并成一个大的配置类，方便管理和维护。

2. 导入普通类：如果需要在当前配置类中使用某些工具类或者其他普通类，也可以使用@Import注解将这些类导入进来。

3. 导入Selector：使用@Import注解可以导入一个实现了ImportSelector接口的类，该接口允许在运行时动态地注册Bean定义。

4. 导入Registrar：使用@Import注解可以导入一个实现了ImportBeanDefinitionRegistrar接口的类，该接口允许在运行时动态地注册Bean定义，并设置Bean的属性。

总之，@Import注解是一个非常灵活且强大的注解，它可以实现复杂的配置和组件管理，并且能够在整个应用程序中起到关键的作用。

---

下面是一些@Import注解的使用示例：

1. 导入配置类

可以通过@Import注解导入其他的配置类，从而将它们合并到当前配置类中，例如：

@Configuration
@Import({DataSourceConfig.class, MyBatisConfig.class})
public class AppConfig {
    // 配置相关的Bean定义...
}
1
2
3
4
5

在上述的示例中，AppConfig配置类使用@Import注解导入了DataSourceConfig和MyBatisConfig两个配置类，从而将它们合并成一个大的配置类。

2. 导入普通类

除了导入其他配置类外，还可以通过@Import注解导入一些普通的Java类，例如：

@Configuration
@Import({MyUtils.class})
public class AppConfig {
    // 配置相关的Bean定义...
}
1
2
3
4
5

在上述的示例中，AppConfig配置类使用@Import注解导入了一个名为MyUtils的普通Java类，该类包含了一些工具方法，方便在配置类中使用。

3. 导入Selector

如果需要在运行时动态地注册Bean定义，可以通过@Import注解导入一个实现了ImportSelector接口的类，例如：

@Configuration
@Import({MySelector.class})
public class AppConfig {
    // 配置相关的Bean定义...
}
1
2
3
4
5

在上述的示例中，AppConfig配置类使用@Import注解导入了一个名为MySelector的实现了ImportSelector接口的类，该类允许在运行时动态地注册Bean定义。

4. 导入Registrar

如果需要在运行时动态地注册Bean定义，并设置一些属性，可以通过@Import注解导入一个实现了ImportBeanDefinitionRegistrar接口的类，例如：

@Configuration
@Import({MyRegistrar.class})
public class AppConfig {
    // 配置相关的Bean定义...
}
1
2
3
4
5

在上述的示例中，AppConfig配置类使用@Import注解导入了一个名为MyRegistrar的实现了ImportBeanDefinitionRegistrar接口的类，该类允许在运行时动态地注册Bean定义，并设置Bean的属性。

15、底层注解-@PropertySource详解

在SpringBoot中，@PropertySource注解用于指定外部属性文件的位置，可以通过该注解将属性文件加载到Spring环境中，从而使用@ConfigurationProperties注解来将属性文件中的值注入到Java Bean中。

具体来说，@PropertySource注解的作用如下：

1. 指定属性文件路径：@PropertySource注解可以用于指定一个或多个属性文件的路径信息。例如：

   @PropertySource("classpath:config.properties")
   1

   在这个例子中，我们指定了一个名为config.properties的属性文件，并且该文件位于classpath根目录下。如果有多个属性文件需要加载，可以使用逗号分隔它们的路径信息，如下所示：

   @PropertySource({"classpath:config.properties", "file:/etc/myapp/config.properties"})
   1

   这里我们指定了两个属性文件，一个是在classpath下，一个是在/etc/myapp/目录下。

2. 加载属性文件：一旦指定了属性文件路径，@PropertySource注解就会自动将其加载到Spring环境中，使得应用程序可以使用这些属性。例如，我们可以使用Spring的Environment对象来访问属性文件中的值，如下所示：

   @Autowired
   private Environment env;
   
   public void someMethod() {
       String username = env.getProperty("db.username");
       String password = env.getProperty("db.password");
       int maxConnections = env.getProperty("db.maxConnections", Integer.class);
       // ...
   }
   1
   2
   3
   4
   5
   6
   7
   8
   9

   在这个例子中，我们通过@Autowired注解自动注入了Environment对象，并使用其getProperty方法来获取属性文件中的值。其中，“db.username”、"db.password"和"db.maxConnections"分别对应于config.properties文件中的三个属性。

总之，@PropertySource注解是一个很有用的工具，它可以方便地将属性文件加载到Spring环境中，从而使得应用程序可以轻松地使用它们。

---

在Spring Boot中，@PropertySource注解用于指定要加载的属性文件。通常情况下，Spring Boot会自动加载名为application.properties或application.yml的属性文件，但如果你需要加载其他名称的属性文件，那么你可以使用该注解指定。

下面是一个使用@PropertySource注解指定要加载外部属性文件的示例：

首先，在你的项目中创建一个名为myapp.properties的属性文件，并将以下内容添加到该文件中：

message=Hello, world!
1

然后，在你的Spring Boot应用程序类中，添加以下注解：

@SpringBootApplication
@PropertySource("classpath:myapp.properties")
public class MyApplication {

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

}
1
2
3
4
5
6
7
8
9

这样就告诉了Spring Boot要加载名为myapp.properties的属性文件，并将其中的属性值注入到应用程序中。在这个例子中，我们只有一个属性，即"message"，它的值为"Hello, world!"。你可以在你的应用程序中调用该属性来输出消息，如下所示：

@RestController
public class MyController {

    @Value("${message}")
    private String message;

    @GetMapping("/hello")
    public String sayHello() {
        return message;
    }

}
1
2
3
4
5
6
7
8
9
10
11
12

现在，当你访问/hello端点时，就会返回"Hello, world!"。

---

☀SpringBoot自动配置的相关注解☀

Spring Boot自动配置的相关注解主要有以下几个：

1. @EnableAutoConfiguration：该注解可以在应用启动时根据类路径下的jar包、类、属性等信息进行自动化配置，无需编写大量的配置。

2. @ConditionalOnClass：指定某个类存在时才进行自动化配置。

3. @ConditionalOnMissingBean：指定某个Bean不存在时才进行自动化配置。

4. @ConditionalOnProperty：指定某个配置属性满足条件时才进行自动化配置。

5. @AutoConfigureAfter和@AutoConfigureBefore：指定自动化配置的顺序，@AutoConfigureAfter表示在某个自动化配置之后进行配置，而@AutoConfigureBefore则表示在某个自动化配置之前进行配置。

6. @ImportResource：加载XML配置文件中的Bean定义。

7. @ConfigurationProperties：将配置文件中的属性映射到Java Bean中。

这些注解可以帮助开发者方便地进行Spring Boot的自动化配置。

---

16、底层注解-@SpringBootConfiguration详解

在Spring Boot中，@SpringBootConfiguration是一个组合注解，它标记一个类作为Spring Boot应用程序的配置类。它包含了以下三个注解：

1. @Configuration - 表示该类是Spring的配置类，它可以定义Bean并将其添加到Spring容器中。

2. @EnableAutoConfiguration - 开启Spring Boot自动配置功能，通过自动扫描classpath下的依赖，自动配置Spring应用程序所需的Bean。

3. @ComponentScan - 开启组件扫描，自动发现和注册带有@Component、@Service、@Repository或@Controller注解的Bean。

因此，使用@SpringBootConfiguration可以让Spring Boot自动配置应用程序并注册所有必要的Bean，而无需手动进行复杂的配置。通过这种方式，开发人员可以更加专注于业务逻辑的开发，提高生产效率。

---

在Spring Boot中，@SpringBootConfiguration注解用于标识一个类是Spring Boot应用程序的配置类。与其他@Configuration注解不同的是，这个注解还提供了一些额外的功能。

具体来说，@SpringBootConfiguration注解可以被用来定义一个基于Java的Spring应用程序上下文的配置信息。它类似于传统的XML文件，但更加灵活和容易维护。

此外，@SpringBootConfiguration注解还隐式地使用了@Configuration和@ComponentScan注解。@Configuration表示这个类是一个配置类，而@ComponentScan则表示应该扫描当前包以及子包中的组件。

以下是一个使用@SpringBootConfiguration注解的示例：

@SpringBootConfiguration
public class MyAppConfiguration {
    // 配置信息
}
1
2
3
4

在上面的示例中，MyAppConfiguration类被标记为@SpringBootConfiguration注解，表示它是一个Spring Boot应用程序的配置类。

17、底层注解-@ComponentScan详解

在Spring Boot中，@ComponentScan注解用于指示Spring应该扫描哪些包以查找组件，例如@Service、@Repository和@Controller等。当使用@ComponentScan时，Spring会自动扫描指定包及其子包下的所有类，如果某个类上有特定的注解（如@Service），则Spring会将其实例化并注册为Bean。

@ComponentScan注解通常放置在应用程序的主类上，这个主类通常是一个带有main()方法的类，并且它的作用是启动Spring应用程序。当应用程序启动时，Spring会扫描所有被@ComponentScan注解标识的包，找到其中所有带有特定注解的类，并将其创建成相应的Bean。

@ComponentScan注解默认扫描主类所在的包及其子包下的所有组件，但也可以通过参数basePackages或者value来指定要扫描的包路径。例如，@ComponentScan(basePackages = "com.example")就会只扫描com.example包及其子包下的组件。

需要注意的是，在使用@ComponentScan注解时，Spring并不会扫描当前类所在的包，因此如果你想要扫描当前类所在的包，需要将当前类所在的包作为参数传递给@ComponentScan注解。

---

在SpringBoot中，@ComponentScan注解用于自动扫描特定的包及其子包，查找带有特定注解的组件，并将它们注册为Spring应用程序上下文中的bean。

例如，在一个基本的SpringBoot应用程序中，如果你想要将使用@Component注解标记的所有类作为bean加载到应用程序上下文中，可以在主应用程序类上添加@ComponentScan注解并指定需要扫描的包名。示例代码如下：

@SpringBootApplication
@ComponentScan(basePackages = "com.example.demo")
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}
1
2
3
4
5
6
7

在这个例子中，@SpringBootApplication是启动SpringBoot应用程序所需的主注解。通过添加@ComponentScan注解并指定要扫描的基础包，我们告诉Spring在com.example.demo包及其子包中查找所有使用@Component注解标记的类，并将它们注册为bean。

如果我们还想扫描其他包，可以使用basePackages参数来指定多个包，或者使用value参数来指定单个包：

@ComponentScan(basePackages = {"com.example.demo", "com.example.controllers"})
// 或者
@ComponentScan(value = "com.example")
1
2
3

总之，@ComponentScan注解是非常强大且灵活的，可以根据需要配置其参数实现不同的自动扫描行为。

18、底层注解-@EnableAutoConfiguration详解

在SpringBoot中，@EnableAutoConfiguration是一个非常重要的注解。它告诉Spring Boot根据你的项目中的依赖来自动配置应用程序。

具体来说，当你使用了@EnableAutoConfiguration时，Spring Boot会根据classpath中的jar包、类路径和其他配置信息来猜测和配置你的应用程序的必需组件，并基于这些信息将它们注入到Spring容器中。

举个例子，如果你的项目中引入了Spring Data JPA，那么@SpringBootApplication注解会启用Spring Boot的自动配置机制并在运行时自动配置数据源、EntityManagerFactory、TransactionManager等Bean。另外，@EnableAutoConfiguration也可以通过exclude属性排除某些自动配置项。

总之，@EnableAutoConfiguration使得开发者无需手动编写大量的配置代码，让开发更加高效和便捷。

---

好的，下面我用一个例子来说明在SpringBoot中如何使用@EnableAutoConfiguration。

假设我们正在开发一个Web应用程序，并希望使用Spring Boot自动配置来简化我们的开发工作。下面是一个基本示例：

// 导入相关依赖
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

// 启用自动配置
@EnableAutoConfiguration
// 控制器注解
@RestController
public class MyController {

    // 处理GET请求
    @GetMapping("/")
    public String home() {
        return "Hello World!";
    }

    // 主方法
    public static void main(String[] args) {
        SpringApplication.run(MyController.class, args);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

上述代码中，我们使用了@EnableAutoConfiguration注解，以启用Spring Boot的自动配置机制。此外，我们还添加了一个@RestController注解，将MyController类标记为控制器，并添加一个处理GET请求的home()方法。

最后，在main()方法中，我们使用SpringApplication.run()方法来运行我们的应用程序，并将MyController类作为参数传递给它。

这样，我们就可以启动我们的应用程序并访问http://localhost:8080/网址来查看“Hello World!”的输出。

总之，通过@EnableAutoConfiguration注解，Spring Boot可以自动配置和管理应用程序的组件，使我们的开发过程更加高效和便捷。

19、底层注解-@AutoConfigurationPackage详解

在Spring Boot中，@AutoConfigurationPackage注解是用来指定自动配置包的基础包的。当Spring Boot启动时，它会根据类路径扫描机制，自动装配合适的bean到Spring上下文中。

但是，如果没有指定自动配置包，则只会扫描@SpringBootApplication注解所在的类及其子包。而@AutoConfigurationPackage可以让我们指定需要被扫描的包，以便让Spring Boot能够自动注册那些位于指定包下的bean。

例如，我们可以这样使用@AutoConfigurationPackage注解：

@Configuration
@ComponentScan(basePackages = {"com.example"})
@AutoConfigurationPackage
public class AppConfig {
    // ...
}
1
2
3
4
5
6

这个示例中，@AutoConfigurationPackage注解没有任何参数，因此默认值为当前包（即AppConfig所在的包）将被用作自动配置包的基础包。这意味着Spring Boot将会扫描com.example包及其子包中的所有组件，并将它们自动注册到Spring上下文中。

总的来说，@AutoConfigurationPackage注解可以让我们更加灵活地控制Spring Boot的自动配置过程，使其仅扫描我们想要的包，而不必扫描整个应用程序的类路径，从而提高了应用程序启动的速度和效率。

---

在 Spring Boot 中，@AutoConfigurationPackage 是一个元注解，通常用于一个应用程序的主类上。它的作用是告诉 Spring Boot 自动配置类扫描 bean 的包的范围。具体来说，它会将主类所在的包及其子包下所有被 @Component、@Service、@Repository、@Controller、@RestController 等注解标记的类都加入到自动配置类的扫描范围中。

举个例子，如果我们有这样一段代码：

@SpringBootApplication
public class MyApp {
    public static void main(String[] args) {
        SpringApplication.run(MyApp.class, args);
    }
}
1
2
3
4
5
6

其中 @SpringBootApplication 注解包括了很多其他注解，其中就包括了 @AutoConfigurationPackage。这样一来，Spring Boot 就会自动扫描 MyApp 所在的包及其子包下所有被标记的类，然后进行自动配置。

如果我们需要自定义扫描包的范围，可以使用 @Import 注解导入另一个配置类，然后在该配置类中使用 @ComponentScan 注解指定要扫描的包。

20、底层注解-@Conditional 条件装配

在 Spring Boot 中，可以使用 @Conditional 注释来根据某些条件来声明 bean。该注释可以用于方法级别或类级别。

@Conditional 注释接受一个实现 Condition 接口的类作为参数。Condition 接口只有一个方法：matches()，它返回一个布尔值，表示是否满足给定条件。

当创建 Spring Bean 时，Spring 容器将根据 Condition 实例的 matches() 方法的结果决定是否创建该 Bean。如果 matches() 方法返回 true，则 Bean 将被创建并添加到 Spring 应用程序上下文中；否则，Bean 不会被创建。

例如，可以使用 @ConditionalOnProperty 注释来根据应用程序配置中的属性值来声明 bean。下面是一个示例：

@Configuration
public class MyConfiguration {

    @Bean
    @ConditionalOnProperty(name = "myproperty.enabled", havingValue = "true")
    public MyBean myBean() {
        return new MyBean();
    }
}
1
2
3
4
5
6
7
8
9

在这个示例中，MyBean 类将只有在 myproperty.enabled 属性设置为 true 时才会被创建，并添加到应用程序上下文中。

除了 @ConditionalOnProperty 外，Spring Boot 还提供了许多其他的 @Conditional 注释，例如 @ConditionalOnClass、@ConditionalOnMissingBean、@ConditionalOnExpression 等等。这些注释可以用于根据各种条件来声明 bean，以使应用程序更具灵活性和可配置性。

---

在Spring Boot中，@Conditional注解是一个条件化的注解，可以用来根据特定条件启用或禁用某个bean，从而实现更灵活的配置。

举个例子，比如我们想要基于不同的环境（开发、测试、生产）来使用不同的数据源，那么就可以通过@Conditional注解来判断当前运行环境，然后选择使用哪个数据源。

示例如下：

@Configuration
public class DataSourceConfig {

    @Bean
    @Conditional(DevDataSourceCondition.class)
    public DataSource devDataSource() {
        // 返回开发环境数据源
    }

    @Bean
    @Conditional(TestDataSourceCondition.class)
    public DataSource testDataSource() {
        // 返回测试环境数据源
    }

    @Bean
    @Conditional(ProdDataSourceCondition.class)
    public DataSource prodDataSource() {
        // 返回生产环境数据源
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

在上面的代码中，我们定义了三个不同的数据源（devDataSource、testDataSource、prodDataSource），并使用了@Conditional注解来指定它们分别在开发环境、测试环境和生产环境下启用。

对应的条件类可以是任何实现了Condition接口的类，在这里我们只需要根据不同的条件返回true或false即可。例如：

public class DevDataSourceCondition implements Condition {
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        String env = context.getEnvironment().getProperty("spring.profiles.active");
        return "dev".equals(env);
    }
}

public class TestDataSourceCondition implements Condition {
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        String env = context.getEnvironment().getProperty("spring.profiles.active");
        return "test".equals(env);
    }
}

public class ProdDataSourceCondition implements Condition {
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        String env = context.getEnvironment().getProperty("spring.profiles.active");
        return "prod".equals(env);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

在上面的代码中，我们分别定义了三个条件类，它们根据当前环境配置中的"spring.profiles.active"属性来判断当前是否为对应的环境。

这样，在不同的环境下启动应用程序时，Spring Boot会自动根据当前的配置选择合适的数据源进行注入。

---

✌@Conditional扩展注解的条件注解✌

好的，下面分别对 Spring Boot 中的 @Conditional 扩展注解的条件注解进行详细举例：

1. @ConditionalOnProperty

@ConditionalOnProperty 注解可以用来控制是否根据某个配置项来加载 Bean。例如，我们有一个名为 mybean 的 Bean，只有在存在属性值为 true 的 mybean.enabled 配置项时才会被加载：

@Configuration
public class MyBeanConfiguration {
    @Bean
    @ConditionalOnProperty(name = "mybean.enabled", havingValue = "true")
    public MyBean myBean() {
        return new MyBean();
    }
}
1
2
3
4
5
6
7
8

在这个例子中，我们使用了 @ConditionalOnProperty 注解，并指定了需要检查的配置项名称为 mybean.enabled，以及当该配置项的值为 true 时才会加载 MyBean 类型的 Bean。

2. @ConditionalOnClass

@ConditionalOnClass 注解可以用于仅在项目中引入了某个类时才进行相关的配置。例如，如果我们希望仅在项目中引入了 Apache HttpClient 时才创建一个名为 myhttpclient 的 Apache HttpClient 实例，可以使用以下代码：

@Configuration
@ConditionalOnClass(HttpClient.class)
public class MyHttpClientConfiguration {
    @Bean
    public HttpClient myHttpClient() {
        return new HttpClient();
    }
}
1
2
3
4
5
6
7
8

在这个例子中，我们使用了 @ConditionalOnClass 注解，并指定了需要检查的类为 HttpClient.class，以确保只有在项目中引入了该类时才会创建名为 myhttpclient 的 HttpClient 实例。

3. @ConditionalOnMissingBean

@ConditionalOnMissingBean 注解可以用于仅在不存在指定类型的 Bean 时才创建相应的 Bean。例如，我们希望仅在项目中不存在名为 mydatasource 的 DataSource 类型的 Bean 时才创建一个名为 mydatasource 的 DataSource 实例，可以使用以下代码：

@Configuration
public class MyDataSourceConfiguration {
    @Bean
    @ConditionalOnMissingBean(DataSource.class)
    public DataSource myDataSource() {
        return new DataSource();
    }
}
1
2
3
4
5
6
7
8

在这个例子中，我们使用了 @ConditionalOnMissingBean 注解，并指定了需要检查的 Bean 类型为 DataSource.class，以确保只有当项目中不存在该类型的 Bean 时才会创建名为 mydatasource 的 DataSource 实例。

4. @ConditionalOnExpression

@ConditionalOnExpression 注解可以根据 SpEL 表达式的结果来判断是否加载 Bean。例如，我们希望仅在当前系统的语言环境为英文时才创建一个名为 mygreeting 的 GreetingService 实例，可以使用以下代码：

@Configuration
public class MyGreetingConfiguration {
    @Bean
    @ConditionalOnExpression("#{ systemProperties['user.language'] == 'en' }")
    public GreetingService myGreeting() {
        return new EnglishGreetingService();
    }
}
1
2
3
4
5
6
7
8

在这个例子中，我们使用了 @ConditionalOnExpression 注解，并指定了 SpEL 表达式为 #{ systemProperties['user.language'] == 'en' }，以确保只有当当前系统的语言环境为英文时才会创建名为 mygreeting 的 EnglishGreetingService 实例。

5. @ConditionalOnWebApplication

@ConditionalOnWebApplication 注解可以用于仅在当前项目是一个 Web 应用程序时才进行相关的配置。例如，我们希望仅在当前项目是一个 Web 应用程序时才创建一个名为 myfilter 的 Filter 实例，可以使用以下代码：

@Configuration
@ConditionalOnWebApplication(type = Type.SERVLET)
public class MyFilterConfiguration {
    @Bean
    public MyFilter myFilter() {
        return new MyFilter();
    }
}
1
2
3
4
5
6
7
8

在这个例子中，我们使用了 @ConditionalOnWebApplication 注解，并指定了需要检查的 Web 应用程序类型为 Type.SERVLET，以确保只有当当前项目是一个基于 Servlet 的 Web 应用程序时才会创建名为 myfilter 的 MyFilter 实例。

---

♒完整罗列下SpringBoot中的 @Conditional扩展注解的条件注解♒

在 Spring Boot 中，@Conditional 注解是一个条件注解，它可以用于控制 bean 的创建和配置。除了 @Conditional 注解本身之外，Spring Boot 还提供了许多扩展的条件注解，包括：

1. @ConditionalOnBean：当指定的 bean 存在时，才会创建当前的 bean。
2. @ConditionalOnMissingBean：当指定的 bean 不存在时，才会创建当前的 bean。
3. @ConditionalOnClass：当指定的类存在于 classpath 中时，才会创建当前的 bean。
4. @ConditionalOnMissingClass：当指定的类不存在于 classpath 中时，才会创建当前的 bean。
5. @ConditionalOnProperty：当指定的属性存在且被设置为指定的值时，才会创建当前的 bean。
6. @ConditionalOnResource：当指定的资源存在于 classpath 中时，才会创建当前的 bean。
7. @ConditionalOnWebApplication：当前应用程序是一个 Web 应用程序时，才会创建当前的 bean。
8. @ConditionalOnNotWebApplication：当前应用程序不是一个 Web 应用程序时，才会创建当前的 bean。
9. @ConditionalOnExpression：当 SpEL 表达式求值结果为 true 时，才会创建当前的 bean。
10. @ConditionalOnJndi：当指定的 JNDI 条目存在时，才会创建当前的 bean。

这些条件注解可以根据特定的条件来控制 bean 的创建和配置，从而实现更加灵活的应用程序配置。

---

☀控制 Spring Boot 自动配置类执行顺序的注解☀

@AutoConfigureAfter、@AutoConfigureBefore 和 @AutoConfigureOrder 这三个注解都是用来控制 Spring Boot 自动配置类执行顺序的。

@AutoConfigureBefore 和 @AutoConfigureAfter 注解用于指定自动配置类的执行顺序，其中 @AutoConfigureBefore 表示在某个自动配置类之前执行，而 @AutoConfigureAfter 则表示在某个自动配置类之后执行。

例如，如果你想要让某个自动配置类在另一个自动配置类之前执行，可以使用 @AutoConfigureBefore 注解：

@Configuration
@AutoConfigureBefore(SomeAutoConfiguration.class)
public class MyAutoConfiguration {
    // ...
}
1
2
3
4
5

相反地，如果你想要让某个自动配置类在另一个自动配置类之后执行，可以使用 @AutoConfigureAfter 注解：

@Configuration
@AutoConfigureAfter(SomeAutoConfiguration.class)
public class MyAutoConfiguration {
    // ...
}
1
2
3
4
5

@AutoConfigureOrder 注解与前两者不同之处在于它可以指定自动配置类的执行顺序，而不是相对于其他自动配置类的顺序。这个注解的参数是一个整数值，值越小的自动配置类越先执行。例如：

@Configuration
@AutoConfigureOrder(1)
public class MyAutoConfiguration {
    // ...
}
1
2
3
4
5

总而言之，这三个注解可以通过控制自动配置类的执行顺序来解决自动配置时出现的依赖问题。

---

21、底层注解-@AutoConfigureAfter

在 Spring Boot 中，@AutoConfigureAfter 注解可以用来控制自动配置类的执行顺序。它的作用是指定当前自动配置类所依赖的其他自动配置类，并确保这些被依赖的自动配置类在当前自动配置类之前执行。

当一个 Spring Boot 应用启动时，Spring Boot 会自动扫描所有的 @Configuration 类，并根据条件自动创建相应的 Bean。如果一个类上面标注了 @AutoConfigureAfter 注解，则说明当前自动配置类依赖于另一个自动配置类。此时，Spring Boot 会在另一个自动配置类执行完毕后再执行当前自动配置类。

举个例子，假设我们有两个自动配置类：MyAutoConfiguration1 和 MyAutoConfiguration2，其中 MyAutoConfiguration2 依赖于 MyAutoConfiguration1。为了确保 MyAutoConfiguration1 在 MyAutoConfiguration2 之前执行，我们可以在 MyAutoConfiguration2 上添加 @AutoConfigureAfter(MyAutoConfiguration1.class) 注解：

@Configuration
@AutoConfigureAfter(MyAutoConfiguration1.class)
public class MyAutoConfiguration2 {
    // ...
}
1
2
3
4
5

这样一来，当 Spring Boot 启动时，会先执行 MyAutoConfiguration1，再执行 MyAutoConfiguration2。

需要注意的是，@AutoConfigureAfter 注解只能用于自动配置类中，不能用于普通的 Spring 组件类。此外，@AutoConfigureAfter 注解可以添加多个参数，用逗号分隔。这样一来，当前自动配置类会依赖于多个其他的自动配置类，并且这些被依赖的自动配置类会在当前自动配置类之前执行。

---

@AutoConfigureAfter 是 Spring Boot 中用于控制自动配置类执行顺序的注解。通过使用 @AutoConfigureAfter 注解，我们可以确保某个自动配置类在另一个自动配置类之后执行。

假设我们有一个 Spring Boot 应用，其中使用了以下两个依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

<dependency>
    <groupId>com.example</groupId>
    <artifactId>my-spring-boot-starter</artifactId>
    <version>1.0.0</version>
</dependency>
1
2
3
4
5
6
7
8
9
10

其中，spring-boot-starter-web 依赖中包含了 WebMvcAutoConfiguration 自动配置类，而 my-spring-boot-starter 依赖中也包含了自己的自动配置类 MyAutoConfiguration。

如果我们想要确保 MyAutoConfiguration 在 WebMvcAutoConfiguration 之后执行，可以在 MyAutoConfiguration 上添加 @AutoConfigureAfter(WebMvcAutoConfiguration.class) 注解，如下所示：

@Configuration
@AutoConfigureAfter(WebMvcAutoConfiguration.class)
public class MyAutoConfiguration {

    // ...

}
1
2
3
4
5
6
7

这样一来，当 Spring Boot 启动时，会先执行 WebMvcAutoConfiguration，然后再执行 MyAutoConfiguration。

需要注意的是，在使用 @AutoConfigureAfter 注解时，被依赖的自动配置类必须存在于应用的 Classpath 中。否则，使用 @AutoConfigureAfter 注解会导致应用启动失败。

22、底层注解-@AutoConfigureBefore

在Spring Boot中，@AutoConfigureBefore注解是用来指定一个自动配置类在另一个自动配置类之前进行加载的。该注解通常用于解决两个自动配置类之间的依赖关系。

具体地说，当我们需要确保一个自动配置类在另一个自动配置类之前被加载时，我们可以在需要先加载的自动配置类上使用@AutoConfigureBefore注解，并在注解中指定需要后加载的自动配置类的类名或类数组。这样，在应用程序启动时，Spring Boot会按照指定的加载顺序优先加载带有@AutoConfigureBefore注解的自动配置类。

当多个自动配置类都需要对同一个功能进行自动配置时，就可能会出现冲突。通过使用@AutoConfigureBefore注解，我们可以强制让一个自动配置类在另一个自动配置类之前进行自动配置。这样就可以避免冲突，并确保应用程序能够正确地运行。

例如，假设我们有两个自动配置类A和B，其中B依赖于A，那么我们可以在A上使用@AutoConfigureBefore注解，并指定B的类名或类数组。这样，在应用程序启动时，Spring Boot会首先加载A，然后才会加载B，从而保证B能够正确地依赖于A。

需要注意的是，@AutoConfigureBefore注解只在两个自动配置类之间存在依赖关系时才有意义。如果两个自动配置类之间不存在依赖关系，则使用@AutoConfigureBefore注解将不会产生任何效果。

---

下面举一个例子，假设我们有两个自动配置类：A和B，其中B依赖于A。

我们希望在应用程序启动时，先加载A再加载B。为此，我们可以在A上使用@AutoConfigureBefore注解，并指定B的类名或类数组。

@Configuration
@AutoConfigureBefore(B.class)
public class A {
    // ...
}
1
2
3
4
5

这样，在应用程序启动时，Spring Boot会首先加载A，然后才会加载B，从而保证B能够正确地依赖于A。

需要注意的是，如果B并不依赖于A，那么在A上使用@AutoConfigureBefore注解将没有任何效果。因此，在使用@AutoConfigureBefore注解时，必须确保存在正确的依赖关系。

23、底层注解-@AutoConfigureOrder

在Spring Boot中，@AutoConfigureOrder注解用于指定自动配置类的加载顺序。自动配置是Spring Boot的一个重要特性，它根据应用程序的依赖关系和配置文件来自动配置应用程序。但是，在某些情况下，您可能希望更改自动配置类的加载顺序，以确保它们按照正确的顺序进行加载。

@AutoConfigureOrder注解是一种元注解，用于指示自动配置类的加载顺序。它接受一个整数值作为参数，该值表示加载顺序。较低的数字意味着优先级更高（即首先加载），而较高的数字意味着优先级更低（即最后加载）。

例如，如果您有两个自动配置类，其中一个依赖于另一个，则可以使用@AutoConfigureOrder注解来指定它们的加载顺序。具体来说，您可以将依赖项的@AutoConfigureOrder设置为比被依赖项的@AutoConfigureOrder更高的值，以确保被依赖项先加载。

在实际开发中，需要注意的是，不应该滥用@AutoConfigureOrder注解，因为它会增加代码复杂性和维护成本。在大多数情况下，自动配置类会按照正确的顺序加载，并且不需要使用@AutoConfigureOrder进行干预。

---

在SpringBoot中，@AutoConfigureOrder是用来指定自动配置类的执行顺序的注解。假设你有多个自定义的自动配置类，在它们都能够对应的条件下，你希望它们按照一定的顺序执行，可以使用@AutoConfigureOrder注解来实现。

例如，假设你有两个自动配置类A和B，它们都会在特定条件下被激活并应用于你的应用程序。如果你想确保A在B之前执行，你可以给A添加@AutoConfigureOrder注解，并为其指定一个较小的值，比如：

@Configuration
@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)
public class AAutoConfiguration {
   // ...
}
1
2
3
4
5

而对于B，则不需要添加@AutoConfigureOrder注解，因为默认情况下所有未设置@AutoConfigureOrder注解的自动配置类的执行顺序都是0。

这样，当SpringBoot启动时，会按照@AutoConfigureOrder指定的顺序依次执行自动配置类，先执行A，再执行B。

24、底层注解-@ImportResource 导入Spring配置文件

在Spring Boot中，@ImportResource注解用于导入XML格式的配置文件。通过使用此注解，您可以将传统的Spring XML配置集成到Spring Boot应用程序中。

当您希望使用已有的XML配置文件时，@ImportResource注解就非常有用了。您可以使用该注解从现有的Spring XML配置文件中加载bean定义和其他组件。

例如，假设您有一个名为“applicationContext.xml”的Spring配置文件，并且您想在Spring Boot应用程序中使用其中定义的bean。您可以将@ImportResource注解添加到启动类上，如下所示：

@SpringBootApplication
@ImportResource("classpath:applicationContext.xml")
public class MyApp {
    public static void main(String[] args) {
        SpringApplication.run(MyApp.class, args);
    }
}
1
2
3
4
5
6
7

这将告诉Spring Boot在启动时加载"applicationContext.xml"文件并将其包含的bean定义注册到Spring应用程序上下文中。

需要注意的是，在使用@ImportResource注解时，您需要确保已经添加了适当的依赖项。如果您正在使用Maven构建项目，则需要添加以下依赖项：

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.3.9</version>
</dependency>
1
2
3
4
5

这将确保您的项目具备正确的Spring上下文支持，以便正确处理XML配置文件。

---

在Spring Boot中，@ImportResource注解用于导入XML配置文件。

假设我们有一个名为applicationContext.xml的Spring配置文件，其中定义了一些bean和其他相关配置。如果我们想要在Spring Boot应用程序中使用这些bean和配置，则可以使用@ImportResource注解将该文件导入到主应用程序的Java配置类中。

例如，我们可以创建一个名为MyAppConfig的Java配置类，并在该类上使用@ImportResource注解，如下所示：

@Configuration
@ImportResource("classpath:applicationContext.xml")
public class MyAppConfig {

    // ... bean definitions and other configuration ...

}
1
2
3
4
5
6
7

这样，Spring Boot将会自动加载applicationContext.xml文件中定义的所有bean和配置，并将它们纳入到应用程序上下文中供其他组件使用。

25、SpringBoot配置绑定功能-@ConfigurationProperties详解

在Spring Boot中，@ConfigurationProperties注解是用于将外部配置文件中的属性值与Java类中的属性进行绑定的一种方式。通过在一个带有@ConfigurationProperties注解的Java类中定义属性，可以将应用程序的配置信息从配置文件中读取出来，并且将这些属性与Java类中的属性进行映射，从而让我们能够更方便地使用应用程序的配置信息。

具体来说，@ConfigurationProperties注解可以用在Spring Boot应用程序的任何一个Bean上，当Spring Boot启动时，它会自动将配置文件中的属性值注入到指定的Bean中。要使用@ConfigurationProperties注解，需要提供一个前缀（prefix）参数，用于指定应该从哪个配置文件中读取属性值。例如：

@ConfigurationProperties(prefix="myapp")
public class MyAppProperties {
    private String name;
    private String version;

    // getters and setters
}
1
2
3
4
5
6
7

在这个示例中，我们定义了一个名为MyAppProperties的Java类，并使用@ConfigurationProperties注解将它标记为一个配置类。我们还指定了一个前缀“myapp”，表示所有以“myapp”为前缀的属性都会被注入到这个类的属性中。在配置文件中，可以像下面这样设置属性值：

myapp.name=My App
myapp.version=1.0.0
1
2

这样，当我们在应用程序中引用MyAppProperties实例时，它的name和version属性就会被分别设置为“My App”和“1.0.0”。

除了使用前缀参数之外，@ConfigurationProperties注解还支持其他一些可选的属性，例如ignoreUnknownFields、ignoreInvalidFields等，这些属性可以帮助我们更好地控制属性绑定的行为。

---

在 Spring Boot 中，@ConfigurationProperties 注解用于将属性绑定到配置文件中。通过使用该注解，可以将一个或多个属性的值从 application.properties 文件或其他外部配置文件中注入到 Spring Bean 中。

具体来说，@ConfigurationProperties 注解可以与 @Component 或 @Configuration 一起使用。当将其与 @Component 一起使用时，Spring Boot 将自动扫描包以查找带有该注解的类，并将其实例化为 Spring Bean。当将其与 @Configuration 一起使用时，则需要手动将其添加到 Spring 上下文中。

举例来说，假设有一个名为 MyProperties 的类，包含以下属性：

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

    // getters and setters
}
1
2
3
4
5
6
7
8

在这里，@Component 注解将 MyProperties 类标记为 Spring Bean，@ConfigurationProperties 注解指定了前缀为 “my” 的属性应绑定到该类的相应字段上。因此，在 application.properties 文件中，可以像下面这样设置这些属性的值：

my.name=John Doe
my.age=30
1
2

然后，在另一个 Spring Bean 中，可以使用 @Autowired 注解将 MyProperties 类自动注入到该 Bean 中，并访问其属性的值：

@Service
public class MyService {
    @Autowired
    private MyProperties myProperties;

    public void doSomething() {
        String name = myProperties.getName();
        int age = myProperties.getAge();
        // ...
    }
}
1
2
3
4
5
6
7
8
9
10
11

这样，MyService 类就可以使用 MyProperties 类中的属性值进行必要的操作。

---

♒SpringBoot一种配置绑定♒

@ConfigurationProperties + @Component

Spring Boot 中一种方便的配置绑定方式是结合使用 @ConfigurationProperties 和 @Component 注解。@ConfigurationProperties 可以将配置文件中的属性值映射到 Java 对象中，@Component 可以让该类被 Spring IOC容器管理并注入到其他组件中。

以下是一个示例：

1. 在 application.properties 文件中定义一些配置属性，例如：

myapp.name=My Application
myapp.version=1.0.0
1
2

2. 创建一个 POJO 类，并使用 @ConfigurationProperties 注解指定需要绑定的前缀，同时使用 @Component 注解标记为 Spring Bean，例如：

@Component
@ConfigurationProperties(prefix = "myapp")
public class MyAppProperties {
    private String name;
    private String version;

    // 省略 getter 和 setter 方法

}
1
2
3
4
5
6
7
8
9

在上面的示例中，@ConfigurationProperties 注解指定了需要绑定的前缀为 “myapp”，表示该类中的属性与 application.properties 文件中以 “myapp.” 开头的属性相对应。@Component 注解则标记该类为 Spring Bean。

3. 在其他组件中注入该对象，例如：

@RestController
public class MyController {
    @Autowired
    private MyAppProperties myAppProperties;

    @GetMapping("/")
    public String index() {
        return myAppProperties.getName() + " " + myAppProperties.getVersion();
    }
}
1
2
3
4
5
6
7
8
9
10

在上面的示例中，我们使用 @Autowired 注解标记了 MyAppProperties 对象的注入。然后，我们可以在控制器方法中使用该对象，例如获取名称和版本号。

这种方式可以让你更加方便地管理应用程序配置，并且支持数据类型转换、属性验证和属性默认值等功能，同时也方便将该对象注入到其他组件中使用。

♒SpringBoot另一种配置绑定♒

@EnableConfigurationProperties + @ConfigurationProperties

除了 @ConfigurationProperties + @Component 方式外，Spring Boot 还可以使用另一种配置绑定方式，即结合使用 @EnableConfigurationProperties 和 @ConfigurationProperties 注解。

以下是一个示例：

1. 在 application.properties 文件中定义一些配置属性，例如：

myapp.name=My Application
myapp.version=1.0.0
1
2

2. 创建一个 POJO 类，并使用 @ConfigurationProperties 注解指定需要绑定的前缀，例如：

@ConfigurationProperties(prefix = "myapp")
public class MyAppProperties {
    private String name;
    private String version;

    // 省略 getter 和 setter 方法

}
1
2
3
4
5
6
7
8

在上面的示例中，@ConfigurationProperties 注解指定了需要绑定的前缀为 “myapp”，表示该类中的属性与 application.properties 文件中以 “myapp.” 开头的属性相对应。

3. 创建一个带有 @EnableConfigurationProperties 注解的配置类，用于启用该 POJO 类的自动配置和注入，例如：

@Configuration
@EnableConfigurationProperties(MyAppProperties.class)
/* 1、开启 MyAppProperties 的配置绑定功能
   2、把 MyAppProperties 这个组件自动注册到IOC容器中 */
public class MyAppAutoConfiguration {

}
1
2
3
4
5
6
7

在上面的示例中，@EnableConfigurationProperties 注解指定了需要启用的 POJO 类为 MyAppProperties.class。这样，在其他组件中就可以直接注入 MyAppProperties 对象来使用。

4. 在其他组件中注入该对象，例如：

@RestController
public class MyController {
    @Autowired
    private MyAppProperties myAppProperties;

    @GetMapping("/")
    public String index() {
        return myAppProperties.getName() + " " + myAppProperties.getVersion();
    }
}
1
2
3
4
5
6
7
8
9
10

在上面的示例中，我们使用 @Autowired 注解标记了 MyAppProperties 对象的注入。然后，我们可以在控制器方法中使用该对象，例如获取名称和版本号。

这种方式同样可以让你更加方便地管理应用程序配置，并且支持数据类型转换、属性验证和属性默认值等功能，同时也方便将该对象注入到其他组件中使用。

✌结论:

1. 如果要使 xxx.properties 配置文件与 Java Bean 动态绑定,那么就必须将这个 Java Bean 加入到容器中,并且需要在该类上使用 @ConfigurationProperties 注解
2. @EnableConfigurationProperties(A.class)的作用就是：如果 A 这个类上使用了@ConfigurationProperties 注解,那么 A 这个类会与 xxx.properties 进行动态绑定,并且会将 A 这个类加入 IOC 容器中,并交由 IOC 容器进行管理
3. 如果@ConfigurationProperties是在第三方包中，由于第三方包中的代码是只读的，无法加入@component注解，所以是不能将此类注入到容器的。只有使用@EnableConfigurationProperties才可以注入到容器

26、底层注解-@Profile详解

@Profile注解是Spring框架中用于根据不同的环境、配置文件或者其他条件来启用或禁用特定的组件和代码段的注解。通过在类或方法上标注@Profile注解，并指定对应的环境，可以让Spring Boot根据当前的激活的配置环境来自动启用或禁用对应的组件和代码段。

例如，我们可以在application.properties或application.yml配置文件中设置spring.profiles.active属性来指定当前的环境，比如dev（开发环境）、test（测试环境） 和 prod（生产环境）。然后，我们可以使用@Profile注解来标注不同的组件和代码段，使得它们只在对应的环境下被启用。

举个例子，假设我们有一个名为DataSourceConfig的Java类，其中定义了数据源相关的配置，我们想让这些配置只在生产环境下生效，可以在该类上加上@Profile("prod")注解，这样无论在哪里引用该类，只有在spring.profiles.active=prod时，才会创建并注入该类的实例。

总之，@Profile注解提供了一种灵活而方便的方式来控制Spring Boot应用程序中不同环境下组件和代码的启用和禁用。

---

在 Spring Boot 中，@Profile 注解用于控制相应的 bean 在特定的环境下是否加载。假设我们有一个开发环境和一个生产环境，我们可以使用 @Profile 注解来提示 Spring Boot 仅在特定的环境下加载相应的 bean。

例如，假设我们有一个名为 MyService 的服务，我们希望在开发环境下使用 mock 实现，而在生产环境下使用真正的实现。我们可以这样定义 MyService 类：

@Service
@Profile("dev")
public class MockMyService implements MyService {
    // 实现代码
}

@Service
@Profile("!dev")
public class RealMyService implements MyService {
    // 实现代码
}
1
2
3
4
5
6
7
8
9
10
11

在上面的代码中，@Profile("dev") 表示只有在 dev 环境下才会使用 MockMyService，而 @Profile("!dev") 则表示除了 dev 环境之外都会使用 RealMyService。

我们还可以通过在 application.properties 文件中指定 spring.profiles.active 属性来设置当前所处的环境，例如：

spring.profiles.active=dev
1

在上面的示例中，我们将当前环境设置为 dev，这样就会自动加载所有标记了 @Profile("dev") 的 bean，而忽略所有标记了 @Profile("!dev") 的 bean。

---

扩展

在SpringBoot中@Primary怎么使用？

在Spring Boot中，使用@Primary注解可以指定该类作为某个接口或抽象类的默认实现。当容器中存在多个候选对象时，被标记为@Primary的对象会被优先选择。

下面是一个使用@Primary注解的示例：

public interface Animal {
    String getName();
}

@Component
class Dog implements Animal {
    @Override
    public String getName() {
        return "dog";
    }
}

@Component
@Primary
class Cat implements Animal {
    @Override
    public String getName() {
        return "cat";
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

在上面的示例中，Animal接口有两个实现类Dog和Cat。其中，Cat类被标记为@Primary，表示它是默认的实现类。因此，当我们需要获取Animal类型的bean时，如果容器中同时存在Dog和Cat这两个bean，那么将会优先选择Cat。

以下是一个在Spring Boot中通过@Autowired自动注入Animal对象的示例：

@RestController
public class MyController {

    private final Animal animal;

    @Autowired
    public MyController(Animal animal) {
        this.animal = animal;
    }

    // ...
}
1
2
3
4
5
6
7
8
9
10
11
12

在上面的示例中，MyController类中通过构造函数注入了Animal类型的bean，由于Cat类被标记为@Primary，因此Spring会自动将该类注入到该构造函数中。

✍此篇博客后续还会持续补充更新！！！

♒ 有帮助的话，点赞支持一下哦！♒