springboot 启动过程之SpringApplication对象实例过程

最新推荐文章于 2024-04-27 14:50:57 发布

圆师傅

最新推荐文章于 2024-04-27 14:50:57 发布

阅读量665

点赞数

分类专栏： spring全家桶文章标签： Springboot SpringApplication

spring全家桶专栏收录该内容

16 篇文章 0 订阅

订阅专栏

springboot所提倡的习惯优于配置的理念，使得java web应用开发不再需要大量的配置文件，可以使开发者更加专注于业务。但是这些是建立在对Spring boot已经了如指掌的情况，仅仅会使用是远远不够的。

如何使用starter去创建一个springboot项目，这里不再赘述。还不会的小伙伴可以暂时先看看如何创建。

这里使用的是springboot 2.1.3的代码。

入口启动类

@SpringBootApplication
public class LearnSbApplication {

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

}

通过上面的代码，可以看出两点：

* @SpringBootApplication注解

* SpringApplication的类方法run()传入参数。

先查看SpringApplication的类方法run

类：org.springframework.boot.SpringApplication

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

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

primarySource是加载的主要资源类，可变参数args是传入的启动参数。

在静态方法中构建了一个SpringApplication对象，调用run()方法。

那么SpringApplication是如何创建的呢？

SpringApplication对象创建过程

类：org.springframework.boot.SpringApplication

public SpringApplication(Class<?>... primarySources) {
		this(null, primarySources);
	}
	
	/**
	 * Create a new {@link SpringApplication} instance. The application context will load
	 * beans from the specified primary sources (see {@link SpringApplication class-level}
	 * documentation for details. The instance can be customized before calling
	 * {@link #run(String...)}.
	 * @param resourceLoader the resource loader to use
	 * @param primarySources the primary bean sources
	 * @see #run(Class, String[])
	 * @see #setSources(Set)
	 */
	@SuppressWarnings({ "unchecked", "rawtypes" })
	public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
        
        //1、资源加载器，这里传入的是null
		this.resourceLoader = resourceLoader;
        
        //2、断言主要资源primarySource不为空
		Assert.notNull(primarySources, "PrimarySources must not be null");
        
        //3、初始化主要资源加载类，并去重。
        //（先将primarySource转换为list，然后将该list转换为链表，链表节点为hashSet）
		this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
        
        //4、推断当前web应用类型
		this.webApplicationType = WebApplicationType.deduceFromClasspath();
        
        //5、设置应用上下文初始化器
		setInitializers((Collection) getSpringFactoriesInstances(
				ApplicationContextInitializer.class));
        
        //6、设置监听器
		setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
		
        //7、确定主入口程序
        this.mainApplicationClass = deduceMainApplicationClass();
	}

第4步中的推断web应用类型的代码如下：

	类：org.springframework.boot.WebApplicationTytpe
	
	public enum WebApplicationType {

	//非web应用
	NONE,
	//基于servlet的web应用，应启动内置的servlet web 服务器
	SERVLET,
	//reactive web 应用，应启动reactive web服务器
	REACTIVE;

	private static final String[] SERVLET_INDICATOR_CLASSES = { "javax.servlet.Servlet",
			"org.springframework.web.context.ConfigurableWebApplicationContext" };
			
	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() {
		//判断对应路径下是否有对应类存在
		//ClassUtils.isPresent(String className, @Nullable ClassLoader classLoader)
		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;
	}

}

在deduceFromClasspath()方法中用到了ClassUtils.isPresent(String name, ClassLoader classLoader)方法，源码如下：

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;
		}
	}
	

	public static Class<?> forName(String name, @Nullable ClassLoader classLoader)
			throws ClassNotFoundException, LinkageError {

		Assert.notNull(name, "Name must not be null");

		Class<?> clazz = resolvePrimitiveClassName(name);
		if (clazz == null) {
			clazz = commonClassCache.get(name);
		}
		if (clazz != null) {
			return clazz;
		}

		// "java.lang.String[]" style arrays
		if (name.endsWith(ARRAY_SUFFIX)) {
			String elementClassName = name.substring(0, name.length() - ARRAY_SUFFIX.length());
			Class<?> elementClass = forName(elementClassName, classLoader);
			return Array.newInstance(elementClass, 0).getClass();
		}

		// "[Ljava.lang.String;" style arrays
		if (name.startsWith(NON_PRIMITIVE_ARRAY_PREFIX) && name.endsWith(";")) {
			String elementName = name.substring(NON_PRIMITIVE_ARRAY_PREFIX.length(), name.length() - 1);
			Class<?> elementClass = forName(elementName, classLoader);
			return Array.newInstance(elementClass, 0).getClass();
		}

		// "[[I" or "[[Ljava.lang.String;" style arrays
		if (name.startsWith(INTERNAL_ARRAY_PREFIX)) {
			String elementName = name.substring(INTERNAL_ARRAY_PREFIX.length());
			Class<?> elementClass = forName(elementName, classLoader);
			return Array.newInstance(elementClass, 0).getClass();
		}

		ClassLoader clToUse = classLoader;
		if (clToUse == null) {
			clToUse = getDefaultClassLoader();
		}
		try {
			return Class.forName(name, false, clToUse);
		}
		catch (ClassNotFoundException ex) {
			int lastDotIndex = name.lastIndexOf(PACKAGE_SEPARATOR);
			if (lastDotIndex != -1) {
				String innerClassName =
						name.substring(0, lastDotIndex) + INNER_CLASS_SEPARATOR + name.substring(lastDotIndex + 1);
				try {
					return Class.forName(innerClassName, false, clToUse);
				}
				catch (ClassNotFoundException ex2) {
					// Swallow - let original exception get through
				}
			}
			throw ex;
		}
	}

根据ClassUtils.isPresent(String name, ClassLoader classLoader)判断，看当前指定的路径下是否存在必要的类，进而确定应该加载的webApplicationType是三个枚举类型中的哪一个。

第5步当中设置应用上下文初始化器

setInitializers((Collection) getSpringFactoriesInstances(
				ApplicationContextInitializer.class));

其中ApplicationContextInitializer的源码：

public interface ApplicationContextInitializer<C extends ConfigurableApplicationContext> {

	/**
	 * Initialize the given application context.
	 * @param applicationContext the application to configure
	 */
	void initialize(C applicationContext);

}

初始化Spring应用上下文，入注册属性资源，激活profile文件等。

setInitializers的源码：

public void setInitializers(
			Collection<? extends ApplicationContextInitializer<?>> initializers) {
		this.initializers = new ArrayList<>();
		this.initializers.addAll(initializers);
	}

其目的就是将initialLizers这个ApplicationContextInitializer加载到集合当中去，以备Spring进行初始化。

再看getSpringFactoriesInstances(ApplicationContextInitializer.class))的源码：

	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();
		// 获取ApplicationContextInitializer的名称，并去重
		Set<String> names = new LinkedHashSet<>(
				SpringFactoriesLoader.loadFactoryNames(type, classLoader));
        //根据获得的名称创建初始化工厂实例
		List<T> instances = createSpringFactoriesInstances(type, parameterTypes,
				classLoader, args, names);
        //排序
		AnnotationAwareOrderComparator.sort(instances);
		return instances;
	}

SpringFactoriesLoader.loadFactoryNames(type, classLoader)的源码如下：

public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";	

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) {
		MultiValueMap<String, String> result = cache.get(classLoader);
		if (result != null) {
			return result;
		}

		try {
            //三目运算符，classloader不为空，去加载META-INF/spring.factories的资源
			Enumeration<URL> urls = (classLoader != null ?
					classLoader.getResources(FACTORIES_RESOURCE_LOCATION) :
					ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));
			result = new LinkedMultiValueMap<>();
			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);
		}
	}

META-INF/spring.factories的initializers部分内容如下：

# Initializers
org.springframework.context.ApplicationContextInitializer=\
org.springframework.boot.autoconfigure.SharedMetadataReaderFactoryContextInitializer,\
org.springframework.boot.autoconfigure.logging.ConditionEvaluationReportLoggingListener

createSpringFactoriesInstances(type, parameterTypes,classLoader, args, names);的源码如下：

	@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 {
				Class<?> instanceClass = ClassUtils.forName(name, classLoader);
				Assert.isAssignable(type, instanceClass);
				Constructor<?> constructor = instanceClass
						.getDeclaredConstructor(parameterTypes);
                //使用BeanUtils创建类实例
				T instance = (T) BeanUtils.instantiateClass(constructor, args);
				instances.add(instance);
			}
			catch (Throwable ex) {
				throw new IllegalArgumentException(
						"Cannot instantiate " + type + " : " + name, ex);
			}
		}
		return instances;
	}

第6步中设置监听器setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));源码

@FunctionalInterface
public interface ApplicationListener<E extends ApplicationEvent> extends EventListener {

	/**
	 * Handle an application event.
	 * @param event the event to respond to
	 */
	void onApplicationEvent(E event);

}

该接口继承了java.util.EventListener接口，实现了观察者模式，它一般用来定义感兴趣的事件类型，事件类型限定于 ApplicationEvent 的子类，这同样继承了 JDK 的 java.util.EventObject 接口。

设置监听器和设置初始化器调用的方法是一样的，只是传入的类型不一样，设置监听器的接口类型为：getSpringFactoriesInstances，对应的 spring-boot-autoconfigure-2.1.3.RELEASE.jar!/META-INF/spring.factories 文件配置内容请见下方。

# Application Listeners
org.springframework.context.ApplicationListener=\
org.springframework.boot.autoconfigure.BackgroundPreinitializer

第7步推断主入口类this.mainApplicationClass = deduceMainApplicationClass();源码为：

	private Class<?> deduceMainApplicationClass() {
		try {
			StackTraceElement[] stackTrace = new RuntimeException().getStackTrace();
			for (StackTraceElement stackTraceElement : stackTrace) {
				if ("main".equals(stackTraceElement.getMethodName())) {
					return Class.forName(stackTraceElement.getClassName());
				}
			}
		}
		catch (ClassNotFoundException ex) {
			// Swallow and continue
		}
		return null;
	}

这个推断入口应用类的方式有点特别，通过构造一个运行时异常，再遍历异常栈中的方法名，获取方法名为 main 的栈帧，从来得到入口类的名字再返回该类。

注：参考了https://www.cnblogs.com/javastack/p/9429102.html内容，在此表示感谢。

圆师傅

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
springboot 启动过程之SpringApplication对象实例过程

springboot所提倡的习惯优于配置的理念，使得java web应用开发不再需要大量的配置文件，可以使开发者更加专注于业务。但是这些是建立在对Spring boot已经了如指掌的情况，仅仅会使用是远远不够的。如何使用starter去创建一个springboot项目，这里不再赘述。还不会的小伙伴可以暂时先看看如何创建。这里使用的是springboot 2.1.3的代码。入口启动类@Spr...
复制链接

扫一扫