Spring Boot 核心架构与自动配置原理深度解析

Spring Boot 核心架构与自动配置原理深度解析 | 极客日志

注解	作用	示例
`@SpringBootApplication`	核心注解，整合 3 个关键注解：`@SpringBootConfiguration` + `@EnableAutoConfiguration` + `@ComponentScan`	标注在启动类上
`@EnableAutoConfiguration`	开启自动配置，触发 Spring Boot 扫描并加载自动配置类	核心底层注解
`@AutoConfiguration`	Spring Boot 2.7+ 替代 `@Configuration` 的自动配置注解，控制配置加载顺序	`@AutoConfiguration(after = WebMvcAutoConfiguration.class)`
`@Conditional`	条件注解父类，满足指定条件才加载 Bean	-
`@ConditionalOnClass`	类路径存在指定类时生效	`@ConditionalOnClass({DispatcherServlet.class})`
`@ConditionalOnMissingClass`	类路径不存在指定类时生效	-
`@ConditionalOnBean`	容器中存在指定 Bean 时生效	-
`@ConditionalOnMissingBean`	容器中不存在指定 Bean 时生效（允许自定义覆盖默认配置）	`@ConditionalOnMissingBean(HandlerMapping.class)`
`@ConditionalOnProperty`	配置文件中存在指定属性时生效	`@ConditionalOnProperty(prefix = "spring.mvc", name = "enabled", havingValue = "true")`

// Spring Boot 启动类核心代码
@SpringBootApplication
public class SpringBootDemoApplication {
    public static void main(String[] args) {
        // 核心方法：启动 Spring Boot 应用
        SpringApplication.run(SpringBootDemoApplication.class, args);
    }
}

// @SpringBootApplication 注解源码（核心拆解）
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration // 等价于 @Configuration，标记配置类
@EnableAutoConfiguration // 开启自动配置
@ComponentScan(excludeFilters = {
    @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
    @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class)
})
public @interface SpringBootApplication {
    Class<?>[] exclude() default {};
    String[] excludeName() default {};
    String[] scanBasePackages() default {};
}

// @EnableAutoConfiguration 注解源码
@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 {};
}

// AutoConfigurationImportSelector 核心方法：加载自动配置类
@Override
public String[] selectImports(AnnotationMetadata annotationMetadata) {
    if (!isEnabled(annotationMetadata)) {
        return NO_IMPORTS;
    }
    // 1. 加载 META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports 文件
    AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry(annotationMetadata);
    return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
}

// 加载自动配置类的核心方法
protected AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {
    if (!isEnabled(annotationMetadata)) {
        return EMPTY_ENTRY;
    }
    AnnotationAttributes attributes = getAttributes(annotationMetadata);
    // 核心：从 META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports 加载所有自动配置类全限定名
    List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
    // 去重、排除指定类、过滤不满足条件的配置类
    configurations = removeDuplicates(configurations);
    Set<String> exclusions = getExclusions(annotationMetadata, attributes);
    checkExcludedClasses(configurations, exclusions);
    configurations.removeAll(exclusions);
    configurations = getConfigurationClassFilter().filter(configurations);
    fireAutoConfigurationImportEvents(configurations, exclusions);
    return new AutoConfigurationEntry(configurations, exclusions);
}

// WebMvcAutoConfiguration（Spring MVC 自动配置类）核心源码
@AutoConfiguration(after = {DispatcherServletAutoConfiguration.class, ValidationAutoConfiguration.class})
@ConditionalOnWebApplication(type = Type.SERVLET) // 仅 Servlet Web 应用生效
@ConditionalOnClass({Servlet.class, DispatcherServlet.class, WebMvcConfigurer.class}) // 类路径存在这些类才生效
@ConditionalOnMissingBean(WebMvcConfigurationSupport.class) // 容器中不存在该类才生效（避免自定义配置被覆盖）
@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE + 10)
public class WebMvcAutoConfiguration {
    // 配置视图解析器（Thymeleaf/JSP）
    @Bean
    @ConditionalOnMissingBean // 自定义 ViewResolver 会覆盖默认配置
    public InternalResourceViewResolver defaultViewResolver() {
        InternalResourceViewResolver resolver = new InternalResourceViewResolver();
        resolver.setPrefix(this.mvcProperties.getView().getPrefix());
        resolver.setSuffix(this.mvcProperties.getView().getSuffix());
        return resolver;
    }

    // 配置 RequestMappingHandlerMapping（Spring MVC 核心组件）
    @Bean
    @ConditionalOnMissingBean
    public RequestMappingHandlerMapping requestMappingHandlerMapping() {
        RequestMappingHandlerMapping mapping = createRequestMappingHandlerMapping();
        // 省略配置逻辑
        return mapping;
    }

    // 配置 RequestMappingHandlerAdapter
    @Bean
    @ConditionalOnMissingBean
    public RequestMappingHandlerAdapter requestMappingHandlerAdapter() {
        // 省略配置逻辑
        return adapter;
    }
}

<!-- spring-boot-starter-web 间接引入 tomcat 依赖 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- 其内部依赖的 tomcat 核心包（无需手动引入） -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-tomcat</artifactId>
</dependency>
<dependency>
    <groupId>org.apache.tomcat.embed</groupId>
    <artifactId>tomcat-embed-core</artifactId>
</dependency>
<dependency>
    <groupId>org.apache.tomcat.embed</groupId>
    <artifactId>tomcat-embed-websocket</artifactId>
</dependency>

// 仅在 Servlet 环境且存在 Tomcat 类时生效
@AutoConfiguration
@ConditionalOnClass({Servlet.class, Tomcat.class, UpgradeProtocol.class})
@ConditionalOnMissingBean(value = ServletWebServerFactory.class, search = SearchStrategy.CURRENT)
public class TomcatServletWebServerFactoryAutoConfiguration {
    // 创建 Tomcat 容器工厂 Bean（核心）
    @Bean
    public TomcatServletWebServerFactory tomcatServletWebServerFactory(
            ObjectProvider<TomcatConnectorCustomizer> connectorCustomizers,
            ObjectProvider<TomcatContextCustomizer> contextCustomizers,
            ObjectProvider<TomcatProtocolHandlerCustomizer<?>> protocolHandlerCustomizers) {
        TomcatServletWebServerFactory factory = new TomcatServletWebServerFactory();
        // 应用自定义配置（如端口、线程池等）
        factory.getTomcatConnectorCustomizers().addAll(connectorCustomizers.orderedStream().toList());
        factory.getTomcatContextCustomizers().addAll(contextCustomizers.orderedStream().toList());
        factory.getTomcatProtocolHandlerCustomizers().addAll(protocolHandlerCustomizers.orderedStream().toList());
        return factory;
    }
}

public class ServletWebServerApplicationContext extends GenericWebApplicationContext implements ConfigurableWebServerApplicationContext {
    private volatile WebServer webServer; // 封装 Tomcat 实例的对象

    @Override
    protected void onRefresh() {
        super.onRefresh();
        try {
            // 核心方法：创建 WebServer（即 Tomcat 容器）
            createWebServer();
        } catch (Throwable ex) {
            throw new ApplicationContextException("Unable to start web server", ex);
        }
    }

    private void createWebServer() {
        WebServer webServer = this.webServer;
        ServletContext servletContext = getServletContext();
        if (webServer == null && servletContext == null) {
            // 1. 获取步骤 2 中创建的 TomcatServletWebServerFactory
            ServletWebServerFactory factory = getWebServerFactory();
            // 2. 工厂创建 TomcatWebServer（核心）
            this.webServer = factory.getWebServer(getSelfInitializer());
            getBeanFactory().registerSingleton("webServerGracefulShutdown", new WebServerGracefulShutdownLifecycle(this.webServer));
            getBeanFactory().registerSingleton("webServerStartStop", new WebServerStartStopLifecycle(this, this.webServer));
        } else if (servletContext != null) {
            try {
                getSelfInitializer().onStartup(servletContext);
            } catch (ServletException ex) {
                throw new ApplicationContextException("Cannot initialize servlet context", ex);
            }
        }
        initPropertySources();
    }
}

public class TomcatServletWebServerFactory extends AbstractServletWebServerFactory {
    @Override
    public WebServer getWebServer(ServletContextInitializer initializers) {
        // 1. 创建 Tomcat 核心实例
        org.apache.catalina.startup.Tomcat tomcat = new org.apache.catalina.startup.Tomcat();
        // 2. 配置 Tomcat 临时目录
        File baseDir = (this.baseDirectory != null) ? this.baseDirectory : createTempDir("tomcat");
        tomcat.setBaseDir(baseDir.getAbsolutePath());
        // 3. 创建连接器（Connector），绑定配置的端口（默认 8080）
        Connector connector = new Connector(this.protocol);
        connector.setThrowOnFailure(true);
        tomcat.getService().addConnector(connector);
        customizeConnector(connector); // 应用端口、编码等配置
        tomcat.setConnector(connector);
        tomcat.getHost().setAutoDeploy(false);
        // 4. 创建 Tomcat 上下文（Context），对应 Web 应用的上下文路径
        prepareContext(tomcat.getHost(), initializers);
        // 5. 创建并返回 TomcatWebServer（封装 Tomcat 实例）
        return new TomcatWebServer(tomcat, getPort() >= 0, getShutdown());
    }
}

public class TomcatWebServer implements WebServer {
    private final org.apache.catalina.startup.Tomcat tomcat; // 原生 Tomcat 实例
    private final boolean autoStart;

    public TomcatWebServer(org.apache.catalina.startup.Tomcat tomcat, boolean autoStart) {
        this.tomcat = tomcat;
        this.autoStart = autoStart;
        initialize(); // 初始化 Tomcat
    }

    private void initialize() throws WebServerException {
        synchronized (this.monitor) {
            try {
                // 配置 Tomcat 引擎
                addInstanceIdToEngineName();
                // 启动 Tomcat（核心）
                this.tomcat.start();
                // 等待 Tomcat 启动完成，确保连接器监听端口
                startDaemonAwaitThread();
            } catch (Exception ex) {
                stopSilently();
                destroySilently();
                throw new WebServerException("Unable to start embedded Tomcat", ex);
            }
        }
    }

    @Override
    public void start() throws WebServerException {
        synchronized (this.monitor) {
            if (this.started) {
                return;
            }
            // 启动 Tomcat（autoStart=true 时会自动调用）
            this.tomcat.start();
            this.started = true;
        }
    }
}

@AutoConfiguration
@ConditionalOnWebApplication(type = Type.SERVLET)
@ConditionalOnClass(DispatcherServlet.class)
@AutoConfigureAfter(ServletWebServerFactoryAutoConfiguration.class)
public class DispatcherServletAutoConfiguration {
    // 注册 DispatcherServlet Bean
    @Bean(name = DEFAULT_DISPATCHER_SERVLET_BEAN_NAME)
    public DispatcherServlet dispatcherServlet(DispatcherServletProperties properties) {
        DispatcherServlet dispatcherServlet = new DispatcherServlet();
        dispatcherServlet.setDispatchOptionsRequest(properties.isDispatchOptionsRequest());
        dispatcherServlet.setDispatchTraceRequest(properties.isDispatchTraceRequest());
        // 省略其他配置
        return dispatcherServlet;
    }

    // 将 DispatcherServlet 注册到 Tomcat 的 ServletContext
    @Bean
    public DispatcherServletRegistrationBean dispatcherServletRegistrationBean(
            DispatcherServlet dispatcherServlet, WebMvcProperties webMvcProperties) {
        DispatcherServletRegistrationBean registration = new DispatcherServletRegistrationBean(
                dispatcherServlet, webMvcProperties.getServlet().getPath());
        registration.setName(DEFAULT_DISPATCHER_SERVLET_BEAN_NAME);
        registration.setLoadOnStartup(webMvcProperties.getServlet().getLoadOnStartup());
        if (webMvcProperties.getServlet().getMultipart() != null) {
            registration.setMultipartConfig(getMultipartConfig(webMvcProperties));
        }
        return registration;
    }
}

# application.yml
spring:
  profiles:
    active: dev # 激活开发环境
---
spring:
  config:
    activate:
      on-profile: dev
server:
  port: 8080
logging:
  level:
    root: DEBUG
---
spring:
  config:
    activate:
      on-profile: prod
server:
  port: 80
logging:
  level:
    root: INFO

// 绑定配置文件中的属性
@Configuration
@ConfigurationProperties(prefix = "app")
public class AppProperties {
    private String name;
    private String version;
    private Database database;

    // 静态内部类绑定嵌套属性
    public static class Database {
        private String url;
        private String username;
        private String password;
        // getter/setter
    }
    // getter/setter
}

# 配置文件（application.yml）
app:
  name: spring-boot-demo
  version: 1.0.0
  database:
    url: jdbc:mysql://localhost:3306/test
    username: root
    password: 123456

server:
  port: 8080
  servlet:
    context-path: /demo
  tomcat:
    uri-encoding: UTF-8
    max-threads: 200
    min-spare-threads: 10
    basedir: tomcat-temp

<!-- pom.xml 排除 Tomcat，引入 Jetty -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <exclusions>
        <exclusion>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
        </exclusion>
    </exclusions>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jetty</artifactId>
</dependency>

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

management:
  endpoints:
    web:
      exposure:
        include: health,info,metrics,beans,env
  base-path: /actuator
  endpoint:
    health:
      show-details: always
  metrics:
    enabled: true
    tags:
      application: spring-boot-demo

端点	功能
`/actuator/health`	应用健康状态
`/actuator/info`	应用自定义信息
`/actuator/metrics`	应用指标（JVM、CPU、内存）
`/actuator/beans`	容器中所有 Bean 信息
`/actuator/env`	环境配置信息
`/actuator/mappings`	Spring MVC 请求映射信息

<!-- pom.xml -->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>3.2.0</version>
    <relativePath/>
</parent>
<dependencies>
    <!-- Web Starter（自动包含 Spring MVC、Tomcat、Jackson） -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- 测试依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

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

@RestController
@RequestMapping("/user")
public class UserController {
    @GetMapping("/{id}")
    public ResponseEntity<User> getUserById(@PathVariable Long id) {
        User user = new User();
        user.setId(id);
        user.setName("Spring Boot + MVC");
        user.setAge(20);
        return ResponseEntity.ok(user);
    }

    @PostMapping
    public ResponseEntity<User> createUser(@RequestBody User user) {
        user.setId(100L);
        return ResponseEntity.status(HttpStatus.CREATED).body(user);
    }
}

// 实体类
public class User {
    private Long id;
    private String name;
    private Integer age;
    // getter/setter/toString
}

server:
  port: 8080
  servlet:
    context-path: /demo
spring:
  mvc:
    servlet:
      load-on-startup: 1
format:
  date: yyyy-MM-dd HH:mm:ss
web:
  resources:
    static-locations: classpath:/static/,classpath:/public/

@Configuration
public class WebMvcConfig implements WebMvcConfigurer {
    // 1. 自定义拦截器
    @Bean
    public LoginInterceptor loginInterceptor() {
        return new LoginInterceptor();
    }

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(loginInterceptor()).addPathPatterns("/api/**").excludePathPatterns("/api/login");
    }

    // 2. 自定义消息转换器（如 FastJson 替换 Jackson）
    @Override
    public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
        // 移除默认 Jackson 转换器
        converters.removeIf(converter -> converter instanceof MappingJackson2HttpMessageConverter);
        // 添加 FastJson 转换器
        FastJsonHttpMessageConverter fastJsonConverter = new FastJsonHttpMessageConverter();
        FastJsonConfig fastJsonConfig = new FastJsonConfig();
        fastJsonConfig.setDateFormat("yyyy-MM-dd HH:mm:ss");
        fastJsonConfig.setSerializerFeatures(SerializerFeature.WriteMapNullValue);
        fastJsonConverter.setFastJsonConfig(fastJsonConfig);
        converters.add(fastJsonConverter);
    }

    // 3. 自定义视图解析器（Thymeleaf）
    @Bean
    public ThymeleafViewResolver thymeleafViewResolver(ITemplateResolver templateResolver) {
        ThymeleafViewResolver resolver = new ThymeleafViewResolver();
        resolver.setTemplateResolver(templateResolver);
        resolver.setCharacterEncoding("UTF-8");
        return resolver;
    }

    // 4. 跨域配置
    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/api/**").allowedOriginPatterns("*").allowedMethods("GET","POST","PUT","DELETE").allowedHeaders("*").allowCredentials(true).maxAge(3600);
    }
}

@Configuration
@EnableWebMvc // 禁用 Spring Boot 的 WebMvcAutoConfiguration
public class FullWebMvcConfig implements WebMvcConfigurer {
    // 需手动配置所有 Spring MVC 组件（HandlerMapping、HandlerAdapter 等）
}

@RestControllerAdvice
public class GlobalExceptionHandler {
    // 处理参数绑定异常
    @ExceptionHandler(MethodArgumentNotValidException.class)
    public ResponseEntity<ErrorResponse> handleValidException(MethodArgumentNotValidException e) {
        String message = e.getBindingResult().getFieldError().getDefaultMessage();
        ErrorResponse error = new ErrorResponse(400, "参数错误", message);
        return ResponseEntity.badRequest().body(error);
    }

    // 处理业务异常
    @ExceptionHandler(BusinessException.class)
    public ResponseEntity<ErrorResponse> handleBusinessException(BusinessException e) {
        ErrorResponse error = new ErrorResponse(e.getCode(), "业务异常", e.getMessage());
        return ResponseEntity.status(e.getCode()).body(error);
    }

    // 处理所有未捕获异常
    @ExceptionHandler(Exception.class)
    public ResponseEntity<ErrorResponse> handleException(Exception e) {
        log.error("系统异常", e);
        ErrorResponse error = new ErrorResponse(500, "服务器内部错误", "系统繁忙，请稍后重试");
        return ResponseEntity.status(500).body(error);
    }

    // 错误响应实体
    @Data
    @AllArgsConstructor
    public static class ErrorResponse {
        private int code;
        private String type;
        private String message;
    }
}

 ____ _ _ _ _ _ 
| _ \ | | | | | | | | (_) | |_) | __ _| |_| |_| | ___ ___| |__ _ _ __ | _ < / _` | __| __| |/ _ \/ __| '_ \| | '_ \| |_) | (_| | |_| |_| | __/\__ \ | | | | |_) | |____/ \__,_|\__|\__|_|\___||___/_| |_|_| .__/ | | |_| :: Spring Boot :: (3.2.0)

@RestController
@RequestMapping("/async")
public class AsyncController {
    @Autowired
    private AsyncService asyncService;

    // 异步请求（返回 Callable）
    @GetMapping("/callable")
    public Callable<ResponseEntity<String>> asyncCallable() {
        return () -> {
            // 模拟耗时操作
            Thread.sleep(3000);
            return ResponseEntity.ok("异步响应（Callable）");
        };
    }

    // 异步请求（返回 CompletableFuture）
    @GetMapping("/future")
    public CompletableFuture<ResponseEntity<String>> asyncFuture() {
        return asyncService.doAsyncTask();
    }
}

// 异步服务
@Service
public class AsyncService {
    @Async // 异步方法
    public CompletableFuture<ResponseEntity<String>> doAsyncTask() {
        try {
            Thread.sleep(3000);
            return CompletableFuture.completedFuture(ResponseEntity.ok("异步响应（CompletableFuture）"));
        } catch (InterruptedException e) {
            return CompletableFuture.failedFuture(e);
        }
    }
}

// 启用异步
@SpringBootApplication
@EnableAsync // 开启异步支持
public class SpringBootDemoApplication {
    // 自定义线程池（可选）
    @Bean
    public Executor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5);
        executor.setMaxPoolSize(10);
        executor.setQueueCapacity(20);
        executor.setThreadNamePrefix("async-");
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        executor.initialize();
        return executor;
    }
}

mvn clean package -DskipTests
# 运行 JAR 包
java -jar target/spring-boot-demo-1.0.0.jar
# 指定配置文件运行
java -jar target/spring-boot-demo-1.0.0.jar --spring.config.location=file:/opt/config/application.yml
# 指定端口运行
java -jar target/spring-boot-demo-1.0.0.jar --server.port=8081

<!-- 1. 打包类型改为 war -->
<packaging>war</packaging>
<!-- 2. 排除嵌入式 Tomcat（由外部容器提供） -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <exclusions>
        <exclusion>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
        </exclusion>
    </exclusions>
</dependency>
<!-- 3. 添加 Tomcat 依赖（提供编译时依赖） -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-tomcat</artifactId>
    <scope>provided</scope>
</dependency>

@SpringBootApplication
public class SpringBootDemoApplication extends SpringBootServletInitializer {
    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
        return application.sources(SpringBootDemoApplication.class);
    }

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

mvn clean package -DskipTests
# 将 target 下的 WAR 包复制到 Tomcat 的 webapps 目录，启动 Tomcat 即可

Spring Boot 核心架构与自动配置原理深度解析

一、Spring Boot 核心定位

二、Spring Boot 核心架构与自动配置原理

2.1 核心架构分层

2.2 自动配置核心原理

2.2.1 自动配置核心注解

2.2.2 自动配置核心流程

步骤 1：启动类触发自动配置

步骤 2：@EnableAutoConfiguration 核心逻辑

步骤 3：自动配置类的加载与生效

2.3 Spring Boot 启动流程（核心步骤）

三、Spring Boot 核心功能解析

3.1 内嵌 Tomcat 运行服务的实现原理

步骤 1：引入内嵌 Tomcat 依赖（基础前提）

关键依赖（Maven）

步骤 2：自动配置 Tomcat 容器工厂（核心触发）

核心源码：TomcatServletWebServerFactoryAutoConfiguration

步骤 3：ApplicationContext 刷新时创建 Tomcat 容器

核心源码：ServletWebServerApplicationContext

步骤 4：TomcatWebServer 初始化 Tomcat 实例

核心源码：TomcatServletWebServerFactory

核心源码：TomcatWebServer（Tomcat 实例封装）

步骤 5：注册 DispatcherServlet 到 Tomcat

核心源码：DispatcherServletAutoConfiguration

步骤 6：Tomcat 启动完成，监听端口处理请求

3.2 配置管理

3.2.1 配置文件类型

3.2.2 激活多环境

3.2.3 配置绑定（@ConfigurationProperties）

3.3 嵌入式容器

3.3.1 默认容器（Tomcat）配置

3.3.2 切换容器（如 Jetty）

3.4 应用监控（Actuator）

3.4.1 核心依赖

3.4.2 核心配置

3.4.3 常用端点

四、Spring Boot 与 Spring MVC 整合实战

4.1 基础整合

4.1.1 核心依赖

4.1.2 启动类

4.1.3 控制器（Spring MVC）

4.1.4 配置文件（application.yml）

4.2 自定义 Spring MVC 配置

4.2.1 扩展 WebMvcConfigurer

4.2.2 完全自定义 Spring MVC 配置（慎用）

4.3 全局异常处理（Spring Boot + MVC）

五、Spring Boot 高级特性

5.1 外部化配置优先级

5.2 自定义启动 Banner

5.3 异步处理

5.3.1 异步控制器

5.4 打包与部署

5.4.1 打包为 JAR 包

5.4.2 打包为 WAR 包

六、Spring Boot 常见问题

6.1 基础概念类

6.2 实战问题类

6.3 性能优化类

七、总结

核心关键点

微信扫一扫，关注极客日志

更多推荐文章

相关免费在线工具