一文掌握Java注解之@SpringBootApplication知识文集(1)

作者简介，普修罗双战士，一直追求不断学习和成长，在技术的道路上持续探索和实践。
多年互联网行业从业经验，历任核心研发工程师，项目技术负责人。
欢迎 点赞✍评论⭐收藏

Java注解知识专栏学习

Java注解知识云集	访问地址	备注
Java注解知识点(1)	https://blog.csdn.net/m0_50308467/article/details/135240536	Java注解专栏
Java注解知识点(2)	https://blog.csdn.net/m0_50308467/article/details/135263693	Java注解专栏
Java注解知识点(3)	https://blog.csdn.net/m0_50308467/article/details/135278911	Java注解专栏
Java注解知识点(4)	https://blog.csdn.net/m0_50308467/article/details/135302054	Java注解专栏
Java注解知识点(5)	https://blog.csdn.net/m0_50308467/article/details/135313158	Java注解专栏

学习Java注解之@SpringBootApplication

Java 注解@SpringBootApplication学习(1)

01、@SpringBootApplication 注解有什么作用？

@SpringBootApplication 是 Spring Boot 的核心注解，它是一个组合注解，包含了其他几个注解：@SpringBootConfiguration、@EnableAutoConfiguration 和 @ComponentScan。

@SpringBootApplication 的作用是：标记一个主程序类，表示这是一个 Spring Boot 应用程序的入口，同时也开启了 Spring Boot 的自动配置和组件扫描功能。

具体来说：

1. @SpringBootConfiguration 表明该类和一个 Spring 配置类类似，配置类通常使用 @Configuration 注解，但是 @SpringBootConfiguration 注解可以用于更明确地指示该类是一个 Spring Boot 配置类。换句话说，它是 @Configuration 的替代品。
2. @EnableAutoConfiguration 是 Spring Boot 自动配置的核心注解，它可以根据当前 Spring Boot 应用程序中使用的 jar 包、类路径和其他配置，来确定需要配置哪些 Spring 框架的组件和第三方库的依赖。自动配置可以避免开发人员手动配置大量的 Bean，让开发更加简单和快速。
3. @ComponentScan 提供了 Spring 组件扫描的基本功能，它默认扫描主程序类所在的包以及其子包中所有的 Spring 组件，包括 @Component、@Service、@Controller、@Repository 等。

综上，@SpringBootApplication 注解的作用是标记 Spring Boot 应用程序的主程序类，同时启用 Spring Boot 的自动配置和组件扫描功能，一种简化 Spring 应用配置的方式。

02、@SpringBootApplication 注解包含哪些其他注解？

@SpringBootApplication 注解包含以下三个注解：@SpringBootConfiguration、@EnableAutoConfiguration 和 @ComponentScan。

当使用 @SpringBootApplication 注解标记一个类作为主程序类时，它包含了以下几个关键注解：

1. @SpringBootConfiguration：该注解是 @Configuration 的特殊形式，用于指示当前类是 Spring Boot 的配置类。@Configuration 注解通常用于标记普通的 Spring 配置类，但是在 Spring Boot 中，推荐使用 @SpringBootConfiguration 注解来明确表示该类是一个 Spring Boot 配置类。配置类主要负责定义应用程序的配置信息，包括创建和配置 Bean 对象、设置数据源、事务管理器等。

2. @EnableAutoConfiguration：这是 Spring Boot 自动配置的核心注解。通过此注解，Spring Boot 可以根据项目的依赖和当前环境来自动配置 Spring 和第三方库的相关组件。自动配置是 Spring Boot 的一大特色，它根据约定大于配置的原则，使用默认的配置来简化开发人员的工作。@EnableAutoConfiguration 注解可以根据项目的依赖，自动配置数据源、Web MVC、数据库、缓存等各种组件，减少了手动编写繁琐配置的工作量。

3. @ComponentScan：该注解用于启用组件扫描机制。在 Spring Boot 中，通常将 @ComponentScan 注解放在主程序类或配置类上。它指定要扫描的包（及其子包），以查找并注册 Spring 组件，如 @Component、@Service、@Controller、@Repository 等。通过组件扫描，Spring Boot 可以自动发现和加载这些组件，无需手动配置所有的 Bean。这样，开发人员可以将更多的精力放在业务逻辑的实现上，提高开发效率。

综上所述，@SpringBootApplication 注解的核心作用是将 @SpringBootConfiguration、@EnableAutoConfiguration 和 @ComponentScan 这三个注解组合在一起。它不仅标识主程序类是一个 Spring Boot 配置类，还启用了自动配置和组件扫描功能。通过这个注解，Spring Boot 可以自动配置项目需要的各种组件，并且扫描和加载符合条件的 Spring 组件。这样，开发人员可以更加方便地开发和配置项目，减少繁琐的手动配置工作，提高开发效率。

03、@SpringBootApplication 注解的来源是哪个包？

@SpringBootApplication 注解的来源是 org.springframework.boot.autoconfigure.SpringBootApplication 包。该包是 Spring Boot 框架中的一部分，提供了许多自动配置相关的注解和类。@SpringBootApplication 注解是其中一个核心注解，用于标记主程序类，并集成了 @SpringBootConfiguration、@EnableAutoConfiguration 和 @ComponentScan 注解的功能，方便地开启自动配置和组件扫描机制。

在使用 @SpringBootApplication 注解时，通常需要添加相关的依赖包到项目的构建配置文件中（如 Maven 的 pom.xml 或 Gradle 的 build.gradle 文件），以确保编译和运行时可以正常使用该注解及相关的类和功能。

总结起来，@SpringBootApplication 注解提供了 Spring Boot 的核心功能，并集成了自动配置和组件扫描等特性，它来自于 Spring Boot 框架的 org.springframework.boot.autoconfigure.SpringBootApplication 包。

值得注意的是，@SpringBootApplication 其实是一个组合注解，它包含了 @SpringBootConfiguration、@EnableAutoConfiguration 和 @ComponentScan 这三个注解。因此，当我们使用 @SpringBootApplication 注解时，实际上就等价于同时使用了这三个注解。

具体来说，@SpringBootConfiguration 注解用于标记当前类为 Spring Boot 的配置类，它是 @Configuration 注解的特殊形式。@Configuration 注解通常用于标记普通的 Spring 配置类，但在 Spring Boot 中，推荐使用 @SpringBootConfiguration 注解来明确表示该类是一个 Spring Boot 配置类，它可以通过 @Import 注解来导入其他配置类。

@EnableAutoConfiguration 注解是 Spring Boot 自动配置的核心注解，通过此注解，Spring Boot 可以根据项目的依赖和当前环境来自动配置 Spring 和第三方库的相关组件。自动配置是 Spring Boot 的一大特色，它可以根据约定大于配置的原则，使用默认的配置来简化开发人员的工作。通过自动配置，Spring Boot 可以根据项目的依赖，自动配置数据源、Web MVC、数据库、缓存等各种组件。

@ComponentScan 注解用于启用组件扫描机制，它通常放在主程序类或配置类上。通过组件扫描，Spring Boot 可以自动发现和加载符合条件的 Spring 组件，如 @Component、@Service、@Controller、@Repository 等。通过组件扫描，可以避免手动配置所有的 Bean，提高开发效率。同时，为了限制扫描范围，@ComponentScan 注解可以结合其他注解（如 @Configuration、@SpringBootApplication）来指定扫描的包路径。

综上所述，@SpringBootApplication 是 Spring Boot 的核心注解之一，它集成了三个注解的功能，方便地开启自动配置和组件扫描机制。在使用该注解时，我们通常需要添加相关的依赖包，并在主程序类上标注该注解，让 Spring Boot 自动完成配置和扫描操作。

04、如何在 @SpringBootApplication 中使用外部配置文件？

在Spring Boot应用中，我们可以使用 application.properties 或 application.yml 文件来指定应用程序配置信息，比如数据源、端口号、日志级别等等。当然，有时我们也需要在配置文件中使用外部的属性文件，比如数据库配置信息。针对这种情况，Spring Boot提供了多种方式来实现。

下面是一些在 @SpringBootApplication 中使用外部配置文件的方式：

1. 使用 @PropertySource 注解

@PropertySource 注解可以用于指定一个属性源文件，该文件中的属性会自动加载到 Spring 环境中。具体来说，我们可以在启动类上添加 @PropertySource 注解，指定外部的属性文件路径。示例如下：

@SpringBootApplication
@PropertySource(value = {"classpath:config/db.properties"})
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}

2. 使用 @ConfigurationProperties 注解

@ConfigurationProperties 注解可以用于将配置文件中的属性绑定到 JavaBean 中。通过 @ConfigurationProperties 注解，Spring Boot 可以自动映射外部属性文件中的数据到 JavaBean 的属性中。示例如下：

@Component
@ConfigurationProperties(prefix="db")
@Data
public class DbConfig {
    private String url;
    private String username;
    private String password;
}

在本例中，我们定义了一个 DbConfig 类，其中的属性与数据库配置信息对应。我们使用 @ConfigurationProperties 注解指定了属性的前缀为 db，并将该类标记为 Spring 组件（通过 @Component 注解）。当 Spring Boot 启动时，会自动将 application.yml 或 application.properties 中以 db 开头的配置信息注入到 DbConfig 对象中。

3. 使用 @Value 注解

@Value 注解可以用于将属性值注入到指定的属性中。与 @ConfigurationProperties 注解不同的是，@Value 注解必须在一个整体 Bean（例如一个 @Component）中使用，而不能单独用于一个属性上。示例如下：

@Component
public class MyComponent {
    @Value("${myprop1}")
    private String myProp1;

    @Value("${myprop2:default-value}")
    private String myProp2;
}

在本例中，我们定义了一个 MyComponent 类，其中的属性 myProp1 和 myProp2 分别对应了配置文件中的属性 myprop1 和 myprop2。${myprop1} 表示将配置文件中的 myprop1 属性注入到 myProp1 变量中，而 ${myprop2:default-value} 表示将配置文件中的 myprop2 属性注入到 myProp2 变量中，如果找不到配置文件中的 myprop2 属性，则使用 default-value 作为默认值。

总结起来，Spring Boot 提供了多种方式来使用外部配置文件，包括使用 @PropertySource 注解、@ConfigurationProperties 注解和 @Value 注解等等。根据具体的应用场景和需求，我们可以选择适合自己的方式来加载外部配置文件。

05、@SpringBootApplication 注解中启用自动配置机制的注解是什么？

在 @SpringBootApplication 注解中，启用自动配置机制的关键注解是 @EnableAutoConfiguration。这个注解告诉Spring Boot根据项目的依赖和配置文件来自动配置应用程序。它将根据路径中的 META-INF/spring.factories 文件来加载自动配置类，并应用相应的自动配置。

通过 @EnableAutoConfiguration 注解，Spring Boot可以根据项目的依赖自动配置各种功能模块，如web、数据库连接、JPA、缓存等。Spring Boot会根据配置文件和项目依赖的自动配置类，自动装配这些功能模块，简化了开发者的工作。

这个注解是Spring Boot的核心注解之一，它可以在主启动类上或者配置类上使用，用于启用自动配置的功能。通常情况下，我们会将 @EnableAutoConfiguration 注解放在主启动类上，以确保自动配置的生效。

例子：

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

在这个例子中，我们将 @EnableAutoConfiguration 所需的 @SpringBootApplication 注解添加到了 MyApplication 主启动类上。这样，Spring Boot会根据项目的依赖和配置文件来自动配置应用程序的各项功能。

06、@SpringBootApplication 中的 @EnableAutoConfiguration 注解的作用是什么？

@EnableAutoConfiguration 是 Spring Boot 的核心注解之一，用于开启 Spring Boot 的自动配置功能。它会根据项目的依赖和配置来自动配置应用程序的各项功能。具体来说，它会检查 classpath 下的各种 jar 包，根据这些 jar 包中的内容来决定应该配置哪些功能模块，比如 web、数据库连接、JPA、缓存等。

@EnableAutoConfiguration 具体的实现方式是通过读取 classpath 下的 META-INF/spring.factories 文件，来获取所有的自动配置类。Spring Boot 会将它们加载进来，并自动为应用程序进行配置。这一过程完全是自动化的，无需手动编写配置代码。

需要注意的是，启用自动配置功能的前提是要首先引入对应的 jar 包或模块。比如，如果需要连接 MySQL 数据库，就需要在 pom.xml 或 build.gradle 文件中引入 mysql-connector-java 的依赖。Spring Boot 使用 Maven 和 Gradle 进行依赖管理，会自动下载相应的依赖。

总之，@EnableAutoConfiguration 的作用是为 Spring Boot 应用程序开启自动配置功能，让开发者可以非常方便地构建基于 Spring Boot 的应用程序。

当您在使用 @SpringBootApplication 注解时，无需显式添加 @EnableAutoConfiguration 注解，因为 @SpringBootApplication 注解已经包含了 @EnableAutoConfiguration 的功能。

以下是一个简单的示例，展示了如何使用 @SpringBootApplication 注解开启自动配置功能：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

在上述示例中，@SpringBootApplication 注解被用于标记主启动类 Application。这个注解会启动自动配置机制，根据项目的依赖和配置来自动配置应用程序。

请注意，在使用此示例之前，您需要确保已经正确配置和引入了项目所需的相关依赖。具体的依赖配置可以通过 Maven 或 Gradle 等构建工具进行。

希望以上示例能够帮助您理解 @SpringBootApplication 注解以及内部的 @EnableAutoConfiguration 的使用方式。如有任何进一步的疑问，请随时提问。

07、@SpringBootApplication 中的 @ComponentScan 注解的作用是什么？

@ComponentScan 是 Spring Framework 的注解之一，也是在 @SpringBootApplication 中常用的注解之一。它的作用是扫描和注册 Spring Bean 组件。

Spring Bean 组件是应用程序中的各个类，通过将其标记为 @Component 或其派生注解（如 @Controller、@Service、@Repository 等），使其成为 Spring IoC 容器的管理对象。这些组件可以通过依赖注入来实现解耦和管理。

@ComponentScan 注解告诉 Spring 在指定的包及其子包下进行组件扫描。Spring 会自动检测注解标记的类，并将其实例化为 Spring Bean。这样，就可以方便地在应用程序中使用通过自动扫描注册的 Spring Bean。

以下是一个示例代码，展示了如何使用 @ComponentScan 注解来指定要扫描的包：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ComponentScan;

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

在上述示例中，@ComponentScan 注解指定了要扫描的包路径为 "com.example"。Spring 将会扫描该包及其子包下的组件，并将它们注册为 Spring Bean。

需要注意的是，默认情况下，@ComponentScan 会扫描主启动类所在的包及其子包下的组件。通过指定 basePackages 属性，我们可以自定义扫描的包路径。

总之，@ComponentScan 的作用是告诉 Spring 扫描指定的包及其子包下的组件，并将它们注册为 Spring Bean，以供应用程序使用。它与 @SpringBootApplication 注解一起使用，可以方便地进行组件的扫描和注册。

08、@SpringBootApplication 中的 @Configuration 注解的作用是什么？

@Configuration 是 Spring Framework 的注解之一，它的作用是将标注的类声明为配置类。在 @SpringBootApplication 中使用 @Configuration 注解意味着将该类作为配置类来使用。

配置类用于定义 Bean 的创建和配置，相当于 Spring 配置文件中的 元素。在配置类中，可以使用 @Bean 注解定义方法，方法的返回值将被注册为 Spring Bean，并交由 Spring IoC 容器进行管理。

@SpringBootApplication 注解本身就包含了 @Configuration 注解的功能，所以在主启动类上添加 @Configuration 注解是可选的。

以下是一个示例代码，展示了如何在 @SpringBootApplication 中使用 @Configuration 注解：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
    
    @Bean
    public MyBean myBean() {
        // 创建并返回 MyBean 实例
        return new MyBean();
    }
}

在上述示例中，Application 类被标注为 @SpringBootApplication 注解，它同时也是一个配置类，因为 @Configuration 在 @SpringBootApplication 中已经包含了。

在 Application 类中，使用 @Bean 注解定义了一个名为 myBean 的方法，该方法会返回一个 MyBean 实例，这个实例会被注册为 Spring Bean。

通过在配置类中定义 @Bean 方法，我们可以更加灵活地创建和配置 Spring Bean，并由 Spring IoC 容器进行管理。

总之，@Configuration 注解的作用是将标注的类声明为配置类，用于定义 Bean 的创建和配置。在 @SpringBootApplication 中使用 @Configuration 注解是可选的，因为 @Configuration 功能已经包含在 @SpringBootApplication 中。

09、@SpringBootApplication 注解的详细用法是怎样的？

@SpringBootApplication 是一个组合注解，它是 Spring Boot 提供的一个用于简化配置的注解。它包含了以下三个注解的功能：

1. @Configuration: 将类标记为配置类，用于定义 Bean 的创建和配置。
2. @EnableAutoConfiguration: 开启自动配置功能，让 Spring Boot 自动根据依赖、配置和类路径等信息来进行自动配置。
3. @ComponentScan: 开启组件扫描，让 Spring Boot 扫描并注册当前包及其子包下的所有 Spring 组件，包括定义的控制器、服务等。

因此，通过在主启动类上添加 @SpringBootApplication 注解，就可以同时实现上述三个注解的功能，简化了配置并提供了自动化的特性。

以下是一个示例代码，展示了 @SpringBootApplication 注解的详细用法：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication // 在主启动类上添加 @SpringBootApplication 注解
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

在上述示例中，Application 类被标注为 @SpringBootApplication 注解，这意味着它是主启动类，并且具备了配置类、自动配置和组件扫描的功能。

通过 SpringApplication.run(Application.class, args) 方法来启动 Spring Boot 应用，它会自动扫描、加载配置，并启动嵌入式的 Tomcat 服务器，以提供 Web 服务。

总之，@SpringBootApplication 是一个组合注解，包含了 @Configuration、@EnableAutoConfiguration 和 @ComponentScan 的功能，可以简化配置并提供自动化的特性。在主启动类上添加该注解，即可启动一个 Spring Boot 应用。

10、如何禁用 @SpringBootApplication 中的自动配置机制？

如果你需要禁用 @SpringBootApplication 中的自动配置机制，你可以使用 exclude 参数来排除特定的自动配置类。你可以在 @SpringBootApplication 注解上使用 exclude 参数，并传入要排除的自动配置类的类对象或类数组。

以下是一个示例代码，展示了如何禁用自动配置：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration;

@SpringBootApplication(exclude = {SecurityAutoConfiguration.class}) // 使用 exclude 参数排除 SecurityAutoConfiguration 类
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

在上述示例中，我们将 SecurityAutoConfiguration.class 作为 exclude 参数传递给 @SpringBootApplication 注解，这样就禁用了 Spring Boot 的安全自动配置。

同样地，你也可以传入其他的自动配置类来禁用相应的自动配置。

需要注意的是，禁用自动配置可能会导致某些功能无法正常工作，因此在禁用自动配置之前，建议仔细考虑和测试应用的需求和功能。

除了使用 exclude 参数来禁用特定的自动配置类，还有其他方法可以禁用 @SpringBootApplication 中的自动配置机制。下面介绍两种常用的方法：

1. 使用 @EnableAutoConfiguration 注解：@SpringBootApplication 实际上包含了@EnableAutoConfiguration 注解，因此你可以直接在主启动类上使用 @EnableAutoConfiguration 注解来启用自动配置。如果你不需要自动配置，可以将该注解添加到主启动类上并添加 exclude 参数来排除所有自动配置类。例如：

   import org.springframework.boot.SpringApplication;
   import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
   import org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration;
   
   @EnableAutoConfiguration(exclude = {SecurityAutoConfiguration.class}) // 使用 exclude 参数排除 SecurityAutoConfiguration 类
   public class Application {
       public static void main(String[] args) {
           SpringApplication.run(Application.class, args);
       }
   }
   

   这样可以禁用 @SpringBootApplication 中的自动配置机制，只保留你手动添加的配置。

2. 使用配置属性：Spring Boot 提供了一系列的配置属性，可以通过配置文件或者代码设置来控制自动配置的行为。你可以通过设置相关的配置属性来禁用自动配置。例如，在 application.properties 或者 application.yml 配置文件中添加以下配置项可以禁用所有自动配置：

   spring.autoconfigure.exclude=org.springframework.boot.autoconfigure.*
   

   或者在主启动类中使用 SpringApplication.setDefaultProperties() 方法来设置配置属性，例如：

   import org.springframework.boot.SpringApplication;
   
   public class Application {
       public static void main(String[] args) {
           SpringApplication.setDefaultProperties(Collections.singletonMap("spring.autoconfigure.exclude", "org.springframework.boot.autoconfigure.*"));
   
           SpringApplication.run(Application.class, args);
       }
   }
   

   通过设置 spring.autoconfigure.exclude 属性为自动配置类的包名或者通配符，可以禁用相应的自动配置。

无论你选择哪种方法，禁用自动配置都需要谨慎操作，确保你明确了解禁用的自动配置对你的应用会产生什么影响。