spring boot启动

java -jar xxx.jar

是Java运行jar程序的标准方式
Java启动程序入口由meta-INFMANIFEST.MF确定，最主要参数是：

Main-Class: org.springframework.boot.loader.JarLauncher

Java启动spring boot的JarLuncher，由spring-boot-loader处理后续加载和配置

要查看spring-boot-loader的代码，可以通过在pom中添加依赖

	org.springframework.boot
	spring-boot-loader
	provided

JarLauncher入口并负责找到加载的类并启动spring boot application

public class JarLauncher extends ExecutableArchiveLauncher {
    protected ClassPathIndexFile getClassPathIndex(Archive archive) throws IOException {
        if (archive instanceof ExplodedArchive) {
            String location = this.getClassPathIndexFileLocation(archive);
            return ClassPathIndexFile.loadIfPossible(archive.getUrl(), location);
        } else {
            return super.getClassPathIndex(archive);
        }
    }
    public static void main(String[] args) throws Exception {
        (new JarLauncher()).launch(args);
    }
}    

ExecutableArchiveLauncher负责找到spring boot的Start-Class主类及其ClassLoader，Start-Class就是我们自定义的application类，位于MANIFEST.MF文件中。

Start-Class: com.example.XXXApplication

public abstract class ExecutableArchiveLauncher extends Launcher {
    public ExecutableArchiveLauncher() {
        try {
            this.archive = this.createArchive();
            this.classPathIndex = this.getClassPathIndex(this.archive);
        } catch (Exception var2) {
            throw new IllegalStateException(var2);
        }
    }
    protected String getMainClass() throws Exception {}
    protected ClassLoader createClassLoader(Iterator archives) throws Exception {}   

Launcher启动应用

	protected void launch(String[] args) throws Exception {
		if (!isExploded()) {
			JarFile.registerUrlProtocolHandler();
		}
		ClassLoader classLoader = createClassLoader(getClassPathArchivesIterator());
		String jarMode = System.getProperty("jarmode");
		String launchClass = (jarMode != null && !jarMode.isEmpty()) ? JAR_MODE_LAUNCHER : getMainClass();
		launch(args, launchClass, classLoader);
	}
	protected void launch(String[] args, String launchClass, ClassLoader classLoader) throws Exception {
		Thread.currentThread().setContextClassLoader(classLoader);
		createMainMethodRunner(launchClass, args, classLoader).run();
	}

MainMethodRunner具体实例化应用的SpringApplication类，并执行main方法。

	public void run() throws Exception {
		Class mainClass = Class.forName(this.mainClassName, false, Thread.currentThread().getContextClassLoader());
		Method mainMethod = mainClass.getDeclaredMethod("main", String[].class);
		mainMethod.setAccessible(true);
		mainMethod.invoke(null, new Object[] { this.args });
	}

补充：JarModeLauncher的介绍:“Delegate class used to launch the fat jar in a specific mode”

参考资料 : The Executable Jar Format

boot负责启动工作，启动过程代码比较简洁，状态变化通过事件机制传递，各个接收方再次初始化配置。

• java.util.EventListener 事件接收/监听
• java.util.EventObject 事件

• SpringFactoriesLoader： General purpose factory loading mechanism for internal use within the framework

• ApplicationEvent: Class to be extended by all application events

• ApplicationListener: Interface to be implemented by application event listeners

• ApplicationContextInitializer： Callback interface for initializing a Spring

• SpringApplicationRunListener： Listener for the SpringApplication.run method.

• ApplicationEventMulticaster： Interface to be implemented by objects that can manage a number of ApplicationListener objects and publish events to them

• ApplicationContext ：Central interface to provide configuration for an application

• ConfigurableApplicationContext： SPI interface to be implemented by most if not all application contexts。SPI in spring is spring.factories

@SpringBootApplication
public class TestApplication {
    public static void main(String[] args) {
        SpringApplication.run(TestApplication.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));
		this.webApplicationType = WebApplicationType.deduceFromClasspath();
		
		// 初始化类ApplicationContextInitializer
		setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
		
		
		// 监听类，当进程进入到某个阶段，再执行一系列操作，比如设置或者初始化
		setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
		
		
		this.mainApplicationClass = deduceMainApplicationClass();
	}

	
	public ConfigurableApplicationContext run(String... args) {
		StopWatch stopWatch = new StopWatch();
		stopWatch.start();
		ConfigurableApplicationContext context = null;
		configureHeadlessProperty();
		
		// 定义SpringApplicationRunListener，监控和反馈系统的各个阶段和状态
		// 实例为EventPublishingRunListener，在之后发布事件和状态
		SpringApplicationRunListeners listeners = getRunListeners(args);
		// 发布状态
		listeners.starting();
		
		try {
		    // 参数准备
			ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
			ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);
			configureIgnoreBeanInfo(environment);
			
			Banner printedBanner = printBanner(environment);
			
			// 上下文
			context = createApplicationContext();
			prepareContext(context, environment, listeners, applicationArguments, printedBanner);
			refreshContext(context);
			afterRefresh(context, applicationArguments);
			
			stopWatch.stop();
			if (this.logStartupInfo) {
				new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
			}
			
			// 发布启动完毕
			listeners.started(context);
			
			// 比如找到声明CommandLineRunner的的bean，会执行run
			callRunners(context, applicationArguments);
		}
		catch (Throwable ex) {
			handleRunFailure(context, ex, listeners);
			throw new IllegalStateException(ex);
		}

		try {
			// 发布应用就绪事件/状态
			listeners.running(context);
		}
		catch (Throwable ex) {
			handleRunFailure(context, ex, null);
			throw new IllegalStateException(ex);
		}
		return context;
	}

Spring的全局的东西可以通过上下文访问，SpringApplication的上下文类型是ConfigurableApplicationContext,默认的两个上下文实现类是

	
	public static final String DEFAULT_CONTEXT_CLASS = "org.springframework.context."
			+ "annotation.AnnotationConfigApplicationContext";

	
	public static final String DEFAULT_SERVLET_WEB_CONTEXT_CLASS = "org.springframework.boot."
			+ "web.servlet.context.AnnotationConfigServletWebServerApplicationContext";

查看AbstractApplicationContext可以看到上下文持有的对象

	
	@Nullable
	private ConfigurableEnvironment environment;

	
	private final List beanFactoryPostProcessors = new ArrayList<>();
	
	private ResourcePatternResolver resourcePatternResolver;

	
	@Nullable
	private LifecycleProcessor lifecycleProcessor;

	
	@Nullable
	private MessageSource messageSource;

	
	@Nullable
	private ApplicationEventMulticaster applicationEventMulticaster;

	
	private final Set> applicationListeners = new linkedHashSet<>();	
	
	@Nullable
	private Set> earlyApplicationListeners;

	
	@Nullable
	private Set earlyApplicationEvents;	

	private void prepareContext(ConfigurableApplicationContext context, ConfigurableEnvironment environment,
			SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments, Banner printedBanner) {
		context.setEnvironment(environment);
		postProcessApplicationContext(context);
		//各类Initializers取得Spring 上下文
		applyInitializers(context);

		// Listeners与上下文关联
		listeners.contextPrepared(context);
		
		if (this.logStartupInfo) {
			logStartupInfo(context.getParent() == null);
			logStartupProfileInfo(context);
		}
		// Add boot specific singleton beans
		ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
		beanFactory.registerSingleton("springApplicationArguments", applicationArguments);
		if (printedBanner != null) {
			beanFactory.registerSingleton("springBootBanner", printedBanner);
		}
		if (beanFactory instanceof DefaultListableBeanFactory) {
			((DefaultListableBeanFactory) beanFactory)
					.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
		}
		// 懒加载里面也有很多加载配置
		if (this.lazyInitialization) {
			context.addBeanFactoryPostProcessor(new LazyInitializationBeanFactoryPostProcessor());
		}
		// Load the sources
		Set