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

2.2.2 自动配置核心流程

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

// 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 {};
}

步骤 2：@EnableAutoConfiguration 核心逻辑

// @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);
}

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

• Spring Boot 启动时，会扫描 META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports 文件（Spring Boot 2.7+），该文件包含所有自动配置类的全限定名；
• 每个自动配置类（如 WebMvcAutoConfiguration）通过 @Conditional 系列注解判断是否生效，例如：

// 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;
    }
}

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

1. 初始化 SpringApplication：解析启动类、设置应用类型（Servlet/Reactive）、加载初始化器和监听器；
2. 加载环境配置：读取 application.yml/application.properties、命令行参数、系统属性等；
3. 创建 ApplicationContext：根据应用类型创建 AnnotationConfigServletWebServerApplicationContext（Servlet 应用）；
4. 刷新容器：
   • 执行 BeanFactoryPostProcessor；
   • 注册 BeanPostProcessor；
   • 初始化 MessageSource；
   • 初始化事件多播器；
   • 初始化嵌入式 Servlet 容器（Tomcat）；
   • 注册并初始化所有 Bean；
5. 启动嵌入式容器：启动 Tomcat/Jetty，绑定端口；
6. 执行启动后处理器：触发 ApplicationReadyEvent 事件，应用启动完成。

三、Spring Boot 核心功能解析

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

Spring Boot 实现内嵌 Tomcat 运行服务的核心逻辑是：通过自动配置创建 Tomcat 容器实例 → 将 Spring MVC 核心 Servlet（DispatcherServlet）注册到 Tomcat → 启动 Tomcat 并绑定端口监听请求，整个过程无需手动部署 WAR 包，完全由 Spring Boot 自动完成。

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

Spring Boot 的 spring-boot-starter-web 起步依赖会自动引入内嵌 Tomcat 的核心依赖，无需手动添加 Tomcat 相关 jar 包。

关键依赖（Maven）

<!-- 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>

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

Spring Boot 通过 TomcatServletWebServerFactoryAutoConfiguration 自动配置类，创建 Tomcat 容器的工厂类 TomcatServletWebServerFactory，这是创建 Tomcat 实例的核心入口。

核心源码：TomcatServletWebServerFactoryAutoConfiguration

// 仅在 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;
    }
}

关键说明：

• @ConditionalOnClass：确保类路径存在 Tomcat 核心类时才生效；
• TomcatServletWebServerFactory：Tomcat 容器的工厂类，负责创建 TomcatWebServer（封装 Tomcat 实例的类）。

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

Spring Boot 启动的核心阶段是 ApplicationContext 的 refresh() 方法，对于 Web 应用（ServletWebServerApplicationContext），会在刷新过程中调用 createWebServer() 方法创建 Tomcat 容器。

核心源码：ServletWebServerApplicationContext

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();
    }
}

关键说明：

• onRefresh()：ApplicationContext 刷新时触发，是创建 Web 容器的核心时机；
• factory.getWebServer()：调用 TomcatServletWebServerFactory 的方法创建 TomcatWebServer（Tomcat 容器实例）。

步骤 4：TomcatWebServer 初始化 Tomcat 实例

TomcatServletWebServerFactory 的 getWebServer() 方法会创建 Tomcat 实例，配置连接器（Connector）、引擎（Engine）、主机（Host）、上下文（Context）等核心组件。

核心源码：TomcatServletWebServerFactory

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());
    }
}

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

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;
        }
    }
}

关键说明：

• TomcatWebServer 封装了原生 Tomcat 实例，负责 Tomcat 的启动、停止；
• tomcat.start()：调用原生 Tomcat 的启动方法，启动连接器监听端口。

步骤 5：注册 DispatcherServlet 到 Tomcat

Spring MVC 的核心 Servlet（DispatcherServlet）会被注册到 Tomcat 的 ServletContext 中，绑定默认的 / 路径，接收所有请求。

核心源码：DispatcherServletAutoConfiguration

@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;
    }
}

关键说明：

• DispatcherServletRegistrationBean：负责将 DispatcherServlet 注册到 Tomcat 的 ServletContext；
• 默认映射路径为 /：所有请求都会被 DispatcherServlet 接收，然后转发到对应的 Controller。

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

Tomcat 启动后，连接器（Connector）会监听配置的端口（默认 8080），当客户端发送请求时：

1. Tomcat 的连接器接收请求；
2. 请求被转发到 DispatcherServlet；
3. DispatcherServlet 按照 Spring MVC 的流程处理请求（匹配 Controller、执行业务逻辑、返回响应）；
4. Tomcat 将响应返回给客户端。

Spring Boot 中内嵌 Tomcat 的启动是：Spring Boot 应用上下文（ApplicationContext）执行 refresh() 刷新操作时，在 onRefresh() 方法中触发 createWebServer()，最终在 TomcatWebServer 初始化阶段调用原生 Tomcat 的 start() 方法完成启动。

3.2 配置管理

3.2.1 配置文件类型

• 核心文件：application.properties / application.yml（优先级：yml > properties）；
• 多环境配置：
  • application-dev.yml（开发环境）；
  • application-test.yml（测试环境）；
  • application-prod.yml（生产环境）。

3.2.2 激活多环境

# 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

3.2.3 配置绑定（@ConfigurationProperties）

// 绑定配置文件中的属性
@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

3.3 嵌入式容器

3.3.1 默认容器（Tomcat）配置

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

3.3.2 切换容器（如 Jetty）

<!-- 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>

3.4 应用监控（Actuator）

3.4.1 核心依赖

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

3.4.2 核心配置

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

3.4.3 常用端点

四、Spring Boot 与 Spring MVC 整合实战

4.1 基础整合

4.1.1 核心依赖

<!-- 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>

4.1.2 启动类

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

4.1.3 控制器（Spring MVC）

@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
}

4.1.4 配置文件（application.yml）

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/

4.2 自定义 Spring MVC 配置

4.2.1 扩展 WebMvcConfigurer

@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);
    }
}

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

若需要完全替换 Spring Boot 的默认 MVC 配置，可添加 @EnableWebMvc 注解（会禁用自动配置）：

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

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

@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 高级特性

5.1 外部化配置优先级

Spring Boot 加载配置的优先级（从高到低）：

1. 命令行参数（如 java -jar app.jar --server.port=8081）；
2. 系统环境变量；
3. 应用外部的 application-{profile}.yml；
4. 应用内部的 application-{profile}.yml；
5. 应用外部的 application.yml；
6. 应用内部的 application.yml；
7. @PropertySource 注解加载的配置；
8. 默认配置（Spring Boot 自动配置）。

5.2 自定义启动 Banner

1. 在 resources 目录下创建 banner.txt 文件；
2. 写入自定义 Banner（可通过 Banner 生成工具 生成）：

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

5.3 异步处理

5.3.1 异步控制器

@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;
    }
}

5.4 打包与部署

5.4.1 打包为 JAR 包

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

5.4.2 打包为 WAR 包

1. 修改 pom.xml：

<!-- 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>

2. 修改启动类：

@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);
    }
}

3. 打包并部署到外部 Tomcat：

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

六、Spring Boot 常见问题

6.1 基础概念类

1. Spring Boot 的核心注解是什么？各部分作用？
   • @SpringBootApplication：核心注解，整合 @SpringBootConfiguration（配置类）、@EnableAutoConfiguration（自动配置）、@ComponentScan（组件扫描）；
   • @EnableAutoConfiguration：开启自动配置，通过 AutoConfigurationImportSelector 加载自动配置类。
2. Spring Boot 自动配置原理？
   • 核心：@EnableAutoConfiguration → AutoConfigurationImportSelector → 加载 META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports 中的自动配置类 → 通过 @Conditional 注解判断是否生效 → 注册默认 Bean（可通过 @ConditionalOnMissingBean 自定义覆盖）。
3. Spring Boot 与 Spring MVC 的关系？
   • Spring Boot 是开发脚手架，Spring MVC 是 Web 开发框架；
   • 引入 spring-boot-starter-web 后，Spring Boot 通过 WebMvcAutoConfiguration 自动配置 Spring MVC 核心组件（DispatcherServlet、HandlerMapping、HandlerAdapter 等）；
   • 开发者可通过 WebMvcConfigurer 扩展 Spring MVC 配置，或通过 @EnableWebMvc 完全自定义。

6.2 实战问题类

1. 如何自定义 Spring Boot 的自动配置？
   • 步骤：
     1. 编写自动配置类（@Configuration + @Conditional 系列注解）；
     2. 编写配置属性绑定类（@ConfigurationProperties）；
     3. 在 META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports 中配置自动配置类全限定名；
     4. 打包为 starter，引入即可自动生效。
2. Spring Boot 如何实现多环境配置？
   • 方式 1：通过 spring.profiles.active 激活指定环境（如 spring.profiles.active=prod）；
   • 方式 2：通过命令行参数激活（java -jar app.jar --spring.profiles.active=test）；
   • 方式 3：通过系统环境变量激活（SPRING_PROFILES_ACTIVE=dev）。
3. Spring Boot 启动失败，端口被占用如何解决？
   • 方式 1：修改端口（server.port=8081）；
   • 方式 2：查找并杀死占用端口的进程（netstat -ano | findstr 8080 → taskkill /F /PID 进程 ID）；
   • 方式 3：配置端口随机（server.port=0）。

6.3 性能优化类

1. Spring Boot 应用性能优化要点？
   • 容器优化：调整 Tomcat 线程池（server.tomcat.max-threads）、连接超时时间；
   • JVM 优化：设置 JVM 参数（-Xms512m -Xmx1024m）；
   • 依赖优化：移除无用 starter，减少依赖体积；
   • 配置优化：关闭不必要的自动配置，启用缓存（如 Thymeleaf 缓存）；
   • 代码优化：使用异步处理（@Async）、减少拦截器耗时逻辑。

七、总结

核心关键点

1. 核心定位：Spring Boot 是 Spring 生态的快速开发脚手架，核心理念是「约定优于配置」，通过自动配置和起步依赖简化开发；
2. 自动配置：
   • 核心触发点：@EnableAutoConfiguration → AutoConfigurationImportSelector → 加载自动配置类；
   • 核心控制：@Conditional 系列注解（如 @ConditionalOnClass、@ConditionalOnMissingBean）控制配置是否生效；
3. 与 Spring MVC 整合：
   • 引入 spring-boot-starter-web 自动配置 Spring MVC 核心组件；
   • 通过 WebMvcConfigurer 扩展 MVC 配置（拦截器、跨域、消息转换器）；
   • 避免滥用 @EnableWebMvc（会禁用自动配置）；
4. 最佳实践：
   • 优先使用起步依赖，避免手动管理依赖版本；
   • 多环境配置通过 spring.profiles.active 激活；
   • 自定义配置优先使用 @ConfigurationProperties 绑定，而非 @Value；
   • 部署优先选择 JAR 包（内置容器），简化部署流程；
   • 应用监控引入 spring-boot-starter-actuator，实时监控应用状态。