【框架源码】SpringBoot核心源码解读之启动类源码分析

首先我们要先带着我们的疑问，spring boot是如何启动应用程序？去分析SpringBoot的启动源码。

我们在新建SpringBoot项目时，核心方法就是主类的run方法。

SpringApplication.run(ArchWebApplication.class, args)

我们点击run方法进入到源码中，这块传入的了一个我们当前程序主类的类对象以及主程序参数。

	public static ConfigurableApplicationContext run(Class<?> primarySource,
			String... args) {
		return run(new Class<?>[] { primarySource }, args);
	}

再往下走，调用本身的run方法，这里就开始初始化SpringApplication对象啦，然后在调用run方法。初始化SpringApplication对象时也是将主类的类对象传入进去，然后调用run方法，将主程序传进来的参数传进去。

	public static ConfigurableApplicationContext run(Class<?>[] primarySources,
			String[] args) {
		return new SpringApplication(primarySources).run(args);
	}

我们先来看SpringApplication对象初始化时都做了哪些操作。

同样调用自身的双参构造方法，null为传入的资源加载器。

	public SpringApplication(Class<?>... primarySources) {
		this(null, primarySources);
	}

再往下走就到了初始化SpringApplication的核心逻辑啦。

	public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
    //首先是将传来的资源加载器进行赋值，当然我们知道这个资源加载器是null
		this.resourceLoader = resourceLoader;
    //然后在进行类对象的判空
		Assert.notNull(primarySources, "PrimarySources must not be null");
    //然后将传进来的类对像的数组转成list在转成set。
    //（我估计这里是为了去重类对象，因为可以穿进来的可变参数有重复的，可变参数实质就是一个数组）。
		this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
    //deduceFromClasspath 方法的目的是用来判断应用是servlet还是reactive应用
		this.webApplicationType = WebApplicationType.deduceFromClasspath();
    //这一步的逻辑是从spring.factories文件中读取 key为ApplicationContextInitializer的类信息，采用反射实例化对象
    //设置上下文信息
		setInitializers((Collection) getSpringFactoriesInstances(
				ApplicationContextInitializer.class));
    //这一步的逻辑同上，也是从spring.factories文件中读取 key为ApplicationListener的类信息，采用反射实例化对象
  	//设置监听器
		setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
    //判断是否为main函数，配置主函数启动类 class信息
		this.mainApplicationClass = deduceMainApplicationClass();
	}

上面是一个创建SpringApplication的整体逻辑，那么我们在具体看一下 WebApplicationType.deduceFromClasspath()里面的逻辑是怎么样的。WebApplicationType本身是一个枚举类。

  //一共三种方式返回服务条件的一种	
	static WebApplicationType deduceFromClasspath() {
    //判断当前应用是不是 REACTIVE应用
		if (ClassUtils.isPresent(WEBFLUX_INDICATOR_CLASS, null)
				&& !ClassUtils.isPresent(WEBMVC_INDICATOR_CLASS, null)
				&& !ClassUtils.isPresent(JERSEY_INDICATOR_CLASS, null)) {
			return WebApplicationType.REACTIVE;
		}
    //判断是不是 非web应用
		for (String className : SERVLET_INDICATOR_CLASSES) {
			if (!ClassUtils.isPresent(className, null)) {
				return WebApplicationType.NONE;
			}
		}
    //都不是的话返回 web应用方式
		return WebApplicationType.SERVLET;
	}

ClassUtils.isPresent()这个方法的主要作用是通过反射判断相应的类存不存在。

	public static boolean isPresent(String className, @Nullable ClassLoader classLoader) {
		try {
			forName(className, classLoader);
			return true;
		}
		catch (IllegalAccessError err) {
			throw new IllegalStateException("Readability mismatch in inheritance hierarchy of class [" +
					className + "]: " + err.getMessage(), err);
		}
		catch (Throwable ex) {
			// Typically ClassNotFoundException or NoClassDefFoundError...
			return false;
		}
	}

ok，分析完WebApplicationType.deduceFromClasspath()，我们在来看一下getSpringFactoriesInstances()这个方法的核心逻辑。

	private <T> Collection<T> getSpringFactoriesInstances(Class<T> type,
			Class<?>[] parameterTypes, Object... args) {
    //获取ClassLoader
		ClassLoader classLoader = getClassLoader();
		//这一步很重要，重点在于内部是从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中都干了什么，它这里面的核心就在于加载配置文件，反射实例化对象

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

	//核心逻辑在这个方法
	private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
		//首先先去判断下Map中是否有值，有值的话，就直接返回，相当于一个本地缓存。
    MultiValueMap<String, String> result = cache.get(classLoader);
		if (result != null) {
			return result;
		}

		try {
      //如果Map没有值的话，获取资源目录下的spring.factories文件。加载配置
      //源码中 FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories"
			Enumeration<URL> urls = (classLoader != null ?
					classLoader.getResources(FACTORIES_RESOURCE_LOCATION) :
					ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));
			result = new LinkedMultiValueMap<>();
      //下面就是遍历放进map中
			while (urls.hasMoreElements()) {
				URL url = urls.nextElement();
				UrlResource resource = new UrlResource(url);
				Properties properties = PropertiesLoaderUtils.loadProperties(resource);
				for (Map.Entry<?, ?> entry : properties.entrySet()) {
					String factoryClassName = ((String) entry.getKey()).trim();
					for (String factoryName : StringUtils.commaDelimitedListToStringArray((String) entry.getValue())) {
						result.add(factoryClassName, factoryName.trim());
					}
				}
			}
			cache.put(classLoader, result);
			return result;
		}
		catch (IOException ex) {
			throw new IllegalArgumentException("Unable to load factories from location [" +
					FACTORIES_RESOURCE_LOCATION + "]", ex);
		}
	}

OK，这里关于SpringApplication初始化的操作就已经完成啦，那么下面我们在一下run()方法里都做些什么操作。传进去的是主程序的参数。

public ConfigurableApplicationContext run(String... args) {
  	//创建StopWatch对象，用于记录服务启动的时间
		StopWatch stopWatch = new StopWatch();
  	//记录服务启动开始时间
		stopWatch.start();
  	//定义应用程序上下文
		ConfigurableApplicationContext context = null;
		Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
  	//配置运行程序的系统环境，以确保可正确的运行。
		configureHeadlessProperty();
  	//获取在SpringApplication上的所有监听器。
		SpringApplicationRunListeners listeners = getRunListeners(args);
  	//通知所有监听器，启动应用程序
		listeners.starting();
		try {
      //封装应用程序的主程序参数
			ApplicationArguments applicationArguments = new DefaultApplicationArguments(
					args);
      //准备应用环境，生成环境变量
			ConfigurableEnvironment environment = prepareEnvironment(listeners,
					applicationArguments);
			configureIgnoreBeanInfo(environment);
      //打印应用程序的banner
			Banner printedBanner = printBanner(environment);
      //创建应用上下文对象
			context = createApplicationContext();
      //从spring.factories中获取SpringBootExceptionReporter类型的异常解析器。
			exceptionReporters = getSpringFactoriesInstances(
					SpringBootExceptionReporter.class,
					new Class[] { ConfigurableApplicationContext.class }, context);
      //用已有的数据准备上下文，为刷新做准备
			prepareContext(context, environment, listeners, applicationArguments,
					printedBanner);
      //启动应用程序上下文，通过refresh实现
			refreshContext(context);
      //上下文刷新后执行一些后置处理
			afterRefresh(context, applicationArguments);
      //记录结束时间
			stopWatch.stop();
      //判断是否需要记录应用程序的启动信息
			if (this.logStartupInfo) {
				new StartupInfoLogger(this.mainApplicationClass)
						.logStarted(getApplicationLog(), stopWatch);
			}
      //通知所有监听器，应用程序已经启动，传递上下文对象和启动时间
			listeners.started(context);
      //运行所有已经注册的runner
			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;
	}

ok，下面我们来断点调试下springboot启动类的源码执行。

启动SpringBoot应用程序。

后面就是排序实例 ，返回实例。

剩下的就是我们上面画的那些流程啦。

ok，至此SpringBoot启动的全流程就已经完成啦，最后在总结一下大体的流程。文章来源地址https://www.toymoban.com/news/detail-463866.html

• 初始化SpringApplication，运行SpringApplication的run方法
• 读取 spring.factories 的多个初始化器和监听器
• 配置项目中环境变量、jvm配置信息、配置文件信息
• 预初始化环境，创建环境对象
• 创建Spring容器对象（ApplicationContext）
• 调用spring的refresh加载IOC容器、自动配置类，并创建bean等信息
• 调用很多监听器并传递上下文对象
• 运行相关runner

到了这里，关于【框架源码】SpringBoot核心源码解读之启动类源码分析的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！