SpringBoot底层实现原理

1202 字

6 分钟

SpringBoot底层实现原理

2025-09-05

后端

编程学习

/

后端开发

自动配置的核心机制#

1. @SpringBootApplication注解#

这是自动配置的起点，它实际上是三个注解的组合：

1
@SpringBootConfiguration  // 标识为配置类
2
@EnableAutoConfiguration  // 启用自动配置
3
@ComponentScan           // 组件扫描

2. @EnableAutoConfiguration的工作原理#

这个注解是自动配置的关键，它通过@Import导入了AutoConfigurationImportSelector：

1
@Import(AutoConfigurationImportSelector.class)
2
public @interface EnableAutoConfiguration {
3
    // ...
4
}

3. AutoConfigurationImportSelector的实现#

这个类负责选择并加载自动配置类：

1
public class AutoConfigurationImportSelector implements ImportSelector {
2

3
    @Override
4
    public String[] selectImports(AnnotationMetadata annotationMetadata) {
5
        // 获取所有自动配置类
6
        List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
7
        // 去重、排除、过滤
8
        configurations = removeDuplicates(configurations);
9
        configurations = getExcluded(configurations);
10
        configurations = filter(configurations, autoConfigurationMetadata);
11
        // 返回需要导入的配置类
12
        return configurations.toArray(new String[0]);
13
    }
14
}

4. 加载自动配置类的过程#

Spring Boot通过SpringFactoriesLoader加载配置：

1
protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
2
    List<String> configurations = SpringFactoriesLoader.loadFactoryNames(
3
        getSpringFactoriesLoaderFactoryClass(),
4
        getBeanClassLoader()
5
    );
6
    return configurations;
7
}

它会扫描所有jar包下的META-INF/spring.factories文件，查找key为org.springframework.boot.autoconfigure.EnableAutoConfiguration的配置。

5. 条件注解的使用#

自动配置类通常使用条件注解来决定是否生效：

@ConditionalOnClass: 当classpath中存在指定类时
@ConditionalOnMissingBean: 当容器中不存在指定Bean时
@ConditionalOnProperty: 当配置文件中有指定属性时
@ConditionalOnWebApplication: 当是Web应用时

示例：

1
@Configuration
2
@ConditionalOnClass(DataSource.class)
3
@ConditionalOnProperty(prefix = "spring.datasource", name = "url")
4
public class DataSourceAutoConfiguration {
5

6
    @Bean
7
    @ConditionalOnMissingBean
8
    public DataSource dataSource() {
9
        // 创建数据源
10
    }
11
}

6. 配置属性绑定#

通过@ConfigurationProperties将配置文件中的属性绑定到Java对象：

1
@ConfigurationProperties(prefix = "spring.datasource")
2
public class DataSourceProperties {
3
    private String url;
4
    private String username;
5
    private String password;
6
    // getters and setters
7
}

7. 自动配置的执行顺序#

使用以下注解控制加载顺序：

@AutoConfigureAfter: 在指定配置类之后配置
@AutoConfigureBefore: 在指定配置类之前配置
@AutoConfigureOrder: 指定配置顺序

8. 自动配置报告#

可以通过以下方式查看哪些自动配置生效了：

启动时添加--debug参数
在配置文件中设置debug=true
使用Actuator的/conditions端点

自动配置的完整流程#

启动应用 → SpringApplication.run()
解析@SpringBootApplication → 发现@EnableAutoConfiguration
导入AutoConfigurationImportSelector → 执行selectImports()
加载spring.factories → 获取所有自动配置类列表
应用条件过滤 → 根据@Conditional注解决定是否加载
创建配置Bean → 将符合条件的配置类注册到容器
属性绑定 → 将配置文件中的值绑定到配置类

Web自动配置的核心组件#

1. WebMvcAutoConfiguration#

这是Spring MVC的核心自动配置类：

1
@Configuration(proxyBeanMethods = false)
2
@ConditionalOnWebApplication(type = Type.SERVLET)
3
@ConditionalOnClass({ Servlet.class, DispatcherServlet.class, WebMvcConfigurer.class })
4
@ConditionalOnMissingBean(WebMvcConfigurationSupport.class)
5
@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE + 10)
6
@AutoConfigureAfter({ DispatcherServletAutoConfiguration.class, TaskExecutionAutoConfiguration.class,
7
        ValidationAutoConfiguration.class })
8
public class WebMvcAutoConfiguration {
9
    // Web MVC相关配置
10
}

2. 内嵌服务器的自动配置#

ServletWebServerFactoryAutoConfiguration#

负责配置内嵌的Servlet容器：

1
@Configuration(proxyBeanMethods = false)
2
@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)
3
@ConditionalOnClass(ServletRequest.class)
4
@ConditionalOnWebApplication(type = Type.SERVLET)
5
@EnableConfigurationProperties(ServerProperties.class)
6
@Import({ ServletWebServerFactoryAutoConfiguration.BeanPostProcessorsRegistrar.class,
7
        ServletWebServerFactoryConfiguration.EmbeddedTomcat.class,
8
        ServletWebServerFactoryConfiguration.EmbeddedJetty.class,
9
        ServletWebServerFactoryConfiguration.EmbeddedUndertow.class })
10
public class ServletWebServerFactoryAutoConfiguration {
11

12
    @Bean
13
    public ServletWebServerFactoryCustomizer servletWebServerFactoryCustomizer(
14
            ServerProperties serverProperties) {
15
        return new ServletWebServerFactoryCustomizer(serverProperties);
16
    }
17
}

内嵌Tomcat的配置#

1
@Configuration(proxyBeanMethods = false)
2
@ConditionalOnClass({ Servlet.class, Tomcat.class, UpgradeProtocol.class })
3
@ConditionalOnMissingBean(value = ServletWebServerFactory.class, search = SearchStrategy.CURRENT)
4
static class EmbeddedTomcat {
5

6
    @Bean
7
    TomcatServletWebServerFactory tomcatServletWebServerFactory(
8
            ObjectProvider<TomcatConnectorCustomizer> connectorCustomizers,
9
            ObjectProvider<TomcatContextCustomizer> contextCustomizers,
10
            ObjectProvider<TomcatProtocolHandlerCustomizer<?>> protocolHandlerCustomizers) {
11
        TomcatServletWebServerFactory factory = new TomcatServletWebServerFactory();
12
        // 配置Tomcat
13
        return factory;
14
    }
15
}

3. DispatcherServlet的自动配置#

1
@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)
2
@Configuration(proxyBeanMethods = false)
3
@ConditionalOnWebApplication(type = Type.SERVLET)
4
@ConditionalOnClass(DispatcherServlet.class)
5
@AutoConfigureAfter(ServletWebServerFactoryAutoConfiguration.class)
6
public class DispatcherServletAutoConfiguration {
7

8
    @Configuration(proxyBeanMethods = false)
9
    @Conditional(DefaultDispatcherServletCondition.class)
10
    @ConditionalOnClass(ServletRegistration.class)
11
    @EnableConfigurationProperties({ HttpProperties.class, WebMvcProperties.class })
12
    protected static class DispatcherServletConfiguration {
13

14
        @Bean(name = DEFAULT_DISPATCHER_SERVLET_BEAN_NAME)
15
        public DispatcherServlet dispatcherServlet(HttpProperties httpProperties,
16
                WebMvcProperties webMvcProperties) {
17
            DispatcherServlet dispatcherServlet = new DispatcherServlet();
18
            dispatcherServlet.setDispatchOptionsRequest(webMvcProperties.isDispatchOptionsRequest());
19
            dispatcherServlet.setDispatchTraceRequest(webMvcProperties.isDispatchTraceRequest());
20
            // 其他配置...
21
            return dispatcherServlet;
22
        }
23
    }
24

25
    @Configuration(proxyBeanMethods = false)
26
    @Conditional(DispatcherServletRegistrationCondition.class)
27
    @ConditionalOnClass(ServletRegistration.class)
28
    @EnableConfigurationProperties(WebMvcProperties.class)
29
    @Import(DispatcherServletConfiguration.class)
30
    protected static class DispatcherServletRegistrationConfiguration {
31

32
        @Bean(name = DEFAULT_DISPATCHER_SERVLET_REGISTRATION_BEAN_NAME)
33
        @ConditionalOnBean(value = DispatcherServlet.class, name = DEFAULT_DISPATCHER_SERVLET_BEAN_NAME)
34
        public DispatcherServletRegistrationBean dispatcherServletRegistration(
35
                DispatcherServlet dispatcherServlet, WebMvcProperties webMvcProperties,
36
                ObjectProvider<MultipartConfigElement> multipartConfig) {
37
            DispatcherServletRegistrationBean registration = new DispatcherServletRegistrationBean(
38
                    dispatcherServlet, webMvcProperties.getServlet().getPath());
39
            registration.setName(DEFAULT_DISPATCHER_SERVLET_BEAN_NAME);
40
            registration.setLoadOnStartup(webMvcProperties.getServlet().getLoadOnStartup());
41
            multipartConfig.ifAvailable(registration::setMultipartConfig);
42
            return registration;
43
        }
44
    }
45
}

4. Web MVC核心组件的配置#

视图解析器配置#

1
@Configuration(proxyBeanMethods = false)
2
@ConditionalOnMissingBean(name = "viewResolver", value = ContentNegotiatingViewResolver.class)
3
public static class WebMvcAutoConfigurationAdapter implements WebMvcConfigurer {
4

5
    @Bean
6
    @ConditionalOnBean(ViewResolver.class)
7
    @ConditionalOnMissingBean(name = "viewResolver", value = ContentNegotiatingViewResolver.class)
8
    public ContentNegotiatingViewResolver viewResolver(BeanFactory beanFactory) {
9
        ContentNegotiatingViewResolver resolver = new ContentNegotiatingViewResolver();
10
        resolver.setContentNegotiationManager(beanFactory.getBean(ContentNegotiationManager.class));
11
        resolver.setOrder(Ordered.HIGHEST_PRECEDENCE);
12
        return resolver;
13
    }
14
}

静态资源处理#

1
@Override
2
public void addResourceHandlers(ResourceHandlerRegistry registry) {
3
    if (!this.resourceProperties.isAddMappings()) {
4
        logger.debug("Default resource handling disabled");
5
        return;
6
    }
7
    // 配置静态资源路径
8
    addResourceHandler(registry, "/webjars/**", "classpath:/META-INF/resources/webjars/");
9
    addResourceHandler(registry, this.mvcProperties.getStaticPathPattern(),
10
        this.resourceProperties.getStaticLocations());
11
}

5. HttpMessageConverters自动配置#

1
@Configuration(proxyBeanMethods = false)
2
@ConditionalOnClass(HttpMessageConverter.class)
3
@Conditional(NotReactiveWebApplicationCondition.class)
4
@AutoConfigureAfter({ GsonAutoConfiguration.class, JacksonAutoConfiguration.class })
5
@Import({ JacksonHttpMessageConvertersConfiguration.class,
6
        GsonHttpMessageConvertersConfiguration.class })
7
public class HttpMessageConvertersAutoConfiguration {
8

9
    @Bean
10
    @ConditionalOnMissingBean
11
    public HttpMessageConverters messageConverters(ObjectProvider<HttpMessageConverter<?>> converters) {
12
        return new HttpMessageConverters(converters.orderedStream().collect(Collectors.toList()));
13
    }
14
}

6. Web服务器启动流程#

1
// SpringApplication.run() 最终会调用
2
private void createWebServer() {
3
    WebServer webServer = this.webServer;
4
    ServletContext servletContext = getServletContext();
5
    if (webServer == null && servletContext == null) {
6
        // 获取ServletWebServerFactory
7
        ServletWebServerFactory factory = getWebServerFactory();
8
        // 创建WebServer
9
        this.webServer = factory.getWebServer(getSelfInitializer());
10
    }
11
}
12

13
// Tomcat的实现
14
@Override
15
public WebServer getWebServer(ServletContextInitializer... initializers) {
16
    Tomcat tomcat = new Tomcat();
17
    File baseDir = (this.baseDirectory != null) ? this.baseDirectory : createTempDir("tomcat");
18
    tomcat.setBaseDir(baseDir.getAbsolutePath());
19
    Connector connector = new Connector(this.protocol);
20
    connector.setThrowOnFailure(true);
21
    tomcat.getService().addConnector(connector);
22
    customizeConnector(connector);
23
    tomcat.setConnector(connector);
24
    tomcat.getHost().setAutoDeploy(false);
25
    configureEngine(tomcat.getEngine());
26
    prepareContext(tomcat.getHost(), initializers);
27
    return getTomcatWebServer(tomcat);
28
}

7. 自动配置的属性配置#

通过application.properties或application.yml配置：

1
server:
2
  port: 8080
3
  servlet:
4
    context-path: /app
5
  tomcat:
6
    max-threads: 200
7
    connection-timeout: 20000
8

9
spring:
10
  mvc:
11
    view:
12
      prefix: /WEB-INF/views/
13
      suffix: .jsp
14
    static-path-pattern: /static/**