Spring的执行流程
Spring的执行流程源码
前言
再 AbstractApplicationContext的refresh()中定义了Spring的执行流程。
@Override
public void refresh() throws BeansException, IllegalStateException {synchronized (this.startupShutdownMonitor) {// 刷新容器准备环境prepareRefresh();// 告诉子类刷新内部bean工厂ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();// 准备Bean工厂prepareBeanFactory(beanFactory);try {// 执行子类中的后置处理器：空方法postProcessBeanFactory(beanFactory);// 执行bean工厂的后置处理器invokeBeanFactoryPostProcessors(beanFactory);// 注册Bean的后置处理器registerBeanPostProcessors(beanFactory);// 初始化MessageSourceinitMessageSource();// 为此上下文初始化事件多播器。initApplicationEventMulticaster();// 让子类有点参与感，留给子类的初始化方法onRefresh();// 给容器中将所有项目里面的ApplicationListener注册进来 registerListeners();// 最后初始化bean工厂，初始化所有剩下的单实例bean finishBeanFactoryInitialization(beanFactory);// 完成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();}}
}
执行流程解析
prepareRefresh();
protected void prepareRefresh() {// Switch to active.this.startupDate = System.currentTimeMillis();this.closed.set(false);this.active.set(true);if (logger.isDebugEnabled()) {if (logger.isTraceEnabled()) {logger.trace("Refreshing " + this);}else {logger.debug("Refreshing " + getDisplayName());}}// 空方法：初始化属性资源文件initPropertySources();// Validate that all properties marked as required are resolvable:// see ConfigurablePropertyResolver#setRequiredPropertiesgetEnvironment().validateRequiredProperties();// 初始化监听器：ApplicationListenersif (this.earlyApplicationListeners == null) {this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);}else {// Reset local application listeners to pre-refresh state.this.applicationListeners.clear();this.applicationListeners.addAll(this.earlyApplicationListeners);}// Allow for the collection of early ApplicationEvents,// to be published once the multicaster is available...this.earlyApplicationEvents = new LinkedHashSet<>();
}
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {refreshBeanFactory();return getBeanFactory();
}//子类
@Override
protected final void refreshBeanFactory() throws BeansException {//如果bean工厂存在则销毁并关闭if (hasBeanFactory()) {destroyBeans();closeBeanFactory();}try {//创建一个默认的bean工厂DefaultListableBeanFactory beanFactory = createBeanFactory();//设置序列化参数beanFactory.setSerializationId(getId());/*** 设置两个属性：* 1. 是否允许覆盖同名称的不同定义的对象* 2. 是否允许bean之间存在循环依赖*/customizeBeanFactory(beanFactory);//加载BD（通过Annotation或者XML）loadBeanDefinitions(beanFactory);//创建并初始化完毕，返回this.beanFactory = beanFactory;}catch (IOException ex) {throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);}
}
prepareBeanFactory(beanFactory);
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {// 设置bean的类加载器beanFactory.setBeanClassLoader(getClassLoader());//设置bean的表达式的解析器比如SPELbeanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));//设置bean的属性管理类beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));//添加bean的后置处理器：ApplicationContextAwareProcessorbeanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));//忽略该接口实现类中存在依赖外部的bean属性注入而不是在自动装配时忽略该接口的实现//用于装配接口时忽略的类：实现了EnvironmentAware接口重写setEnvironment方法后，在工程启动时可以获得application.properties的配置文件配置的属性值。beanFactory.ignoreDependencyInterface(EnvironmentAware.class);//用于装配接口时忽略的类：EmbeddedValueResolverAware可以获取配置文件的属性值，比如自动注入beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);//用于装配接口时忽略的类：ResourceLoaderAware可以获取资源加载器,可以获得外部资源文件beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);//用于装配接口时忽略的类：ApplicationEventPublisherAware可以用于发布事件获取事件（监听器）beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);//用于装配接口时忽略的类：MessageSourceAware国际化的注册类beanFactory.ignoreDependencyInterface(MessageSourceAware.class);//用于装配接口时忽略的类：ApplicationContextAware通过它可以获取Application的上下文对象beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);// BeanFactory interface not registered as resolvable type in a plain factory.// MessageSource registered (and found for autowiring) as a bean.//用于装配接口时注册的类：自动注册了bean工厂beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);beanFactory.registerResolvableDependency(ResourceLoader.class, this);beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);beanFactory.registerResolvableDependency(ApplicationContext.class, this);// 将ApplicationListenerDetector注册到Bean的后置处理器中beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));// Detect a LoadTimeWeaver and prepare for weaving, if found.//在这增加了对AspacJ的支持if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));// Set a temporary ClassLoader for type matching.beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));}// 注册默认的系统环境的Beanif (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());}if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());}if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());}
}
invokeBeanFactoryPostProcessors(beanFactory);、
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {//执行Bean工厂的后置处理器-------- 1PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());// Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime// (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));}
}
// 1
public static void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {// Invoke BeanDefinitionRegistryPostProcessors first, if any.Set<String> processedBeans = new HashSet<>();if (beanFactory instanceof BeanDefinitionRegistry) {BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {BeanDefinitionRegistryPostProcessor registryProcessor =(BeanDefinitionRegistryPostProcessor) postProcessor;registryProcessor.postProcessBeanDefinitionRegistry(registry);registryProcessors.add(registryProcessor);}else {regularPostProcessors.add(postProcessor);}}// Do not initialize FactoryBeans here: We need to leave all regular beans// uninitialized to let the bean factory post-processors apply to them!// Separate between BeanDefinitionRegistryPostProcessors that implement// PriorityOrdered, Ordered, and the rest.List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();//首先，加载实现PriorityOrdered类的BeanDefinitionRegistryPostProcessorsString[] postProcessorNames =beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);for (String ppName : postProcessorNames) {if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {//获取并创建所有的bean将其添加到currentRegistryProcessors中currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));processedBeans.add(ppName);}}、//对已经创建好的Bean进行排序sortPostProcessors(currentRegistryProcessors, beanFactory);registryProcessors.addAll(currentRegistryProcessors);invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);currentRegistryProcessors.clear();//接下来，加载实现了Ordered接口的BeanDefinitionRegistryPostProcessorspostProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);for (String ppName : postProcessorNames) {if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));processedBeans.add(ppName);}}sortPostProcessors(currentRegistryProcessors, beanFactory);registryProcessors.addAll(currentRegistryProcessors);invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);currentRegistryProcessors.clear();//最后，加载没有实现优先级接口的BeanDefinitionRegistryPostProcessorsboolean reiterate = true;while (reiterate) {reiterate = false;postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);for (String ppName : postProcessorNames) {if (!processedBeans.contains(ppName)) {currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));processedBeans.add(ppName);reiterate = true;}}sortPostProcessors(currentRegistryProcessors, beanFactory);registryProcessors.addAll(currentRegistryProcessors);invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);currentRegistryProcessors.clear();}// Now, invoke the postProcessBeanFactory callback of all processors handled so far.//现在，调用所有的后置处理器的postProcessBeanFactory()，进行回调invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);}else {// 直接执行Bean工厂的beanFactoryPostProcessorsinvokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);}// Do not initialize FactoryBeans here: We need to leave all regular beans//不要在这里初始化factorybean:我们需要保留所有常规bean// uninitialized to let the bean factory post-processors apply to them!//未初始化，让bean工厂后处理器应用到它们!String[] postProcessorNames =beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);// Separate between BeanFactoryPostProcessors that implement PriorityOrdered,// Ordered, and the rest.List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();List<String> orderedPostProcessorNames = new ArrayList<>();List<String> nonOrderedPostProcessorNames = new ArrayList<>();for (String ppName : postProcessorNames) {if (processedBeans.contains(ppName)) {// skip - already processed in first phase above}else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));}else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {orderedPostProcessorNames.add(ppName);}else {nonOrderedPostProcessorNames.add(ppName);}}//对之间加载的PostProcesser进行执行// First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.sortPostProcessors(priorityOrderedPostProcessors, beanFactory);invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);// Next, invoke the BeanFactoryPostProcessors that implement Ordered.List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());for (String postProcessorName : orderedPostProcessorNames) {orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));}sortPostProcessors(orderedPostProcessors, beanFactory);invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);// Finally, invoke all other BeanFactoryPostProcessors.List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());for (String postProcessorName : nonOrderedPostProcessorNames) {nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));}invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);// Clear cached merged bean definitions since the post-processors might have// modified the original metadata, e.g. replacing placeholders in values...beanFactory.clearMetadataCache();
}
registerBeanPostProcessors(beanFactory);
public static void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {//获取所有的后置处理器String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);// Register BeanPostProcessorChecker that logs an info message when// a bean is created during BeanPostProcessor instantiation, i.e. when// a bean is not eligible for getting processed by all BeanPostProcessors.int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));// Separate between BeanPostProcessors that implement PriorityOrdered,// Ordered, and the rest.//根据优先级注册后置处理器List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();List<String> orderedPostProcessorNames = new ArrayList<>();List<String> nonOrderedPostProcessorNames = new ArrayList<>();for (String ppName : postProcessorNames) {if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);priorityOrderedPostProcessors.add(pp);if (pp instanceof MergedBeanDefinitionPostProcessor) {internalPostProcessors.add(pp);}}else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {orderedPostProcessorNames.add(ppName);}else {nonOrderedPostProcessorNames.add(ppName);}}// First, register the BeanPostProcessors that implement PriorityOrdered.sortPostProcessors(priorityOrderedPostProcessors, beanFactory);registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);// Next, register the BeanPostProcessors that implement Ordered.List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());for (String ppName : orderedPostProcessorNames) {BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);orderedPostProcessors.add(pp);if (pp instanceof MergedBeanDefinitionPostProcessor) {internalPostProcessors.add(pp);}}sortPostProcessors(orderedPostProcessors, beanFactory);registerBeanPostProcessors(beanFactory, orderedPostProcessors);// Now, register all regular BeanPostProcessors.List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());for (String ppName : nonOrderedPostProcessorNames) {BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);nonOrderedPostProcessors.add(pp);if (pp instanceof MergedBeanDefinitionPostProcessor) {internalPostProcessors.add(pp);}}registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);// Finally, re-register all internal BeanPostProcessors.sortPostProcessors(internalPostProcessors, beanFactory);registerBeanPostProcessors(beanFactory, internalPostProcessors);// Re-register post-processor for detecting inner beans as ApplicationListeners,// moving it to the end of the processor chain (for picking up proxies etc).beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}
initMessageSource();
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.isTraceEnabled()) {logger.trace("Using MessageSource [" + this.messageSource + "]");}}else {// Use empty MessageSource to be able to accept getMessage calls.//使用空的MessageSourceDelegatingMessageSource dms = new DelegatingMessageSource();dms.setParentMessageSource(getInternalParentMessageSource());this.messageSource = dms;beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);if (logger.isTraceEnabled()) {logger.trace("No '" + MESSAGE_SOURCE_BEAN_NAME + "' bean, using [" + this.messageSource + "]");}}
}
initApplicationEventMulticaster();
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.isTraceEnabled()) {logger.trace("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");}}else {this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);if (logger.isTraceEnabled()) {logger.trace("No '" + APPLICATION_EVENT_MULTICASTER_BEAN_NAME + "' bean, using " +"[" + this.applicationEventMulticaster.getClass().getSimpleName() + "]");}}
}
registerListeners();
protected void registerListeners() {// 首先注册指定的静态监听器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 (!CollectionUtils.isEmpty(earlyEventsToProcess)) {for (ApplicationEvent earlyEvent : earlyEventsToProcess) {getApplicationEventMulticaster().multicastEvent(earlyEvent);}}
}
finishBeanFactoryInitialization(beanFactory)
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {// Initialize conversion service for this context.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));}// Register a default embedded value resolver if no bean post-processor// (such as a PropertyPlaceholderConfigurer bean) registered any before:// at this point, primarily for resolution in annotation attribute values.if (!beanFactory.hasEmbeddedValueResolver()) {beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));}// Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);for (String weaverAwareName : weaverAwareNames) {getBean(weaverAwareName);}// Stop using the temporary ClassLoader for type matching.beanFactory.setTempClassLoader(null);// Allow for caching all bean definition metadata, not expecting further changes.beanFactory.freezeConfiguration();// Instantiate all remaining (non-lazy-init) singletons.beanFactory.preInstantiateSingletons();
}
Spring的执行流程总结
1、prepareRefresh();刷新前的预处理工作
1）、initPropertySources();初始化一些属性设置
2）、getEnvironment().validateRequiredProperties();检查属性的合法信息等
3）、this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);初始化容器的监听
4）、this.earlyApplicationEvents = new LinkedHashSet<>();保存容器中的一些早期事件
2、obtainFreshBeanFactory();获取BeanFactory
1）、refreshBeanFactory();创建BeanFactory
在GenericApplicationContext对象构造时this.beanFactory=new DefaultListableBeanFactory();
2）、getBeanFactory(); 返回刚才创建的BeanFactory【DefaultListableBeanFactory】对象
3、prepareBeanFactory(beanFactory);BeanFactory的一些预准备工作
1）、setBeanClassLoader(getClassLoader());设置Bean的类加载器
2）、addBeanPostProcessor();添加部分Bean的后置处理器【ApplicationContextAwareProcessor】
3）、设置忽略的自动装配的接口EnvironmentAware、EmbeddedValueResolverAware、xxx
4）、注册可以解析的自动装配；我们能直接在任何组件中自动注入：BeanFactory、ResourceLoader、ApplicationEventPublisher、ApplicationContext
5）、添加BeanPostProcessor【ApplicationListenerDetector】
6）、添加编译时的AspectJ；
7）、给BeanFactory中注册一些能用的组件：
environment【ConfigurableEnvironment】
systemProperties【Map<String,Object>】
systemEnvironment【Map<String,Object>
4、postProcessBeanFactory(beanFactory);准备工作完成后进行的后置处理工作；
1）、子类通过重写这方法在BeanFactory创建并预准备完成以后做进一步的设置
**===================**
以上是BeanFactory的创建及预准备工作
**===================**
5、invokeBeanFactoryPostProcessors(beanFactory);执行BeanFactoryPostProcessor的方法
BeanFactoryPostProcessor：BeanFactory的后置处理器，在BeanFactory标注初始化之后执行
两个接口：BeanFactoryPostProcessor、BeanDefinitionRegistryPostProcessor接口
1）、执行BeanFactoryPostProcessor的方法：
1）、获取所有BeanDefinitionRegistryPostProcessor
2）、先执行实现了PriorityOrdered优先级接口的、再执行实现了Ordered的接口的、最后执行其它的
3）、获取所有BeanFactoryPostProcessor
2）、先执行实现了PriorityOrdered优先级接口的、再执行实现了Ordered的接口的、最后执行其它的
6、registerBeanPostProcessors(beanFactory);注册BeanPostProcessor
BeanPostProcessor（Bean的后置处理器）【拦截Bean的创建过程】
不同类型的BeanPostProcessor，在Bean创建前后的执行时机是不一样的，有如下几类：
BeanPostProcessor
DestructionAwareBeanPostProcessor
InstantiationAwareBeanPostProcessor
SmartInstantiationAwareBeanPostProcessor
MergedBeanDefinitionPostProcessor【internalPostProcessors】
1）、获取所有的BeanPostProcessor； 后置处理器都默认可以通过PriorityOrdered、Ordered来指定优先级
2）、先注册PriorityOrdered优先级接口的BeanPostProcessor 把每一个BeanPostProcessor添加到BeanFactory中， beanFactory.addBeanPostProcessor(postProcessor);
3）、再注册了实现Ordered接口的
4）、最后注册其它的
5）、最终注册MergedBeanDefinitionPostProcessor类型的
6）、注册一个ApplicationListenerDetector；来在Bean创建完成后检查是否是ApplicationListener
addApplicationListener((ApplicationListener) bean);
7、initMessageSource();初始化MessageSource组件（做国际化功能；消息绑定；消息解析等功能）
1）、获取BeanFactory
2）、看容器中是否有id为messageSource，类型是MessageSource的组件 如果有赋值给messageSource，如果没有自己创建一个DelegatingMessageSource； MessageSource：取出国际化配置文件中的某个key的值；能按照区域信息获取；
3）、把创建好的MessageSource注册在容器中，以后获取国际化配置文件的值的时候，可以自动注入MessageSource；调用其方法可以获得相关配置属性 beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
8、initApplicationEventMulticaster();初始化事件派发器【多播器】
1）、获取BeanFactory
2）、从BeanFactory获取applicationEventMulticaster的组件
3）、如果上一步没有配置；创建一个SimpleApplicationEventMulticaster
4）、将创建的ApplicationEventMulticaster添加到BeanFactory中，以后其他组件直接自动注入
9、onRefresh();留给子容器（子类）
1）、子类重写这个方法，在容器刷新的时候可以自定义逻辑；
10、registerListeners();给容器中将所有项目里面的ApplicationListener注册进来
1）、从容器中拿到所有ApplicationListener组件
2）、将每个监听器添加到事件派发器中 getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
3）、派发之前步骤产生的事件；
11、finishBeanFactoryInitialization(beanFactory);初始化所有剩下的单实例bean
1）、beanFactory.preInstantiateSingletons();初始化剩下的单实例bean
1）、获取容器中的所有Bean，依次进行初始化和创建对象 List beanNames = new ArrayList<>(this.beanDefinitionNames);
2）、遍历beanNames获取bean 的定义信息； RootBanDefinition bd = getMergedLocalBeanDefinition(beanName);
3）、Bean不是抽象的，是单实例的，是懒加载；
1）、判断是否是FactoryBean；是否是实现FactoryBean接口的Bean；
1）、如果是，利用工厂方法创建对象
2）、不是工厂Bean，利用getBean（过程如下）（beanName）；创建对象
4）、所有Bean都利用getBean创建完成以后； 检查所有的Bean是否是SmartInitializingSingleton接口类型的，如果是就执行 afterSingletonsInstantiated()方法;
12、finishRefresh();完成BeanFactory初始化创建工作；IOC容器就创建完成
1）、initLifecycleProcessor();初始化声明周期有关的后置处理器，允许我们写一个LifecycleProcessor的实现类，可以在BeanFactory进行到特定生命周期时进行调用 ， 默认从容器中找是否有LifeCycleProcessor的组件，如果没有，默认会创建一个 new DefaultLifecycleProcessor();然后加入到容器中
2）、getLifecycleProcessor().onRefresh();拿到所有前面定义的生命周期处理器回调onRefresh()方法
3）、publishEvent(new ContextRefreshedEvent(this));发布容器刷新完成事件
4）、LiveBeansView.registerApplicationContext(this);
getBean(beanName);ioc.getBean;1、AbstractBeanFactory.doGetBean();2、先获取缓存中保存的单实例bean，如果能获取到，说明这Bean之前被创建过（所有创建过的单实例Bean都会被缓存起来）从singletonObjects=new ConcurrentHashMap<String,Object>中获取到3、缓存中获取不到，开始Bean的创建对象流程；4、标记当前Bean已经被创建，markBeanAsCreated(beanName);5、获取Bean的定义信息6、获取当前Bean依赖的其它Bean；如果有，按照getBean（）把依赖的Bean先创建出来7、启动单实例Bean的创建流程1、createBean(beanName,mbd,args);/***先让BeanPostProcessor【InstantiationAwareBeanPostProcessor】先拦截返回代理对象*先触发所有该接口的postProcessBeforeInstantiation()方法，如果有返回对象，调用 *applyBeanPostProcessorsAfterInitialization()，即会执行所有的BeanPostProcessor的 *postProcessAfterInitialization()方法，将bean返回*/1、Object bean = resolveBeforeInstantiation(beanName, mbdToUse);2、如果没有返回bean，调用doCreateBean();Object beanInstance = doCreateBean(beanName, mbdToUse, args);//利用工厂方法或者对象的构造器等创建bean实例1、createBeanInstance(beanName, mbd, args);//调用MergedBeanDefinitionPostProcessor的postProcessMergedBeanDefinition()2、applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);//为bean的属性赋值3、populateBean(beanName, mbd, instanceWrapper);1、拿到InstantiationAwareBeanPostProcessor类型的后置处理器执行postProcessAfterInstantiation();2、拿到InstantiationAwareBeanPostProcessor类型的后置处理器执行postProcessProperties();//应用Bean属性的值，为属性利用setter方法等进行赋值3、applyPropertyValues(beanName, mbd, bw, pvs);//【Bean初始化】4、initializeBean(beanName, exposedObject, mbd);//执行xxxAware接口的方法1、invokeAwareMethods(beanName, bean);BeanNameAware\BeanClassLoaderAware\BeanFactoryAware//执行后置处理器在初始化之前2、applyBeanPostProcessorsBeforeInitialization();BeanPostProcessor.postProcessBeforeInitialization();//执行初始化方法3、invokeInitMethods();1、判断是否是InitializingBean接口的实现；执行接口规定的初始化2、是否自定义初始化方法//执行后置处理器在初始化之后4、applyBeanPostProcessorsAfterInitialization();//注册Bean的销毁方法5、registerDisposableBeanIfNecessary(beanName, bean, mbd);//Bean的实例创建完成，将bean添加到缓存中3、addSingleton(beanName, singletonObject);ioc容器就是这些Map;很多Map里面保存了单实例bean，环境信息。。。
Spring容器创建总结
1、Spring容器在启动的时候，先会保存所有注册进来的Bean的定义信息
1、xml注册bean
2、使用注解；@Service、@Bean、@Component、…
2、Spring容器会在合适的时机创建这些Bean
1、用到这个bean的时候，利用getBean方法创建bean，创建好以后保存在容器中
2、统一创建剩下所有bean的时候，即finishBeanFactoryInitialize();
3、后置处理器
1、每一个bean创建完成，都会使用各种后置处理器进行处理，来增强bean 的功能
AutowiredAnnotationBeanPostProcessor会处理自动注入功能
AnnotationAwareAspectJAutoProxyCreator来做AOP功能；
xxx
4、事件驱动模型：
ApplicationListener：事件监听
ApplicationEventMulticaster：事件派发：
本文来自互联网用户投稿，文章观点仅代表作者本人，不代表本站立场，不承担相关法律责任。如若转载，请注明出处。 如若内容造成侵权/违法违规/事实不符，请点击【内容举报】进行投诉反馈！