Spring Boot启动流程示例详解

package com.example.demo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
/**
 * @SpringBootApplication 是三个注解的组合：
 * - @Configuration：表示该类是一个配置类
 * - @EnableAutoConfiguration：开启自动配置
 * - @ComponentScan：开启包扫描
 */
@SpringBootApplication
public class DemoApplication {
    public static void main(String[] args) {
        // run方法会启动整个Spring Boot应用
        SpringApplication.run(DemoApplication.class, args);
    }
}

SpringApplication.run(DemoApplication.class, args);

public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
    this.resourceLoader = resourceLoader;
    Assert.notNull(primarySources, "PrimarySources must not be null");
    this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
    // 推断应用类型（Servlet / Reactive / None）
    this.webApplicationType = WebApplicationType.deduceFromClasspath();
    // 从 spring.factories 加载 ApplicationContextInitializer
    setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
    // 从 spring.factories 加载 ApplicationListener
    setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
    // 推断并设置 main 方法所在类
    this.mainApplicationClass = deduceMainApplicationClass();
}

public class MyInitializer implements ApplicationContextInitializer<ConfigurableApplicationContext> {
    @Override
    public void initialize(ConfigurableApplicationContext context) {
        System.out.println("MyInitializer: 应用上下文初始化中...");
    }
}

org.springframework.context.ApplicationContextInitializer=\
com.example.demo.MyInitializer

public ConfigurableApplicationContext run(String... args) {
    StopWatch stopWatch = new StopWatch();
    stopWatch.start();
    // 启动监听器集合
    SpringApplicationRunListeners listeners = getRunListeners(args);
    listeners.starting();
    // 初始化引导上下文（BootstrapContext）
    DefaultBootstrapContext bootstrapContext = createBootstrapContext();
    // 创建并配置 Environment
    ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, args);
    // 打印 Banner
    Banner printedBanner = printBanner(environment);
    // 创建 ApplicationContext
    context = createApplicationContext();
    // 准备上下文
    prepareContext(bootstrapContext, context, environment, listeners, args, printedBanner);
    // 刷新上下文（加载Bean、启动内嵌容器）
    refreshContext(context);
    // 执行 CommandLineRunner、ApplicationRunner
    afterRefresh(context, args);
    stopWatch.stop();
    if (this.logStartupInfo) {
        new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
    }
    listeners.started(context);
    listeners.running(context);
    return context;
}

@Component
public class MyStartupListener implements ApplicationListener<ApplicationStartingEvent> {
    @Override
    public void onApplicationEvent(ApplicationStartingEvent event) {
        System.out.println("应用启动中：执行早期初始化逻辑...");
    }
}

public static WebApplicationType deduceFromClasspath() {
    if (ClassUtils.isPresent(REACTIVE_DISPATCHER, null) && !ClassUtils.isPresent(DISPATCHER_SERVLET, null)) {
        return WebApplicationType.REACTIVE;
    }
    for (String className : SERVLET_INDICATOR_CLASSES) {
        if (!ClassUtils.isPresent(className, null)) {
            return WebApplicationType.NONE;
        }
    }
    return WebApplicationType.SERVLET;
}

private ConfigurableEnvironment getOrCreateEnvironment() {
    if (this.environment != null) {
        return this.environment;
    }
    switch (this.webApplicationType) {
        case SERVLET:
            return new StandardServletEnvironment();
        case REACTIVE:
            return new StandardReactiveWebEnvironment();
        default:
            return new StandardEnvironment();
    }
}

@Component
public class EnvPrinter implements CommandLineRunner {
    @Autowired
    private Environment environment;
    @Override
    public void run(String... args) {
        System.out.println("当前激活的profile: " + Arrays.toString(environment.getActiveProfiles()));
        System.out.println("server.port=" + environment.getProperty("server.port"));
    }
}

server.port=8080

java -jar demo.jar --server.port=9001

protected void configureEnvironment(ConfigurableEnvironment environment,
                                    String[] args) {
    new CommandLinePropertySource<>("commandLineArgs", args);
}

@Value("${server.port}")
private int port;

@Component
@ConfigurationProperties(prefix = "myapp")
public class MyAppConfig {
    private String name;
    private int timeout;
    // getters and setters
}

myapp.name=DemoApp
myapp.timeout=30

protected ConfigurableApplicationContext createApplicationContext() {
    Class<?> contextClass = this.applicationContextClass;
    if (contextClass == null) {
        try {
            switch (this.webApplicationType) {
                case SERVLET:
                    contextClass = Class.forName(
                        "org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext");
                    break;
                case REACTIVE:
                    contextClass = Class.forName(
                        "org.springframework.boot.web.reactive.context.AnnotationConfigReactiveWebServerApplicationContext");
                    break;
                default:
                    contextClass = Class.forName(
                        "org.springframework.context.annotation.AnnotationConfigApplicationContext");
            }
        } catch (ClassNotFoundException ex) {
            throw new IllegalStateException("Unable to create ApplicationContext", ex);
        }
    }
    return (ConfigurableApplicationContext) BeanUtils.instantiateClass(contextClass);
}

@Component
public class MyBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) {
        if (beanName.equals("myService")) {
            System.out.println("Before init: " + beanName);
        }
        return bean;
    }
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        if (beanName.equals("myService")) {
            System.out.println("After init: " + beanName);
        }
        return bean;
    }
}

DefaultBootstrapContext bootstrapContext = createBootstrapContext();
ApplicationEnvironmentPreparedEvent event =
        new ApplicationEnvironmentPreparedEvent(this, args, environment);
listeners.environmentPrepared(bootstrapContext, environment);

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

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(
    excludeFilters = {@Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
                      @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class)}
)
public @interface SpringBootApplication {
    // ...
}

@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {
    String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";
    Class<?>[] exclude() default {};
    String[] excludeName() default {};
}

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.web.servlet.DispatcherServletAutoConfiguration,\
org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration,\
org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration

public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
    String factoryTypeName = factoryType.getName();
    return loadSpringFactories(classLoader).getOrDefault(factoryTypeName, Collections.emptyList());
}

@Configuration(proxyBeanMethods = false)
@ConditionalOnClass(ObjectMapper.class)
@EnableConfigurationProperties(JacksonProperties.class)
public class JacksonAutoConfiguration {
    @Bean
    @ConditionalOnMissingBean
    public ObjectMapper jacksonObjectMapper(Jackson2ObjectMapperBuilder builder) {
        return builder.createXmlMapper(false).build();
    }
}

public class HelloService {
    public String sayHello(String name) {
        return "Hello, " + name;
    }
}

@Configuration
@ConditionalOnClass(HelloService.class)
public class HelloServiceAutoConfiguration {
    @Bean
    @ConditionalOnMissingBean
    public HelloService helloService() {
        return new HelloService();
    }
}

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.example.demo.config.HelloServiceAutoConfiguration

@RestController
public class HelloController {
    @Autowired
    private HelloService helloService;
    @GetMapping("/hello")
    public String hello(String name) {
        return helloService.sayHello(name);
    }
}

@ConditionalOnClass(ObjectMapper.class)

@Retention(RetentionPolicy.RUNTIME)
@Target({ ElementType.TYPE, ElementType.METHOD })
@Documented
@Conditional(OnClassCondition.class)
public @interface ConditionalOnClass {
    Class<?>[] value() default {};
    String[] name() default {};
}

public boolean shouldSkip(AnnotatedTypeMetadata metadata, @Nullable ConfigurationPhase phase) {
    if (metadata.isAnnotated(Conditional.class.getName())) {
        List<Condition> conditions = getConditionClasses(metadata);
        for (Condition condition : conditions) {
            if (!condition.matches(context, metadata)) {
                return true; // 跳过
            }
        }
    }
    return false;
}

java -jar demo.jar --debug

=========================
CONDITIONS EVALUATION REPORT
=========================
Positive matches:
-----------------
   JacksonAutoConfiguration matched:
      - @ConditionalOnClass found required class 'com.fasterxml.jackson.databind.ObjectMapper' (OnClassCondition)
Negative matches:
-----------------
   DataSourceAutoConfiguration:
      Did not match:
         - @ConditionalOnClass did not find required class 'javax.sql.DataSource' (OnClassCondition)

@Bean
@ConditionalOnMissingBean
public ObjectMapper objectMapper() {
    return new ObjectMapper();
}

@AutoConfigureBefore(JacksonAutoConfiguration.class)
public class MyCustomJsonConfig { ... }

spring:
  main:
    allow-bean-definition-overriding: true

@SpringBootApplication(exclude = DataSourceAutoConfiguration.class)
public class MyApp {}

spring:
  autoconfigure:
    exclude:
      - org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration

Arrays.stream(context.getBeanDefinitionNames()).forEach(System.out::println);

org.springframework.boot.SpringApplicationRunListener=\
org.springframework.boot.context.event.EventPublishingRunListener,\
org.springframework.boot.context.logging.ClasspathLoggingApplicationListener,\
org.springframework.boot.context.logging.LoggingApplicationListener

public class MyRunListener implements SpringApplicationRunListener {
    public MyRunListener(SpringApplication app, String[] args) {
        // 构造器，必须包含这两个参数
    }
    @Override
    public void starting() {
        System.out.println("应用开始启动");
    }
    @Override
    public void environmentPrepared(ConfigurableEnvironment environment) {
        System.out.println("环境已准备好");
    }
    @Override
    public void contextPrepared(ConfigurableApplicationContext context) {
        System.out.println("上下文已准备好");
    }
    @Override
    public void contextLoaded(ConfigurableApplicationContext context) {
        System.out.println("上下文已加载");
    }
    @Override
    public void started(ConfigurableApplicationContext context) {
        System.out.println("应用已启动");
    }
    @Override
    public void running(ConfigurableApplicationContext context) {
        System.out.println("应用正在运行");
    }
    @Override
    public void failed(ConfigurableApplicationContext context, Throwable exception) {
        System.out.println("应用启动失败，异常信息：" + exception.getMessage());
    }
}

org.springframework.boot.SpringApplicationRunListener=com.example.MyRunListener

@Component
public class MyReadyListener implements ApplicationListener<ApplicationReadyEvent> {
    @Override
    public void onApplicationEvent(ApplicationReadyEvent event) {
        System.out.println("应用已准备就绪，执行自定义初始化操作...");
        // 例如启动缓存预热、消息监听器等
    }
}

new SpringApplicationBuilder()
    .sources(MyApplication.class)
    .initializers(new MyContextInitializer())
    .listeners(new MyReadyListener())
    .profiles("dev")
    .run(args);

public class MyContextInitializer implements ApplicationContextInitializer<ConfigurableApplicationContext> {
    @Override
    public void initialize(ConfigurableApplicationContext applicationContext) {
        System.out.println("ApplicationContext初始化逻辑...");
        // 可以动态注册Bean、修改环境变量等
    }
}

StopWatch stopWatch = new StopWatch();
stopWatch.start("SpringApplication启动");
// 启动流程中的重要阶段代码...
stopWatch.stop();
System.out.println(stopWatch.prettyPrint());

java -jar myapp.jar --debug

@Configuration
public class MyConfig {
    @Bean
    @Lazy
    public HeavyService heavyService() {
        return new HeavyService();
    }
}

@SpringBootApplication(scanBasePackages = "com.example.myapp.service")
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}

@SpringBootApplication(exclude = {DataSourceAutoConfiguration.class})
public class MyApplication { ... }

@SpringBootApplication
public class PerformanceApp {
    public static void main(String[] args) {
        StopWatch stopWatch = new StopWatch();
        stopWatch.start("启动应用");
        SpringApplication app = new SpringApplication(PerformanceApp.class);
        app.run(args);
        stopWatch.stop();
        System.out.println(stopWatch.prettyPrint());
    }
    @Bean
    @Lazy
    public ExpensiveBean expensiveBean() {
        System.out.println("初始化ExpensiveBean...");
        return new ExpensiveBean();
    }
}