精华内容
下载资源
问答
  • SpringBoot启动过程-面试题
    千次阅读
    2021-12-09 19:55:15
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    
    /**
     * Hello world!
     *
     */
    @SpringBootApplication
    public class App 
    {
        public static void main( String[] args )
        {
    
            System.out.println( "Hello World!" );
    
            SpringApplication.run(App.class,args);
        }
    }

    一、Spring  SPI机制,自动装配:

    启动类使用@SpringApplication注解,看一下注解代码:

    代码中使用@EnableAutoConfiguration以及@ComponentScan自动装配

    其中注解@EnableAutoConfiguration使用了@Import加载,最后使用了SpringFactoriesLoader反射出maven中META-INF下spring.factories。

    public @interface SpringBootApplication {
        @AliasFor(
            annotation = EnableAutoConfiguration.class
        )
        Class<?>[] exclude() default {};
    
        @AliasFor(
            annotation = EnableAutoConfiguration.class
        )
        String[] excludeName() default {};
    
        @AliasFor(
            annotation = ComponentScan.class,
            attribute = "basePackages"
        )
        String[] scanBasePackages() default {};
    
        @AliasFor(
            annotation = ComponentScan.class,
            attribute = "basePackageClasses"
        )
        Class<?>[] scanBasePackageClasses() default {};
    }
    
    package org.springframework.boot.autoconfigure;
    
    import java.lang.annotation.Documented;
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Inherited;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    import org.springframework.context.annotation.Import;
    
    @Target({ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Inherited
    @AutoConfigurationPackage
    @Import({AutoConfigurationImportSelector.class})
    public @interface EnableAutoConfiguration {
        String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";
    
        Class<?>[] exclude() default {};
    
        String[] excludeName() default {};
    }
    
    
    //
    public class AutoConfigurationImportSelector ...{
    
    ...
    protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
    
    //加载类路径下面  META-INF/spring.factories
            List<String> configurations = SpringFactoriesLoader.loadFactoryNames(this.getSpringFactoriesLoaderFactoryClass(), this.getBeanClassLoader());
    
            Assert.notEmpty(configurations, "No auto configuration classes found in META-INF/spring.factories. If you are using a custom packaging, make sure that file is correct.");
            return configurations;
        }
    
    }
    
    
    public abstract class SpringFactoriesLoader {
        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 (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 {
                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();
                            List<String> factoryClassNames = Arrays.asList(StringUtils.commaDelimitedListToStringArray((String)entry.getValue()));
                            result.addAll((String)entry.getKey(), factoryClassNames);
                        }
                    }
    
                    cache.put(classLoader, result);
                    return result;
                } catch (IOException var9) {
                    throw new IllegalArgumentException("Unable to load factories from location [META-INF/spring.factories]", var9);
                }
            }
        }
    
    ....
    }

    感兴趣的老铁,可以看一下java 的SPI和Spring的SPI,自动装配机制

    二、SpringBoot启动时通过执行main方法中的SpringApplication.run方法去启动,在run方法中调用了SpringApplication的构造方法,在该构造方法中加载了META-INFA\spring.factories文件配置的ApplicationContextInitializer的实现类和ApplicationListenerr的实现类: 

     SpringApplication.run(..,..)

     

     

    二、ApplicationContextInitializer 这个类当springboot上下文Context初始化完成后会调用。                   ApplicationListener当springboot启动时事件change后都会触发。


    三、SpringApplication实例构造完之后会调用它的run方法,在run方法中作了以下几步重要操作:


    1. 获取事件监听器SpringApplicationRunListener类型,并且执行starting()方法


    2. 准备环境,并且把环境跟spring上下文绑定好,并且执行environmentPrepared()方法


    3. 创建上下文,根据项目类型创建上下文


    4. 执行spring的启动流程扫描并且初始化单实列bean


    四、通过@SpringBootApplication注解将ClassPath路径下所有的META-INF\spring.factories文件中的EnableAutoConfiguration实例注入到IOC容器中

    更多相关内容
  • SpringBoot启动过程

    万次阅读 多人点赞 2019-03-14 17:18:40
    SpringBoot启动过程分析,首先打开SpringBoot的启用入口Main类: @SpringBootApplication public class ApplicationMain{ public static void main(String[] args) { SpringApplication.run(ApplicationMain.class...

    SpringBoot启动过程分析,首先打开SpringBoot的启用入口Main类:

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

    可以看到main方法里面只有一行核心启用类:SpringApplication.run(ApplicationMain.class, args);这个是关键,在改行打上断点,debug模式启动该main类。点击下一步进入SpringApplication的源码对应的run方法:

    public static ConfigurableApplicationContext run(Object[] sources, String[] args) {
            return (new SpringApplication(sources)).run(args);
        }
    

    初始化SpringApplication

    SpringApplication实例化之前会调用构造方法进行初始化:

    public SpringApplication(Object... sources) {
            this.bannerMode = Mode.CONSOLE;
            this.logStartupInfo = true;
            this.addCommandLineProperties = true;
            this.headless = true;
            this.registerShutdownHook = true;
            this.additionalProfiles = new HashSet();
            this.initialize(sources);
        }
    

    而SpringApplication构造方法的核心是:this.initialize(sources);初始化方法,SpringApplication通过调用该方法来初始化。

    private void initialize(Object[] sources) {
        if (sources != null && sources.length > 0) {
            this.sources.addAll(Arrays.asList(sources));
        }
        this.webEnvironment = deduceWebEnvironment();
        setInitializers((Collection) getSpringFactoriesInstances(
                ApplicationContextInitializer.class));
        setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
        this.mainApplicationClass = deduceMainApplicationClass();
    }
    

    1.deduceWebEnvironment方法是用来判断当前应用的环境,该方法通过获取这两个类来判断当前环境是否是web环境,如果能获得这两个类说明是web环境,否则不是。

    javax.servlet.Servlet
    org.springframework.web.context.ConfigurableWebApplicationContext
    

    2.getSpringFactoriesInstances方法主要用来从spring.factories文件中找出key为ApplicationContextInitializer的类并实例化,然后调用setInitializers方法设置到SpringApplication的initializers属性中。这个过程就是找出所有的应用程序初始化器。

    private <T> Collection<? extends T> getSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes, Object... args) {
            ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
            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, ClassLoader classLoader) {
            String factoryClassName = factoryClass.getName();
    
            try {
               //从spring.factories文件中找出key为ApplicationContextInitializer的类
                Enumeration<URL> urls = classLoader != null ? classLoader.getResources("META-INF/spring.factories") : ClassLoader.getSystemResources("META-INF/spring.factories");
                ArrayList result = new ArrayList();
    
                while(urls.hasMoreElements()) {
                    URL url = (URL)urls.nextElement();
                    Properties properties = PropertiesLoaderUtils.loadProperties(new UrlResource(url));
                    String factoryClassNames = properties.getProperty(factoryClassName);
                    result.addAll(Arrays.asList(StringUtils.commaDelimitedListToStringArray(factoryClassNames)));
                }
    
                return result;
            } catch (IOException var8) {
                throw new IllegalArgumentException("Unable to load [" + factoryClass.getName() + "] factories from location [" + "META-INF/spring.factories" + "]", var8);
            }
        }
    

    当前的初始化器有如下几个:
    在这里插入图片描述
    3.同理调用getSpringFactoriesInstances从spring.factories文件中找出key为ApplicationListener的类并实例化,然后调用setListeners方法设置到SpringApplication的listeners属性中。这个过程就是找出所有的应用程序事件监听器。
    当前的事件监听器有如下几个:
    在这里插入图片描述
    4.调用deduceMainApplicationClass方法找出main类,就是这里的ApplicationMain类。

    运行SpringApplication

    初始化SpringApplication完成之后,调用run方法运行:

    public ConfigurableApplicationContext run(String... args) {
            //计时器,统计任务的执行时间
            StopWatch stopWatch = new StopWatch();
            //开始执行
            stopWatch.start();
            ConfigurableApplicationContext context = null;
            FailureAnalyzers analyzers = null;
            this.configureHeadlessProperty();
            // 获取SpringApplicationRunListeners启动事件监听器,这里只有一个EventPublishingRunListener
            SpringApplicationRunListeners listeners = this.getRunListeners(args);
            // 封装成SpringApplicationEvent事件然后广播出去给SpringApplication中的listeners所监听
            listeners.starting();
    
            try {
                // 构造一个应用程序参数持有类
                ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
                // 准备并配置环境
                ConfigurableEnvironment environment = this.prepareEnvironment(listeners, applicationArguments);
                 // 打印banner图形
                Banner printedBanner = this.printBanner(environment);
                // 创建Spring容器
                context = this.createApplicationContext();
                new FailureAnalyzers(context);
                // 配置Spring容器
                this.prepareContext(context, environment, listeners, applicationArguments, printedBanner);
                // 容器上下文刷新
                this.refreshContext(context);
                // 容器创建完成之后调用afterRefresh方法
                this.afterRefresh(context, applicationArguments);
                // 调用监听器,广播Spring启动结束的事件
                listeners.finished(context, (Throwable)null);
                // 停止计时器
                stopWatch.stop();
                if (this.logStartupInfo) {
                    (new StartupInfoLogger(this.mainApplicationClass)).logStarted(this.getApplicationLog(), stopWatch);
                }
    
                return context;
            } catch (Throwable var9) {
                this.handleRunFailure(context, listeners, (FailureAnalyzers)analyzers, var9);
                throw new IllegalStateException(var9);
            }
        }
    

    SpringApplicationRunListeners

    1.获取启动事件监听器,可以看看该方法:

    SpringApplicationRunListeners listeners = this.getRunListeners(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文件中拿到SpringApplicationRunListener监听器,当前的SpringApplicationRunListener事件监听器只有一个EventPublishingRunListener广播事件监听器:
    在这里插入图片描述
    SpringApplicationRunListeners内部持有SpringApplicationRunListener集合和1个Log日志类。用于SpringApplicationRunListener监听器的批量执行。

    SpringApplicationRunListener用于监听SpringApplication的run方法的执行,它定义了5个步骤:

    1. starting:run方法执行的时候立马执行,对应的事件类型是ApplicationStartedEvent
    2. environmentPrepared:ApplicationContext创建之前并且环境信息准备好的时候调用,对应的事件类型是ApplicationEnvironmentPreparedEvent
    3. contextPrepared:ApplicationContext创建好并且在source加载之前调用一次,没有具体的对应事件
    4. contextLoaded:ApplicationContext创建并加载之后并在refresh之前调用,对应的事件类型是ApplicationPreparedEvent
    5. finished:run方法结束之前调用,对应事件的类型是ApplicationReadyEvent或ApplicationFailedEvent

    SpringApplicationRunListener目前只有一个实现类EventPublishingRunListener,详见获取SpringApplicationRunListeners。它把监听的过程封装成了SpringApplicationEvent事件并让内部属性ApplicationEventMulticaster接口的实现类SimpleApplicationEventMulticaster广播出去,广播出去的事件对象会被SpringApplication中的listeners属性进行处理。

    所以说SpringApplicationRunListener和ApplicationListener之间的关系是通过ApplicationEventMulticaster广播出去的SpringApplicationEvent所联系起来的

    2.启动事件监听器

    通过listeners.starting()可以启动事件监听器SpringApplicationRunListener ,SpringApplicationRunListener 是一个启动事件监听器接口:

    public interface SpringApplicationRunListener {
        void starting();
    
        void environmentPrepared(ConfigurableEnvironment var1);
    
        void contextPrepared(ConfigurableApplicationContext var1);
    
        void contextLoaded(ConfigurableApplicationContext var1);
    
        void finished(ConfigurableApplicationContext var1, Throwable var2);
    }
    

    SpringApplicationRunListener 接口的具体实现就是EventPublishingRunListener类,我们主要来看一下它的startting方法,该方法会封装成SpringApplicationEvent事件然后广播出去给SpringApplication中的listeners所监听。

     public void starting() {
            this.initialMulticaster.multicastEvent(new ApplicationStartedEvent(this.application, this.args));
        }
    

    配置并准备环境

    private ConfigurableEnvironment prepareEnvironment(
            SpringApplicationRunListeners listeners,
            ApplicationArguments applicationArguments) {
        // 创建应用程序的环境信息。如果是web程序,创建StandardServletEnvironment;否则,创建StandardEnvironment
        ConfigurableEnvironment environment = getOrCreateEnvironment();
        // 配置环境信息。比如profile,命令行参数
        configureEnvironment(environment, applicationArguments.getSourceArgs());
        // 广播出ApplicationEnvironmentPreparedEvent事件给相应的监听器执行
        listeners.environmentPrepared(environment);
        // 环境信息的校对
        if (!this.webEnvironment) {
            environment = new EnvironmentConverter(getClassLoader())
                    .convertToStandardEnvironmentIfNecessary(environment);
        }
        return environment;
    }
    

    判断环境,如果是web程序,创建StandardServletEnvironment;否则,创建StandardEnvironment。

    private ConfigurableEnvironment getOrCreateEnvironment() {
            if (this.environment != null) {
                return this.environment;
            } else {
                return (ConfigurableEnvironment)(this.webEnvironment ? new StandardServletEnvironment() : new StandardEnvironment());
            }
        }
    

    创建Spring容器上下文

    protected ConfigurableApplicationContext createApplicationContext() {
        Class<?> contextClass = this.applicationContextClass;
        if (contextClass == null) {
            try {
                // 判断是否是web应用,
                // 如果是则创建AnnotationConfigEmbeddedWebApplicationContext,否则创建AnnotationConfigApplicationContext
                contextClass = Class.forName(this.webEnvironment
                        ? DEFAULT_WEB_CONTEXT_CLASS : DEFAULT_CONTEXT_CLASS);
            }
            catch (ClassNotFoundException ex) {
                throw new IllegalStateException(
                        "Unable create a default ApplicationContext, "
                                + "please specify an ApplicationContextClass",
                        ex);
            }
        }
        return (ConfigurableApplicationContext) BeanUtils.instantiate(contextClass);
    }
    

    配置Spring容器上下文

    private void prepareContext(ConfigurableApplicationContext context,
            ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,
            ApplicationArguments applicationArguments, Banner printedBanner) {
        // 设置Spring容器上下文的环境信息
        context.setEnvironment(environment);
        // Spring容器创建之后做一些额外的事
        postProcessApplicationContext(context);
        // SpringApplication的初始化器开始工作
        applyInitializers(context);
        // 遍历调用SpringApplicationRunListener的contextPrepared方法。目前只是将这个事件广播器注册到Spring容器中
        listeners.contextPrepared(context);
        if (this.logStartupInfo) {
            logStartupInfo(context.getParent() == null);
            logStartupProfileInfo(context);
        }
    
        // 把应用程序参数持有类注册到Spring容器中,并且是一个单例
        context.getBeanFactory().registerSingleton("springApplicationArguments",
                applicationArguments);
        if (printedBanner != null) {
            context.getBeanFactory().registerSingleton("springBootBanner", printedBanner);
        }
    
        // 加载sources,sources是main方法所在的类
        Set<Object> sources = getSources();
        Assert.notEmpty(sources, "Sources must not be empty");
        // 将sources加载到应用上下文中。最终调用的是AnnotatedBeanDefinitionReader.registerBean方法
        load(context, sources.toArray(new Object[sources.size()]));
        // 广播出ApplicationPreparedEvent事件给相应的监听器执行
        // 执行EventPublishingRunListener.contextLoaded方法
        listeners.contextLoaded(context);
    }
    

    Spring容器创建之后回调方法postProcessApplicationContext

    protected void postProcessApplicationContext(ConfigurableApplicationContext context) {
        // 如果SpringApplication设置了实例命名生成器,则注册到Spring容器中
        if (this.beanNameGenerator != null) {
            context.getBeanFactory().registerSingleton(
                    AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR,
                    this.beanNameGenerator);
        }
        // 如果SpringApplication设置了资源加载器,设置到Spring容器中
        if (this.resourceLoader != null) {
            if (context instanceof GenericApplicationContext) {
                ((GenericApplicationContext) context)
                        .setResourceLoader(this.resourceLoader);
            }
            if (context instanceof DefaultResourceLoader) {
                ((DefaultResourceLoader) context)
                        .setClassLoader(this.resourceLoader.getClassLoader());
            }
        }
    }
    

    初始化器开始工作

    protected void applyInitializers(ConfigurableApplicationContext context) {
        // 遍历每个初始化器,调用对应的initialize方法
        for (ApplicationContextInitializer initializer : getInitializers()) {
            Class<?> requiredType = GenericTypeResolver.resolveTypeArgument(
                    initializer.getClass(), ApplicationContextInitializer.class);
            Assert.isInstanceOf(requiredType, context, "Unable to call initializer.");
            initializer.initialize(context);
        }
    }
    

    Spring容器创建完成之后会调用afterRefresh方法

    ApplicationRunner、CommandLineRunner类都是在在afterRefresh方法中调用的,也就是说在Spring容器创建之后执行的。

    protected void afterRefresh(ConfigurableApplicationContext context,
            ApplicationArguments args) {
        callRunners(context, args);
    }
    
    private void callRunners(ApplicationContext context, ApplicationArguments args) {
        List<Object> runners = new ArrayList<Object>();
        // 找出Spring容器中ApplicationRunner接口的实现类
        runners.addAll(context.getBeansOfType(ApplicationRunner.class).values());
        // 找出Spring容器中CommandLineRunner接口的实现类
        runners.addAll(context.getBeansOfType(CommandLineRunner.class).values());
        // 对runners进行排序
        AnnotationAwareOrderComparator.sort(runners);
        // 遍历runners依次执行
        for (Object runner : new LinkedHashSet<Object>(runners)) {
            if (runner instanceof ApplicationRunner) {
                callRunner((ApplicationRunner) runner, args);
            }
            if (runner instanceof CommandLineRunner) {
                callRunner((CommandLineRunner) runner, args);
            }
        }
    }
    

    参考:https://blog.wangqi.love/articles/Spring/SpringBoot启动过程.html

    展开全文
  • springboot启动原理, 源码发现,过程详解 SpringBootApplication背后的秘密 深入探索SpringApplication执行流程
  • SpringBoot springboot是依赖于spring的,bi'qi

    来自面试官发自内审深处的灵魂拷问:“说一下springboot的启动流程”;
    一脸懵逼的面试者:“它简化了spring的配置,主要是因为有自动装配的功能,并且可以直接启动,因为它内嵌了tomcat容器”
    面试官:“嗯, 没错,这是 它的一些概念,你还没回答我的问题,它是怎么启动的,启懂时都经过了哪些东西?”;
    一脸懵逼的面试者:“额~~~不知道额····,我用的很熟练,但是不知道它里面做了哪些事情!”;
    面试官:“了解内部原理是为了帮助我们做扩展,同时也是验证了一个人的学习能力,如果你想让自己的职业道路更上一层楼,这些底层的东西你是必须要会的,行吧,你回去等消息吧!
    面试者:↓

     

    SpringBoot是什么

            springboot是依赖于spring的,比起spring,除了拥有spring的全部功能以外,springboot无需繁琐的xml配置,这取决于它自身强大的自动装配功能;并且自身已嵌入Tomcat、Jetty等web容器,集成了springmvc,使得springboot可以直接运行,不需要额外的容器,提供了一些大型项目中常见的非功能性特性,如嵌入式服务器、安全、指标,健康检测、外部配置等,

        其实spring大家都知道,boot是启动的意思。所以,spring boot其实就是一个启动spring项目的一个工具而已,总而言之,springboot 是一个服务于框架的框架;也可以说springboot是一个工具,这个工具简化了spring的配置;

     

    Spring Boot的核心功能

    1、 可独立运行的Spring项目:Spring Boot可以以jar包的形式独立运行。

    2、 内嵌的Servlet容器:Spring Boot可以选择内嵌Tomcat、Jetty或者Undertow,无须以war包形式部署项目。

    3、 简化的Maven配置:Spring提供推荐的基础 POM 文件来简化Maven 配置。

    4、 自动配置Spring:Spring Boot会根据项目依赖来自动配置Spring 框架,极大地减少项目要使用的配置。

    5、 提供生产就绪型功能:提供可以直接在生产环境中使用的功能,如性能指标、应用信息和应用健康检查。

    6、 无代码生成和xml配置:Spring Boot不生成代码。完全不需要任何xml配置即可实现Spring的所有配置。
     

    SpringBoot启动过程

        springboot的启动经过了一些一系列的处理,我们先看看整体过程的流程图

    你别说,步骤还挺多,但是不要紧,为了帮助大家理解,接下来将上面的编号一个个地讲解,以通俗易懂的方式告诉大家,里面都做了什么事情,废话不多说,开整

    1、运行 SpringApplication.run() 方法

    可以肯定的是,所有的标准的springboot的应用程序都是从run方法开始的

    package com.spring;
    import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.context.ConfigurableApplicationContext;
    
    @SpringBootApplication
    public class App  {
    
        public static void main(String[] args) {
            // 启动springboot
            ConfigurableApplicationContext run = SpringApplication.run(App.class, args);
        }
    
    }

    进入run方法后,会 new 一个SpringApplication 对象,创建这个对象的构造函数做了一些准备工作,编号第2~5步就是构造函数里面所做的事情

    	/**
    	 * Static helper that can be used to run a {@link SpringApplication} from the
    	 * specified sources using default settings and user supplied arguments.
    	 * @param primarySources the primary sources to load
    	 * @param args the application arguments (usually passed from a Java main method)
    	 * @return the running {@link ApplicationContext}
    	 */
    	public static ConfigurableApplicationContext run(Class<?>[] primarySources,
    			String[] args) {
    		return new SpringApplication(primarySources).run(args);
    	}

    另外在说明一下,springboot启动有三种方式,其他的启动方式可参照我的另一个帖子: SpringBoot的三种启动方式

    2、确定应用程序类型

    在SpringApplication的构造方法内,首先会通过 WebApplicationType.deduceFromClasspath(); 方法判断当前应用程序的容器,默认使用的是Servlet 容器,除了servlet之外,还有NONE  和 REACTIVE (响应式编程);

    3、加载所有的初始化器

    这里加载的初始化器是springboot自带初始化器,从从 META-INF/spring.factories 配置文件中加载的,那么这个文件在哪呢?自带有2个,分别在源码的jar包的  spring-boot-autoconfigure 项目 和 spring-boot 项目里面各有一个

    spring.factories文件里面,看到开头是  org.springframework.context.ApplicationContextInitializer 接口就是初始化器了 ,

    当然,我们也可以自己实现一个自定义的初始化器:实现  ApplicationContextInitializer接口既可

    MyApplicationContextInitializer.java

    package com.spring.application;
    
    import org.springframework.context.ApplicationContextInitializer;
    import org.springframework.context.ConfigurableApplicationContext;
    /**
     * 自定义的初始化器
     */
    public class MyApplicationContextInitializer implements ApplicationContextInitializer<ConfigurableApplicationContext> {
        @Override
        public void initialize(ConfigurableApplicationContext configurableApplicationContext) {
            System.out.println("我是初始化的 MyApplicationContextInitializer...");
        }
    }

    在resources目录下添加 META-INF/spring.factories 配置文件,内容如下,将自定义的初始化器注册进去;

    org.springframework.context.ApplicationContextInitializer=\
    com.spring.application.MyApplicationContextInitializer

    启动springboot后,就可以看到控制台打印的内容了,在这里我们可以很直观的看到它的执行顺序,是在打印banner的后面执行的;

     4、加载所有的监听器

    加载监听器也是从 META-INF/spring.factories 配置文件中加载的,与初始化不同的是,监听器加载的是实现了 ApplicationListener 接口的类

    自定义监听器也跟初始化器一样,依葫芦画瓢就可以了,这里不在举例;

    5、设置程序运行的主类

    deduceMainApplicationClass();  这个方法仅仅是找到main方法所在的类,为后面的扫包作准备,deduce是推断的意思,所以准确地说,这个方法作用是推断出主方法所在的类;

    6、开启计时器

    程序运行到这里,就已经进入了run方法的主体了,第一步调用的run方法是静态方法,那个时候还没实例化SpringApplication对象,现在调用的run方法是非静态的,是需要实例化后才可以调用的,进来后首先会开启计时器,这个计时器有什么作用呢?顾名思义就使用来计时的嘛,计算springboot启动花了多长时间;关键代码如下:

    // 实例化计时器
    StopWatch stopWatch = new StopWatch(); 
    // 开始计时
    stopWatch.start();

     run方法代码段截图

     

    7、将java.awt.headless设置为true

    这里将java.awt.headless设置为true,表示运行在服务器端,在没有显示器器和鼠标键盘的模式下照样可以工作,模拟输入输出设备功能。

    做了这样的操作后,SpringBoot想干什么呢?其实是想设置该应用程序,即使没有检测到显示器,也允许其启动.对于服务器来说,是不需要显示器的,所以要这样设置.

    方法主体如下:

    	private void configureHeadlessProperty() {
    		System.setProperty(SYSTEM_PROPERTY_JAVA_AWT_HEADLESS, System.getProperty(
    				SYSTEM_PROPERTY_JAVA_AWT_HEADLESS, Boolean.toString(this.headless)));
    	}

    通过方法可以看到,setProperty()方法里面又有个getProperty();这不多此一举吗?其实getProperty()方法里面有2个参数, 第一个key值,第二个是默认值,意思是通过key值查找属性值,如果属性值为空,则返回默认值 true;保证了一定有值的情况;

    8、获取并启用监听器

    这一步 通过监听器来实现初始化的的基本操作,这一步做了2件事情

    1. 创建所有 Spring 运行监听器并发布应用启动事件
    2. 启用监听器

    9、设置应用程序参数

    将执行run方法时传入的参数封装成一个对象

     仅仅是将参数封装成对象,没啥好说的,对象的构造函数如下

    	public DefaultApplicationArguments(String[] args) {
    		Assert.notNull(args, "Args must not be null");
    		this.source = new Source(args);
    		this.args = args;
    	}

    那么问题来了,这个参数是从哪来的呢?其实就是main方法里面执行静态run方法传入的参数,

    10、准备环境变量

    准备环境变量,包含系统属性和用户配置的属性,执行的代码块在  prepareEnvironment 方法内

    打了断点之后可以看到,它将maven和系统的环境变量都加载进来了

    11、忽略bean信息

     这个方法configureIgnoreBeanInfo() 这个方法是将 spring.beaninfo.ignore 的默认值值设为true,意思是跳过beanInfo的搜索,其设置默认值的原理和第7步一样;

        private void configureIgnoreBeanInfo(ConfigurableEnvironment environment) {
    		if (System.getProperty(
    				CachedIntrospectionResults.IGNORE_BEANINFO_PROPERTY_NAME) == null) {
    			Boolean ignore = environment.getProperty("spring.beaninfo.ignore",
    					Boolean.class, Boolean.TRUE);
    			System.setProperty(CachedIntrospectionResults.IGNORE_BEANINFO_PROPERTY_NAME,
    					ignore.toString());
    		}
    	}

    当然也可以在配置文件中添加以下配置来设为false

    spring.beaninfo.ignore=false

    目前还不知道这个配置的具体作用,待作者查明后在补上

    12、打印 banner 信息

    显而易见,这个流程就是用来打印控制台那个很大的spring的banner的,就是下面这个东东

    那他在哪里打印的呢?他在 SpringBootBanner.java 里面打印的,这个类实现了Banner 接口,

    而且banner信息是直接在代码里面写死的;

    有些公司喜欢自定义banner信息,如果想要改成自己喜欢的图标该怎么办呢,其实很简单,只需要在resources目录下添加一个 banner.txt 的文件即可,txt文件内容如下

                     _           _
                    (_)         | |
     _   _  _____  ___ _ __   __| | ___  _ __   __ _
    | | | |/ _ \ \/ / | '_ \ / _` |/ _ \| '_ \ / _` |
    | |_| |  __/>  <| | | | | (_| | (_) | | | | (_| |
     \__, |\___/_/\_\_|_| |_|\__,_|\___/|_| |_|\__, |
      __/ |                                     __/ |
     |___/                                     |___/
    :: yexindong::

    一定要添加到resources目录下,别加错了

    只需要加一个文件即可,其他什么都不用做,然后直接启动springboot,就可以看到效果了

    13、创建应用程序的上下文

    实例化应用程序的上下文, 调用 createApplicationContext() 方法,这里就是用反射创建对象,没什么好说的;

    14、实例化异常报告器

    异常报告器是用来捕捉全局异常使用的,当springboot应用程序在发生异常时,异常报告器会将其捕捉并做相应处理,在spring.factories 文件里配置了默认的异常报告器,

    需要注意的是,这个异常报告器只会捕获启动过程抛出的异常,如果是在启动完成后,在用户请求时报错,异常报告器不会捕获请求中出现的异常,

    了解原理了,接下来我们自己配置一个异常报告器来玩玩;

    MyExceptionReporter.java 继承 SpringBootExceptionReporter 接口

    package com.spring.application;
    
    import org.springframework.boot.SpringBootExceptionReporter;
    import org.springframework.context.ConfigurableApplicationContext;
    
    public class MyExceptionReporter implements SpringBootExceptionReporter {
    
    
        private ConfigurableApplicationContext context;
        // 必须要有一个有参的构造函数,否则启动会报错
        MyExceptionReporter(ConfigurableApplicationContext context) {
            this.context = context;
        }
    
        @Override
        public boolean reportException(Throwable failure) {
            System.out.println("进入异常报告器");
            failure.printStackTrace();
            // 返回false会打印详细springboot错误信息,返回true则只打印异常信息 
            return false;
        }
    }
    

    在  spring.factories 文件中注册异常报告器

    # Error Reporters 异常报告器
    org.springframework.boot.SpringBootExceptionReporter=\
    com.spring.application.MyExceptionReporter

    接着我们在application.yml 中 把端口号设置为一个很大的值,这样肯定会报错,

    server:
      port: 80828888

    启动后,控制台打印如下图

    15、准备上下文环境 

    这里准备的上下文环境是为了下一步刷新做准备的,里面还做了一些额外的事情;

    15.1、实例化单例的beanName生成器

    在  postProcessApplicationContext(context); 方法里面。使用单例模式创建 了BeanNameGenerator 对象,其实就是beanName生成器,用来生成bean对象的名称

    15.2、执行初始化方法

    初始化方法有哪些呢?还记得第3步里面加载的初始化器嘛?其实是执行第3步加载出来的所有初始化器,实现了ApplicationContextInitializer 接口的类

    15.3、将启动参数注册到容器中

    这里将启动参数以单例的模式注册到容器中,是为了以后方便拿来使用,参数的beanName 为 :springApplicationArguments

    16、刷新上下文

    刷新上下文已经是spring的范畴了,自动装配和启动 tomcat就是在这个方法里面完成的,还有其他的spring自带的机制在这里就不一一细说了,

    17、刷新上下文后置处理

    afterRefresh 方法是启动后的一些处理,留给用户扩展使用,目前这个方法里面是空的,

    /**
    	 * Called after the context has been refreshed.
    	 * @param context the application context
    	 * @param args the application arguments
    	 */
    	protected void afterRefresh(ConfigurableApplicationContext context,
    			ApplicationArguments args) {
    	}

    18、结束计时器

    到这一步,springboot其实就已经完成了,计时器会打印启动springboot的时长

    在控制台看到启动还是挺快的,不到2秒就启动完成了;

    19、发布上下文准备就绪事件

    告诉应用程序,我已经准备好了,可以开始工作了

    20、执行自定义的run方法

     这是一个扩展功能,callRunners(context, applicationArguments) 可以在启动完成后执行自定义的run方法;有2中方式可以实现:

    1. 实现 ApplicationRunner 接口
    2. 实现 CommandLineRunner 接口

    接下来我们验证一把,为了方便代码可读性,我把这2种方式都放在同一个类里面

    package com.spring.init;
    
    import org.springframework.boot.ApplicationArguments;
    import org.springframework.boot.ApplicationRunner;
    import org.springframework.boot.CommandLineRunner;
    import org.springframework.stereotype.Component;
    
    /**
     * 自定义run方法的2种方式
     */
    @Component
    public class MyRunner implements ApplicationRunner, CommandLineRunner {
    
        @Override
        public void run(ApplicationArguments args) throws Exception {
            System.out.println(" 我是自定义的run方法1,实现 ApplicationRunner 接口既可运行"        );
        }
    
        @Override
        public void run(String... args) throws Exception {
            System.out.println(" 我是自定义的run方法2,实现 CommandLineRunner 接口既可运行"        );
        }
    }
    

    启动springboot后就可以看到控制台打印的信息了

        其实了解springboot启动原理对开发人员还是有好处的,至少你知道哪些东西是可以扩展的,以及怎么扩展,它的内部原理是怎么做的,我相信了解这些思路之后,让你自己写一个springboot出来也是可以的; 但是这里只是列出了启动过程,并不涉及到全部,源码是很负杂,记得一个大牛说过:“我们看源码的时候,只能通过联想或猜测作者是怎么想的,并且小心验证,就像我们小时候学古诗一样,也只能去猜测古人的想法,拿道德经来说,每个人读完后都有不同的看法,这就需要见仁见智了”;

    展开全文
  • 这就是Spring Boot的整个启动流程,其核⼼就是在Spring容器初始化并启动的基础上加⼊各种扩展点,这些扩展点包括: ApplicationContextInitializer、ApplicationListener以及各种BeanFactoryPostProcessor等等。你对...

    概述

    上一篇我们介绍了SpringBoot的自动装配的知识,这一篇我们将介绍SpringBoot最核心的知识点,SpringBoot应用的启动过程。这个启动过程比较复杂,在此我只介绍核心的知识点。其启动过程大概分为两步。1. 初始化SpringApplication对象,2.执行SpringApplication对象的run方法。

    SpringBoot启动流程图(以SpringBoot 1.5.8.RELEASE为例)

    在这里插入图片描述
    那我们就根据上面的启动流程图进行分析。

    初始化SpingApplication对象

    我们直接找到初始化SpingApplication对象的initialize方法。

    	private void initialize(Object[] sources) {
    		if (sources != null && sources.length > 0) {
    			this.sources.addAll(Arrays.asList(sources));
    		}
    		//检查当前环境是否是web环境
    		this.webEnvironment = deduceWebEnvironment();
    		//初始化ApplicationContextInitializer的实现类
    		setInitializers((Collection) getSpringFactoriesInstances(
    				ApplicationContextInitializer.class));
    		//初始化ApplicationListener的实现类
    		setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
    		this.mainApplicationClass = deduceMainApplicationClass();
    	}
    

    如上初始化SpringApplication对象,主要的步骤有两步

    1. 加载spring.factories中ApplicationContextInitializer的配置类
    2. 加载spring.factories中ApplicationListener的配置类
      都是通过SpringFactoriesLoader找到META-INF/spring.factories文件下配置了ApplicationContextInitializerApplicationListener两个接口的实现类,并且进行实例化。
      在这里插入图片描述
      其中ApplicationContextInitializer接口主要目的是ConfigurableApplicationContext做refresh之前,对ConfigurableApplicationContext实例做进一步的设置或处理。如下图所示:
    	protected void applyInitializers(ConfigurableApplicationContext context) {
    		for (ApplicationContextInitializer initializer : getInitializers()) {
    			Class<?> requiredType = GenericTypeResolver.resolveTypeArgument(
    					initializer.getClass(), ApplicationContextInitializer.class);
    			Assert.isInstanceOf(requiredType, context, "Unable to call initializer.");
    			initializer.initialize(context);
    		}
    	}
    

    ApplicationListener则是一个监听器,他是Spring框架对Java事件监听机制的⼀种框架实现。

    执行Run方法

    说完了初始化SpingApplication对象的过程,接下来让我们看看run()方法的执行逻辑。

    public ConfigurableApplicationContext run(String... args) {
    		StopWatch stopWatch = new StopWatch();
    		stopWatch.start();
    		ConfigurableApplicationContext context = null;
    		FailureAnalyzers analyzers = null;
    		//1
            SpringApplicationRunListeners listeners = getRunListeners(args);
    		listeners.starting();
    		try {
    			//2
    			ApplicationArguments applicationArguments = new DefaultApplicationArguments(
    					args);
    			ConfigurableEnvironment environment = prepareEnvironment(listeners,
    					applicationArguments);
    			//3
    			Banner printedBanner = printBanner(environment);
    			//4
    			context = createApplicationContext();
    			//5
    			analyzers = new FailureAnalyzers(context);
    			//6
    			prepareContext(context, environment, listeners, applicationArguments,
    					printedBanner);
    			//7
    			refreshContext(context);
    			//8
    			afterRefresh(context, applicationArguments);
    			//9
    			listeners.finished(context, null);
    			stopWatch.stop();
    			return context;
    		}
    		catch (Throwable ex) {
    			handleRunFailure(context, listeners, analyzers, ex);
    			throw new IllegalStateException(ex);
    		}
    

    如上,就是执行run方法的主要逻辑,主要分为9个步骤。

    1. 加载SpringApplicationRunListeners

    首先第一步是:通过SpringFactoriesLoader 到META-INF/spring.factories查找并加载所有的SpringApplicationRunListeners,通过start()方法通知所有的SpringApplicationRunListener,本质上这是一个事件发布者,他在SpringBoot应用启动的不同阶段会发布不同的事件类型。SpringApplicationRunListener接口只有一个实现类EventPublishingRunListener,也就是说SpringApplicationRunListeners类的List<SpringApplicationRunListener> listeners中只会生成一个EventPublishingRunListener实例。那么SpringApplicationRunListeners是如何发布事件类型的呢?首先我们看下SpringApplicationRunListener这个接口。

    public interface SpringApplicationRunListener {
    	/**
    	 * run方法刚执行时通知
    	 */
    	void starting();
    	/**
    	 * Called once the environment has been prepared, but before the
    	 * {@link ApplicationContext} has been created.
    		Environment准备好,ApplicationContext被创建好之前通知
    	 */
    	void environmentPrepared(ConfigurableEnvironment environment);
    	/**
    	 * Called once the {@link ApplicationContext} has been created and prepared, but
    	 * before sources have been loaded.
    		ApplicationContext被创建好之后,但是资源加载好之前通知
    	 */
    	void contextPrepared(ConfigurableApplicationContext context);
    	/**
    	 * Called once the application context has been loaded but before it has been
    	 * refreshed.
    ApplicationContext被加载好之后,但是没有被刷新之前通知
    	 */
    	void contextLoaded(ConfigurableApplicationContext context);
    	/**
    	 * Called immediately before the run method finishes.
    	 * @param context the application context or null if a failure occurred before the
    	 * context was created
    		应用启动完成之后通知
    	 */
    	void finished(ConfigurableApplicationContext context, Throwable exception);
    }
    

    如上我们看到SpringApplicationRunListener监听器SpringBoot应用启动的不同阶段都会有相应的监听通知。通知贯穿了SpringBoot应用启动的完成过程。我们以environmentPrepared通知为例看看,SpringApplicationRunListener是如何发布事件类型的,在其实现类EventPublishingRunListener中有属性名为initialMulticasterSimpleApplicationEventMulticaster实例。在environmentPrepared方法中调用了SimpleApplicationEventMulticastermulticastEvent方法,说明发布过程被委托给了SimpleApplicationEventMulticaster类,其中在multicastEvent方法中指定了相应的事件类型。

    	public void environmentPrepared(ConfigurableEnvironment environment) {
    		this.initialMulticaster.multicastEvent(new ApplicationEnvironmentPreparedEvent(
    				this.application, this.args, environment));
    	}
    

    2. 创建并配置当前应用将要使用的环境

    	private ConfigurableEnvironment prepareEnvironment(
    			SpringApplicationRunListeners listeners,
    			ApplicationArguments applicationArguments) {
    		// 获取创建的环境,如果没有则创建,如果是web环境则创建StandardServletEnvironment
    		ConfigurableEnvironment environment = getOrCreateEnvironment();
    		//配置Environment:配置profile以及properties
    		configureEnvironment(environment, applicationArguments.getSourceArgs());
    		//调⽤SpringApplicationRunListener的 environmentPrepared()⽅法,通知事件监听者:应⽤的Environment已经准备好
    		listeners.environmentPrepared(environment);
    		if (!this.webEnvironment) {
    			environment = new EnvironmentConverter(getClassLoader())
    					.convertToStandardEnvironmentIfNecessary(environment);
    		}
    		return environment;
    	}
    

    第二步是创建并配置当前应用的环境(Environment),Environment用于描述应用程序当前的运行环境,其抽象了两方面的内容:1. 配置文件(profile)和属性(properties),我们知道不同的环境(开发环境,测试环境,发布环境)可以使用不同的属性配置,这些属性配置可以从配置文件,环境变量,命令行参数等来源获取。因此,当Environment准备好之后,在整个应用的任何时候,都可以获取这些属性。
    所以,第二步的做的事情主要有如下三件:

    1. 获取创建的环境(Environment),如果没有则创建,如果是web环境则创建StandardServletEnvironment,如果不是的话则创建StandardEnvironment
    2. 配置环境(Environment):主要是配置profile和属性properties。
    3. 调用SpringApplicationRunListenerenvironmentPrepared方法,通知事件监听者:应用环境(Environment)已经准备好了。

    3.设置SpringBoot应用在启动时输出的Banner。

    第三步是设置SpringBoot应用在启动时输出的Banner,默认的Banner如下图所示:
    在这里插入图片描述
    当然我们也可以修改默认的Banner,修改的方法就是在resources下新建一个banner.txt文件,替换掉默认的banner

    4. 根据是否是web项目,来创建不同的ApplicationContext容器

    protected ConfigurableApplicationContext createApplicationContext() {
    		Class<?> contextClass = this.applicationContextClass;
    		if (contextClass == null) {
    				contextClass = Class.forName(this.webEnvironment
    						? DEFAULT_WEB_CONTEXT_CLASS : DEFAULT_CONTEXT_CLASS);
    			}
    		}
    		return (ConfigurableApplicationContext) BeanUtils.instantiate(contextClass);
    	}
    

    第四步是:创建不同的ApplicationContext容器;经过了前面的初始化SpingApplication对象的过程,我们就已经知道了当前应用的环境,那么如果是web应用,则创建AnnotationConfigEmbeddedWebApplicationContext对象,否则创建AnnotationConfigApplicationContext对象。

    5. 创建一系列的FailureAnalyzer

    	FailureAnalyzers(ConfigurableApplicationContext context, ClassLoader classLoader) {
    		this.classLoader = (classLoader == null ? context.getClassLoader() : classLoader);
    		this.analyzers = loadFailureAnalyzers(this.classLoader);
    		prepareFailureAnalyzers(this.analyzers, context);
    	}
    

    第五步是创建FailureAnalyzer的代码如上所示:创建的流程依然是通过SpringFactoriesLoader获取所有的FailureAnalyzer接口的实现类名称,然后创建对应的实例。FailureAnalyzer的作用是用于分析故障并提供相关的诊断信息。

    6. 初始化ApplicationContext

    前面第四步,我们已经创建好了与本应用环境相匹配的ApplicationContext实例,那么第六步,就是对ApplicationContext进行初始化了。这一步也是比较核心的一步。首先让我们来看看实现逻辑的相关代码:

    private void prepareContext(ConfigurableApplicationContext context,
    			ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,
    			ApplicationArguments applicationArguments, Banner printedBanner) {
    		//1. 将准备好的Environment设置给ApplicationContext
    		context.setEnvironment(environment);
    		postProcessApplicationContext(context);
    		//2. 遍历调用所有的ApplicationContextInitializer的  initialize()  方法来对已经创建好的 ApplicationContext 进行进一步的处理。
    		applyInitializers(context);
    		//3. 调用SpringApplicationRunListeners的 contextPrepared()  方法,通知所有的监听者,ApplicationContext已经准备完毕
    		listeners.contextPrepared(context);
    		//4. 将applicationArguments实例注入到IOC容器
    		context.getBeanFactory().registerSingleton("springApplicationArguments",
    				applicationArguments);
    		if (printedBanner != null) {
    			//5. 将printedBanner实例注入到IOC容器
    			context.getBeanFactory().registerSingleton("springBootBanner", printedBanner);
    		}
    		//6. 加载资源,这里的资源一般是启动类xxxApplication
    		Set<Object> sources = getSources();
    		//7. 将所有的bean加载到容器中
    		load(context, sources.toArray(new Object[sources.size()]));
    		//8. 调⽤SpringApplicationRunListener的 contextLoaded()⽅法,通知所有的监听者:ApplicationContext已经装载完毕
    		listeners.contextLoaded(context);
    	}
    
    

    如上就是初始化ApplicationContext的主要逻辑,主要有如下逻辑:

    1. 将准备好的Environment设置给ApplicationContext
    2. 遍历调用所有的ApplicationContextInitializerinitialize() 方法来对已经创建好的 ApplicationContext 进行进一步的处理。
    3. 调用SpringApplicationRunListenerscontextPrepared() 方法,通知所有的监听者,ApplicationContext已经准备完毕
    4. applicationArguments实例注入到IOC容器。
    5. printedBanner实例注入到IOC容器,这个就是第三步生成的Banner的实例。
    6. 加载资源,这里的资源一般是启动类xxxApplication
    7. 将所有的bean加载到容器中
    8. 调⽤SpringApplicationRunListenerscontextLoaded()⽅法,通知所有的监听者:ApplicationContext已经装载完毕。

    7. 调用ApplicationContext的refresh() 方法

    第七步就是调用ApplicationContext的refresh() 方法,完成IOC容器的最后一道工序,为何要刷新容器呢?主要就是插手容器的启动。这里的 SpringApplicationrefresh方法最终还是调用到AbstractApplicationContextrefresh方法。
    说到AbstractApplicationContextrefresh方法,就要回到我们前面说的Bean的生命周期。一个是BeanFactoryProcessor接口,用于插手容器的初始化。另外一个是BeanPostProcessor接口,用于插手Bean的实例化。

    8.查找当前context中是否注册

    查找当前context中是否注册有CommandLineRunner和ApplicationRunner,
    如果有则遍历执行它们。

    9.执行所有SpringApplicationRunListener的finished() 方法

    对run方法的断点调试

    1. 1.5.8 版本的
      在这里插入图片描述
    2. 2.1.3 版本的
      在这里插入图片描述

    总结

    这就是Spring Boot的整个启动流程,其核⼼就是在Spring容器初始化并启动的基础上加⼊各种扩展点,这些扩展点包括:
    ApplicationContextInitializer、ApplicationListener以及各种BeanFactoryPostProcessor等等。你对整个流程的细节不必太过关注,你只要理解这些扩展点是在何时如何⼯作的,能让它们为你所⽤即可。

    展开全文
  • SpringBoot启动过程原理一

    万次阅读 多人点赞 2018-06-06 12:20:35
    1.1 Springboot启动: @SpringBootApplication public class ServerApplication { public static void main(String[] args) { SpringApplication.run(ServerApplication.class,args); } } 从上面代码看,调用了...
  • Springboot介绍 Springboot并不是一个新的功能框架,...Springboot启动离不开@SpringBootApplication注解,它为SpringApplication上下文的各类Bean加载提供了很大的支持 @SpringBootApplication注解 @SpringBootApplic
  • 前言 前一篇分析了SpringBoot如何启动以及内置web容器,这篇我们一起看一下SpringBoot的整个启动过程,废话不多说,正文开始。 正文
  • SpringBoot启动过程分析

    2020-12-20 16:51:22
    SpringBoot启动过程分析 注意:本文分析的是SpringBoot的启动流程,关于自动装配,如何加载application.yml配置等内容在之后的文章分析。SpringBoot是基于Spring开发的,所以分析SpringBoot启动过程,就是在分析...
  • 主要介绍了SpringBoot启动及自动装配原理过程详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 项目启动入口 实际执行的内容是通过SpringApplication类的静态方法创建一个ConfigurableApplicationContext,顾名思义,即可配置的对象容器,也就是Springboot中的上下文 /** * Static helper that can be used to...
  • springboot启动过程(3)-refresh方法

    千次阅读 2019-07-18 22:25:56
    1 springboot启动的时候,会调用run方法,创建环境设置spring容器,其中包含refresh方法,完成配置类解析,各种beanFactoryPostProcess和beanPostProcessor注册,web内置容器构造,国际化配置初始化等,refresh调用...
  • 主要给大家介绍了关于SpringBoot项目启动时如何读取配置以及初始化资源的相关资料,文中通过示例代码介绍的非常详细,对大家的学习或者使用SpringBoot具有一定的参考学习价值,需要的朋友们下面来一起学习学习吧
  • 接上篇SpringBoot启动流程,有几个可以自定义扩展的点: 自定义初始化器:ApplicationContextInitializer 自定义监听器: ApplicationListener 自定义异常报告器:SpringBootExceptionReporter 自定义run方法(可以...
  • springboot启动过程中常用的回调 常用的回调接口 ApplicationContextInitializer ApplicationListener ApplicationRunner CommandLineRunner 示例 ApplicationContextInitializer接口是在spring容器初初始化...
  • 参考https://my.oschina.net/xiaoqiyiye/blog/1624181 SpringBoot初始化器和监听器 https://www.cnblogs.com/zhangxiaoguang/p/spring-notification.html Spring事件机制 ...
  • Spring Boot 学习笔记一(SpringBoot启动过程

    万次阅读 多人点赞 2017-04-10 09:12:41
    SpringBoot启动详解
  • SpringBoot启动过程图解

    千次阅读 2018-09-10 10:14:56
    最近看了一下SpringBoot启动过程源码,做了一个粗略的图解,在此记录下。 启动流程图 相关方法 initialize(Object[] sources)方法 设置webEnvironment; 获取ApplicationContextInitializer接口的...
  • 主要介绍了手动构建springBoot启动过程图解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • Springboot启动流程解析

    千次阅读 2022-03-01 15:57:53
    打印容器启动过程 18.listeners.started(context); 19.通过SpringApplicationRunListeners将运行状态回调 深度解读: 1.从配置文件加载子类-----SPI机制,减少耦合,增加可配置扩展 2.IOC容器的生成--IOC 3.加载监听...
  • SpringBoot启动流程

    千次阅读 2021-09-08 09:35:48
    SpringBoot启动过程主要分为bootstrapContext创建、环境准备、applicationContext准备、bean加载、runner调用五个步骤 SpringBoot启动过程分为操作线和事件线(图中蓝色标识),操作线包括上面的五个步骤,而事件线...
  • Springboot启动过程流程图记录留存
  • Springboot启动流程

    2022-02-27 08:13:19
    Springboot启动分为三个部分: 1、初始化阶段 此阶段会创建一个SpringApplication实例,并设置实例的资源、环境、监听器、构造器。 2、应用启动过程 该阶段会创建监听器模块、创建并设置环境实例(如果是servlet...
  • [springboot]springboot启动流程

    千次阅读 2021-05-06 18:51:09
    main里面调用SpringApplication.run()启动整个Spring Boot程序,该方法所在类需要使用@SpringBootApplication复合注解。 其中需要关注的是: @SpringBootApplication注解其实是包含了三个注解: @...
  • 1.SpringBoot的类加载顺序怎么能知道?...这要搞清楚SpringBoot启动过程,连Tomcat都是在run程序之后创建的,Spring容器更是之后了。在启动类中用注解为成员变量注入值,由于先加载成员变量,之后加载静态
  • 面试经常会问道springboot启动流程或者原理,看了多数博友的文章,都是大同小异,但是面试的时候不可能那么多,所以我将启动流程总结一下。 启动流程: 1.启动springboot这需要执行SpringApplication执行类即可 ...
  • SpringBoot启动全流程源码解析(超详细版)

    万次阅读 多人点赞 2020-11-04 20:30:09
    SpringBoot启动过程流程图 源码解析 大家不要抗拒源码解析,这个非常优秀的代码,我们如果能够学会对自己代码编写水平大有裨益 首先,我们先来看下SpringBoot项目的启动类 @SpringBootApplication public class ...
  • SpringBoot启动流程简述

    千次阅读 2020-08-31 14:39:35
    又回顾了springboot启动流量,有了新的理解,进行以下补充: 1、listeners.starting()等方法,第一次出现了误解,以为是启动监听器,但是我很奇怪监听器为什么要启动。再次看源码,才知道不同的方法是用来发布不同的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 73,485
精华内容 29,394
关键字:

springboot启动过程

spring 订阅