🔬 Spring Boot 自动配置 vs 原生 Spring

🎯 场景：搭一个 Spring MVC Web 项目

先看 DispatcherServlet 初始化时需要哪些组件（源码 spring-webmvc/DispatcherServlet.java:441）：

protected void initStrategies(ApplicationContext context) {
    initMultipartResolver(context);          // 1. 文件上传解析器
    initLocaleResolver(context);             // 2. 国际化解析器
    initHandlerMappings(context);            // 3. 处理器映射器（URL → Controller）
    initHandlerAdapters(context);            // 4. 处理器适配器（调用Controller方法）
    initHandlerExceptionResolvers(context);  // 5. 异常解析器
    initRequestToViewNameTranslator(context);// 6. 视图名称翻译器
    initViewResolvers(context);              // 7. 视图解析器
    initFlashMapManager(context);            // 8. Flash属性管理器
}

原生 Spring 手动配置全过程

① web.xml（必须手动声明 Servlet）

<servlet>
    <servlet-name>dispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:spring-mvc.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
    <servlet-name>dispatcherServlet</servlet-name>
    <url-pattern>/</url-pattern>
</servlet-mapping>

② spring-mvc.xml（每个组件都要手写）

<context:component-scan base-package="com.example.controller"/>
<mvc:annotation-driven/>

<!-- 视图解析器 -->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <property name="prefix" value="/WEB-INF/views/"/>
    <property name="suffix" value=".jsp"/>
</bean>

<!-- 文件上传 -->
<bean id="multipartResolver"
      class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
    <property name="maxUploadSize" value="10485760"/>
    <property name="defaultEncoding" value="UTF-8"/>
</bean>

<!-- 静态资源 -->
<mvc:resources mapping="/static/**" location="/static/"/>

<!-- 国际化 -->
<bean id="localeResolver" class="org.springframework.web.servlet.i18n.SessionLocaleResolver">
    <property name="defaultLocale" value="zh_CN"/>
</bean>

<!-- 异常解析 -->
<bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
    <property name="defaultErrorView" value="error"/>
</bean>

③ 还要手动整合数据源、事务、MyBatis...

<bean id="dataSource" class="com.zaxxer.hikari.HikariDataSource" destroy-method="close">
    <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
    <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/mydb"/>
    <property name="username" value="root"/>
    <property name="password" value="123456"/>
</bean>

<bean id="transactionManager"
      class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
</bean>

<tx:annotation-driven transaction-manager="transactionManager"/>

<!-- 还没完...还有 Jackson消息转换器、跨域配置、字符编码Filter等 -->

Spring Boot 自动配置全过程

Spring Boot 用户只需要：

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

# application.yml（只写差异化配置）
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydb
    username: root
    password: "123456"

🔍 全链路源码追踪（5步）

// 源码：spring-boot-autoconfigure/SpringBootApplication.java
@SpringBootConfiguration     // 就是 @Configuration
@EnableAutoConfiguration     // ← 核心！开启自动配置
@ComponentScan(              // 组件扫描
    excludeFilters = {
        @Filter(type = CUSTOM, classes = TypeExcludeFilter.class),
        @Filter(type = CUSTOM, classes = AutoConfigurationExcludeFilter.class)
    })
public @interface SpringBootApplication { ... }

// 源码：EnableAutoConfiguration.java
@AutoConfigurationPackage      // 自动注册主类所在包
@Import(AutoConfigurationImportSelector.class)  // ← 关键！
public @interface EnableAutoConfiguration {
    String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";
    Class<?>[] exclude() default {};
    String[] excludeName() default {};
}

// 源码：AutoConfigurationImportSelector.java
protected AutoConfigurationEntry getAutoConfigurationEntry(...) {
    // ① 获取注解属性
    AnnotationAttributes attributes = getAttributes(annotationMetadata);
    // ② 【核心】从 .imports 文件加载所有候选配置类
    List<String> configurations = getCandidateConfigurations(...);
    // ③ 去重
    configurations = removeDuplicates(configurations);
    // ④ 排除 exclude 列表
    Set<String> exclusions = getExclusions(...);
    configurations.removeAll(exclusions);
    // ⑤ 【核心】条件过滤！@ConditionalOnClass / @ConditionalOnMissingBean
    configurations = getConfigurationClassFilter().filter(configurations);
    // ⑥ 发送事件
    fireAutoConfigurationImportEvents(configurations, exclusions);
    return new AutoConfigurationEntry(configurations, exclusions);
}

// 源码：ImportCandidates.java
private static final String LOCATION = "META-INF/spring/%s.imports";

public static ImportCandidates load(Class<?> annotation, ClassLoader classLoader) {
    String location = String.format(LOCATION, annotation.getName());
    // 实际读取：META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports
    Enumeration<URL> urls = findUrlsInClasspath(classLoaderToUse, location);
    List<String> importCandidates = new ArrayList<>();
    while (urls.hasMoreElements()) {
        URL url = urls.nextElement();
        importCandidates.addAll(readCandidateConfigurations(url));  // 逐行读取类名
    }
    return new ImportCandidates(importCandidates);
}

// 源码：OnClassCondition.java
class OnClassCondition extends FilteringSpringBootCondition {
    protected ConditionOutcome[] getOutcomes(String[] autoConfigurationClasses, ...) {
        // 多核CPU时拆成两半并行处理，提高效率！
        if (autoConfigurationClasses.length > 1
                && Runtime.getRuntime().availableProcessors() > 1) {
            return resolveOutcomesThreaded(autoConfigurationClasses, ...);
        }
    }

    private ConditionOutcome getOutcome(String className, ClassLoader classLoader) {
        // 只检查 classpath 是否存在该类，不真正加载！
        if (ClassNameFilter.MISSING.matches(className, classLoader)) {
            return ConditionOutcome.noMatch(...);  // 类不存在 → 不生效
        }
        return null;  // 类存在 → 候选通过
    }
}

⚔️ 核心对比：DispatcherServletAutoConfiguration 源码全解析

// 源码：spring-boot-webmvc/DispatcherServletAutoConfiguration.java

@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)  // ← 最高优先级
@AutoConfiguration                                // ← 标记为自动配置类
@ConditionalOnWebApplication(type = Type.SERVLET) // ← 条件1：必须是Servlet Web应用
@ConditionalOnClass(DispatcherServlet.class)       // ← 条件2：classpath必须有DispatcherServlet
public final class DispatcherServletAutoConfiguration {

    // ===== 内部配置类1：创建 DispatcherServlet =====
    @Configuration(proxyBeanMethods = false)
    @Conditional(DefaultDispatcherServletCondition.class)  // ← 条件3：用户没自定义才生效！
    @ConditionalOnClass(ServletRegistration.class)
    @EnableConfigurationProperties(WebMvcProperties.class)  // ← 绑定 spring.mvc.* 配置
    protected static class DispatcherServletConfiguration {

        @Bean(name = "dispatcherServlet")
        DispatcherServlet dispatcherServlet(WebMvcProperties props) {
            DispatcherServlet ds = new DispatcherServlet();
            // 从 application.yml 的 spring.mvc.* 读取，替代XML中的 <property>
            ds.setDispatchOptionsRequest(props.isDispatchOptionsRequest());
            ds.setDispatchTraceRequest(props.isDispatchTraceRequest());
            ds.setPublishEvents(props.isPublishRequestHandledEvents());
            ds.setEnableLoggingRequestDetails(props.isLogRequestDetails());
            return ds;
        }

        // 兼容性Bean：用户可能命名错误的multipartResolver
        @Bean
        @ConditionalOnBean(MultipartResolver.class)
        @ConditionalOnMissingBean(name = "multipartResolver")  // ← 容器没有才注册！
        MultipartResolver multipartResolver(MultipartResolver resolver) {
            return resolver;  // 自动重命名为标准名
        }
    }

    // ===== 内部配置类2：注册 DispatcherServlet 到Servlet容器 =====
    @Configuration(proxyBeanMethods = false)
    @Conditional(DispatcherServletRegistrationCondition.class)
    @ConditionalOnClass(ServletRegistration.class)
    @EnableConfigurationProperties(WebMvcProperties.class)
    @Import(DispatcherServletConfiguration.class)  // ← 依赖上面的配置类
    protected static class DispatcherServletRegistrationConfiguration {

        @Bean(name = "dispatcherServletRegistration")
        @ConditionalOnBean(value = DispatcherServlet.class, name = "dispatcherServlet")
        DispatcherServletRegistrationBean dispatcherServletRegistration(
                DispatcherServlet ds, WebMvcProperties props,
                ObjectProvider<MultipartConfigElement> multipartConfig) {
            // 自动注册Servlet映射路径（默认"/"）—— 替代 web.xml 中的 <servlet-mapping>
            DispatcherServletRegistrationBean registration =
                new DispatcherServletRegistrationBean(ds, props.getServlet().getPath());
            registration.setName("dispatcherServlet");
            registration.setLoadOnStartup(props.getServlet().getLoadOnStartup());
            multipartConfig.ifAvailable(registration::setMultipartConfig);
            return registration;
        }
    }

    // ===== 自定义条件判断：用户是否已定义DispatcherServlet =====
    private static final class DefaultDispatcherServletCondition extends SpringBootCondition {
        public ConditionOutcome getMatchOutcome(ConditionContext context, ...) {
            List<String> beans = Arrays.asList(
                beanFactory.getBeanNamesForType(DispatcherServlet.class, false, false));
            // 用户已经定义了名为 "dispatcherServlet" 的Bean → 不匹配（用户优先！）
            if (beans.contains("dispatcherServlet")) {
                return ConditionOutcome.noMatch(...);
            }
            // 容器中没有任何DispatcherServlet → 匹配（自动配置补上）
            if (beans.isEmpty()) {
                return ConditionOutcome.match(...);
            }
            return ConditionOutcome.match(...);
        }
    }
}

🌲 自动配置决策树（以 DispatcherServlet 为例）

📊 逐行对比表

🔧 核心条件注解一览

💬 面试金句