SpringBoot启动过程分析之SpringApplication的初始化

这是一条海鱼

已于 2022-03-21 14:50:42 修改

阅读量508

点赞数

分类专栏： SpringBoot 文章标签： spring

于 2020-05-05 21:08:11 首次发布

本文链接：https://blog.csdn.net/qq_41071876/article/details/105895911

版权

SpringBoot 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

前言

SpringApplication是一个类，提供一些便利的功能，引导Spring的程序进行启动

Spring Boot 的入口类

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

做过 Spring Boot 项目的都知道，上面是 Spring Boot 最简单通用的入口类。入口类的要求是最顶层包下面第一个含有 main 方法的类，使用注解 @SpringBootApplication 来启用 Spring Boot 特性，使用 SpringApplication.run 方法来启动 Spring Boot 项目。

来看一下这个类的run方法调用关系源码：

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

这里有2个核心1个是SpringApplication的创建，另一个是其run方法的调用。本文重点研究SpringApplication的创建

一、SpringApplication源码概括

public class SpringApplication {

	//默认情况下将用于非web环境的应用程序上下文的类名.
	public static final String DEFAULT_CONTEXT_CLASS ="org.springframework.context.annotation.AnnotationConfigApplicationContext";

    //默认情况下将用于web环境的应用程序上下文的类名
	public static final String DEFAULT_SERVLET_WEB_CONTEXT_CLASS ="org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext";

	//应用程序上下文的类名，默认情况下将用于被动web环境.
	public static final String DEFAULT_REACTIVE_WEB_CONTEXT_CLASS ="org.springframework.boot.web.reactive.context.AnnotationConfigReactiveWebServerApplicationContext";

	//默认横幅位置。“banner.txt”
	public static final String BANNER_LOCATION_PROPERTY_VALUE =SpringApplicationBannerPrinter.DEFAULT_BANNER_LOCATION;

	//横幅位置属性键 “”spring.banner.location.
	public static final String BANNER_LOCATION_PROPERTY = SpringApplicationBannerPrinter.BANNER_LOCATION_PROPERTY;

	private static final String SYSTEM_PROPERTY_JAVA_AWT_HEADLESS = "java.awt.headless";

	private Set<Class<?>> primarySources;

	private Set<String> sources = new LinkedHashSet<>();

	private Class<?> mainApplicationClass;

	private Banner.Mode bannerMode = Banner.Mode.CONSOLE;

	private boolean logStartupInfo = true;

	private boolean addCommandLineProperties = true;

	private boolean addConversionService = true;

	private Banner banner;

	private ResourceLoader resourceLoader;

	private BeanNameGenerator beanNameGenerator;

	private ConfigurableEnvironment environment;

	private Class<? extends ConfigurableApplicationContext> applicationContextClass;

	private WebApplicationType webApplicationType;

	private boolean headless = true;

	private boolean registerShutdownHook = true;

	private List<ApplicationContextInitializer<?>> initializers;

	private List<ApplicationListener<?>> listeners;

	private Map<String, Object> defaultProperties;

	private Set<String> additionalProfiles = new HashSet<>();

	private boolean allowBeanDefinitionOverriding;

	private boolean isCustomEnvironment = false;

	private boolean lazyInitialization = false;
	
	public SpringApplication(Class<?>... primarySources) {
		this(null, primarySources);
	}
	
   public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
			// 1、资源初始化资源加载器为 null
		    this.resourceLoader = resourceLoader;
		
		    // 2、断言主要加载资源类不能为 null，否则报错
		    Assert.notNull(primarySources, "PrimarySources must not be null");
		
		    // 3、初始化主要加载资源类集合并去重
		    this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
		
		    // 4、推断当前 WEB 应用类型
		    this.webApplicationType = deduceWebApplicationType();
		
		    // 5、设置应用上线文初始化器
		    setInitializers((Collection) getSpringFactoriesInstances( ApplicationContextInitializer.class));      
		
		    // 6、设置监听器
		    setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
		
		    // 7、推断主入口应用类
		    this.mainApplicationClass = deduceMainApplicationClass();
	}

二. 推断当前 WEB 应用类型

这个就是根据类路径下是否有对应项目类型的类推断出不同的应用类型。

private WebApplicationType deduceWebApplicationType() {

    //如果“org.springframework.web.reactive.DispatcherHandler"存在，且"org.springframework.web.servlet.DispatcherServlet"不存在
    //，当前程序类型就是响应式 WEB 项目，启动时会嵌入响应式web服务器
    if (ClassUtils.isPresent(REACTIVE_WEB_ENVIRONMENT_CLASS, null)&& !ClassUtils.isPresent(MVC_WEB_ENVIRONMENT_CLASS, null)) {
        return WebApplicationType.REACTIVE;
    }
    //如果javax.servlet.Servlet和org.springframework.web.context.ConfigurableWebApplicationContext
    //有一个不存在，当前程序类型就是非 WEB 项目,如果是这个那么项目不会启动时嵌入web服务器
    for (String className : WEB_ENVIRONMENT_CLASSES) {
        if (!ClassUtils.isPresent(className, null)) {
            return WebApplicationType.NONE;
        }
    }//当前程序类型就是SERVLET WEB 项目，启动时会嵌入servlet web服务器
    return WebApplicationType.SERVLET;
}

三、设置应用上线文初始化器

ApplicationContextInitializer 的作用是什么？源码如下。

public interface ApplicationContextInitializer<C extends ConfigurableApplicationContext> {
    void initialize(C applicationContext);
}

用来初始化指定的 Spring 应用上下文，如注册属性资源、激活 Profiles 等。

来看下 setInitializers 方法源码，其实就是初始化一个 ApplicationContextInitializer 应用上下文初始化器实例的集合。

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

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

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 = Thread.currentThread().getContextClassLoader();
    // 读取META-INF/spring.factories文件中的类放到set集合中，使用名称并确保唯一以防止重复，下面
    Set<String> names = new LinkedHashSet<>(SpringFactoriesLoader.loadFactoryNames(type, classLoader));
    //使用反射创建他们，放到集合中
    List<T> instances = createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);
    //排序
    AnnotationAwareOrderComparator.sort(instances);
    return instances;
}

根据类路径下的 META-INF/spring.factories 文件解析并获取 ApplicationContextInitializer 接口的所有配置的类路径名称。

spring-boot-autoconfigure-2.0.3.RELEASE.jar!/META-INF/spring.factories 的初始化器相关配置内容如下：

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

四. 设置监听器

ApplicationListener 的作用是什么？源码如下。

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

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

}

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

//setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));

public void setListeners(Collection<? extends ApplicationListener<?>> listeners) {
		this.listeners = new ArrayList<>(listeners);
}
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();
		Set<String> names = new LinkedHashSet<>(SpringFactoriesLoader.loadFactoryNames(type, classLoader));
		List<T> instances = createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);
		AnnotationAwareOrderComparator.sort(instances);
		return instances;
	}

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

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

五.推断主入口应用类

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 的栈帧，从来得到入口类的名字再返回该类。



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

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

private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
    MultiValueMap<String, String> result = cache.get(classLoader);
    if (result != null) {
        return result;
    }
    try {
        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()) {
                //根据键获取值，并去2边空格
                String factoryTypeName = ((String) entry.getKey()).trim();
                //逗号分割字符串，并放到集合中
                List<String> factoryClassNames = Arrays.asList(StringUtils.commaDelimitedListToStringArray((String) entry.getValue()));
                //放到Map<K, List<V>>中
                result.add(factoryTypeName, factoryImplementationName.trim());
            }
        }
        cache.put(classLoader, result);
        return result;
    }
    catch (IOException ex) {
        throw new IllegalArgumentException("");
    }
}


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);
            T instance = (T) BeanUtils.instantiateClass(constructor, args);
            instances.add(instance);
        }
        catch (Throwable ex) {
            throw new IllegalArgumentException("");
        }
    }
    return instances;
}

这是一条海鱼

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
SpringBoot启动过程分析之SpringApplication的初始化

前言SpringApplication是一个类，提供一些便利的功能，引导Spring的程序进行启动Spring Boot 的入口类@SpringBootApplicationpublic class App { public static void main(String[] args) { SpringApplication.run(App.class, args...
复制链接

扫一扫