SpringBoot通过main方法启动web项目实践_开发_开发者

1. 启动入口：SpringApplication.run()

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

SpringApplication.run() 是启动的核心入口，它主要完成以下工作：

2. SpringApplication初始化

// SpringApplication 构造函数核心逻辑
public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
    // 1. 设置资源加载器
    this.resourceLoader = resourceLoadphper;
    // 2. 校验并保存主配置类（即 @SpringBootApplication 标注的类）
    this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
    // 3. 推断应用类型（REACTIVE、SERVLET、NONE）
    this.webApplicationType = WebApplicationType.deduceFromClasspath();
   编程客栈 // 4. 加载并实例化 ApplicationContextInitializer
    setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
    // 5. 加载并实例化 ApplicationListener
    setListeners((Collection) getSpringFactoriesInstancjses(ApplicationListener.class));
    // 6. 推断 main 方法所在类
    this.mainApplicationClass = deduceMainApplicationClass();
}

关键步骤：

应用类型推断：通过检查类路径中是否存在 org.springframework.web.reactive.DispatcherHandler（REACTIVE）或 Javax.servlet.Servlet（SERVLET）来确定应用类型。
初始化器（Initializer）：从 META-INF/spring.factories 加载 ApplicationContextInitializer，用于在 ApplicationContext 刷新前自定义配置。
监听器（Listener）：加载 ApplicationListener，监听启动过程中的事件（如 ApplicationStartingEvent）。

3. run()方法核心流程

public ConfigurableApplicationContext run(String... args) {
    // 1. 计时和发布启动事件
    StopWatch stopWatch = new StopWatch();
    stopWatch.start();
    ConfigurableApplicationContext context = null;
    Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
    configureHeadlessProperty();
    
    // 2. 获取并启动监听器
    SpringApplicationRunListeners listeners = getRunListeners(args);
    listeners.starting();
    
    try {
        // 3. 构建应用参数和环境配置
        ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
        ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);
        
        // 4. 创建并配置 ApplicationContext
        context = createApplicationContext();
        exceptionReporters = getSpringFactoriesInstances(SpringBootExceptionReporter.class,
                new Class[] { ConfigurableApplicationContext.class }, context);
        
        // 5. 准备上下文（加载 Bean 定义）
        prepareContext(context, environment, listeners, applicationArguments, printedBanner);
        // 6. 刷新上下文（核心启动逻辑）
        refreshContext(context);
        // 7. 刷新后的回调处理
        afterRefresh(context, applicationArguments);
        // 8. 发布应用就绪事件
        listeners.started(context);
        // 9. 执行 Runner（如 CommandLineRunner）
        callRunners(context, applicationArguments);
    }
    catch (Throwable ex) {
        handleRunFailure(context, ex, exceptionReporters, listeners);
        throw new IllegalStateException(ex);
    }
    
    stopWatch.stop();
    if (this.logStartupInfo) {
        new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
    }
    // 10. 发布应用运行中事件
    listeners.running(context);
    return context;
}

4. 嵌入式 Web 服务器启动关键点

4.1refreshContext()方法触发服务器启动

private void refreshContext(ConfigurableApplicationContext context) {
    refresh(context);
    if (this.registerShutdownHook) {
        try {
            context.registerShutdownHook();
        }
        catch (AccessControlException ex) {
            // Not allowed in some environments.
        }
    }
}

protected void refresh(ConfigurableApplicationContext context) {
    // 调用 AbstractApplicationContext 的 refresh() 方法
    context.refresh();
}

4.2ServletWebServerApplicationContext的核心作用

对于 Web 应用，ApplicationContext 实际类型为 AnnotationConfigServletWebServerApplicationContext，它继承自 ServletWebServerApplicationContext，后者在 refresh() 过程中会：

// ServletWebServerApplicationContext 核心方法
@Override
protected void onRefresh() {
    super.onRefresh();
    try {
        // 创建并启动嵌入式 Web 服务器
        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. 获取 ServletWebServerFactory（如 TomcatServletWebServerFactory）
        ServletWebServerFactory factory = getWebServerFactory();
        // 2. 创建并配置 Web 服务器
        this.webServer = factory.getWebServer(getSelfInitializer());
    }
    else if (servletContext != null) {
        try {
            getSelfInitializer().onStartup(servletContext);
        }
        catch (ServletException ex) {
            throw new ApplicationContextException("Cannot initialize servlet context", ex);
        }
    }
    initPropertySources();
}

4.3ServletWebServerFactory实例化服务器

以 Tomcat 为例，TomcatServletWebServerFactory 的 getWebServer() 方法会：

@Override
public WebServer getWebServer(ServletContextInitializer... initializers) {
    // 1. 创建 Tomcat 实例
    Tomcat tomcat = new Tomcat();
    // 2. 配置服务器基本参数（端口、上下文路径等）
    File baseDir = (this.baseDirectory != null) ? this.baseDirectory : createTempDir("tomcat");
    tomcat.setBaseDir(baseDir.getAbsolutePath());
    Connector connector = new Connector(this.protocol);
    tomcat.getService().addConnector(connector);
    custwww.devze.comomizeConnector(connector);
    tomcat.setConnector(connector);
    tomcat.getHost().setAutoDeploy(false);
    // 3. 配置 ServletContextInitializer（如 DispatcherServlet）
    prepareContext(tomcat.getHost(), initializers);
    // 4. 启动服务器
    return getTomcatWebServer(tomcat);
}

5. Spring MVC 组件自动配置

通过 WebMvcAutoConfiguration 自动配置核心组件：

DispatcherServlet：作为前端控制器，处理所有 HTTP 请求。
HandlerMapping：映射 URL 到具体的 Controller 方法。
ViewResolver：解析视图名称到实际视图。

关键代码（WebMvcAutoConfiguration）：

@Bean
@Primary
@ConditionalOnMissingBean(DispatcherServlet.class)
public DispatcherServlet dispatcherServlet(WebMvcProperties properties) {
    DispatcherServlet dispatcherServlet = new DispatcherServlet();
    dispatcherServlet.setDispatchOptionsRequest(properties.isDispatchOptionsRequest());
    dispatcherServlet.setDispatchTraceRequest(properties.isDispatchTraceRequest());
    dispatcherServlet.setThrowExceptionIfNoHandlerFound(properties.isThrowExceptionIfNoHandlerFound());
    dispatcherServlet.setPublishEvents(properties.isPublishRequestHandledEvents());
    dispatcherServlet.setEnableLoggingRequestDetails(properties.isLogRequestDetails());
    return dispatcherServlet;
}