七、SpringBoot启动配置原理

几个重要的时间回调机制：
配置在META-INF/spring.factories中：
ApplicationContextInitializer
SpringApplicationRunListener

加载在IOC容器中：
ApplicationRunner
CommandLineRunner

一、启动流程

1、创建SpringApplication对象

public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
	this.resourceLoader = resourceLoader;
	Assert.notNull(primarySources, "PrimarySources must not be null");
	//保存主配置类
	this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
	//判断当前应用是否web应用
	this.webApplicationType = WebApplicationType.deduceFromClasspath();
	this.bootstrapRegistryInitializers = new ArrayList<>(
			getSpringFactoriesInstances(BootstrapRegistryInitializer.class));
	//从类路径下找到META-INF/spring.factories配置的所有ApplicationContextInitializer；然后保存起来
	setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
	//从类路径下找到META-INF/spring.factories配置的所有ApplicationListener
	setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
	//从多个配置类中找到有main方法的配置类
	this.mainApplicationClass = deduceMainApplicationClass();
}

2、运行run方法

	public ConfigurableApplicationContext run(String... args) {
		long startTime = System.nanoTime();
		DefaultBootstrapContext bootstrapContext = createBootstrapContext();
		ConfigurableApplicationContext context = null;
		configureHeadlessProperty();
		//获取所有的SpringApplicationRunListeners：从类路径下META-INF/spring.factories获取
		SpringApplicationRunListeners listeners = getRunListeners(args);
		//回调所有的SpringApplicationRunListener.starting方法
		listeners.starting(bootstrapContext, this.mainApplicationClass);
		try {
			//封装命令行参数
			ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
			//准备环境
			//环境创建完成后回调SpringApplicationRunListener.environmentPrepared表示环境准备完成
			ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments);
			configureIgnoreBeanInfo(environment);
			//打印Springboot标识
			Banner printedBanner = printBanner(environment);
			//创建ApplicationContext；决定创建web的IOC容器还是普通的IOC容器；
			context = createApplicationContext();
			context.setApplicationStartup(this.applicationStartup);
			//准备上下文环境；将environment保存到IOC容器中；而且applyInitializers
			//applyInitializers()：回调之前保存的所有的ApplicationContextInitializer的initialize方法
			//回调所有的SpringApplicationRunListener的contextPrepared方法；
			//contextPrepared运行完成后回调所有的SpringApplicationRunListener的contextLoaded方法；
			prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);
			//刷新容器，IOC容器初始化，如果是web应用，还会创建嵌入式tomcat容器
			//扫描，创建，加载所有组件的地方
			refreshContext(context);
			afterRefresh(context, applicationArguments);
			Duration timeTakenToStartup = Duration.ofNanos(System.nanoTime() - startTime);
			if (this.logStartupInfo) {
				new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), timeTakenToStartup);
			}
			//所有的SpringApplicationRunListener的回调started方法
			listeners.started(context, timeTakenToStartup);
			//从IOC容器中获取所有的ApplicationRunner和CommandLineRunner进行回调
			//ApplicationRunner先回调，CommandLineRunner再回调
			callRunners(context, applicationArguments);
		}
		catch (Throwable ex) {
			handleRunFailure(context, ex, listeners);
			throw new IllegalStateException(ex);
		}
		try {
			Duration timeTakenToReady = Duration.ofNanos(System.nanoTime() - startTime);
			listeners.ready(context, timeTakenToReady);
		}
		catch (Throwable ex) {
			handleRunFailure(context, ex, null);
			throw new IllegalStateException(ex);
		}
		//整个SpringBoot应用启动，返回启动的IOC容器
		return context;
	}

3、事件监听机制

配置在META-INF/spring.factories中：
ApplicationContextInitializer:

public class HelloApplicationContextInitializer implements ApplicationContextInitializer<ConfigurableApplicationContext> {

    @Override
    public void initialize(ConfigurableApplicationContext applicationContext) {
        System.out.println("ApplicationContextInitializer... initialize... " + applicationContext);
  

SpringApplicationRunListener:

public class HelloSpringApplicationRunListener implements SpringApplicationRunListener {

    public HelloSpringApplicationRunListener(SpringApplication application, String[] args) {
    }

    @Override
    public void starting(ConfigurableBootstrapContext bootstrapContext) {
        System.out.println("SpringApplicationRunListener...starting... " + bootstrapContext);
    }

    @Override
    public void environmentPrepared(ConfigurableBootstrapContext bootstrapContext, ConfigurableEnvironment environment) {

        final Object o = environment.getSystemEnvironment().get("os.name");
        System.out.println("SpringApplicationRunListener... environmentPrepared... " + o);
    }

    @Override
    public void contextPrepared(ConfigurableApplicationContext context) {
        System.out.println("SpringApplicationRunListener...contextPrepared...");
    }

    @Override
    public void contextLoaded(ConfigurableApplicationContext context) {
        System.out.println("SpringApplicationRunListener...contextLoaded...");
    }

    @Override
    public void started(ConfigurableApplicationContext context, Duration timeTaken) {
        System.out.println("SpringApplicationRunListener...started...");
    }

    @Override
    public void ready(ConfigurableApplicationContext context, Duration timeTaken) {
        System.out.println("SpringApplicationRunListener...ready...");
    }

    @Override
    public void failed(ConfigurableApplicationContext context, Throwable exception) {
        System.out.println("SpringApplicationRunListener...failed...");
    }
}

编写META-INF/spring.factories：

org.springframework.context.ApplicationContextInitializer=\
cn.hymll.springboot.listener.HelloApplicationContextInitializer

org.springframework.boot.SpringApplicationRunListener=\
cn.hymll.springboot.listener.HelloSpringApplicationRunListener

加载在IOC容器中：
ApplicationRunner:

@Component
public class HelloApplicationRunner implements ApplicationRunner {
    @Override
    public void run(ApplicationArguments args) throws Exception {
        System.out.println("HelloApplicationRunner... run... " + args);
    }
}

CommandLineRunner:

@Component
public class HelloCommandLineRunner implements CommandLineRunner {
    @Override
    public void run(String... args) throws Exception {
        System.out.println("HelloCommandLineRunner... run..." + Arrays.asList(args));
    }
}

二、自定义Starters

1.starter：

1. 这个场景需要使用到的依赖是什么？
2. 如何编写自动配置

@Configuration //指定这个类是一个配置类
@ConditionalOnXXX //在指定条件成立的情况下自动配置类生效
@AutoConfigureAfter //指定自动配置类的顺序
@Bean //给容器中添加组件

@ConfigurationProperties //结合相关XXXProperties类来绑定相关的配置
@EnableConfigurationProperties //让XXXProperties生效加入到容器中

//自动配置类要能加载
//将需要启动就加载的字段配置类，配置在META-INF/spring.factories
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\

3. 模式
   • 启动器模块是一个空jar文件，仅提供辅助性依赖管理，这些依赖可能用于自动装配或者其他类库；
   • 命名规范：
     官方：spring-boot-starter-模块名
     自定义：模块-spring-boot-starter