SpringBoot启动流程源码分析 - DiligentCoder

/**
* @param primarySource springboot启动类
* @param args 启动参数
*/
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);
    }

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

public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
        // 实例化sources属性    
        this.sources = new LinkedHashSet(); 
        // 打印模式为控制台打印
        this.bannerMode = Mode.CONSOLE;
        // 设置记录启动日志信息标识为true
        this.logStartupInfo = true; 
        // 设置添加命令行属性标识为true
        this.addCommandLineProperties = true;
        //设置addConversionService属性为true
        this.addConversionService = true;
        // 设置headless属性为true
        this.headless = true; 
        // 设置注册应用关停钩子属性为true
        this.registerShutdownHook = true; 
        // 实例化additionalProfiles属性
        this.additionalProfiles = new HashSet();
        //默认非自定义环境 
        this.isCustomEnvironment = false;
        // 上一步传过来的resourceLoader为null
        this.resourceLoader = resourceLoader; 
        // 断言primarySources参数不能为空，也就是springboot应用类不能为空
        Assert.notNull(primarySources, "PrimarySources must not be null");
        // 将传递过来的springboot启动类参数转成List后加入LinkedHashSet集合后赋值给primarySources属性
        this.primarySources = new LinkedHashSet(Arrays.asList(primarySources));
        // 根据类路径推断web应用类型
        this.webApplicationType = WebApplicationType.deduceFromClasspath(); 
 this.setInitializers(this.getSpringFactoriesInstances(ApplicationContextInitializer.class));  // 设置初始化器属性   
        // 设置监听器属性
        this.setListeners(this.getSpringFactoriesInstances(ApplicationListener.class));
        // 推断主启动类
        this.mainApplicationClass = this.deduceMainApplicationClass();
    }

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

static WebApplicationType deduceFromClasspath() {
        if (ClassUtils.isPresent("org.springframework.web.reactive.DispatcherHandler", (ClassLoader)null) && !ClassUtils.isPresent("org.springframework.web.servlet.DispatcherServlet", (ClassLoader)null) && !ClassUtils.isPresent("org.glassfish.jersey.servlet.ServletContainer", (ClassLoader)null)) {
            return REACTIVE;
        } else {
            String[] var0 = SERVLET_INDICATOR_CLASSES;
            int var1 = var0.length;

            for(int var2 = 0; var2 < var1; ++var2) {
                String className = var0[var2];
                if (!ClassUtils.isPresent(className, (ClassLoader)null)) {
                    return NONE;
                }
            }

            return SERVLET;
        }
    }

/**
*根据传入的type参数获取类路径META-INF/spring.factories文件中的自动配置初始化类集合
@param type 类型
@return Collection<T> 泛型集合
*/
private <T> Collection<T> getSpringFactoriesInstances(Class<T> type) {
        return this.getSpringFactoriesInstances(type, new Class[0]);
    }
/**
*上一个方法的多参数重载方法
* @param type 类型
* @param parameterTypes 参数类型数组
* @param args 参数数组
*/
private <T> Collection<T> getSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes, Object... args) {
        ClassLoader classLoader = this.getClassLoader();
        // 通过SpringFactoriesLoader#loadFactoryNames方法获取
        Set<String> names = new LinkedHashSet(SpringFactoriesLoader.loadFactoryNames(type, classLoader));
        List<T> instances = this.createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);
        AnnotationAwareOrderComparator.sort(instances);
        return instances;
    }

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

private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
        // 如果缓存里有则直接从双层缓存中获取类加载器对应的结果
        MultiValueMap<String, String> result = (MultiValueMap)cache.get(classLoader);
        if (result != null) {
            return result;
        } else {
            // 缓存中没有则去META-INF/spring.factories文件中加载并读取解析
            try {
                Enumeration<URL> urls = classLoader != null ? classLoader.getResources("META-INF/spring.factories") : ClassLoader.getSystemResources("META-INF/spring.factories");
                LinkedMultiValueMap result = new LinkedMultiValueMap();

                while(urls.hasMoreElements()) {
                    URL url = (URL)urls.nextElement();
                    UrlResource resource = new UrlResource(url);
                    Properties properties = PropertiesLoaderUtils.loadProperties(resource);
                    Iterator var6 = properties.entrySet().iterator();

                    while(var6.hasNext()) {
                        Entry<?, ?> entry = (Entry)var6.next();
                        String factoryClassName = ((String)entry.getKey()).trim();
                        String[] var9 = StringUtils.commaDelimitedListToStringArray((String)entry.getValue());
                        int var10 = var9.length;

                        for(int var11 = 0; var11 < var10; ++var11) {
                            String factoryName = var9[var11];
                            result.add(factoryClassName, factoryName.trim());
                        }
                    }
                }

                cache.put(classLoader, result);
                return result;
            } catch (IOException var13) {
                throw new IllegalArgumentException("Unable to load factories from location [META-INF/spring.factories]", var13);
            }
        }
    }

/**
* 创建spring.factories文件中的初始化类实例集合
*/
private <T> List<T> createSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes, ClassLoader classLoader, Object[] args, Set<String> names) {
        List<T> instances = new ArrayList(names.size());
        Iterator var7 = names.iterator();
        while(var7.hasNext()) {
            String name = (String)var7.next();
            try {
                // 调用反射工具类加载spring.factories文件中的初始化类
                Class<?> instanceClass = ClassUtils.forName(name, classLoader);
                Assert.isAssignable(type, instanceClass);
                Constructor<?> constructor = instanceClass.getDeclaredConstructor(parameterTypes);
                // 通过构造函数实例化类
                T instance = BeanUtils.instantiateClass(constructor, args);
                instances.add(instance);
            } catch (Throwable var12) {
                throw new IllegalArgumentException("Cannot instantiate " + type + " : " + name, var12);
            }
        }

        return instances;
    }

 private Class<?> deduceMainApplicationClass() {
        try {
            StackTraceElement[] stackTrace = (new RuntimeException()).getStackTrace();
            StackTraceElement[] var2 = stackTrace;
            int var3 = stackTrace.length;
            for(int var4 = 0; var4 < var3; ++var4) {
                StackTraceElement stackTraceElement = var2[var4];
                if ("main".equals(stackTraceElement.getMethodName())) {
                    return Class.forName(stackTraceElement.getClassName());
                }
            }
        } catch (ClassNotFoundException var6) {
        }

        return null;
    }

public ConfigurableApplicationContext run(String... args) {
        // new了一个 StopWatch并启动了它
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        // springboot启动时使用ConfigurableApplicationContext作为BeanFactory接口的实现类
        ConfigurableApplicationContext context = null;
        // 实例化一个异常报告集合
        Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList();
        // 设置系统属性java.awt.headless,默认为false
        this.configureHeadlessProperty();
        // 获取所有的启动监听器
        SpringApplicationRunListeners listeners = this.getRunListeners(args);
        // 遍历启动类监听器列表，并逐个启动
        listeners.starting();
        Collection exceptionReporters;
        try {
            // 实例化启动类命令参数
            ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
            // 准备启动环境
            ConfigurableEnvironment environment = this.prepareEnvironment(listeners, applicationArguments);
            // 配置环境中可忽略的bean信息
            this.configureIgnoreBeanInfo(environment);
            // 打印springboot项目的logo图标
            Banner printedBanner = this.printBanner(environment);
            // 创建应用上下文，也就是Spring IOC容器
            context = this.createApplicationContext();
            // 收集异常报告集合
            exceptionReporters = this.getSpringFactoriesInstances(SpringBootExceptionReporter.class, new Class[]{ConfigurableApplicationContext.class}, context);
            // 准备应用上下文环境，会去加载配置类基于注解的bean、xml配置文件中定义的bean
            this.prepareContext(context, environment, listeners, applicationArguments, printedBanner);
            // 刷新上下文，对于servlet应用程序这个方法会去创建和启动web服务器
            this.refreshContext(context);
            // 这个方法啥也没干
            this.afterRefresh(context, applicationArguments);
            // 启动完成，记时停止
            stopWatch.stop();
            if (this.logStartupInfo) {
                // 如果开启了记录启动日志，则记录应用程序启动过程耗时
                (new StartupInfoLogger(this.mainApplicationClass)).logStarted(this.getApplicationLog(), stopWatch);
            }
            // 应用运行时监听器发布应用启动事件
            listeners.started(context);
            // 调用启动类中的任务
            this.callRunners(context, applicationArguments);
        } catch (Throwable var10) {
            // 启动过程发生异常则处理异常，并跑出IllegalStateException类型异常
            this.handleRunFailure(context, var10, exceptionReporters, listeners);
            throw new IllegalStateException(var10);
        }

public void starting() {
        Iterator var1 = this.listeners.iterator();

        while(var1.hasNext()) {
            SpringApplicationRunListener listener = (SpringApplicationRunListener)var1.next();
            listener.starting();
        }

    }

private final SimpleApplicationEventMulticaster initialMulticaster;
public void starting() {
        this.initialMulticaster.multicastEvent(new ApplicationStartingEvent(this.application, this.args));
    }

private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments) {
        // 获取或者创建一个配置环境
        ConfigurableEnvironment environment = this.getOrCreateEnvironment();
        // 配置环境
        this.configureEnvironment((ConfigurableEnvironment)environment, applicationArguments.getSourceArgs());
        // 通过启动类应用监听器发布环境准备事件
        listeners.environmentPrepared((ConfigurableEnvironment)environment);
        // 将配置环境绑定到SpringApplication
        this.bindToSpringApplication((ConfigurableEnvironment)environment);
        if (!this.isCustomEnvironment) {
            // 如果是非自定义环境则根据需要转换成推断出的Web环境
            environment = (new EnvironmentConverter(this.getClassLoader())).convertEnvironmentIfNecessary((ConfigurableEnvironment)environment, this.deduceEnvironmentClass());
        }
        // 通过环境变量添加属性配置源
        ConfigurationPropertySources.attach((Environment)environment);
        // 返回经过处理的配置环境
        return (ConfigurableEnvironment)environment;
    }

private ConfigurableEnvironment environment;

private ConfigurableEnvironment getOrCreateEnvironment() {
        if (this.environment != null) {
            // this.environment不为空则直接返回
            return this.environment;
        } else {
            switch(this.webApplicationType) {
            // 根据web应用类型创建环境
            case SERVLET:
                // servlet web应用返回标准StandardServletEnvironment实例
                return new StandardServletEnvironment();
            case REACTIVE:
                // reactive web应用环境返回StandardReactiveWebEnvironment实例
                return new StandardReactiveWebEnvironment();
            default:
                // 默认返回非web应用的StandardEnvironment实例
                return new StandardEnvironment();
            }
        }
    }

public void environmentPrepared(ConfigurableEnvironment environment) {
        Iterator var2 = this.listeners.iterator();

        while(var2.hasNext()) {
            SpringApplicationRunListener listener = (SpringApplicationRunListener)var2.next();
            // 通过迭代遍历启动监听器发布环境准备事件
            listener.environmentPrepared(environment);
        }

    }

protected void bindToSpringApplication(ConfigurableEnvironment environment) {
        try {
            Binder.get(environment).bind("spring.main", Bindable.ofInstance(this));
        } catch (Exception var3) {
            throw new IllegalStateException("Cannot bind to SpringApplication", var3);
        }
    }

public static Binder get(Environment environment) {
        // 这里传入了一个属性源占位符解析器类实例参数
        return new Binder(ConfigurationPropertySources.get(environment), new PropertySourcesPlaceholdersResolver(environment));
    }

public Binder(Iterable<ConfigurationPropertySource> sources, PlaceholdersResolver placeholdersResolver) {
        this(sources, placeholdersResolver, (ConversionService)null, (Consumer)null);
    }

public Binder(Iterable<ConfigurationPropertySource> sources, PlaceholdersResolver placeholdersResolver, ConversionService conversionService, Consumer<PropertyEditorRegistry> propertyEditorInitializer) {
        Assert.notNull(sources, "Sources must not be null");
        this.sources = sources;
        this.placeholdersResolver = placeholdersResolver != null ? placeholdersResolver : PlaceholdersResolver.NONE;
        this.conversionService = conversionService != null ? conversionService : ApplicationConversionService.getSharedInstance();
        this.propertyEditorInitializer = propertyEditorInitializer;
    }

public PropertySourcesPlaceholdersResolver(Environment environment) {
        this(getSources(environment), (PropertyPlaceholderHelper)null);
    }

public PropertySourcesPlaceholdersResolver(Iterable<PropertySource<?>> sources, PropertyPlaceholderHelper helper) {
        this.sources = sources;
        // 属性占位符解析器会去解析"${" 和 "}"两个符号包裹的环境变量
        this.helper = helper != null ? helper : new PropertyPlaceholderHelper("${", "}", ":", true);
    }

private static PropertySources getSources(Environment environment) {
        // 断言environment不为空 
        Assert.notNull(environment, "Environment must not be null");
        // 断言environment是一个ConfigurableEnvironment类实例
        Assert.isInstanceOf(ConfigurableEnvironment.class, environment, "Environment must be a ConfigurableEnvironment");
        return ((ConfigurableEnvironment)environment).getPropertySources();
    }

public static void attach(Environment environment) {
        Assert.isInstanceOf(ConfigurableEnvironment.class, environment);
        // 从环境变量中获取多属性配置源
        MutablePropertySources sources = ((ConfigurableEnvironment)environment).getPropertySources();
        PropertySource<?> attached = sources.get("configurationProperties");
        if (attached != null && attached.getSource() != sources) {
            // 若attached且attach#getSource得到的结果不等于sources，则删除sources中configurationProperties对应的键值对并置空attached
            sources.remove("configurationProperties");
            attached = null;
        }
        if (attached == null) {
            // 若attached为空则构建新的属性源并添加到sources的属性源列表的第一个位置
            sources.addFirst(new ConfigurationPropertySourcesPropertySource("configurationProperties", new SpringConfigurationPropertySources(sources)));
        }

    }

public <T> BindResult<T> bind(String name, Bindable<T> target) {
        return this.bind((ConfigurationPropertyName)ConfigurationPropertyName.of(name), target, (BindHandler)null);
    }

public <T> BindResult<T> bind(ConfigurationPropertyName name, Bindable<T> target, BindHandler handler) {
        Assert.notNull(name, "Name must not be null");
        Assert.notNull(target, "Target must not be null");
        handler = handler != null ? handler : BindHandler.DEFAULT;
        Binder.Context context = new Binder.Context();
        T bound = this.bind(name, target, handler, context, false);
        return BindResult.of(bound);
    }

protected final <T> T bind(ConfigurationPropertyName name, Bindable<T> target, BindHandler handler, Binder.Context context, boolean allowRecursiveBinding) {
        context.clearConfigurationProperty();

        try {
            target = handler.onStart(name, target, context);
            if (target == null) {
                return null;
            } else {
                Object bound = this.bindObject(name, target, handler, context, allowRecursiveBinding);
                return this.handleBindResult(name, target, handler, context, bound);
            }
        } catch (Exception var7) {
            return this.handleBindError(name, target, handler, context, var7);
        }
    }
// 绑定对象
private <T> Object bindObject(ConfigurationPropertyName name, Bindable<T> target, BindHandler handler, Binder.Context context, boolean allowRecursiveBinding) {
        ConfigurationProperty property = this.findProperty(name, context);
        if (property == null && this.containsNoDescendantOf(context.getSources(), name)) {
            return null;
        } else {
            AggregateBinder<?> aggregateBinder = this.getAggregateBinder(target, context);
            if (aggregateBinder != null) {
                return this.bindAggregate(name, target, handler, context, aggregateBinder);
            } else if (property != null) {
                try {
                    return this.bindProperty(target, context, property);
                } catch (ConverterNotFoundException var10) {
                    Object bean = this.bindBean(name, target, handler, context, allowRecursiveBinding);
                    if (bean != null) {
                        return bean;
                    } else {
                        throw var10;
                    }
                }
            } else {
                return this.bindBean(name, target, handler, context, allowRecursiveBinding);
            }
        }
    }

private <T> Object bindProperty(Bindable<T> target, Binder.Context context, ConfigurationProperty property) {
        context.setConfigurationProperty(property);
        Object result = property.getValue();
        // 使用占位符解析器解析属性占位符
        result = this.placeholdersResolver.resolvePlaceholders(result);
        // 从context中获取转换器转换result
        result = context.getConverter().convert(result, target);
        return result;
    }

protected ConfigurableApplicationContext createApplicationContext() {
        Class<?> contextClass = this.applicationContextClass;
        if (contextClass == null) {
            // 若启动类的应用上下文为空，则根据实例化SpringApplication启动类过程中推断出来的web应用类型加载对应的应用上下文类ApplicationContext
            try {
                switch(this.webApplicationType) {
                case SERVLET:
                    contextClass = Class.forName("org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext");
                    break;
                case REACTIVE:
                    contextClass = Class.forName("org.springframework.boot.web.reactive.context.AnnotationConfigReactiveWebServerApplicationContext");
                    break;
                default:
                    contextClass = Class.forName("org.springframework.context.annotation.AnnotationConfigApplicationContext");
                }
            } catch (ClassNotFoundException var3) {
                throw new IllegalStateException("Unable create a default ApplicationContext, please specify an ApplicationContextClass", var3);
            }
        }

        return (ConfigurableApplicationContext)BeanUtils.instantiateClass(contextClass);
    }

private void prepareContext(ConfigurableApplicationContext context, ConfigurableEnvironment environment, SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments, Banner printedBanner) {
        // 应用上下文设置配置环境属性
        context.setEnvironment(environment);
        // 应用上下文后置处理
        this.postProcessApplicationContext(context);
        // 申请初始化器
        this.applyInitializers(context);
        // 启动运行时监听器发布应用上下文预备事件
        listeners.contextPrepared(context);
        if (this.logStartupInfo) {
            // 记录日志
            this.logStartupInfo(context.getParent() == null);
            this.logStartupProfileInfo(context);
        }
        // 获取ConfigurableListableBeanFactory类型beanFactory，注意该类是个接口类
        ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
        // 注册启动参数类型单例bean
        beanFactory.registerSingleton("springApplicationArguments", applicationArguments);
        if (printedBanner != null) {
            // 注册PrintedBanner类型单例bean
            beanFactory.registerSingleton("springBootBanner", printedBanner);
        }
        // 判断应用上下文中的beanFactory是否是一个DefaultListableBeanFactory类型的实例
        if (beanFactory instanceof DefaultListableBeanFactory) {
            ((DefaultListableBeanFactory)beanFactory).setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);// 设置是否允许覆写bean定义标识
        }

        if (this.lazyInitialization) {
            // 若是延迟初始化，则添加延迟初始化类型beanFactory后置处理器
            context.addBeanFactoryPostProcessor(new LazyInitializationBeanFactoryPostProcessor());
        }
        // 获取启动来源类集合，也就是我们项目中加上@SpringBootApplication注解的启动类集合
        Set<Object> sources = this.getAllSources();
        // 断言启动来源类不为空
        Assert.notEmpty(sources, "Sources must not be empty");
        // 加载应用上下文，这个方法会通过beanDefinationReader读取通过注解和xml配置的bean
        this.load(context, sources.toArray(new Object[0]));
        // 启动监听器发布上下文完成加载事件
        listeners.contextLoaded(context);
    }

protected void postProcessApplicationContext(ConfigurableApplicationContext context) {
        if (this.beanNameGenerator != null) {            context.getBeanFactory().registerSingleton("org.springframework.context.annotation.internalConfigurationBeanNameGenerator", this.beanNameGenerator); // 应用上下文中的beanFactory注册单例BeanNameGenerator bean
        }
        if (this.resourceLoader != null) {
            if (context instanceof GenericApplicationContext) {
                ((GenericApplicationContext)context).setResourceLoader(this.resourceLoader);// 设置资源加载器
            }

            if (context instanceof DefaultResourceLoader) {
                ((DefaultResourceLoader)context).setClassLoader(this.resourceLoader.getClassLoader());// 设置类加载器
            }
        }

        if (this.addConversionService) {
           context.getBeanFactory().setConversionService(ApplicationConversionService.getSharedInstance());// 设置conversionService属性
        }

    }

protected void applyInitializers(ConfigurableApplicationContext context) {
        // 获取初始化器迭代器
        Iterator var2 = this.getInitializers().iterator();
        // 循环遍历初始化器迭代器
        while(var2.hasNext()) {
            ApplicationContextInitializer initializer = (ApplicationContextInitializer)var2.next();
            // 根据解析器calss类型和应用上下文初始化器calss类型解析参数类型
            Class<?> requiredType = GenericTypeResolver.resolveTypeArgument(initializer.getClass(), ApplicationContextInitializer.class);
            Assert.isInstanceOf(requiredType, context, "Unable to call initializer.");
            initializer.initialize(context);
        }
    }

@Nullable
public static Class<?> resolveTypeArgument(Class<?> clazz, Class<?> genericIfc) {
        ResolvableType resolvableType = ResolvableType.forClass(clazz).as(genericIfc);
        return !resolvableType.hasGenerics() ? null : getSingleGeneric(resolvableType);
}
// 加载解析类
public static ResolvableType forClass(@Nullable Class<?> clazz) {
        return new ResolvableType(clazz);
}
// 判断是否有解析类型数组
public boolean hasGenerics() {
        return this.getGenerics().length > 0;
}
// 获取单个解析类型
@Nullable
private static Class<?> getSingleGeneric(ResolvableType resolvableType) {
        Assert.isTrue(resolvableType.getGenerics().length == 1, () -> {
            return "Expected 1 type argument on generic interface [" + resolvableType + "] but found " + resolvableType.getGenerics().length;
        });
        return resolvableType.getGeneric(new int[0]).resolve();
}

protected void load(ApplicationContext context, Object[] sources) {
        if (logger.isDebugEnabled()) {
            // 如果开启了debug级别日志，则记录debug日志
            logger.debug("Loading source " + StringUtils.arrayToCommaDelimitedString(sources));
        }
        // 创建BeanDefinitionLoader类实例
        BeanDefinitionLoader loader = this.createBeanDefinitionLoader(this.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();
    }
// 通过BeanDefinitionRegistry类实例参数和应用源数组构造BeanDefinitionLoader类实例
protected BeanDefinitionLoader createBeanDefinitionLoader(BeanDefinitionRegistry registry, Object[] sources) {
        return new BeanDefinitionLoader(registry, sources);
 }

BeanDefinitionLoader(BeanDefinitionRegistry registry, Object... sources) {
        // 断言registry和sources两个参数不能为空
        Assert.notNull(registry, "Registry must not be null");
        Assert.notEmpty(sources, "Sources must not be empty");
        this.sources = sources;
        // 初始化基于注解的BeanDefinitionReader
        this.annotatedReader = new AnnotatedBeanDefinitionReader(registry);
        // 初始化基于xml的BeanDefinitionReader
        this.xmlReader = new XmlBeanDefinitionReader(registry);
        if (this.isGroovyPresent()) {
            // 如果存在groovy脚本则初始化基于Groovy的BeanDefinitionReader
            this.groovyReader = new GroovyBeanDefinitionReader(registry);
        }
        // 初始化类路径bean定义扫描器
        this.scanner = new ClassPathBeanDefinitionScanner(registry);
        // 扫描器添加排除过滤器，排除扫描启动类
        this.scanner.addExcludeFilter(new BeanDefinitionLoader.ClassExcludeFilter(sources));
    }

int load() {
        int count = 0;
        Object[] var2 = this.sources;
        int var3 = var2.length;
        for(int var4 = 0; var4 < var3; ++var4) {
            Object source = var2[var4];
            // 每加载一个bean来源，记录加载数量的count会+1
            count += this.load(source);
        }
        return count;
    }

// 这个加载bean的方法会根据不同的bean来源进行加载，bean是如何加载的关键就在下面这几个load方法里面
private int load(Object source) {
        Assert.notNull(source, "Source must not be null");
        if (source instanceof Class) {
            // 加载配置类中的bean
            return this.load((Class)source);
        } else if (source instanceof Resource) {
            // 加载类路径资源中的bean,包括groovy和xml文件中配置的bean
            return this.load((Resource)source);
        } else if (source instanceof Package) {
            // 加载包下面的不同配置类中的bean
            return this.load((Package)source);
        } else if (source instanceof CharSequence) {
            // 加载根据制定路径的xml文件中配置的bean
            return this.load((CharSequence)source);
        } else {
            throw new IllegalArgumentException("Invalid source type " + source.getClass());
        }
    }

private int load(Class<?> source) {
        if (this.isGroovyPresent() && BeanDefinitionLoader.GroovyBeanDefinitionSource.class.isAssignableFrom(source)) {
            BeanDefinitionLoader.GroovyBeanDefinitionSource loader = (BeanDefinitionLoader.GroovyBeanDefinitionSource)BeanUtils.instantiateClass(source, BeanDefinitionLoader.GroovyBeanDefinitionSource.class);
            this.load(loader);
        }

        if (this.isComponent(source)) {
            this.annotatedReader.register(new Class[]{source});
            return 1;
        } else {
            return 0;
        }
    }

private int load(Resource source) {
        if (source.getFilename().endsWith(".groovy")) {
            if (this.groovyReader == null) {
                throw new BeanDefinitionStoreException("Cannot load Groovy beans without Groovy on classpath");
            } else {
                return this.groovyReader.loadBeanDefinitions(source);
            }
        } else {
            return this.xmlReader.loadBeanDefinitions(source);
        }
    }

private int load(Package source) {
        return this.scanner.scan(new String[]{source.getName()});
    }

private int load(CharSequence source) {
        String resolvedSource = this.xmlReader.getEnvironment().resolvePlaceholders(source.toString());

        try {
            return this.load(ClassUtils.forName(resolvedSource, (ClassLoader)null));
        } catch (ClassNotFoundException | IllegalArgumentException var10) {
            Resource[] resources = this.findResources(resolvedSource);
            int loadCount = 0;
            boolean atLeastOneResourceExists = false;
            Resource[] var6 = resources;
            int var7 = resources.length;

            for(int var8 = 0; var8 < var7; ++var8) {
                Resource resource = var6[var8];
                if (this.isLoadCandidate(resource)) {
                    atLeastOneResourceExists = true;
                    loadCount += this.load(resource);
                }
            }

            if (atLeastOneResourceExists) {
                return loadCount;
            } else {
                Package packageResource = this.findPackage(resolvedSource);
                if (packageResource != null) {
                    return this.load(packageResource);
                } else {
                    throw new IllegalArgumentException("Invalid source '" + resolvedSource + "'");
                }
            }
        }
    }

 private void refreshContext(ConfigurableApplicationContext context) {
        // 刷新应用上下文
        this.refresh(context);
        if (this.registerShutdownHook) {
            try {
                // 如果需要注册关闭钩子，则应用上下文注册关闭钩子
                context.registerShutdownHook();
            } catch (AccessControlException var3) {
            }
        }

    }

protected void refresh(ApplicationContext applicationContext) {
        Assert.isInstanceOf(AbstractApplicationContext.class, applicationContext);
        ((AbstractApplicationContext)applicationContext).refresh();
    }

public void refresh() throws BeansException, IllegalStateException {
        // 刷新应用上下文过程使用了监视器锁
        synchronized(this.startupShutdownMonitor) {
            // 预刷新
            this.prepareRefresh();
            // 获取刷新beanFactory
            ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
            // 预备beanFactory
            this.prepareBeanFactory(beanFactory);
            try {
                // 后置处理beanFactory
                this.postProcessBeanFactory(beanFactory);
                // 执行beanFactory后置处理器
                this.invokeBeanFactoryPostProcessors(beanFactory);
                // 注册bean后置处理器
                this.registerBeanPostProcessors(beanFactory);
                // 初始化消息源
                this.initMessageSource();
                // 初始化应用事件广播
                this.initApplicationEventMulticaster();
                // 调用onRefres方法，如果是Servlet应用程序，这个方法会去创建web服务器
                this.onRefresh();
                // 注册监听器
                this.registerListeners();
                // 结束beanFactory初始化
                this.finishBeanFactoryInitialization(beanFactory);
                // 结束刷新，如果是Servlet应用程序，个方法会去启动web服务器
                this.finishRefresh();
            } catch (BeansException var9) {
                if (this.logger.isWarnEnabled()) {
                    this.logger.warn("Exception encountered during context initialization - cancelling refresh attempt: " + var9);
                }
                // 发生异常时会销毁bean并取消刷新
                this.destroyBeans();
                this.cancelRefresh(var9);
                throw var9;
            } finally {
                // finally语句块中重新设置公共缓存
                this.resetCommonCaches();
            }

        }
    }
　　

protected void onRefresh() {
        super.onRefresh();
        try {
            this.createWebServer();
        } catch (Throwable var2) {
            throw new ApplicationContextException("Unable to start web server", var2);
        }
    }

private void createWebServer() {
        WebServer webServer = this.webServer;
        ServletContext servletContext = this.getServletContext();
        if (webServer == null && servletContext == null) {
            ServletWebServerFactory factory = this.getWebServerFactory();
            this.webServer = factory.getWebServer(new ServletContextInitializer[]{this.getSelfInitializer()});
        } else if (servletContext != null) {
            try {
                this.getSelfInitializer().onStartup(servletContext);
            } catch (ServletException var4) {
                throw new ApplicationContextException("Cannot initialize servlet context", var4);
            }
        }

        this.initPropertySources();
    }

private void callRunners(ApplicationContext context, ApplicationArguments args) {
        List<Object> runners = new ArrayList();
        // 通过应用上下文获取所有ApplicationRunner接口实现类的bean集合
        runners.addAll(context.getBeansOfType(ApplicationRunner.class).values());
        // 通过应用上下文获取所有CommandLineRunner接口实现类的bean集合
        runners.addAll(context.getBeansOfType(CommandLineRunner.class).values());
        AnnotationAwareOrderComparator.sort(runners);
        Iterator var4 = (new LinkedHashSet(runners)).iterator();
        // 遍历执行ApplicationRunner实现类和CommandLineRunner实现类中的run方法
        while(var4.hasNext()) {
            Object runner = var4.next();
            if (runner instanceof ApplicationRunner) {
                this.callRunner((ApplicationRunner)runner, args);
            }

            if (runner instanceof CommandLineRunner) {
                this.callRunner((CommandLineRunner)runner, args);
            }
        }
    
private void callRunner(ApplicationRunner runner, ApplicationArguments args) {
        try {
            runner.run(args);
        } catch (Exception var4) {
            throw new IllegalStateException("Failed to execute ApplicationRunner", var4);
        }
}
    
private void callRunner(CommandLineRunner runner, ApplicationArguments args) {
        try {
            runner.run(args.getSourceArgs());
        } catch (Exception var4) {
            throw new IllegalStateException("Failed to execute CommandLineRunner", var4);
        }
    }

 private void handleRunFailure(ConfigurableApplicationContext context, Throwable exception, Collection<SpringBootExceptionReporter> exceptionReporters, SpringApplicationRunListeners listeners) {
        try {
            try {
                // 处理程序退出编码
                this.handleExitCode(context, exception);
                if (listeners != null) {
                    // 应用启动监听器发布启动失败事件
                    listeners.failed(context, exception);
                }
            } finally {
                // 报告异常
                this.reportFailure(exceptionReporters, exception);
                if (context != null) {
                    // 关闭Spring IOC容器
                    context.close();
                }

            }
        } catch (Exception var9) {
            logger.warn("Unable to close ApplicationContext", var9);
        }
        // 调用反射工具类抛出运行时异常
        ReflectionUtils.rethrowRuntimeException(exception);
    }