SpringBoot核心特性详解

1、什么是SpringBoot？

Spring Boot 是由 Pivotal 团队提供的一个基于 Spring 框架的项目，它旨在简化 Spring 应用的开发和部署。Spring Boot 通过提供一系列的约定和开箱即用的功能，使得开发者可以更快地构建独立的、生产级的 Spring 应用程序，而无需进行繁琐的配置。

2、为什么要学SpringBoot？

提高开发效率SpringBoot通过自动化配置和简化的依赖管理，使开发者能够更专注于业务逻辑的实现，从而提高开发效率。

降低学习曲线对于新手来说，Spring框架的配置较为复杂，而SpringBoot通过自动化配置，降低了学习曲线。

简化部署SpringBoot应用可以打包成独立的JAR文件，直接运行，简化了部署过程。

强大的社区支持SpringBoot拥有强大的社区支持，遇到问题可以快速找到解决方案。

3、SpringBoot的核心特性

自动配置： Spring Boot 提供了自动配置功能，能够根据项目中的依赖和配置自动设置 Spring 应用的默认配置。这减少了开发者手动配置的工作量。
独立运行的 Spring 应用： Spring Boot 可以将应用打包成一个独立的 JAR 文件，内嵌一个 Web 容器（如 Tomcat、Jetty），使得应用可以通过java -jar命令直接运行。
生产级功能： Spring Boot 提供了一系列生产级功能，如监控、健康检查、外部化配置、指标收集等，帮助开发者更好地管理和监控应用。
简化的依赖管理： Spring Boot 提供了一系列的 "starter" 依赖，帮助开发者快速引入常用的库和框架。这些 starter 依赖已经过精心选择和配置，确保它们能够很好地协同工作。

4、SpringBoot的核心功能

起步依赖:起步依赖本质上是一个Maven项目对象模型（Project Object Model，POM），定义了对其他库的传递依赖，这些东西加在一起即支持某项功能。简单的说，起步依赖就是将具备某种功能的坐标打包到一起，并提供一些默认的功能。

2.自动配置: Spring Boot的自动配置是一个运行时（更准确地说，是应用程序启动时）的过程，考虑了众多因素，才决定Spring配置应该用哪个，不该用哪个。该过程是Spring自动完成的。

5、以简单案例认识SpringBoot？

1、打开 IntelliJ IDEA，点击 New Project（新建项目），选择 Spring Initializr，设置项目相关配置。

2、根据需要选择SpringBoot版本，及所需依赖。

3、查看项目创建，测试项目启动是否报错。

4、添加依赖

5、Spring Boot 项目目录结构搭建

6、编写Controller，测试接口是否访问成功

6、SpringBoot应用注解＠SpringBootApplication

在SpringBoot入口上添加的了注解＠SpringBootApplication，这个注解的定义如下：

复制代码

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package org.springframework.boot.autoconfigure;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import org.springframework.beans.factory.support.BeanNameGenerator;
import org.springframework.boot.SpringBootConfiguration;
import org.springframework.boot.context.TypeExcludeFilter;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.FilterType;
import org.springframework.context.annotation.ComponentScan.Filter;
import org.springframework.core.annotation.AliasFor;

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(
    excludeFilters = {@Filter(
    type = FilterType.CUSTOM,
    classes = {TypeExcludeFilter.class}
), @Filter(
    type = FilterType.CUSTOM,
    classes = {AutoConfigurationExcludeFilter.class}
)}
)
public @interface SpringBootApplication {
    @AliasFor(
        annotation = EnableAutoConfiguration.class
    )
    Class<?>[] exclude() default {};

    @AliasFor(
        annotation = EnableAutoConfiguration.class
    )
    String[] excludeName() default {};

    @AliasFor(
        annotation = ComponentScan.class,
        attribute = "basePackages"
    )
    String[] scanBasePackages() default {};

    @AliasFor(
        annotation = ComponentScan.class,
        attribute = "basePackageClasses"
    )
    Class<?>[] scanBasePackageClasses() default {};

    @AliasFor(
        annotation = ComponentScan.class,
        attribute = "nameGenerator"
    )
    Class<? extends BeanNameGenerator> nameGenerator() default BeanNameGenerator.class;

    @AliasFor(
        annotation = Configuration.class
    )
    boolean proxyBeanMethods() default true;
}

@SpringBootApplication注解实际上封装了以下三个核心注解：

@SpringBootConfiguration ：
标识该类是一个Spring Boot的配置类，是**@Configuration**注解的特殊形式，专门用于Spring Boot应用。
@EnableAutoConfiguration ：
启用Spring Boot的自动配置机制。该注解会根据项目的依赖（如classpath中的jar包）自动配置Spring应用的Bean。
@ComponentScan ：
启用组件扫描功能，自动发现并注册项目中的组件（如**@Component**、@Service、@Repository等注解标记的类），默认扫描当前包及其子包。

Spring Boot配置类注解

＠SpringBootConfiguration 其实是 Spring Boot 包装的＠Configuration 注解

复制代码

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration
@Indexed
public @interface SpringBootConfiguration {
    @AliasFor(
        annotation = Configuration.class
    )
    boolean proxyBeanMethods() default true;
}

＠Component 注解的功能是把普通 POJO 实例化到 Spring 容器中，相当于配置文件中的＜bean id =""class ＝""／＞。

在类上添加注解＠Configuration ，表明这个类代表一个 Spring 配置文件，与原来 XML配置是等效的。只不过现在用 Java 类加上一个＠Configuration 注解进行配置了，这种方式与 XML 相比可以称得上是极简风格了。同时基于注解的配置风格，使得代码的可读性也大大增高了。

Spring 容器可以扫描出任何我们添加了＠Component 注解的类， Bean 的注册逻辑在 ClassPathScanningCandidateComponentProvider 这个类的 registerDefaultFilters 方法里。

启用自动配置注解

@EnableAutoConfiguration 这个注解是 Spring Boot 的最核心注解。

复制代码

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import({AutoConfigurationImportSelector.class})
public @interface EnableAutoConfiguration {
    String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";

    Class<?>[] exclude() default {};

    String[] excludeName() default {};
}

其中，导入配置类注解＠Import 标识导入＠Configuration 标注的配置类。＠Import 用来整合所有在＠Configuration 注解中定义的 Bean 配置。这与我们将多个 XML 配置文件导人到单个文件的场景一致。＠Import注解实现了相同的功能。

使用＠EnableAutoConfiguration 注解可以启用Spring 应用程序上下文的自动配置， Spring Boot 会去尝试猜测和配置你可能需要的 Bean。自动配置类通常是根据类路径中你定义的 Bean来推断可能需要怎样的配置。

例如，如果在你的类路径中有tomcat-embedded.r这个类库，那么Spring Boot 会根据此信息来判断你可能需要一个 TomcatServletWebServerFactory（除非你已经定义了你自己的 ServletWebServerFactory Bean）。当然我们还可以通过设置exclude或者 excludeName 变量的值来手动排除你不想要的自动配置。

Spring Boot 默认扫描的包路径是人口类 DemoOHelloWorldApplication 所在的根包中，及其所有的子包。通常， SpringBoot 自动配置 Bean 是根据 Conditional Bean （条件Bean) 中注解的类信息来推断的。例如＠ConditionalOnClass 、＠ConditionalOnMissingBean注解。

组件扫描注解

组件扫描注解 ＠ComponentScan 提供的功能与 Spring XML 配置文件中的＜context: component-scan＞元素等价。对应＠ComponentScan注解的处理类是 ConfigurationClassParser。 @ComponentScan 告诉Spring去哪个package下面扫描 Spring 注解。Spring 会去自动扫描这些被 Spring 注解标注的类，并且将其注册到 Bean 容器中。

复制代码

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package org.springframework.context.annotation;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Repeatable;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import org.springframework.beans.factory.support.BeanNameGenerator;
import org.springframework.core.annotation.AliasFor;

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
@Documented
@Repeatable(ComponentScans.class)
public @interface ComponentScan {
    @AliasFor("basePackages")
    String[] value() default {};

    @AliasFor("value")
    String[] basePackages() default {};

    Class<?>[] basePackageClasses() default {};

    Class<? extends BeanNameGenerator> nameGenerator() default BeanNameGenerator.class;

    Class<? extends ScopeMetadataResolver> scopeResolver() default AnnotationScopeMetadataResolver.class;

    ScopedProxyMode scopedProxy() default ScopedProxyMode.DEFAULT;

    String resourcePattern() default "**/*.class";

    boolean useDefaultFilters() default true;

    Filter[] includeFilters() default {};

    Filter[] excludeFilters() default {};

    boolean lazyInit() default false;

    @Retention(RetentionPolicy.RUNTIME)
    @Target({})
    public @interface Filter {
        FilterType type() default FilterType.ANNOTATION;

        @AliasFor("classes")
        Class<?>[] value() default {};

        @AliasFor("value")
        Class<?>[] classes() default {};

        String[] pattern() default {};
    }
}

7、SpringBoot的自动配置原理

Spring Boot自动配置是一个智能化的配置机制，它能够：

自动检测依赖：根据classpath中存在的依赖jar包，自动判断需要配置哪些组件
条件化配置：只有在满足特定条件时才会进行自动配置
提供默认配置：为常用场景提供开箱即用的默认配置
支持自定义：允许开发者覆盖默认配置，提供个性化定制

Java配置

在整个SpringBoot 应用程序中，我们将看不到一个传统意义上的 Spring XMI 配置文件。其实，在 Spring3.x和 Spring4.x 中就出现了大量简化 XML 配置的解决方案。

例如：

组件扫描（ Component Scan) : Spring 去自动发现应用上下文中创建的 Bean。
自动装配（ Autowired) :Spring自动创建 Bean 之间的依赖。
通过 JavaConfig 方式实现 Java 代码配置 Bean。

条件化 Bean

Spring Boot 除了采用Java 、 Config 方式实现"零 XML "配置外，还大量采用了条件化 Bean 方式来实现自动化配置。

条件注解＠ Conditional

Spring 的条件装配机制基于 Condition 接口实现，该接口定义了 matches() 方法用于条件判断逻辑。开发者通过实现该接口创建自定义条件类，再结合 @Conditional 注解使用，Spring 容器会在启动时执行条件判断，仅当条件满足时才会注册对应的 Bean。这种机制是 Spring Boot 自动配置的核心基础，支持根据不同运行时环境动态控制组件的装配。

复制代码

@FunctionalInterface
public interface Condition {
    boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata);
}

假如你想一个或多个 Bean 只有在应用的路径下包含特定的库时才创建，那么这就会使用到＠Conditional 注解定义条件化的 Bean 。

复制代码

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Conditional {
    Class<? extends Condition>[] value();
}

Spring4.0中引入了条件化配置特性。条件化配置通过条件注解＠Conditional 来标注。条件注解是根据特定的条件来选择 Bean 对象的创建。条件注解根据不同的条件来做出不同的事情（简单说就是ifelse逻辑）。在 Spring中条件注解可以说是设计模式中状态模式的一种体现方式，同时也是面向对象编程中多态的应用部分。

常用的条件注解包括：

@ConditionalOnClass：当类路径上存在指定的类时，配置才会生效。

@ConditionalOnMissingClass：当类路径上不存在指定的类时，配置才会生效。

@ConditionalOnBean：当 Spring 容器中存在指定的 Bean 时，配置才会生效。

@ConditionalOnMissingBean：当 Spring 容器中不存在指定的 Bean 时，配置才会生效。@ConditionalOnProperty：当指定的属性存在或具有特定值时，配置才会生效。

@ConditionalOnResource：当类路径下存在指定的资源时，配置才会生效。

@ConditionalOnWebApplication：当当前应用是 Web 应用时，配置才会生效。@ConditionalOnNotWebApplication：当当前应用不是 Web 应用时，配置才会生效。

Spring Boot 自动配置过程

复制代码

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import({AutoConfigurationImportSelector.class})
public @interface EnableAutoConfiguration {
    String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";

    Class<?>[] exclude() default {};

    String[] excludeName() default {};
}

Spring Boot 自动配置其中的核心注解是＠Import(EnableAutoConfigurationlmportSelector.class），借助 EnableAutoConfigurationlmportSelector 、＠EnableAutoConfiguration 、 Spring Boot 应用将所有符合条件的＠Configuration 配置类都加载到当前Spring容器中。具体的实现是使用了 Spring 框架中原有的一个工具类 SpringFactoriesLoader。这样，＠ EnableAutoConfiguration 就可以智能实现 Bean 的自动配置。

@EnableAutoConfiguration注解

Spring Boot 中通过＠EnableAutoConfiguration 启用 Spring 应用程序上下文的自动配置，这个注解会导人一个 EnableAutoConfigurationlmportSelector 的类，而 AutoConf1gurationlmportSelector 这个类会去读取一个 spring.factories 下 key 为 EnableAutoConfiguration 对应的类全限定名的值。

复制代码

protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
    List<String> configurations = SpringFactoriesLoader.loadFactoryNames(this.getSpringFactoriesLoaderFactoryClass(), this.getBeanClassLoader());
    Assert.notEmpty(configurations, "No auto configuration classes found in META-INF/spring.factories. If you are using a custom packaging, make sure that file is correct.");
    return configurations;
}

这个 spring.factories里面配置的那些类，主要作用是告诉Spring Boot这个stareter所需要加载的那些＊ AutoConfiguration类，也就是你真正的要自动注册的那些 Bean或功能。然后，再实现一个 spring.factories指定的类，标上＠Configuration注解，一个starter就定义完了。通过org.springframework.boot.autoconfigure.AutoConfigurationimportSelector里面的 getCandidateConfigurations方法，获取到候选类的名字列表 List<String＞。

其中， loadFactoryNames的第 1 个参数是getSpringFactoriesLoaderFactorγClass（）方法直接返回的是 EnableAutoConfiguration.class

复制代码

protected Class<?> getSpringFactoriesLoaderFactoryClass() {
    return EnableAutoConfiguration.class;
}

所以， getCandidateConfigurations 方法里面的这段代码：

复制代码

List<String> configurations = SpringFactoriesLoader.
loadFactoryNames(this.getSpringFactoriesLoaderFactoryClass()
                 , this.getBeanClassLoader());

会过滤出 key 为org.springframework.boot.autoconfigure.EnableAutoConfiguration的全限定名对应的值。其中， SpringFactoriesLoader主要用来查询 META-INF/spring.factories 的properties 配置中指定class对应的所有实现类。

spring.factories 文件

Spring Boot 中的 META-INF/spring.factories ( spring-boot/spring-boot-autoconfigure/src/ main/resources/META-INF/spring.factories）配置文件的完整内容可参考SpringBoot 源代码工程，其中关于 EnableAutoConfiguration 的配置是：

复制代码

# Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\
org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration,\
org.springframework.boot.autoconfigure.batch.BatchAutoConfiguration,\
org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration,\
org.springframework.boot.autoconfigure.cassandra.CassandraAutoConfiguration,\
org.springframework.boot.autoconfigure.context.ConfigurationPropertiesAutoConfiguration,\
org.springframework.boot.autoconfigure.context.LifecycleAutoConfiguration,\
org.springframework.boot.autoconfigure.context.MessageSourceAutoConfiguration,\
org.springframework.boot.autoconfigure.context.PropertyPlaceholderAutoConfiguration,\
...

这些 AutoConfiguration 不是所有都会加载的，会根据 AutoConfiguration 上的 @ConditionalOnClass 等条件，再进一步判断是否加载。

Spring Boot 自动配置的工作流程可以分为以下几个步骤：

1、启动应用并初始化自动配置

当 Spring Boot 应用启动时，@SpringBootApplication 注解中的 @EnableAutoConfiguration 会触发自动配置机制。AutoConfigurationImportSelector 开始工作，在 Spring 上下文刷新阶段调用 selectImports() 方法，准备加载符合条件的自动配置类。

2、扫描并加载 spring.factories 中的候选配置

AutoConfigurationImportSelector 通过 SpringFactoriesLoader.loadFactoryNames() 扫描所有依赖中的 META-INF/spring.factories 文件，提取 org.springframework.boot.autoconfigure.EnableAutoConfiguration 下列出的所有自动配置类（如 DataSourceAutoConfiguration、WebMvcAutoConfiguration 等），形成候选配置列表。

3、过滤重复配置并排除指定类

Spring Boot 会去除重复的配置类，并检查 @EnableAutoConfiguration 的 exclude 或 excludeName 属性，移除显式排除的配置类，确保最终的候选列表不包含被排除的自动配置。

4、评估条件注解决定是否生效

每个候选配置类上的条件注解（如 @ConditionalOnClass、@ConditionalOnMissingBean）会被逐一检查，只有满足所有条件的配置类才会被真正加载。例如，DataSourceAutoConfiguration 仅在检测到 DataSource 类存在且未手动定义 DataSource Bean 时才会生效。

5、注册符合条件的配置类并应用

通过条件检查的自动配置类会被 Spring 容器处理，其中定义的 @Bean 方法会向 IoC 容器注册相应的 Bean（如自动配置的 DataSource、JdbcTemplate）。最终，这些自动配置的 Bean 会被集成到应用中，完成零配置或按需加载的自动化行为。

8、SpringBoot的启动流程是怎么样的？

1. 入口类与main方法

Spring Boot应用的启动入口是标注**@SpringBootApplication**的主类，其main方法调用SpringApplication.run()。@SpringBootApplication组合了@SpringBootConfiguration、@EnableAutoConfiguration和@ComponentScan，标记该类为配置类并启用自动配置与组件扫描。

2. SpringApplication实例化

SpringApplication构造函数通过getSpringFactoriesInstances 加载META-INF/spring.factories中定义的ApplicationContextInitializer和ApplicationListener实现类，初始化应用上下文初始化器和监听器，为后续事件发布做准备。

3. 运行阶段准备

run()方法启动时，先创建StopWatch计时器，接着通过SpringApplicationRunListeners发布ApplicationStartingEvent事件，通知监听器应用启动开始。此时环境变量和配置尚未加载。

4. 环境准备

构造ConfigurableEnvironment（根据Web应用类型选择StandardServletEnvironment或StandardEnvironment），加载配置文件（如application.properties）、命令行参数等，并发布ApplicationEnvironmentPreparedEvent事件，允许监听器修改环境配置。

根据spring.banner.location配置或默认规则加载Banner文本（如banner.txt），通过SpringApplicationBannerPrinter输出到控制台，支持自定义Banner实现。

6. 创建应用上下文

根据应用类型（Servlet/Reactive）实例化对应的ApplicationContext，如AnnotationConfigServletWebServerApplicationContext。此时会初始化Bean定义读取器和扫描器，但尚未加载Bean。

7. 预处理上下文

调用prepareContext()方法，注册主配置类（primarySources）、绑定环境到上下文，并执行之前加载的ApplicationContextInitializer的initialize方法，对上下文进行自定义扩展。

8. 刷新上下文

核心阶段：调用refreshContext()触发AbstractApplicationContext.refresh()，完成Bean工厂配置、Bean定义加载、依赖注入、AOP代理等。其中invokeBeanFactoryPostProcessors处理自动配置类（如@EnableAutoConfiguration逻辑）。

9. 内嵌服务器启动

如果是Web应用，onRefresh()会调用createWebServer()创建内嵌Tomcat/Jetty/Netty服务器，初始化Servlet容器（如注册DispatcherServlet），并通过start()启动服务。此时应用已可处理HTTP请求。

10. 后置处理与启动完成

执行afterRefresh()钩子方法，发布ApplicationReadyEvent事件，启动完成。同时调用CommandLineRunner和ApplicationRunner的实现类，执行自定义启动逻辑。最后返回初始化好的ConfigurableApplicationContext。

SpringBoot核心特性详解

1、什么是SpringBoot？

2、为什么要学SpringBoot？

3、SpringBoot的核心特性

4、SpringBoot的核心功能

5、以简单案例认识SpringBoot？

1、打开 IntelliJ IDEA，点击 New Project（新建项目），选择 Spring Initializr，设置项目相关配置。

2、根据需要选择SpringBoot版本，及所需依赖。

3、查看项目创建，测试项目启动是否报错。

4、添加依赖

5、Spring Boot 项目目录结构搭建

6、编写Controller，测试接口是否访问成功

6、SpringBoot应用注解＠SpringBootApplication

Spring Boot配置类注解

启用自动配置注解

组件扫描注解

7、SpringBoot的自动配置原理

Java配置

条件化 Bean

条件注解＠ Conditional

Spring Boot 自动配置过程

@EnableAutoConfiguration注解

spring.factories 文件

Spring Boot 自动配置的工作流程可以分为以下几个步骤：

1、启动应用并初始化自动配置

2、扫描并加载 spring.factories 中的候选配置

3、过滤重复配置并排除指定类

4、评估条件注解决定是否生效

5、注册符合条件的配置类并应用

8、SpringBoot的启动流程是怎么样的？

1. 入口类与main方法

2. SpringApplication实例化

3. 运行阶段准备

4. 环境准备

5. 打印Banner

6. 创建应用上下文

7. 预处理上下文

8. 刷新上下文

9. 内嵌服务器启动

10. 后置处理与启动完成