SpringBoot源码解析（二）------springboot启动流程原理

已于 2022-08-05 23:50:27 修改
阅读量437 收藏
点赞数
分类专栏： Spring Boot 文章标签： spring boot servlet java
于 2022-07-25 15:02:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34344432/article/details/125965896
版权

目录

入口类

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

run方法源码解析

我们可以看到进入run方法后调用静态方法并声明一个SpringApplication的实例并传入参数HelloWorldApplication.class，然后运行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);
    }

首先我们先看一下SpringApplication构造方法都做了哪些操作

public SpringApplication(ResourceLoader resourceLoader, Class... primarySources) {
   this.sources = new LinkedHashSet();
   this.bannerMode = Mode.CONSOLE;
   this.logStartupInfo = true;
   this.addCommandLineProperties = true;
   this.addConversionService = true;
   this.headless = true;
   this.registerShutdownHook = true;
   this.additionalProfiles = new HashSet();
   this.isCustomEnvironment = false;
   this.lazyInitialization = false;
   this.resourceLoader = resourceLoader;
   Assert.notNull(primarySources, "PrimarySources must not be null");
   this.primarySources = new LinkedHashSet(Arrays.asList(primarySources));
   this.webApplicationType = WebApplicationType.deduceFromClasspath();
   this.setInitializers(this.getSpringFactoriesInstances(ApplicationContextInitializer.class));
   this.setListeners(this.getSpringFactoriesInstances(ApplicationListener.class));
   this.mainApplicationClass = this.deduceMainApplicationClass();
}

1.设置应用类型

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

这里主要是通过类加载器判断REACTIVE相关的Class是否存在，如果不存在，则web环境即为SERVLET类型。

2.设置初始化器

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

我们先来看看getSpringFactoriesInstances( ApplicationContextInitializer.class)

 private <T> Collection<T> getSpringFactoriesInstances(Class<T> type) {
     return this.getSpringFactoriesInstances(type, new Class[0]);
 }

// 这里的入参type就是ApplicationContextInitializer.class
 private <T> Collection<T> getSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes, Object... args) {
     ClassLoader classLoader = this.getClassLoader();
     // 使用Set保存names来避免重复元素
     Set<String> names = new LinkedHashSet(SpringFactoriesLoader.loadFactoryNames(type, classLoader));
      // 根据names来进行实例化
     List<T> instances = this.createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);
     //对实例进行排序
     AnnotationAwareOrderComparator.sort(instances);
     return instances;
 }

我们看下根据入参type读取所有的name

public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
        String factoryTypeName = factoryType.getName();
        return (List)loadSpringFactories(classLoader).getOrDefault(factoryTypeName, 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 {
        try {
        	//从类路径的META-INF/spring.factories中加载所有默认的自动配置类
            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();
                     //获取ApplicationContextInitializer.class的所有值
                    String factoryTypeName = ((String)entry.getKey()).trim();
                    String[] var9 = StringUtils.commaDelimitedListToStringArray((String)entry.getValue());
                    int var10 = var9.length;

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

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

这个方法会尝试从类路径的META-INF/spring.factories处读取相应配置文件，然后进行遍历，读取配置文件中Key为：org.springframework.context.ApplicationContextInitializer的value,比如以spring-boot-autoconfigure这个包为例，它的META-INF/spring.factories部分定义如下所示：
在这里插入图片描述
读取里面的两个类名，然后放到Set集合中，然后进行实例化过程。

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 {
            Class<?> instanceClass = ClassUtils.forName(name, classLoader);
            //确认被加载类是ApplicationContextInitializer的子类
            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;
}

确认被加载的类确实是org.springframework.context.ApplicationContextInitializer的子类，然后就是得到构造器进行初始化，最后放入到实例列表中。

3.设置监听器

this.setListeners(this.getSpringFactoriesInstances(ApplicationListener.class));

这里我们具体看下getSpringFactoriesInstances方法

private <T> Collection<T> getSpringFactoriesInstances(Class<T> type) {
    return this.getSpringFactoriesInstances(type, new Class[0]);
}

private <T> Collection<T> getSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes, Object... args) {
    ClassLoader classLoader = this.getClassLoader();
    Set<String> names = new LinkedHashSet(SpringFactoriesLoader.loadFactoryNames(type, classLoader));
    List<T> instances = this.createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);
    AnnotationAwareOrderComparator.sort(instances);
    return instances;
}

可以发现，这个加载相应的类名，然后完成实例化的过程和上面在设置初始化器时如出一辙，至此，对于SpringApplication实例的初始化过程就结束了。

SpringApplication.run方法

public ConfigurableApplicationContext run(String... args) {
	//计时工具
    StopWatch stopWatch = new StopWatch();
    stopWatch.start();
    ConfigurableApplicationContext context = null;
    Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList();
    this.configureHeadlessProperty();
     // 第一步：获取并启动监听器
    SpringApplicationRunListeners listeners = this.getRunListeners(args);
    listeners.starting();

    Collection exceptionReporters;
    try {
        ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
        // 第二步：根据SpringApplicationRunListeners以及参数来准备环境
        ConfigurableEnvironment environment = this.prepareEnvironment(listeners, applicationArguments);
        this.configureIgnoreBeanInfo(environment);
        //准备banner打印器
        Banner printedBanner = this.printBanner(environment);
        // 第三步：创建Spring容器
        context = this.createApplicationContext();
        exceptionReporters = this.getSpringFactoriesInstances(SpringBootExceptionReporter.class, new Class[]{ConfigurableApplicationContext.class}, context);
        // 第四步：Spring容器前置处理
        this.prepareContext(context, environment, listeners, applicationArguments, printedBanner);
         // 第五步：刷新容器
        this.refreshContext(context);
        // 第六步：Spring容器后置处理
        this.afterRefresh(context, applicationArguments);
        stopWatch.stop();
        if (this.logStartupInfo) {
            (new StartupInfoLogger(this.mainApplicationClass)).logStarted(this.getApplicationLog(), stopWatch);
        }

        listeners.started(context);
         // 第八步：执行Runners
        this.callRunners(context, applicationArguments);
    } catch (Throwable var10) {
        this.handleRunFailure(context, var10, exceptionReporters, listeners);
        throw new IllegalStateException(var10);
    }

    try {
        listeners.running(context);
        // 返回容器
        return context;
    } catch (Throwable var9) {
        this.handleRunFailure(context, var9, exceptionReporters, (SpringApplicationRunListeners)null);
        throw new IllegalStateException(var9);
    }
}
  • 第一步：获取并启动监听器
  • 第二步：根据SpringApplicationRunListeners以及参数来准备环境
  • 第三步：创建Spring容器
  • 第四步：Spring容器前置处理
  • 第五步：刷新容器
  • 第六步：Spring容器后置处理
  • 第七步：发出结束执行的事件
  • 第八步：执行Runners

下面我们详细介绍一下这几个步骤究竟做了哪些事情

1.第一步：获取并启动监听器

SpringApplicationRunListeners listeners = this.getRunListeners(args);

我们看下getRunListener(args)

private SpringApplicationRunListeners getRunListeners(String[] args) {
    Class<?>[] types = new Class[]{SpringApplication.class, String[].class};
    return new SpringApplicationRunListeners(logger, this.getSpringFactoriesInstances(SpringApplicationRunListener.class, types, this, args));
}

这里仍然利用了getSpringFactoriesInstances方法来获取实例，大家可以看看前面的这个方法分析，从META-INF/spring.factories中读取Key为org.springframework.boot.SpringApplicationRunListener的Values：
org.springframework.boot.context.event.EventPublishingRunListener。
getSpringFactoriesInstances中反射获取实例时会触发EventPublishingRunListener的构造函数，我们来看看EventPublishingRunListener的构造函数：

public class EventPublishingRunListener implements SpringApplicationRunListener, Ordered {
    private final SpringApplication application;
    private final String[] args;
    //广播器
    private final SimpleApplicationEventMulticaster initialMulticaster;

    public EventPublishingRunListener(SpringApplication application, String[] args) {
        this.application = application;
        this.args = args;
        this.initialMulticaster = new SimpleApplicationEventMulticaster();
        Iterator var3 = application.getListeners().iterator();

        while(var3.hasNext()) {
            ApplicationListener<?> listener = (ApplicationListener)var3.next();
            //将监听器全部加入到广播中
            this.initialMulticaster.addApplicationListener(listener);
        }

    }
   ......
}

我们看到EventPublishingRunListener里面有一个广播器，EventPublishingRunListener 的构造方法将SpringApplication的十一个监听器全部添加到SimpleApplicationEventMulticaster这个广播器中。

我们看下接口SpringApplicationRunListener这个接口

public interface SpringApplicationRunListener {

    // 在run()方法开始执行时，该方法就立即被调用，可用于在初始化最早期时做一些工作
    void starting();
    // 当environment构建完成，ApplicationContext创建之前，该方法被调用
    void environmentPrepared(ConfigurableEnvironment environment);
    // 当ApplicationContext构建完成时，该方法被调用
    void contextPrepared(ConfigurableApplicationContext context);
    // 在ApplicationContext完成加载，但没有被刷新前，该方法被调用
    void contextLoaded(ConfigurableApplicationContext context);
    // 在ApplicationContext刷新并启动后，CommandLineRunners和ApplicationRunner未被调用前，该方法被调用
    void started(ConfigurableApplicationContext context);
    // 在run()方法执行完成前该方法被调用
    void running(ConfigurableApplicationContext context);
    // 当应用运行出错时该方法被调用
    void failed(ConfigurableApplicationContext context, Throwable exception);
}

SpringApplicationRunListener接口在Spring Boot 启动初始化的过程中各种状态时执行，我们也可以添加自己的监听器，在SpringBoot初始化时监听事件执行自定义逻辑，我们先来看看SpringBoot启动时第一个启动事件listeners.starting()：

public void starting() {
	//关键代码，先创建application启动事件`ApplicationStartingEvent`
    this.initialMulticaster.multicastEvent(new ApplicationStartingEvent(this.application, this.args));
}

这里先创建了一个启动事件ApplicationStartingEvent，在multicastEvent中：

public void multicastEvent(ApplicationEvent event, @Nullable ResolvableType eventType) {
    ResolvableType type = eventType != null ? eventType : this.resolveDefaultEventType(event);
    Executor executor = this.getTaskExecutor();
    //通过事件类型ApplicationStartingEvent获取对应的监听器
    Iterator var5 = this.getApplicationListeners(event, type).iterator();

    while(var5.hasNext()) {
        ApplicationListener<?> listener = (ApplicationListener)var5.next();
        if (executor != null) {
            executor.execute(() -> {
             	//异步发送事件
                this.invokeListener(listener, event);
            });
        } else {
         	//同步发送事件
            this.invokeListener(listener, event);
        }
    }

}

因为我们的事件类型为ApplicationEvent，所以会执行onApplicationStartedEvent((ApplicationStartedEvent) event);。springBoot会在运行过程中的不同阶段，发送各种事件，来执行对应监听器的对应方法

2.环境构建

ConfigurableEnvironment environment = this.prepareEnvironment(listeners, applicationArguments);

我们看下prepareEnvironment

private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments) {
 		//获取对应的ConfigurableEnvironment
        ConfigurableEnvironment environment = this.getOrCreateEnvironment();
      	//配置
        this.configureEnvironment((ConfigurableEnvironment)environment, applicationArguments.getSourceArgs());
        ConfigurationPropertySources.attach((Environment)environment);
        //发布环境已准备事件，这是第二次发布事件
        listeners.environmentPrepared((ConfigurableEnvironment)environment);
        this.bindToSpringApplication((ConfigurableEnvironment)environment);
        if (!this.isCustomEnvironment) {
            environment = (new EnvironmentConverter(this.getClassLoader())).convertEnvironmentIfNecessary((ConfigurableEnvironment)environment, this.deduceEnvironmentClass());
        }

        ConfigurationPropertySources.attach((Environment)environment);
        return (ConfigurableEnvironment)environment;
}

来看一下getOrCreateEnvironment()方法，前面已经提到，environment已经被设置了servlet类型，所以这里创建的是环境对象是StandardServletEnvironment。

private ConfigurableEnvironment getOrCreateEnvironment() {
    if (this.environment != null) {
        return this.environment;
    } else {
        switch(this.webApplicationType) {
        case SERVLET:
            return new StandardServletEnvironment();
        case REACTIVE:
            return new StandardReactiveWebEnvironment();
        default:
            return new StandardEnvironment();
        }
    }
}

接下来看下第二次发布事件listeners.environmentPrepared(environment)，首先还是会去读spring.factories 文件，执行完监听器流程然后会执行监听器类本身的逻辑。

3.创建容器

context = this.createApplicationContext();

 protected ConfigurableApplicationContext createApplicationContext() {
        Class<?> contextClass = this.applicationContextClass;
        if (contextClass == null) {
            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);
    }

这里创建容器的类型 还是根据webApplicationType进行判断的，该类型为SERVLET类型，所以会通过反射装载对应的字节码，也就是AnnotationConfigServletWebServerApplicationContext

4.容器前置处理

这一步主要是在容器刷新之前的准备动作。包含一个非常关键的操作：将启动类注入容器，为后续开启自动化配置奠定基础。

this.prepareContext(context, environment, listeners, applicationArguments, printedBanner);

继续跟进代码

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 = context.getBeanFactory();
        beanFactory.registerSingleton("springApplicationArguments", applicationArguments);
        if (printedBanner != null) {
            beanFactory.registerSingleton("springBootBanner", printedBanner);
        }

        if (beanFactory instanceof DefaultListableBeanFactory) {
            ((DefaultListableBeanFactory)beanFactory).setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
        }

        if (this.lazyInitialization) {
            context.addBeanFactoryPostProcessor(new LazyInitializationBeanFactoryPostProcessor());
        }

        Set<Object> sources = this.getAllSources();
        Assert.notEmpty(sources, "Sources must not be empty");
        this.load(context, sources.toArray(new Object[0]));
        listeners.contextLoaded(context);
    }

调用初始化器

protected void applyInitializers(ConfigurableApplicationContext context) {
    // 1. 从SpringApplication类中的initializers集合获取所有的ApplicationContextInitializer
    for (ApplicationContextInitializer initializer : getInitializers()) {
        // 2. 循环调用ApplicationContextInitializer中的initialize方法
        Class<?> requiredType = GenericTypeResolver.resolveTypeArgument(
                initializer.getClass(), ApplicationContextInitializer.class);
        Assert.isInstanceOf(requiredType, context, "Unable to call initializer.");
        initializer.initialize(context);
    }
}

这里终于用到了在创建SpringApplication实例时设置的初始化器了，依次对它们进行遍历，并调用initialize方法。我们也可以自定义初始化器，并实现initialize方法，然后放入META-INF/spring.factories配置文件中Key为：org.springframework.context.ApplicationContextInitializer的value中，这里我们自定义的初始化器就会被调用，是我们项目初始化的一种方式

加载启动指定类（重点）

大家先回到文章最开始看看，在创建SpringApplication实例时，先将HelloWorldMainApplication.class存储在this.primarySources属性中，现在就是用到这个属性的时候了，我们来看看getAllSources（）。

public Set<Object> getAllSources() {
    Set<Object> allSources = new LinkedHashSet();
    if (!CollectionUtils.isEmpty(this.primarySources)) {
        //获取primarySources属性，也就是之前存储的HelloWorldMainApplication.class
        allSources.addAll(this.primarySources);
    }

    if (!CollectionUtils.isEmpty(this.sources)) {
        allSources.addAll(this.sources);
    }

    return Collections.unmodifiableSet(allSources);
}

很明显，获取了this.primarySources属性，也就是我们的启动类HelloWorldMainApplication.class，我们接着看load(context, sources.toArray(new Object[0]));

protected void load(ApplicationContext context, Object[] sources) {
    BeanDefinitionLoader loader = createBeanDefinitionLoader(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();
}

private int load(Class<?> source) {
    if (isGroovyPresent()
            && GroovyBeanDefinitionSource.class.isAssignableFrom(source)) {
        // Any GroovyLoaders added in beans{} DSL can contribute beans here
        GroovyBeanDefinitionSource loader = BeanUtils.instantiateClass(source,
                GroovyBeanDefinitionSource.class);
        load(loader);
    }
    if (isComponent(source)) {
        //以注解的方式，将启动类bean信息存入beanDefinitionMap，也就是将HelloWorldMainApplication.class存入了beanDefinitionMap
        this.annotatedReader.register(source);
        return 1;
    }
    return 0;
}

被加载到 beanDefinitionMap中，后续该启动类将作为开启自动化配置的入口
通知监听器，容器已准备就绪
listeners.contextLoaded(context);
主还是针对一些日志等监听器的响应处理。

5.刷新容器

我们来看看refreshContext

private void refreshContext(ConfigurableApplicationContext context) {
	this.refresh((ApplicationContext)context);
	if (this.registerShutdownHook) {
		try {
			context.registerShutdownHook();
		} catch (AccessControlException var3) {
		}
	}
}

public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
        /**
         * 刷新上下文环境
         */
        prepareRefresh();

        /**
         * 初始化BeanFactory，解析XML，相当于之前的XmlBeanFactory的操作，
         */
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

        /**
         * 为上下文准备BeanFactory，即对BeanFactory的各种功能进行填充，如常用的注解@Autowired @Qualifier等
         * 添加ApplicationContextAwareProcessor处理器
         * 在依赖注入忽略实现*Aware的接口，如EnvironmentAware、ApplicationEventPublisherAware等
         * 注册依赖，如一个bean的属性中含有ApplicationEventPublisher(beanFactory)，则会将beanFactory的实例注入进去
         */
        prepareBeanFactory(beanFactory);

        try {
            /**
             * 提供子类覆盖的额外处理，即子类处理自定义的BeanFactoryPostProcess
             */
            postProcessBeanFactory(beanFactory);

            /**
             * 激活各种BeanFactory处理器,包括BeanDefinitionRegistryBeanFactoryPostProcessor和普通的BeanFactoryPostProcessor
             * 执行对应的postProcessBeanDefinitionRegistry方法 和  postProcessBeanFactory方法
             */
            invokeBeanFactoryPostProcessors(beanFactory);

            /**
             * 注册拦截Bean创建的Bean处理器，即注册BeanPostProcessor，不是BeanFactoryPostProcessor，注意两者的区别
             * 注意，这里仅仅是注册，并不会执行对应的方法，将在bean的实例化时执行对应的方法
             */
            registerBeanPostProcessors(beanFactory);

            /**
             * 初始化上下文中的资源文件，如国际化文件的处理等
             */
            initMessageSource();

            /**
             * 初始化上下文事件广播器，并放入applicatioEventMulticaster,如ApplicationEventPublisher
             */
            initApplicationEventMulticaster();

            /**
             * 给子类扩展初始化其他Bean
             */
            onRefresh();

            /**
             * 在所有bean中查找listener bean，然后注册到广播器中
             */
            registerListeners();

            /**
             * 设置转换器
             * 注册一个默认的属性值解析器
             * 冻结所有的bean定义，说明注册的bean定义将不能被修改或进一步的处理
             * 初始化剩余的非惰性的bean，即初始化非延迟加载的bean
             */
            finishBeanFactoryInitialization(beanFactory);

            /**
             * 通过spring的事件发布机制发布ContextRefreshedEvent事件，以保证对应的监听器做进一步的处理
             * 即对那种在spring启动后需要处理的一些类，这些类实现了ApplicationListener<ContextRefreshedEvent>，
             * 这里就是要触发这些类的执行(执行onApplicationEvent方法)
             * 另外，spring的内置Event有ContextClosedEvent、ContextRefreshedEvent、ContextStartedEvent、ContextStoppedEvent、RequestHandleEvent
             * 完成初始化，通知生命周期处理器lifeCycleProcessor刷新过程，同时发出ContextRefreshEvent通知其他人
             */
            finishRefresh();
        }

        finally {
    
            resetCommonCaches();
        }
    }
}

refresh方法在spring整个源码体系中举足轻重，是实现 ioc 和 aop的关键。

6.容器后置处理

protected void afterRefresh(ConfigurableApplicationContext context, ApplicationArguments args) {}

扩展接口，设计模式中的模板方法，默认为空实现。如果有自定义需求，可以重写该方法。

7.发出结束执行的事件

public void started(ConfigurableApplicationContext context) {
    //这里就是获取的EventPublishingRunListener
    Iterator var2 = this.listeners.iterator();

    while(var2.hasNext()) {
        SpringApplicationRunListener listener = (SpringApplicationRunListener)var2.next();
        //执行EventPublishingRunListener的started方法
        listener.started(context);
    }
}

获取EventPublishingRunListener监听器，并执行其started方法，并且将创建的Spring容器传进去了，创建一个ApplicationStartedEvent事件，并执行ConfigurableApplicationContext 的publishEvent方法，也就是说这里是在Spring容器中发布事件，并不是在SpringApplication中发布事件，和前面的starting是不同的，前面的starting是直接向SpringApplication中的监听器发布启动事件。

8.执行Runners

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

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

}

因此，我们可以自定义一些ApplicationRunner或者CommandLineRunner，实现其run方法，并注入到Spring容器中,在SpringBoot启动完成后，会执行所有的runner的run方法。

走进IT
关注
专栏目录
SpringBoot源码分析(2)--SpringBoot启动源码(万字图文源码debug讲解springboot启动原理)
weixin_49114503的博客
07-04 1178
、SpringApplication实例化及run()方法 2.1、SpringApplication实例化 2.1.1、 web应用判断 2.1.2、设置初始化器 2.1.3、设置监听器 2.1.4、判断主应用入口类 2.2、run()方法 2.2.1、获取监听器集合getRunListeners(args) 2.2.1.1、开启监听器 2.2.2、准备Spring环境 prepareEnvironment() 2.2.3、打印banner图 2.2.4、创建Spring应用上下文createApplic
springboot application启动报错NoSuchMethodError
weixin_41688518的博客
11-11 1173
Exception in thread "main" java.lang.NoSuchMethodError: org.springframework.boot.SpringApplication.run(Ljava/lang/Object;[Ljava/lang/String;)Lorg/springframework/context/ConfigurableApplicationContext; at titan.app.core.Application.main(Application.jav...
解决：ERROR org.springframework.boot.SpringApplication - Application run failed
BlackDlag的博客
02-23 1万+
折腾了一个下午也没有解决，网上找的解决方法也都不行，第二天早上再次仔细查看出问题的原因，可以定位到是mapper和beam出问题了，那就对每个文件进行排查，最终定位到xml文件里的。字段，之前因为偷懒，只写了对应的实体类名字，没有写在项目里的路径，也许是idea比较智能，会扫描整个项目找到实体类，但是jdk不会，最终改成如下路径，打成jar包后就可以正常运行了。把写好的项目达成jar包后运行就报下面的错误，但是在idea里却可以正常运行，非常奇怪。
Spring Boot－SpringApplication.run方法执行流程详解
了解➔熟悉➔掌握➔精通
10-16 8015
分享一个大牛的人工智能教程。零基础！通俗易懂！风趣幽默！希望你也加入到人工智能的队伍中来！请点击http://www.captainbed.net SpringApplication 是将一个典型的 Spring 应用启动的流程“模板化”，在没有特殊需求的情况下，默认模板化后的执行流程就可以满足需求。但如果有特殊需求也没关系，SpringApplication 在适当的流程结点开放了一系列不同类型的扩展点，我们可以通过这些扩展点对 SpringBoot 程序的启动和关闭过程进行扩展。 最直接的扩展是 S
spring boot整合quartz报错：Ljava/lang/Class;[Ljava/lang/Class;)Ljava/lang/reflect/Constructor;
u013905744的专栏
04-17 5239
今天在做spring boot与quartz整合的时候报错org.quartz.SchedulerException: Job instantiation failed at org.springframework.scheduling.quartz.AdaptableJobFactory.newJob(AdaptableJobFactory.java:47) at org.quartz.co...
spring-cloud 启动报错 NoSuchMethodError: SpringApplicationBuilder.<init>([Ljava/lang/Class;)V
xnarutox的博客
05-18 4067
遇到两次这种报错，在此记录下java.lang.NoSuchMethodError: org.springframework.boot.builder.SpringApplicationBuilder.&lt;init&gt;([Ljava/lang/Class;)V at org.springframework.cloud.bootstrap.BootstrapApplicationListe...
第三节-springboot源码解析-王炸篇.pdf
11-11
Spring Boot源码解析是深入了解Spring Boot内部工作原理和机制的重要途径。通过源码分析，开发者可以更好地理解Spring Boot的自动装配、启动流程以及如何自定义启动器。Spring Boot的自动装配原理涉及到Spring Boot...
springbootstudy:springboot原始码解析-源码解析
03-24
总的来说，通过对"springbootstudy:springboot原始码解析-源码解析"项目的探索，开发者可以深入了解SpringBoot的工作原理，提升解决实际问题的能力，更好地利用SpringBoot的特性来优化和设计应用程序。这个过程涉及...
springboot 3.0.2 自动配置（auto-configuration） 启动器（starter）保姆级教程带源码
02-12
**源码解析** `AutoConfigurationImportSelector`类通过`ConfigurationMetadataReader`读取`META-INF/spring/autoconfigure-metadata.properties`文件来获取所有可能的自动配置类。然后，它使用`ConditionEvaluator`...
Spring Boot源码（spring-boot-2.6.2.zip）
01-07
在这个版本中，我们将深入探讨Spring Boot的核心特性、工作原理以及如何通过源码来理解其内部机制。 首先，Spring Boot的核心理念是“约定优于配置”，它通过预设许多默认配置，减少了开发者需要手动配置的繁琐工作...
SpringBoot —SpringApplication.run()方法剖析
m0_63330888的博客
11-03 2561
springboot一键启动原理解析
springboot整合quarzt实现动态定时任务
我想问问天的专栏
05-12 3536
springboot整合quarzt实现动态定时任务实现定时任务的几种方式:1.使用linux的crontab2.使用spring自带的ScheduledExecutor3. 使用JDK自带的Timer4.使用quarzt整合步骤:遇到的坑：源码地址：[github源码地址](https://github.com/wxwwt/dynamic_scheduler)，朋友们觉得写得还行的帮忙star个...
[main] ERROR org.springframework.boot.SpringApplication - Application run failed java.lang.NoSuchMet
weixin_43858776的博客
09-09 5763
编写程序时候出现 [main] ERROR org.springframework.boot.SpringApplication - Application run failed java.lang.NoSuchMethodError: org.springframework.boot.builder.SpringApplicationBuilder.([Ljava/lang/Object;)V ，百度说是spring boot的版本错误 实际上还有一种可能是引入的maven依赖中包含更高版本的依赖，而项目
ERROR org.springframework.boot.SpringApplication - Application run failed org.yaml.snakeyaml.reader
最新发布
qq_47291002的博客
03-21 2143
提示：以下是本篇文章正文内容，下面案例可供参考就解决了我的问题。
报错ERROR org.springframework.boot.SpringApplication -Application run failed
qq_45615393的博客
05-24 2万+
出现这种异常是因为yaml的配置文件里面，有\t字符，所以报错，我们去看那个yaml文件，上面提示的是redis。所以我们得去看yaml配置文件里写redis配置的地方，查看发现根本就没有\t字符（其实是被隐藏了我们看不出来）。 决解办法：出现这个问题的原因有可能是因为我们的配置是从其他地方复制过来的（我就是复制的，而不是自己写的），所以会自带这种看不见的字符。那就把这个配置给删除了，然后重新照着写一遍就行了。 完美解决。 贴心小提示：注意，如果从其他地方直接复制配置内容到配置文件里，然后程序..
SpringBoot报错ERROR org.springframework.boot.SpringApplication - Application run failed
热门推荐
清风微凉亦暖心
11-26 5万+
有时候启动springboot会成功，有时候会报下面的错误 10:27:27.556 [main] ERROR org.springframework.boot.SpringApplication - Application run failed org.yaml.snakeyaml.error.YAMLException: java.nio.charset.MalformedInputException: Input length = 1 at org.yaml.snakeyaml.reader.Str
SpringBoot启动流程之SpringApplication.run()运行阶段之SpringApplicationRunListener
ystyaoshengting的专栏
09-05 751
SpringApplication 构造SpringApplication之后，就会调用ApingApplication的非静态run方法 public ConfigurableApplicationContext run(String... args) { StopWatch stopWatch = new StopWatch(); stopWatch.start(); ConfigurableApplicationContext context = nu
Spring-boot Unable to start EmbeddedWebApplicationContext 分析与解决方法
Revivedsun的专栏
08-06 4186
org.springframework.context.ApplicationContextException: Unable to start EmbeddedWebApplicationContext due to missing EmbeddedServletContainerFactory bean. Unable to start EmbeddedWebApplicationContext due to
springboot项目启动报 [source error] getPropertyValue (Ljava/lang/Object；Ljava/lang/String；)
selah1的专栏
08-03 3175
springboot项目启动报错： [source error] getPropertyValue (Ljava/lang/Object;Ljava/lang/String;)Ljava/lang/Object; in org.apache.dubbo.common.bytecode.Wrapper4: inconsistent stack height -1 Error starting ApplicationContext. To display the conditions report r..
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

走进IT

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值