精华内容
下载资源
问答
  • 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启动过程

    2021-02-01 14:11:11
    Springboot启动过程 1.调用SpringApplication的Run方法 2.初始化SpringApplication时,实例化,上线文初始化器,和监听器jar包的spring.factories下的善想问 找到jar包下的ApplicationContextInitializer实现类和...

    Springboot启动过程
    1.调用SpringApplication的Run方法
    在这里插入图片描述
    2.初始化SpringApplication时,实例化,上线文初始化器,和监听器jar包的spring.factories下
    在这里插入图片描述
    找到jar包下的ApplicationContextInitializer实现类和ApplicationListener实现类,并实例化。
    在这里插入图片描述
    3.初始化后开始运行run方法

    public ConfigurableApplicationContext run(String... args) {
            //开启watch,统计启动时长
            StopWatch stopWatch = new StopWatch();
            stopWatch.start();
            DefaultBootstrapContext bootstrapContext = this.createBootstrapContext();
            ConfigurableApplicationContext context = null;
            this.configureHeadlessProperty();
            //listeners是SpringApplicationRunListener.class的实现类集合,其中SpringApplicationRunListener.class的实现类为EventPublishingRunListener,其中EventPublishingRunListener有广播机制,EventPublishingRunListener会将后续所有事件广播给其他ApplicationListeners。
            SpringApplicationRunListeners listeners = this.getRunListeners(args);
            //通知ApplicationListeners,广播事件。
            listeners.starting(bootstrapContext, this.mainApplicationClass);
    
            try {
                //初始化Applicationarguments,
                ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
                //创建配置环境,一些环境变量的配置
                ConfigurableEnvironment environment = this.prepareEnvironment(listeners, bootstrapContext, applicationArguments);
                //忽略信息配置
                this.configureIgnoreBeanInfo(environment);
                //打印,控制台信息Banneer的dayin
                Banner printedBanner = this.printBanner(environment);
                //创建应用上下文,创建环境时都会根据WebApplicationType创建环境和上下文,Springboot技术内幕69页。
                context = this.createApplicationContext();
                context.setApplicationStartup(this.applicationStartup);
                //准备上下文,主要有  a.对上下文设置环境变量  b.应用上下文后置处理 c.调用applicationContextInitializer初始化上下文.
                this.prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);
                //Spring上下文应用刷新,实例化,
                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) {
                this.handleRunFailure(context, var10, listeners);
                throw new IllegalStateException(var10);
            }
    
            try {
                listeners.running(context);
                return context;
            } catch (Throwable var9) {
                this.handleRunFailure(context, var9, (SpringApplicationRunListeners)null);
                throw new IllegalStateException(var9);
            }
        }
    
    EventPublishingRunListener代码如下:
    
    public class EventPublishingRunListener implements SpringApplicationRunListener, Ordered {
        // Spring上下文
        private final SpringApplication application;
        // main方法启动的参数
        private final String[] args;
        // 事件发送器
        private final SimpleApplicationEventMulticaster initialMulticaster;
     
        public EventPublishingRunListener(SpringApplication application, String[] args) {
            this.application = application;
            this.args = args;
            this.initialMulticaster = new SimpleApplicationEventMulticaster();
            for (ApplicationListener<?> listener : application.getListeners()) {
                this.initialMulticaster.addApplicationListener(listener);
            }
        }
        // 其余省略
    
    详见:https://blog.csdn.net/qq_16992475/article/details/109225816
    

    其中广播事件代码如下:
    观察者模式:https://www.runoob.com/design-pattern/observer-pattern.html,被观察者需要持有观察者的对象,当被观察者方法执行时,可执行观察者的方法。

    public void multicastEvent(final ApplicationEvent event, ResolvableType eventType) {
    		ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
            // getApplicationListeners获取当前event所有的监听器
    		for (final ApplicationListener<?> listener : getApplicationListeners(event, type)) {
    			Executor executor = getTaskExecutor();
    			if (executor != null) {
    				executor.execute(new Runnable() {
    					@Override
    					public void run() {
                            // 执行监听器的onApplicationEvent方法
    						invokeListener(listener, event);
    					}
    				});
    			}
    			else {
                    // 不存在executor的情况下,在这里执行监听器的onApplicationEvent方法
    				invokeListener(listener, event);
    			}
    		}
    	}
    详见,其中onApplicationEvent可自定义事件,写想要监听的事件,当然事件也可自己定义。
    其中调用上下文publishEvent广播时间,需要等到将监听器关联到上下文中,
    ContextLoaded方法中在Springboot指南61页。
    https://segmentfault.com/a/1190000011433514?utm_source=tag-newest
    

    prepareContext代码如下:

        private void prepareContext(DefaultBootstrapContext bootstrapContext, ConfigurableApplicationContext context, ConfigurableEnvironment environment, SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments, Banner printedBanner) {
            context.setEnvironment(environment);
            this.postProcessApplicationContext(context);
            this.applyInitializers(context);
            listeners.contextPrepared(context);
            bootstrapContext.close(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]));
            //完成上下文加载,将ApplicationListeners绑定到上下文中。上下文可执行,publishEvent发布事件,62页。
            listeners.contextLoaded(context);
        }
    

    执行完prepareContext后, Context中的bean如下:
    在这里插入图片描述
    其中主Source类完成加载。

    4.refreshContext
    1.准备刷新。
    2.初始化bean工厂。
    3.准备bean工厂
    4.对bean工厂设置后置处理器
    5.调用bean工厂的后置处理器,并实例化bean。
    6.注册beanPostProcessor
    7.注册multicaster
    8.创建内置的Servlet容器
    9.registerListeners给容器注册listeners。之后容器可广播事件。
    10.完成BeanFactory初始化,初始化剩余单例bean。
    11.广播完成事件。

    @Override
    public void refresh() throws BeansException, IllegalStateException {
    	synchronized (this.startupShutdownMonitor) {
    	    // 准备刷新
    	    prepareRefresh();
     
    	    // 通知子类刷新内部bean工厂
    	    ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
     
    	    // 准备bean工厂以便在此上下文中使用
    	    prepareBeanFactory(beanFactory);
     
    	    try {
    	    	// 允许上下文子类中对bean工厂进行后处理
    	    	postProcessBeanFactory(beanFactory);
     
    	    	// 在bean创建之前调用BeanFactoryPostProcessors后置处理方法
    	    	invokeBeanFactoryPostProcessors(beanFactory);
     
    	    	// 注册BeanPostProcessor
    	    	registerBeanPostProcessors(beanFactory);
     
    	    	// 注册DelegatingMessageSource
    	    	initMessageSource();
     
    	    	// 注册multicaster
    	    	initApplicationEventMulticaster();
     
    	    	// 创建内置的Servlet容器
    	    	onRefresh();
     
    	    	// 注册Listener
    	    	registerListeners();
     
    	    	// 完成BeanFactory初始化,初始化剩余单例bean
    	    	finishBeanFactoryInitialization(beanFactory);
     
    	    	// 发布对应事件
    	    	finishRefresh();
    	    }
     
    	    catch (BeansException ex) {
    	    	if (logger.isWarnEnabled()) {
    	    		logger.warn("Exception encountered during context initialization - " +
    	    					"cancelling refresh attempt: " + ex);
    	    	}
     
    	    	// Destroy already created singletons to avoid dangling resources.
    	    	destroyBeans();
     
    	    	// Reset 'active' flag.
    	    	cancelRefresh(ex);
     
    	    	// Propagate exception to caller.
    	    	throw ex;
    	    }
     
    	    finally {
    	    	// Reset common introspection caches in Spring's core, since we
    	    	// might not ever need metadata for singleton beans anymore...
    	    	resetCommonCaches();
    	    }
        }
    }
    

    整体关键流程简要理解:

    1. 运行SpringApplication.run初始化,完成Spring.factories下的创建监听器类和上下文初始化类的加载,并实例化。
    2. 创建配置环境,一些环境变量的配置
    3. 打印banner
    4. 创建上下文,准备上下文。
      5…初始化bean工厂,准备bean工厂
      6.对bean工厂设置后置处理器
      7.调用bean工厂的后置处理器,并实例化bean。
      8.注册beanPostProcessor
      8.创建内置的Servlet容器
      9.注册listeners到容器中
      10.实例化所有懒加载单例
      11.广播完成事件。
    展开全文
  • SpringBoot 启动过程

    2017-09-29 00:57:04
    SpringBoot 启动过程  @SpringBootApplication SpringApplication.run(SpringbootlearnApplication.class, args);    主启动类, 一个SpringBootApplication 一个SpringApplication  发现...

    SpringBoot 启动过程

     

    @SpringBootApplication

    SpringApplication.run(SpringbootlearnApplication.class, args);
    								

     

     

    主启动类, 一个SpringBootApplication 一个SpringApplication

     

    发现SpringBootApplication可以拆分为三个annotation

    @Configuration
    @EnableAutoConfiguration
    @ComponentScan

     

    分别解释:

    1@Configuration

    相当于JavaConfig格式的xml注解 ,可以看下列例子

    一个javaBean一个xml形式

    2@ComponentScan

    @ComponentScan这个注解在Spring中很重要,它对应XML配置中的元素,@ComponentScan的功能其实就是自动扫描并加载符合条件的组件(比如@Component@Repository等)或者bean定义,最终将这些bean定义加载到IoC容器中。

    我们可以通过basePackages等属性来细粒度的定制@ComponentScan自动扫描的范围,如果不指定,则默认Spring框架实现会从声明@ComponentScan所在类的package进行扫描。

    注:所以SpringBoot的启动类最好是放在root package下,因为默认不指定basePackages

    3@EnableAutoConfiguration

    算是最重要的一个ANNOTATION了

     

    @EnableAutoConfiguration的理念和做事方式其实一脉相承,简单概括一下就是,借助@Import的支持,收集和注册特定场景相关的bean定义

     

    打开 @EnableAutoCOnfiguration

    最终要的是 Import

    @Import(EnableAutoConfigurationImportSelector.class),借助EnableAutoConfigurationImportSelector@EnableAutoConfiguration可以帮助SpringBoot应用将所有符合条件的@Configuration配置都加载到当前SpringBoot创建并使用的IoC容器。就像一只"八爪鱼"一样

    1 如果我们使用的是SpringApplication的静态run方法,那么,这个方法里面首先要创建一个SpringApplication对象实例,然后调用这个创建好的SpringApplication的实例方法。在SpringApplication实例初始化的时候,它会提前做几件事情:

    • 根据classpath里面是否存在某个特征类(org.springframework.web.context.ConfigurableWebApplicationContext)来决定是否应该创建一个为Web应用使用的ApplicationContext类型。
    • 使用SpringFactoriesLoader在应用的classpath中查找并加载所有可用的ApplicationContextInitializer
    • 使用SpringFactoriesLoader在应用的classpath中查找并加载所有可用的ApplicationListener
    • 推断并设置main方法的定义类。

    2 SpringApplication实例初始化完成并且完成设置后,就开始执行run方法的逻辑了,方法执行伊始,首先遍历执行所有通过SpringFactoriesLoader可以查找到并加载的SpringApplicationRunListener。调用它们的started()方法,告诉这些SpringApplicationRunListener"嘿,SpringBoot应用要开始执行咯!"

    3 创建并配置当前Spring Boot应用将要使用的Environment(包括配置要使用的PropertySource以及Profile)。

    4 遍历调用所有SpringApplicationRunListenerenvironmentPrepared()的方法,告诉他们:"当前SpringBoot应用使用的Environment准备好了咯!"

    5 如果SpringApplicationshowBanner属性被设置为true,则打印banner

    6 根据用户是否明确设置了applicationContextClass类型以及初始化阶段的推断结果,决定该为当前SpringBoot应用创建什么类型的ApplicationContext并创建完成,然后根据条件决定是否添加ShutdownHook,决定是否使用自定义的BeanNameGenerator,决定是否使用自定义的ResourceLoader,当然,最重要的,将之前准备好的Environment设置给创建好的ApplicationContext使用。

    7 ApplicationContext创建好之后,SpringApplication会再次借助Spring-FactoriesLoader,查找并加载classpath中所有可用的ApplicationContext-Initializer,然后遍历调用这些ApplicationContextInitializerinitializeapplicationContext)方法来对已经创建好的ApplicationContext进行进一步的处理。

    8 遍历调用所有SpringApplicationRunListenercontextPrepared()方法。

    9 最核心的一步,将之前通过@EnableAutoConfiguration获取的所有配置以及其他形式的IoC容器配置加载到已经准备完毕的ApplicationContext

    10 遍历调用所有SpringApplicationRunListenercontextLoaded()方法。

    11 调用ApplicationContextrefresh()方法,完成IoC容器可用的最后一道工序。

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

    13 正常情况下,遍历执行SpringApplicationRunListenerfinished()方法、(如果整个过程出现异常,则依然调用所有SpringApplicationRunListenerfinished()方法,只不过这种情况下会将异常信息一并传入处理)

     

    Thymeleaf模板引擎

    Thymeleaf是一款用于渲染XML/XHTML/HTML5内容的模板引擎。类似JSPVelocityFreeMaker等,它也可以轻易的与Spring MVCWeb框架进行集成作为Web应用的模板引擎。与其它模板引擎相比,Thymeleaf最大的特点是能够直接在浏览器中打开并正确显示模板页面,而不需要启动整个Web应用。它的功能特性如下:

    • Spring MVC@Controller中的方法可以直接返回模板名称,接下来Thymeleaf模板引擎会自动进行渲染
    • 模板中的表达式支持Spring表达式语言(Spring EL)
    • 表单支持,并兼容Spring MVC的数据绑定与验证机制
    • 国际化支持

    Spring官方也推荐使用Thymeleaf,所以本篇代码整合就使用Thymeleaf来整合。

     

     

    浏览器输入http://localhost:8989/learn/test

     

    1. templates 里面的 controller可以自动跳转
    2. webapp里也可以

     

     

    对于JSP渲染

    依赖的jar包

    展开全文
  • springboot启动过程

    2020-04-14 14:10:38
    上图为SpringBoot启动结构图,我们发现启动流程主要分为三个部分,第一部分进行SpringApplication的初始化模块,配置一些基本的环境变量、资源、构造器、监听器,第二部分实现了应用具体的启动方案,包括启动流程的...

          上图为SpringBoot启动结构图,我们发现启动流程主要分为三个部分,第一部分进行SpringApplication的初始化模块,配置一些基本的环境变量、资源、构造器、监听器,第二部分实现了应用具体的启动方案,包括启动流程的监听模块、加载配置环境模块、及核心的创建上下文环境模块,第三部分是自动化配置模块,该模块作为springboot自动配置核心,在后面的分析中会详细讨论。在下面的启动程序中我们会串联起结构中的主要功能。

    启动:

          每个SpringBoot程序都有一个主入口,也就是main方法,main里面调用SpringApplication.run()启动整个spring-boot程序,该方法所在类需要使用@SpringBootApplication注解,以及@ImportResource注解(if need),@SpringBootApplication包括三个注解,功能如下:@EnableAutoConfiguration:SpringBoot根据应用所声明的依赖来对Spring框架进行自动配置

    @SpringBootConfiguration(内部为@Configuration):被标注的类等于在spring的XML配置文件中(applicationContext.xml),装配所有bean事务,提供了一个spring的上下文环境

    @ComponentScan:组件扫描,可自动发现和装配Bean,默认扫描SpringApplication的run方法里的Booter.class所在的包路径下文件,所以最好将该启动类放到根包路径下

    SpringBoot启动类

    首先进入run方法

     

    run方法中去创建了一个SpringApplication实例,在该构造方法内,我们可以发现其调用了一个初始化的initialize方法

     

     

    这里主要是为SpringApplication对象赋一些初值。构造函数执行完毕后,我们回到run方法

     

    该方法中实现了如下几个关键步骤:

    1.创建了应用的监听器SpringApplicationRunListeners并开始监听

    2.加载SpringBoot配置环境(ConfigurableEnvironment),如果是通过web容器发布,会加载StandardEnvironment,其最终也是继承了ConfigurableEnvironment,类图如下

     

    可以看出,*Environment最终都实现了PropertyResolver接口,我们平时通过environment对象获取配置文件中指定Key对应的value方法时,就是调用了propertyResolver接口的getProperty方法

    3.配置环境(Environment)加入到监听器对象中(SpringApplicationRunListeners)

    4.创建run方法的返回对象:ConfigurableApplicationContext(应用配置上下文),我们可以看一下创建方法:

     

    方法会先获取显式设置的应用上下文(applicationContextClass),如果不存在,再加载默认的环境配置(通过是否是web environment判断),默认选择AnnotationConfigApplicationContext注解上下文(通过扫描所有注解类来加载bean),最后通过BeanUtils实例化上下文对象,并返回,ConfigurableApplicationContext类图如下:

     

    主要看其继承的两个方向:

    LifeCycle:生命周期类,定义了start启动、stop结束、isRunning是否运行中等生命周期空值方法

    ApplicationContext:应用上下文类,其主要继承了beanFactory(bean的工厂类)

    5.回到run方法内,prepareContext方法将listeners、environment、applicationArguments、banner等重要组件与上下文对象关联

    6.接下来的refreshContext(context)方法(初始化方法如下)将是实现spring-boot-starter-*(mybatis、redis等)自动化配置的关键,包括spring.factories的加载,bean的实例化等核心工作。

    refresh方法

    配置结束后,Springboot做了一些基本的收尾工作,返回了应用环境上下文。回顾整体流程,Springboot的启动,主要创建了配置环境(environment)、事件监听(listeners)、应用上下文(applicationContext),并基于以上条件,在容器中开始实例化我们需要的Bean,至此,通过SpringBoot启动的程序已经构造完成,接下来我们来探讨自动化配置是如何实现。


    自动化配置:

           之前的启动结构图中,我们注意到无论是应用初始化还是具体的执行过程,都调用了SpringBoot自动配置模块

    SpringBoot自动配置模块

           该配置模块的主要使用到了SpringFactoriesLoader,即Spring工厂加载器,该对象提供了loadFactoryNames方法,入参为factoryClass和classLoader,即需要传入上图中的工厂类名称和对应的类加载器,方法会根据指定的classLoader,加载该类加器搜索路径下的指定文件,即spring.factories文件,传入的工厂类为接口,而文件中对应的类则是接口的实现类,或最终作为实现类,所以文件中一般为如下图这种一对多的类名集合,获取到这些实现类的类名后,loadFactoryNames方法返回类名集合,方法调用方得到这些集合后,再通过反射获取这些类的类对象、构造方法,最终生成实例

    工厂接口与其若干实现类接口名称

    下图有助于我们形象理解自动配置流程

    SpringBoot自动化配置关键组件关系图 

          mybatis-spring-boot-starter、spring-boot-starter-web等组件的META-INF文件下均含有spring.factories文件,自动配置模块中,SpringFactoriesLoader收集到文件中的类全名并返回一个类全名的数组,返回的类全名通过反射被实例化,就形成了具体的工厂实例,工厂实例来生成组件具体需要的bean。

    之前我们提到了EnableAutoConfiguration注解,其类图如下

     

    可以发现其最终实现了ImportSelector(选择器)和BeanClassLoaderAware(bean类加载器中间件),重点关注一下AutoConfigurationImportSelector的selectImports方法

     

    该方法在springboot启动流程——bean实例化前被执行,返回要实例化的类信息列表。我们知道,如果获取到类信息,spring自然可以通过类加载器将类加载到jvm中,现在我们已经通过spring-boot的starter依赖方式依赖了我们需要的组件,那么这些组建的类信息在select方法中也是可以被获取到的,不要急我们继续向下分析

     

    该方法中的getCandidateConfigurations方法,通过方法注释了解到,其返回一个自动配置类的类名列表,方法调用了loadFactoryNames方法,查看该方法

     

    在上面的代码可以看到自动配置器会跟根据传入的factoryClass.getName()到项目系统路径下所有的spring.factories文件中找到相应的key,从而加载里面的类。我们就选取这个mybatis-spring-boot-autoconfigure下的spring.factories文件

     

    进入org.mybatis.spring.boot.autoconfigure.MybatisAutoConfiguration中,主要看一下类头

     

    发现@Spring的Configuration,俨然是一个通过注解标注的springBean,继续向下看,

    @ConditionalOnClass({ SqlSessionFactory.class, SqlSessionFactoryBean.class})这个注解的意思是:当存在SqlSessionFactory.class, SqlSessionFactoryBean.class这两个类时才解析MybatisAutoConfiguration配置类,否则不解析这一个配置类,make sence,我们需要mybatis为我们返回会话对象,就必须有会话工厂相关类

    @CondtionalOnBean(DataSource.class):只有处理已经被声明为bean的dataSource

    @ConditionalOnMissingBean(MapperFactoryBean.class)这个注解的意思是如果容器中不存在name指定的bean则创建bean注入,否则不执行(该类源码较长,篇幅限制不全粘贴)

           以上配置可以保证sqlSessionFactory、sqlSessionTemplate、dataSource等mybatis所需的组件均可被自动配置,@Configuration注解已经提供了Spring的上下文环境,所以以上组件的配置方式与Spring启动时通过mybatis.xml文件进行配置起到一个效果。通过分析我们可以发现,只要一个基于SpringBoot项目的类路径下存在SqlSessionFactory.class, SqlSessionFactoryBean.class,并且容器中已经注册了dataSourceBean,就可以触发自动化配置,意思说我们只要在maven的项目中加入了mybatis所需要的若干依赖,就可以触发自动配置,但引入mybatis原生依赖的话,每集成一个功能都要去修改其自动化配置类,那就得不到开箱即用的效果了。所以Spring-boot为我们提供了统一的starter可以直接配置好相关的类,触发自动配置所需的依赖(mybatis)如下:

     

    这里是截取的mybatis-spring-boot-starter的源码中pom.xml文件中所有依赖:

     

    因为maven依赖的传递性,我们只要依赖starter就可以依赖到所有需要自动配置的类,实现开箱即用的功能。也体现出Springboot简化了Spring框架带来的大量XML配置以及复杂的依赖管理,让开发人员可以更加关注业务逻辑的开发

     

    展开全文
  • springBoot启动过程

    2019-05-18 10:47:04
    一、启动过程 (一)、new SpringApplication 1、判断是否为web环境 2、从spring.factories中加载: key = ApplicationContextInitializer 注:改接口是执行refresh()方法之前调用 3、从spring.factories中...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,805
精华内容 1,122
关键字:

springboot启动过程

spring 订阅