从Springboot源码分析启动过程

这篇博客主要是通过Springboot的源码，分析Springboot项目的启动过程，深入理解spring的工作原理。其次，我对部分源码加上了注解，新手可以稍微看一下，同时我也希望大佬们能指出我理解有误的地方。

一、springboot启动源码解析

public ConfigurableApplicationContext run(String... args) {
    StopWatch stopWatch = new StopWatch();
    stopWatch.start();//项目计时器开始计时
    ConfigurableApplicationContext context = null;
    Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();//异常处理类集合
    configureHeadlessProperty();//设置System全局参数
    SpringApplicationRunListeners listeners = getRunListeners(args);//SpringApplicationRunListener.class创建监视器实例
    listeners.starting();//发起starting事件(event)
    try {
        ApplicationArguments applicationArguments = new DefaultApplicationArguments(
                args);//将启动参数转换成spring能解析的格式，例如:--foo=bar --foo="tom"
        ConfigurableEnvironment environment = prepareEnvironment(listeners,
                applicationArguments);
        configureIgnoreBeanInfo(environment);
        Banner printedBanner = printBanner(environment);
        context = createApplicationContext();//根据webApplicationType的类型创建Context对象实例
        exceptionReporters = getSpringFactoriesInstances(
                SpringBootExceptionReporter.class,
                new Class[] { ConfigurableApplicationContext.class }, context);
        prepareContext(context, environment, listeners, applicationArguments,
                printedBanner);//准备项目运行的环境，加载xml文件中配置的bean
        refreshContext(context);//更新Context 执行用户定义的postProcessBeanFactory操作，注册listener相关的bean，初始化所以剩下的单例类
        afterRefresh(context, applicationArguments);//用户自定义的操作
        stopWatch.stop();//项目计时器结束计时
        if (this.logStartupInfo) {
            new StartupInfoLogger(this.mainApplicationClass)
                    .logStarted(getApplicationLog(), stopWatch);//打印日志信息
        }
        listeners.started(context);//发起ApplicationStartedEvent事件
        callRunners(context, applicationArguments);//启动SpringApplication
    }
    catch (Throwable ex) {
        handleRunFailure(context, ex, exceptionReporters, listeners);
        throw new IllegalStateException(ex);
    }

    try {
        listeners.running(context);//发起ApplicationReadyEvent事件
    }
    catch (Throwable ex) {
        handleRunFailure(context, ex, exceptionReporters, null);
        throw new IllegalStateException(ex);
    }
    return context;
}

二、SpringApplication 类部分源码解析

/**
 * 准备项目运行时的环境变量
 * @param listeners 各种监听器
 * @param applicationArguments 参数对象
 * @return
 */
private ConfigurableEnvironment prepareEnvironment(
        SpringApplicationRunListeners listeners,
        ApplicationArguments applicationArguments) {
    // Create and configure the environment
    ConfigurableEnvironment environment = getOrCreateEnvironment();//初始化environment的Properties和configuration
    configureEnvironment(environment, applicationArguments.getSourceArgs());//添加或替换commandLineArgs在environment中的属性值 确保profile被正确配置
    listeners.environmentPrepared(environment);//发起ApplicationEnvironmentPreparedEvent事件
    bindToSpringApplication(environment);
    if (!this.isCustomEnvironment) {
        environment = new EnvironmentConverter(getClassLoader())
                .convertEnvironmentIfNecessary(environment, deduceEnvironmentClass());
    }
    ConfigurationPropertySources.attach(environment);
    return environment;
}

/**
 * 根据项目类型选择具体的环境参数类
 * @return
 */
private Class<? extends StandardEnvironment> deduceEnvironmentClass() {
    switch (this.webApplicationType) {
    case SERVLET:
        return StandardServletEnvironment.class;
    case REACTIVE:
        return StandardReactiveWebEnvironment.class;
    default:
        return StandardEnvironment.class;
    }
}

/**
 * 初始化项目上下文环境,具体的初始化内容看参数命名就清楚了
 * @param context
 * @param environment
 * @param listeners
 * @param applicationArguments
 * @param printedBanner
 */
private void prepareContext(ConfigurableApplicationContext context,
        ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,
        ApplicationArguments applicationArguments, Banner printedBanner) {
    context.setEnvironment(environment);
    postProcessApplicationContext(context);
    applyInitializers(context);
    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);
    }
    // Load the sources
    Set<Object> sources = getAllSources();
    Assert.notEmpty(sources, "Sources must not be empty");
    load(context, sources.toArray(new Object[0]));
    listeners.contextLoaded(context);
}

/**
 * 从spring的资源目录下加载factory对象的路径名,资源文件是META-INF/spring.factories
 * @param type
 * @param parameterTypes
 * @param args
 * @param <T>
 * @return
 */
private <T> Collection<T> getSpringFactoriesInstances(Class<T> type,
        Class<?>[] parameterTypes, Object... args) {
    ClassLoader classLoader = getClassLoader();
    // Use names and ensure unique to protect against duplicates
    Set<String> names = new LinkedHashSet<>(
            SpringFactoriesLoader.loadFactoryNames(type, classLoader));//从spring的资源目录下加载factory对象的路径名,资源文件是META-INF/spring.factories
    List<T> instances = createSpringFactoriesInstances(type, parameterTypes,
            classLoader, args, names);
    AnnotationAwareOrderComparator.sort(instances);
    return instances;
}

/**
 * 创建spring各种工厂对象实例 使用classLoader动态加载
 * @param type
 * @param parameterTypes
 * @param classLoader
 * @param args
 * @param names
 * @param <T>
 * @return
 */
@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);//使用Constructor反射类调用有参构造函数创建实例
            T instance = (T) BeanUtils.instantiateClass(constructor, args);
            instances.add(instance);
        }
        catch (Throwable ex) {
            throw new IllegalArgumentException(
                    "Cannot instantiate " + type + " : " + name, ex);
        }
    }
    return instances;
}

private ConfigurableEnvironment getOrCreateEnvironment() { //配置项目的环境属性，Note:在java自带的servlet context初始化之前
    if (this.environment != null) {
        return this.environment;
    }
    switch (this.webApplicationType) {
    case SERVLET:
        return new StandardServletEnvironment();
    case REACTIVE:
        return new StandardReactiveWebEnvironment();
    default:
        return new StandardEnvironment();
    }
}

protected void configureEnvironment(ConfigurableEnvironment environment,
        String[] args) {
    if (this.addConversionService) {
        ConversionService conversionService = ApplicationConversionService
                .getSharedInstance();
        environment.setConversionService(
                (ConfigurableConversionService) conversionService);
    }
    configurePropertySources(environment, args);//添加或替换commandLineArgs在environment中的属性值
    configureProfiles(environment, args);//确保profile被正确配置
}

protected void load(ApplicationContext context, Object[] sources) {
    if (logger.isDebugEnabled()) {
        logger.debug(
                "Loading source " + StringUtils.arrayToCommaDelimitedString(sources));
    }
    BeanDefinitionLoader loader = createBeanDefinitionLoader(
            getBeanDefinitionRegistry(context), sources);//创建一个bean加载器，每个被加载的bean会被自动注册到cache中
    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();
}

以后我会根据启动过程和你们一起慢慢的解析spring的各种相关的源码，有机会的话实现一个@EnableXXXX注解,已经实现但是有bug。