1.1 Springboot启动：
@SpringBootApplication public class ServerApplication { public static void main(String[] args) { SpringApplication.run(ServerApplication.class,args); } }
从上面代码看，调用了SpringApplication的静态方法run。这个run方法会构造一个SpringApplication的实例，然后再调用这里实例的run方法就表示启动SpringBoot。具体对象处理流程看下边时序图：
概述：
构造SpringApplication的实例（时序图步骤1-2）
调用SpringApplication.run()方法（时序图步骤3）
构造SpringApplicationRunListeners 实例（时序图步骤3.1.1）
发布ApplicationStartedEvent事件（时序图步骤3.1.2）
SpringApplicationRunListeners 实例准备环境信息（时序图步骤3.1.3）
创建ApplicationContext对象（时序图步骤3.1.4）
ApplicationContext实例准备环境信息（时序图步骤3.1.5）
刷新的上下文（时序图步骤3.1.6）
注：文章按照该顺序讲解【1.2 启动加载过程分析】
时序图：
1.2 启动加载过程分析
1.2.1 构造SpringApplication的实例（时序图步骤1-2）
代码
public static ConfigurableApplicationContext run(Object[] sources, String[] args) { // 步骤1 return new SpringApplication(sources).run(args); } public SpringApplication(Object... sources) { // 步骤1.1 initialize(sources); } @SuppressWarnings({ "unchecked", "rawtypes" }) private void initialize(Object[] sources) { if (sources != null && sources.length > 0) { this.sources.addAll(Arrays.asList(sources)); } this.webEnvironment = deduceWebEnvironment(); //加载META-INF/spring.factories路径ApplicationContextInitializer.class getSpringFactoriesInstances( ApplicationContextInitializer.class)); setListeners((Collection) //加载META-INF/spring.factories路径ApplicationListener.class getSpringFactoriesInstances(ApplicationListener.class)); this.mainApplicationClass = deduceMainApplicationClass(); }
1.2.2 步骤3.1.1:
代码
private SpringApplicationRunListeners getRunListeners(String[] args) { Class<?>[] types = new Class<?>[] { SpringApplication.class, String[].class }; // (1) return new SpringApplicationRunListeners(logger, getSpringFactoriesInstances( SpringApplicationRunListener.class, types, this, args)); }
分析
(1). 通过ClassLoader.getResources加载META-INF/spring.factories路径下的
文件信息，从中找key为SpringApplicationRunListener对应类，并实例化。
1.2.3 步骤3.1.2：
代码
public void starting() { for (SpringApplicationRunListener listener : this.listeners) { listener.starting(); } } @Override @SuppressWarnings("deprecation") public void starting() { this.initialMulticaster.multicastEvent(new ApplicationStartedEvent(this.application, this.args)); }
分析
发布ApplicationStartedEvent事件。
1.2.4 步骤3.1.3：
代码
private ConfigurableEnvironment prepareEnvironment( SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments) { // Create and configure the environment // ⑴. 得到环境对象ConfigurableEnvironment，没有则创建一个StandardServletEnvironment ConfigurableEnvironment environment = getOrCreateEnvironment(); // ⑵. 配置环境信息（激活环境，通过从系统环境变量里取） configureEnvironment(environment, applicationArguments.getSourceArgs()); // ⑶. 发布ApplicationEnvironmentPreparedEvent事件，加载配置文件，具体请看（ConfigFileApplicationListener）。 listeners.environmentPrepared(environment); if (isWebEnvironment(environment) && !this.webEnvironment) { environment = convertToStandardEnvironment(environment); } return environment; } protected void configureEnvironment(ConfigurableEnvironment environment,String[] args) { configurePropertySources(environment, args); // 配置ConfigurableEnvironment中的激活属性 configureProfiles(environment, args); } protected void configureProfiles(ConfigurableEnvironment environment, String[] args) { environment.getActiveProfiles(); // ensure they are initialized // additionalProfiles是项目启动时在main中SpringApplication.setAdditionalProfiles("")配置的 Set<String> profiles = new LinkedHashSet<>(this.additionalProfiles); // 获取环境变量中设置的spring.profiles.active属性 profiles.addAll(Arrays.asList(environment.getActiveProfiles())); // 赋值 activeProfiles environment.setActiveProfiles(StringUtils.toStringArray(profiles)); }
分析
⑴. 得到环境对象ConfigurableEnvironment，没有则创建一个StandardServletEnvironment
⑵. 配置激活环境信息，通过从系统环境变量里取或启动时通过SpringApplication.setAdditionalProfiles("")添加进来的
⑶. 发布ApplicationEnvironmentPreparedEvent事件，加载Spring配置文件信息，例如application.properties等。具体请看Spring Boot 属性文件（三）
步骤3.1.4：
分析
创建ApplicationContext对象 ，本文启动的是SERVLET所以会创建AnnotationConfigServletWebServerApplicationContext对象
protected ConfigurableApplicationContext createApplicationContext() { Class<?> contextClass = this.applicationContextClass; if (contextClass == null) { try { switch (this.webApplicationType) { case SERVLET: contextClass = Class.forName(DEFAULT_SERVLET_WEB_CONTEXT_CLASS); break; case REACTIVE: contextClass = Class.forName(DEFAULT_REACTIVE_WEB_CONTEXT_CLASS); break; default: contextClass = Class.forName(DEFAULT_CONTEXT_CLASS); } } catch (ClassNotFoundException ex) { throw new IllegalStateException( "Unable create a default ApplicationContext, " + "please specify an ApplicationContextClass",ex); } } return (ConfigurableApplicationContext) BeanUtils.instantiateClass(contextClass); } public AnnotationConfigServletWebServerApplicationContext() { this.reader = new AnnotatedBeanDefinitionReader(this); this.scanner = new ClassPathBeanDefinitionScanner(this); }
会创建AnnotatedBeanDefinitionReader对象检测是否需要将一下对象放到Spring上下文中
// 用户配置Configuration注解，实现了BeanDefinitionRegistryPostProcessor接口，在容器刷新时，处理后置工厂处理器用来扫描Spring，注册Bean ConfigurationClassPostProcessor // 用于配置Autowired注解，实现了MergedBeanDefinitionPostProcessor接口 AutowiredAnnotationBeanPostProcessor // 用于配置Required注解，实现了MergedBeanDefinitionPostProcessor接口 RequiredAnnotationBeanPostProcessor // 用于配置JSR-250注解，实现了InstantiationAwareBeanPostProcessor接口 CommonAnnotationBeanPostProcessor // 用于配置JPA注解 PersistenceAnnotationBeanPostProcessor // 用于配置EventListener注解，实现了SmartInitializingSingleton接口 EventListenerMethodProcessor // EventListener工厂 DefaultEventListenerFactory
步骤3.1.5：
代码
private void prepareContext(ConfigurableApplicationContext context, ConfigurableEnvironment environment, SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments, Banner printedBanner) { // ⑴.对ApplicationContext设置环境变量； context.setEnvironment(environment); // ⑵.配置属性ResourceLoader和ClassLoader属性； postProcessApplicationContext(context); // ⑶.循环初始化继承ApplicationContextInitializer接口的类 applyInitializers(context); listeners.contextPrepared(context); if (this.logStartupInfo) { logStartupInfo(context.getParent() == null); logStartupProfileInfo(context); } // Add boot specific singleton beans context.getBeanFactory().registerSingleton("springApplicationArguments", applicationArguments); if (printedBanner != null) { context.getBeanFactory().registerSingleton("springBootBanner", printedBanner); } // Load the sources Set<Object> sources = getSources(); Assert.notEmpty(sources, "Sources must not be empty"); load(context, sources.toArray(new Object[sources.size()])); listeners.contextLoaded(context); } @Override public void setEnvironment(ConfigurableEnvironment environment) { super.setEnvironment(environment); this.reader.setEnvironment(environment); this.scanner.setEnvironment(environment); }
分析：
⑴.对ApplicationContext设置环境变量；
⑵.配置属性ResourceLoader和ClassLoader属性；
⑶.调用步骤1查询出来ApplicationContextInitializer子类，循环调用initialize()方法。
@SuppressWarnings({ "rawtypes", "unchecked" })
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);
}
}
⑷.发布ApplicationPreparedEvent事件。
步骤3.1.6
代码：
@Override public void refresh() throws BeansException, IllegalStateException { synchronized (this.startupShutdownMonitor) { // ⑴.准备刷新的上下文环境 prepareRefresh(); // ⑵.初始化BeanFactory ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory(); // ⑶.对BeanFactory进行各种功能填充 prepareBeanFactory(beanFactory); try { // ⑷.子类覆盖方法做额外的处理 postProcessBeanFactory(beanFactory); // ⑸.激活各种BeanFactory处理器 invokeBeanFactoryPostProcessors(beanFactory); // ⑹.注册拦截Bean创建的Bean处理，这里只是注册，真正调用是再拿去Bean的时候 registerBeanPostProcessors(beanFactory); // ⑺.为上下文初始化Message源，即不同语言的消息体，国际化处理 initMessageSource(); // ⑻.初始化应用消息广播器，并放到applicationEventMulticaster bean中 initApplicationEventMulticaster(); // ⑼.留给子类来初始化其他bean onRefresh(); // ⑽.在所有注册的bean中查找Listener bean，注册到消息广播中 registerListeners(); // ⑾.初始化剩下的单实例（非惰性） finishBeanFactoryInitialization(beanFactory); // ⑿.完成刷新过程，通知生命周期处理器lifecycleProcessor刷新过程，同时发出ContextRefreshEvent通知别人 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(); } } }
分析：
⑴.准备刷新的上下文环境
⑵.初始化BeanFactory
⑶.对BeanFactory进行各种功能填充
⑷.子类覆盖方法做额外的处理，这里会调用子类AnnotationConfigServletWebServerApplicationContext注入
⑸.激活各种BeanFactory处理器
⑹.注册拦截Bean创建的Bean处理，这里只是注册，真正调用是再拿去Bean的时候
⑺.为上下文初始化Message源，即不同语言的消息体，国际化处理
⑻.初始化事件派发器，并放到applicationEventMulticaster bean中
⑼.留给子类来初始化其他bean
⑽.在所有注册的bean中查找Listener bean，注册到事件派发器中
⑾.初始化剩下的单实例（非惰性）
⑿.完成刷新过程，通知生命周期处理器lifecycleProcessor刷新过程，同时发出ContextRefreshEvent通知别人
⑷.子类覆盖方法做额外的处理
@Override protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) { super.postProcessBeanFactory(beanFactory); if (this.basePackages != null && this.basePackages.length > 0) { this.scanner.scan(this.basePackages); } if (!this.annotatedClasses.isEmpty()) { this.reader.register(ClassUtils.toClassArray(this.annotatedClasses)); } } @Override protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) { // 添加后置处理器，在创建Tomcat时会利用这个后置处理器来初始化Tomcat Server类 beanFactory.addBeanPostProcessor( new WebApplicationContextServletContextAwareProcessor(this)); beanFactory.ignoreDependencyInterface(ServletContextAware.class); registerWebApplicationScopes(); }
添加后置处理器，在创建Tomcat时会利用这个后置处理器来初始化Tomcat Server类
⑸.激活各种BeanFactory处理器
主要利用**步骤3.1.4：**创建AnnotatedBeanDefinitionReader对象往Spring容器中注入的ConfigurationClassPostProcessor来处理组件的注入
具体请看容器刷新，
⑺.为上下文初始化Message源，即不同语言的消息体，国际化处理
protected void initMessageSource() { ConfigurableListableBeanFactory beanFactory = getBeanFactory(); if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) { this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class); // Make MessageSource aware of parent MessageSource. if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) { HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource; if (hms.getParentMessageSource() == null) { // Only set parent context as parent MessageSource if no parent MessageSource // registered already. hms.setParentMessageSource(getInternalParentMessageSource()); } } if (logger.isDebugEnabled()) { logger.debug("Using MessageSource [" + this.messageSource + "]"); } } else { // // Use empty MessageSource to be able to accept getMessage calls. DelegatingMessageSource dms = new DelegatingMessageSource(); dms.setParentMessageSource(getInternalParentMessageSource()); this.messageSource = dms; beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource); if (logger.isDebugEnabled()) { logger.debug("Unable to locate MessageSource with name '" + MESSAGE_SOURCE_BEAN_NAME + "': using default [" + this.messageSource + "]"); } } }
如果容器中没有则创建一个DelegatingMessageSource国际化，并将它注册到Spring容器中
⑻.初始化事件派发器，并放到applicationEventMulticaster bean中
protected void initApplicationEventMulticaster() { ConfigurableListableBeanFactory beanFactory = getBeanFactory(); if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) { this.applicationEventMulticaster = beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class); if (logger.isDebugEnabled()) { logger.debug("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]"); } } else { this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory); beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster); if (logger.isDebugEnabled()) { logger.debug("Unable to locate ApplicationEventMulticaster with name '" + APPLICATION_EVENT_MULTICASTER_BEAN_NAME + "': using default [" + this.applicationEventMulticaster + "]"); } } }
如果容器中没有则创建一个SimpleApplicationEventMulticaster事件派发器，并将它注册到Spring容器中
⑼.留给子类来初始化其他bean
主要目的是初始化Tomcat等内置服务器
SpingBoot启动过程二
⑽.在所有注册的bean中查找Listener bean，注册到事件派发器中
protected void registerListeners() { // Register statically specified listeners first. for (ApplicationListener<?> listener : getApplicationListeners()) { getApplicationEventMulticaster().addApplicationListener(listener); } // Do not initialize FactoryBeans here: We need to leave all regular beans // uninitialized to let post-processors apply to them! // 从容器中获取所有的事件监听器，添加到事件派发器 String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false); for (String listenerBeanName : listenerBeanNames) { getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName); } // Publish early application events now that we finally have a multicaster... // 如果早期有些事件，则在此将其派发出去 Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents; this.earlyApplicationEvents = null; if (earlyEventsToProcess != null) { for (ApplicationEvent earlyEvent : earlyEventsToProcess) { getApplicationEventMulticaster().multicastEvent(earlyEvent); } } }
⑾.初始化剩下的单实例（非惰性）
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) { if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) && beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) { beanFactory.setConversionService( beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)); } if (!beanFactory.hasEmbeddedValueResolver()) { beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal)); } String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false); for (String weaverAwareName : weaverAwareNames) { getBean(weaverAwareName); } beanFactory.setTempClassLoader(null); beanFactory.freezeConfiguration(); // 实例化单实例bean beanFactory.preInstantiateSingletons(); } @Override public void preInstantiateSingletons() throws BeansException { if (logger.isDebugEnabled()) { logger.debug("Pre-instantiating singletons in " + this); } // 获取容器中所有的Bean，实例化 List<String> beanNames = new ArrayList<>(this.beanDefinitionNames); for (String beanName : beanNames) { RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName); // 如果不是抽象，是单实例，并且不是懒加载 if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) { // 没有实现FactoryBean接口的Bean if (isFactoryBean(beanName)) { Object bean = getBean(FACTORY_BEAN_PREFIX + beanName); if (bean instanceof FactoryBean) { final FactoryBean<?> factory = (FactoryBean<?>) bean; boolean isEagerInit; if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) { isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>) ((SmartFactoryBean<?>) factory)::isEagerInit, getAccessControlContext()); } else { isEagerInit = (factory instanceof SmartFactoryBean && ((SmartFactoryBean<?>) factory).isEagerInit()); } if (isEagerInit) { getBean(beanName); } } } else { getBean(beanName); } } } // Trigger post-initialization callback for all applicable beans... for (String beanName : beanNames) { Object singletonInstance = getSingleton(beanName); if (singletonInstance instanceof SmartInitializingSingleton) { final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance; if (System.getSecurityManager() != null) { AccessController.doPrivileged((PrivilegedAction<Object>) () -> { smartSingleton.afterSingletonsInstantiated(); return null; }, getAccessControlContext()); } else { smartSingleton.afterSingletonsInstantiated(); } } } }
首先判断Bean不是抽象，是单实例，不是懒加载，再判断Bean没有实现FactoryBean，则调用getBean()方法创建Bean
1 getBean方法创建Bean
@Override public Object getBean(String name) throws BeansException { return doGetBean(name, null, null, false); } @SuppressWarnings("unchecked") protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType, @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException { final String beanName = transformedBeanName(name); Object bean; // Eagerly check singleton cache for manually registered singletons. Object sharedInstance = getSingleton(beanName); if (sharedInstance != null && args == null) { if (logger.isDebugEnabled()) { if (isSingletonCurrentlyInCreation(beanName)) { logger.debug("Returning eagerly cached instance of singleton bean '" + beanName + "' that is not fully initialized yet - a consequence of a circular reference"); } else { logger.debug("Returning cached instance of singleton bean '" + beanName + "'"); } } bean = getObjectForBeanInstance(sharedInstance, name, beanName, null); } else { ........省略 // 如果实现了dependsOn则现将dependsOn创建出来 String[] dependsOn = mbd.getDependsOn(); if (dependsOn != null) { for (String dep : dependsOn) { if (isDependent(beanName, dep)) { throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'"); } registerDependentBean(dep, beanName); try { getBean(dep); } catch (NoSuchBeanDefinitionException ex) { throw new BeanCreationException(mbd.getResourceDescription(), beanName, "'" + beanName + "' depends on missing bean '" + dep + "'", ex); } } } // 单实例Bean创建 if (mbd.isSingleton()) { sharedInstance = getSingleton(beanName, () -> { try { return createBean(beanName, mbd, args); } catch (BeansException ex) { destroySingleton(beanName); throw ex; } }); bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd); } } }
1.1 createBean
@Override protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException { ....省略 try { // 处理InstantiationAwareBeanPostProcessor类型的后置处理器 Object bean = resolveBeforeInstantiation(beanName, mbdToUse); if (bean != null) { return bean; } } catch (Throwable ex) { } try { // 创建Bean Object beanInstance = doCreateBean(beanName, mbdToUse, args); if (logger.isDebugEnabled()) { logger.debug("Finished creating instance of bean '" + beanName + "'"); } return beanInstance; } catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) { } catch (Throwable ex) { } }
会先调用resolveBeforeInstantiation，判断当前后置处理器是否是InstantiationAwareBeanPostProcessor，如果是，则提前执行applyBeanPostProcessorsBeforeInstantiation，如果applyBeanPostProcessorsBeforeInstantiation方法返回的结果不是null，则执行applyBeanPostProcessorsAfterInitialization方法，如果最终结果不是null则直接返回不是则进行doCreateBean方法
protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) { Object bean = null; if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) { // Make sure bean class is actually resolved at this point. if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) { Class<?> targetType = determineTargetType(beanName, mbd); if (targetType != null) { bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName); if (bean != null) { bean = applyBeanPostProcessorsAfterInitialization(bean, beanName); } } } mbd.beforeInstantiationResolved = (bean != null); } return bean; }
1.1.1 doCreateBean方法
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)throws BeanCreationException { BeanWrapper instanceWrapper = null; ....省略 // 创建bean实例 final Object bean = instanceWrapper.getWrappedInstance(); ....省略 synchronized (mbd.postProcessingLock) { if (!mbd.postProcessed) { try { // 触发后置处理器MergedBeanDefinitionPostProcessor applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName); } catch (Throwable ex) { throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Post-processing of merged bean definition failed", ex); } mbd.postProcessed = true; } } ....省略 Object exposedObject = bean; try { // 为bean属性赋值 populateBean(beanName, mbd, instanceWrapper); exposedObject = initializeBean(beanName, exposedObject, mbd); } }
创建Bean，触发后置处理器MergedBeanDefinitionPostProcessor，执行postProcessMergedBeanDefinition方法
1.1.1.1populateBean方法
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) { if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) { for (BeanPostProcessor bp : getBeanPostProcessors()) { if (bp instanceof InstantiationAwareBeanPostProcessor) { InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp; // 执行后置处理器InstantiationAwareBeanPostProcessor的postProcessAfterInstantiation方法 if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) { continueWithPropertyPopulation = false; break; } } } } ....省略 if (hasInstAwareBpps || needsDepCheck) { if (pvs == null) { pvs = mbd.getPropertyValues(); } PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching); if (hasInstAwareBpps) { for (BeanPostProcessor bp : getBeanPostProcessors()) { if (bp instanceof InstantiationAwareBeanPostProcessor) { // 执行后置处理器InstantiationAwareBeanPostProcessor的postProcessPropertyValues方法 InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp; pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName); if (pvs == null) { return; } } } } if (needsDepCheck) { checkDependencies(beanName, mbd, filteredPds, pvs); } } ....省略 // 为属性赋值 if (pvs != null) { applyPropertyValues(beanName, mbd, bw, pvs); } }
1.1.1.2 initializeBean方法
protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) { if (System.getSecurityManager() != null) { AccessController.doPrivileged((PrivilegedAction<Object>) () -> { invokeAwareMethods(beanName, bean); return null; }, getAccessControlContext()); } else { // 处理Aware接口 invokeAwareMethods(beanName, bean); } Object wrappedBean = bean; if (mbd == null || !mbd.isSynthetic()) { // 后置处理器触发postProcessBeforeInitialization方法 wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName); } try { // 执行初始化方法 invokeInitMethods(beanName, wrappedBean, mbd); } catch (Throwable ex) { throw new BeanCreationException( (mbd != null ? mbd.getResourceDescription() : null), beanName, "Invocation of init method failed", ex); } if (mbd == null || !mbd.isSynthetic()) { // 后置处理器触发postProcessAfterInitialization方法 wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName); } return wrappedBean; }
其它：
SpringBoot_run()启动流程
SpringApplication实例初始化：
a)、根据classpath里面是否存在特征类（org.springframework.web.context.ConfigurableWebApplicationCobtext）来决定创建为web应用使用ApplicationContext类型，还是标准Standalone应用使用的ApplicationContext类型。
b)、使用SpringFactoriesLoader在classpath中查找并加载所有可用的ApplicationContextInitiazier
c)、使用SpringFactoriesLoader在classpath中查找并加载所有可用的ApplicationListener
d)、推断并main方法的定义类
SpringApplication实例初始化完成，遍历SpringFactoriesLoader可以找到并加载的SpringApplicationRunListnner，调用他们的start()方法。
创建并配置当前SpringBoot应用将要使用的Envrioment（包括配置要使用的PropertySource以及Profile）
遍历调用所有SpringApplicationRunListener的environmentPrepared()的方法——即通知【run监听器SpringBoot应用的使用环境已经搭建完成】
创建对应类型的ApplicationContext，根据条件决定是否添加ShutdownHook，决定是否使用自定义的BeanNameGenerator、ResourceLoader。将之前准备好的Enviroment设置给创建好的ApplicationContext使用
完成创建ApplicationContext，通过SpringFactoriesLoader查找并加载classpath中所有可用的ApplicationContextInitializer的Initialize（）方法来对ApplicationContext进行进一步的处理
遍历所有的SpringApplicationRunListenner的contextPrepared（）方法，通知【run监听器】ApplicationContext已经准备好了。
将之前通过@EnableAutoConfiguration获取的所有配置以及其他形式的IOC容器配置加载到已经准备完毕的ApplicationContext
遍历所有的SpringApplicationRunListener的contextLoaded（）方法，通知【run监听器和ApplicationContext装填完毕】
调用ApplicationContext的refresh（）——完成填充IOC容器
查找当前ApplicationContext中是否注册有CommandLineRunner，如果有，则遍历执行它们。
遍历执行SpringApplicationRunListener的finished（）。
——启动完毕
————————————————
原文链接：https://blog.csdn.net/hackerHL/article/details/78270780
原文链接：https://blog.csdn.net/u010811939/article/details/80592461