SpringBoot 2.3.x 启动方法源码解析

最新推荐文章于 2025-02-03 11:47:50 发布

原创最新推荐文章于 2025-02-03 11:47:50 发布 · 477 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #spring #spring boot #后端 #ioc

本文深入探讨了SpringBoot 2.3.x的启动过程，从run方法开始，逐步解析getRunListeners、prepareEnvironment、prepareContext、refreshContext和callRunners等关键步骤，涉及环境配置、监听器、ApplicationContext初始化和Bean加载等内容。

这是最常见的也是使用最多的SpringBoot应用程序启动类，整个SpringBoot应用启动都要靠执行run方法来启动

@SpringBootApplication
public class Hibernate52Application  {

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

}

点进去看看

// 这是SpringApplication的run方法
public static ConfigurableApplicationContext run(Class<?> primarySource, String... args) {
		return run(new Class<?>[] { primarySource }, args);
}
// 上面的run方法实际是调用这个run方法
public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {
		return new SpringApplication(primarySources).run(args);
}

首先实例化SpringApplication

private ResourceLoader resourceLoader;
private WebApplicationType webApplicationType;
private List<ApplicationContextInitializer<?>> initializers;
private List<ApplicationListener<?>> listeners;
private Class<?> mainApplicationClass;
public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
		// 资源加载器
		this.resourceLoader = resourceLoader;
		Assert.notNull(primarySources, "PrimarySources must not be null");
		// JavaConfig类型的类
		this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
		// 根据classPath推导出web应用类型
		this.webApplicationType = WebApplicationType.deduceFromClasspath();
		// 初始化initializers属性
		setInitializers((Collection)getSpringFactoriesInstances(ApplicationContextInitializer.class));
		// 设置监听器
		setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
		// 推导出主应用程序类
		this.mainApplicationClass = deduceMainApplicationClass();
	}

SprigBootApplication 中有非常多的属性，先看这个构造方法中使用到的

resourceLoader 资源加载器
primarySources 在这就是 Hibernate52Application.class
webApplicationType web应用程序类型，看代码是根据Classpath推导而来
Initializer 元素类型为ApplicationContextInitializer的列表
listeners 元素类型为ApplicationListener的列表
mainApplicationClass 主应用程序类

上面的方法，先一个一个看

deduceFormClasspath

public enum WebApplicationType {
/**
	 * The application should not run as a web application and should not start an
	 * embedded web server.
	 * 没有内嵌服务器
	 */
	NONE,

	/**
	 * The application should run as a servlet-based web application and should start an
	 * embedded servlet web server.
	 * Servlet类型的应用
	 */
	SERVLET,

	/**
	 * The application should run as a reactive web application and should start an
	 * embedded reactive web server.
	 * 响应式的应用 比如Spring-Webflux
	 */
	REACTIVE;

	private static final String[] SERVLET_INDICATOR_CLASSES = { "javax.servlet.Servlet",
			"org.springframework.web.context.ConfigurableWebApplicationContext" };

	private static final String WEBMVC_INDICATOR_CLASS = "org.springframework.web.servlet.DispatcherServlet";

	private static final String WEBFLUX_INDICATOR_CLASS = "org.springframework.web.reactive.DispatcherHandler";

	private static final String JERSEY_INDICATOR_CLASS = "org.glassfish.jersey.servlet.ServletContainer";
// 这个方法的作用就是判断当前的应用类型，通过使用反射在类路径下寻找是否存在对应的类，从而判断出该应用属于什么类型的应用
	static WebApplicationType deduceFromClasspath() {
			if (ClassUtils.isPresent(WEBFLUX_INDICATOR_CLASS, null) && !ClassUtils.isPresent(WEBMVC_INDICATOR_CLASS, null)
					&& !ClassUtils.isPresent(JERSEY_INDICATOR_CLASS, null)) {
				return WebApplicationType.REACTIVE;
			}
			for (String className : SERVLET_INDICATOR_CLASSES) {
				if (!ClassUtils.isPresent(className, null)) {
					return WebApplicationType.NONE;
				}
			}
			return WebApplicationType.SERVLET;
		}
}

getSpringFactoriesInstances

	private <T> Collection<T> getSpringFactoriesInstances(Class<T> type) {
		return getSpringFactoriesInstances(type, new Class<?>[] {});
	}

	private <T> Collection<T> getSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes, Object... args) {
		// 获取类加载器
		ClassLoader classLoader = getClassLoader();
		// Use names and ensure unique to protect against duplicates
		// 加载指定类型在"META-INF/spring.factories"对应的类名数组
		Set<String> names = new LinkedHashSet<>(SpringFactoriesLoader.loadFactoryNames(type, classLoader));
		// 根据类名数组创建实例
		List<T> instances = createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);
		// 排序实例
		AnnotationAwareOrderComparator.sort(instances);
		return instances;
	}
	// 其中的loadFactoryNames方法并没有点进去看，其实里面的逻辑就是根据type加载在"META-INF/spring.factories"对应的类名数组
	// 在META-INF/spring.factories中，以KEY-VALUE形式存储了各个类对应的实现类们

	@SuppressWarnings("unchecked")
	private <T> List<T> createSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes,
			ClassLoader classLoader, Object[] args, Set<String> names) {
		List<T> instances = new ArrayList<>(names.size());
		for (String name : names) {
			try {
				// 获取name对应的类
				Class<?> instanceClass = ClassUtils.forName(name, classLoader);
				// 判断实例是否实现自type类
				Assert.isAssignable(type, instanceClass);
				// 获取构造方法
				Constructor<?> constructor = instanceClass.getDeclaredConstructor(parameterTypes);
				// 创建实例
				T instance = (T) BeanUtils.instantiateClass(constructor, args);
				instances.add(instance);
			}
			catch (Throwable ex) {
				throw new IllegalArgumentException("Cannot instantiate " + type + " : " + name, ex);
			}
		}
		return instances;
	}

deduceMainApplicationClass

	private Class<?> deduceMainApplicationClass() {
		try {
			// 获得堆栈元素数组
			// 这有意思的是通过new一个运行时异常来获得堆栈元素数组来找到main方法的栈帧
			StackTraceElement[] stackTrace = new RuntimeException().getStackTrace();
			// 判断到底是哪个类执行了main方法
			for (StackTraceElement stackTraceElement : stackTrace) {
				if ("main".equals(stackTraceElement.getMethodName())) {
					return Class.forName(stackTraceElement.getClassName());
				}
			}
		}
		catch (ClassNotFoundException ex) {
			// Swallow and continue
		}
		return null;
	}
	// 这个方法的作用主要是用来获得启动类，用来打印启动时的日志，说明应用是通过这个类启动的。

构造方法看完了，现在再看看run方法

public ConfigurableApplicationContext run(String... args) {
		// 统计启动时长
		StopWatch stopWatch = new StopWatch();
		stopWatch.start();
		//
		ConfigurableApplicationContext context = null;
		Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
		// 配置 headless属性 和awt相关
		configureHeadlessProperty();
		// 1. 创建SpirngApplicationRunListeners数组
		SpringApplicationRunListeners listeners = getRunListeners(args);
		// 启动监听
		listeners.starting();
		try {
			// 创建applicationArguments 应用程序参数
			ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
			// 2. 加载属性配置
			ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);
			configureIgnoreBeanInfo(environment);
			// 启动打印banner
			Banner printedBanner = printBanner(environment);
			// 3. 创建Spring容器
			context = createApplicationContext();
			// 获得异常报告器
			exceptionReporters = getSpringFactoriesInstances(SpringBootExceptionReporter.class,
					new Class<?>[] { ConfigurableApplicationContext.class }, context);
			// 4.准备环境
			prepareContext(context, environment, listeners, applicationArguments, printedBanner);
			// 5.刷新环境 （初始化容器）
			refreshContext(context);
			// 后置刷新 逻辑为空
			afterRefresh(context, applicationArguments);
			// 停止统计时长
			stopWatch.stop();
			// 打印启动的时长的日志
			if (this.logStartupInfo) {
				new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
			}
			// 启动Spring容器
			listeners.started(context);
			// 6.调用runners
			callRunners(context, applicationArguments);
		}
		catch (Throwable ex) {
			handleRunFailure(context, ex, exceptionReporters, listeners);
			throw new IllegalStateException(ex);
		}

		try {
			listeners.running(context);
		}
		catch (Throwable ex) {
			handleRunFailure(context, ex, exceptionReporters, null);
			throw new IllegalStateException(ex);
		}
		return context;
	}

run方法的逻辑大致如此，这里面有几个比较重要的方法还是点进去看一下，分别是getRunListeners，prepareEnvironment，prepareContext，refreshContext，callRunners，

1. getRunListeners

	// 该方法获取了SpringApplicationRunListener在META-INF/spring.factories中对应的实现类并且返回了他们的实例
	private SpringApplicationRunListeners getRunListeners(String[] args) {
		Class<?>[] types = new Class<?>[] { SpringApplication.class, String[].class };
		return new SpringApplicationRunListeners(logger,
				getSpringFactoriesInstances(SpringApplicationRunListener.class, types, this, args));
	}
	//这里实际上也是用了上面的getSpringFactoriesInstances方法

此时的Listeners变量
在这里插入图片描述

2. prepareEnvironment

	private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners,
			ApplicationArguments applicationArguments) {
		// Create and configure the environment
		// 2.1创建环境
		ConfigurableEnvironment environment = getOrCreateEnvironment();
		// 2.2配置环境
		configureEnvironment(environment, applicationArguments.getSourceArgs());
		// 2.3属性绑定环境
		ConfigurationPropertySources.attach(environment);
		// 2.4通知SpringApplicationRunListeners，环境已经准备好
		listeners.environmentPrepared(environment);
		// 2.5将DefaultProperties移动到environment的最后
		DefaultPropertiesPropertySource.moveToEnd(environment);
		// 2.6配置其他额外的profiles
		configureAdditionalProfiles(environment);
		// 2.7把环境绑定到SpringApplication
		bindToSpringApplication(environment);
		// 2.8如果不是自定义环境，根据条件转换
		if (!this.isCustomEnvironment) {
			environment = new EnvironmentConverter(getClassLoader()).convertEnvironmentIfNecessary(environment,
					deduceEnvironmentClass());
		}
		// 如果有attach到environment的MutablePropertySources，就添加到environment的PropertySources中
		ConfigurationPropertySources.attach(environment);
		return environment;
	}

2.1 getOrCreateEnvironment

	// 创建环境
	private ConfigurableEnvironment getOrCreateEnvironment() {
		// 存在就返回
		if (this.environment != null) {
			return this.environment;
		}
		// 不存在就根据构造方法中推断出的web应用类型来进行创建
		switch (this.webApplicationType) {
		case SERVLET:
			return new StandardServletEnvironment();
		case REACTIVE:
			return new StandardReactiveWebEnvironment();
		default:
			return new StandardEnvironment();
		}
	}

2.2 configureEnvironment

protected void configureEnvironment(ConfigurableEnvironment environment, String[] args) {
		// 设置environment的conversionService属性
		if (this.addConversionService) { //true
			ConversionService conversionService = ApplicationConversionService.getSharedInstance();
			environment.setConversionService((ConfigurableConversionService) conversionService);
		}
		// 2.2.1配置environment的propertySources属性
		configurePropertySources(environment, args);
		// 2.2.2配置environment的profiles属性
		configureProfiles(environment, args);
	}

这涉及到了很多名词比如environment,profile,propertySource等，先挖个坑，知道大体意思就好，具体的细节以后再看

2.2.1 configurePropertySources

	protected void configurePropertySources(ConfigurableEnvironment environment, String[] args) {
		MutablePropertySources sources = environment.getPropertySources();
		DefaultPropertiesPropertySource.ifNotEmpty(this.defaultProperties, sources::addLast);
		if (this.addCommandLineProperties && args.length > 0) {
			// 如果存在就替换
			String name = CommandLinePropertySource.COMMAND_LINE_PROPERTY_SOURCE_NAME;
			if (sources.contains(name)) {
				PropertySource<?> source = sources.get(name);
				CompositePropertySource composite = new CompositePropertySource(name);
				composite.addPropertySource(
						new SimpleCommandLinePropertySource("springApplicationCommandLineArgs", args));
				composite.addPropertySource(source);
				sources.replace(name, composite);
			}
			else {
				// 不存在就添加	
				sources.addFirst(new SimpleCommandLinePropertySource(args));
			}
		}
	}

这段代码大体意思就是propertySource可以通过命令行参数进行附加

2.2.2 configureProfiles

	// 逻辑为空
	protected void configureProfiles(ConfigurableEnvironment environment, String[] args) {
	}

2.3 attach

	// 这个方法的作用大概就是往environment的MutablePropertySources中添加一个新的配置
	public static void attach(Environment environment) {
		Assert.isInstanceOf(ConfigurableEnvironment.class, environment);
		MutablePropertySources sources = ((ConfigurableEnvironment) environment).getPropertySources();
		PropertySource<?> attached = sources.get(ATTACHED_PROPERTY_SOURCE_NAME);
		if (attached != null && attached.getSource() != sources) {
			sources.remove(ATTACHED_PROPERTY_SOURCE_NAME);
			attached = null;
		}
		if (attached == null) {
			sources.addFirst(new ConfigurationPropertySourcesPropertySource(ATTACHED_PROPERTY_SOURCE_NAME,
					new SpringConfigurationPropertySources(sources)));
		}
	}

2.4 environmentPrepared

    //通知SpringApplicationRunListener，环境已经准备完成
	void environmentPrepared(ConfigurableEnvironment environment) {
		for (SpringApplicationRunListener listener : this.listeners) {
			listener.environmentPrepared(environment);
		}
	}

2.5 moveToEnd

	public static final String NAME = "defaultProperties";
	// 将defaultProperties移动到environment的PropertySources的最后，至于这么做的目的，不太清楚
	public static void moveToEnd(ConfigurableEnvironment environment) {
		moveToEnd(environment.getPropertySources());
	}
	public static void moveToEnd(MutablePropertySources propertySources) {
		PropertySource<?> propertySource = propertySources.remove(NAME);
		if (propertySource != null) {
			propertySources.addLast(propertySource);
		}
	}

2.6 configureAdditionalProfiles

	// 配置额外的配置文件
	private void configureAdditionalProfiles(ConfigurableEnvironment environment) {
		if (!CollectionUtils.isEmpty(this.additionalProfiles)) {
			Set<String> profiles = new LinkedHashSet<>(Arrays.asList(environment.getActiveProfiles()));
			if (!profiles.containsAll(this.additionalProfiles)) {
				profiles.addAll(this.additionalProfiles);
				environment.setActiveProfiles(StringUtils.toStringArray(profiles));
			}
		}
	}

2.7 bindToSpringApplication

	// 绑定springApplication到environment 不知道有啥用
	protected void bindToSpringApplication(ConfigurableEnvironment environment) {
		try {
			Binder.get(environment).bind("spring.main", Bindable.ofInstance(this));
		}
		catch (Exception ex) {
			throw new IllegalStateException("Cannot bind to SpringApplication", ex);
		}
	}

2.8 如果不是自定义条件则转换

默认情况下 isCustomEnvironment 为false，所以这的代码一般就会执行，不过返回的还是StandardEnvironment类型的environment 代码不放了

3.createApplicationContext

	private ApplicationContextFactory applicationContextFactory = ApplicationContextFactory.DEFAULT;
	// 根据webApplicationType创建spring容器
	protected ConfigurableApplicationContext createApplicationContext() {
		return this.applicationContextFactory.create(this.webApplicationType);
	}

	//根据webApplicationType创建不同的context
	ApplicationContextFactory DEFAULT = (webApplicationType) -> {
		try {
			switch (webApplicationType) {
			case SERVLET:
				return new AnnotationConfigServletWebServerApplicationContext();
			case REACTIVE:
				return new AnnotationConfigReactiveWebServerApplicationContext();
			default:
				return new AnnotationConfigApplicationContext();
			}
		}
		catch (Exception ex) {
			throw new IllegalStateException("Unable create a default ApplicationContext instance, "
					+ "you may need a custom ApplicationContextFactory", ex);
		}
	};

4.prepareContext

	private void prepareContext(ConfigurableApplicationContext context, ConfigurableEnvironment environment,
			SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments, Banner printedBanner) {
		// 上下文设置环境
		context.setEnvironment(environment);
		// 1.后置处理上下文
		postProcessApplicationContext(context);
		// 2.初始化Initilizers
		applyInitializers(context);
		// 3.通知listeners上下文已经准备好
		listeners.contextPrepared(context);
		// 打印日志
		if (this.logStartupInfo) {
			logStartupInfo(context.getParent() == null);
			logStartupProfileInfo(context);
		}
		// Add boot specific singleton beans
		// 设置beanFactory的属性
		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
		// 加载BeanDefinition们
		Set<Object> sources = getAllSources();
		Assert.notEmpty(sources, "Sources must not be empty");
		// 4.加载
		load(context, sources.toArray(new Object[0]));
		// 通知 SpringApplicationRunListener 的数组，Spring 容器加载完成。
		listeners.contextLoaded(context);
	}

4.1 postProcessApplicationContext

	//后置处理applicationContext
	protected void postProcessApplicationContext(ConfigurableApplicationContext context) {
		if (this.beanNameGenerator != null) {
			context.getBeanFactory().registerSingleton(AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR,
					this.beanNameGenerator);
		}
		if (this.resourceLoader != null) {
			if (context instanceof GenericApplicationContext) {
				((GenericApplicationContext) context).setResourceLoader(this.resourceLoader);
			}
			if (context instanceof DefaultResourceLoader) {
				((DefaultResourceLoader) context).setClassLoader(this.resourceLoader.getClassLoader());
			}
		}
		// 只在SpringMVC环境下，前两个都为空，也就是只会进入这个分支，context的工厂会set一个conversionService
		if (this.addConversionService) {
			context.getBeanFactory().setConversionService(ApplicationConversionService.getSharedInstance());
		}
	}

4.2 applyInitializers

	// 大概意思就是遍历之后判断非空然后初始化initializer
	protected void applyInitializers(ConfigurableApplicationContext context) {
		for (ApplicationContextInitializer initializer : getInitializers()) {
			Class<?> requiredType = GenericTypeResolver.resolveTypeArgument(initializer.getClass(),
					ApplicationContextInitializer.class);
			Assert.isInstanceOf(requiredType, context, "Unable to call initializer.");
			initializer.initialize(context);
		}
	}

4.3 contextPrepared

	// 通知SpringApplicationRunListeners：容器已经准备好了
	void contextPrepared(ConfigurableApplicationContext context) {
		doWithListeners("spring.boot.application.context-prepared", (listener) -> listener.contextPrepared(context));
	}
	private void doWithListeners(String stepName, Consumer<SpringApplicationRunListener> listenerAction) {
		doWithListeners(stepName, listenerAction, StartupStep::end);
	}

	private void doWithListeners(String stepName, Consumer<SpringApplicationRunListener> listenerAction,
			Consumer<StartupStep> stepAction) {
		StartupStep step = this.applicationStartup.start(stepName);
		this.listeners.forEach(listenerAction);
		stepAction.accept(step);
		step.end();
	}

4.4 load

	protected void load(ApplicationContext context, Object[] sources) {
		if (logger.isDebugEnabled()) {
			logger.debug("Loading source " + StringUtils.arrayToCommaDelimitedString(sources));
		}
		BeanDefinitionLoader loader = createBeanDefinitionLoader(getBeanDefinitionRegistry(context), sources);
		if (this.beanNameGenerator != null) {
			loader.setBeanNameGenerator(this.beanNameGenerator);
		}
		if (this.resourceLoader != null) {
			loader.setResourceLoader(this.resourceLoader);
		}
		if (this.environment != null) {
			loader.setEnvironment(this.environment);
		}
		loader.load();
	}
	void load() {
		for (Object source : this.sources) {
			// BeanDefinitionLoader根据sources加载beandefinition
			load(source);
		}
	}

关于IOC加载Bean，可以看【死磕 Spring】—– IOC 之加载 Bean

5.refreshcontext

	private void refreshContext(ConfigurableApplicationContext context) {
		// 1.刷新容器
		// 这里可以触发springboot的自动配置功能，挖个坑 以后研究
		refresh((ApplicationContext) context);
		// 2.注册关闭挂钩，主要用来在容器关闭时销毁bean信息
		if (this.registerShutdownHook) {
			try {
				context.registerShutdownHook();
			}
			catch (AccessControlException ex) {
				// Not allowed in some environments.
			}
		}
	}

6.callRunners

	private void callRunners(ApplicationContext context, ApplicationArguments args) {
		// runners列表
		List<Object> runners = new ArrayList<>();
		// 获得所有ApplicationRunner实例
		runners.addAll(context.getBeansOfType(ApplicationRunner.class).values());
		// 获得所有CommandLineRunner实例
		runners.addAll(context.getBeansOfType(CommandLineRunner.class).values());
		// 排序runners
		AnnotationAwareOrderComparator.sort(runners);
		// 遍历并执行
		for (Object runner : new LinkedHashSet<>(runners)) {
			if (runner instanceof ApplicationRunner) {
				callRunner((ApplicationRunner) runner, args);
			}
			if (runner instanceof CommandLineRunner) {
				callRunner((CommandLineRunner) runner, args);
			}
		}
	}

总结

Spring Boot的启动分为实例化SpringApplication以及run方法。
实例化方法主要做两件事：
1.初始化Initializers
2.初始化Listeners
这两种初始化方法都是通过加载’META-INF/spring.factories’中配置的实现类来实现的。
Spring Boot的启动方法代码就到此结束了，只是简单的过了一遍，还有好多概念不明白，也有几个坑要填，比如environment，profile到底是啥，还有Spring Boot的自动配置功能到底怎么实现的，以及tomcat是怎么嵌入Spring Boot中的。