Spring加载流程源码分析03【refresh】

前面两篇文章分析了super(parent)和setConfigLocations(configLocations)的源代码，本文来分析下refresh的源码，

Spring加载流程源码分析01【super】
Spring加载流程源码分析02【setConfigLocations】

先来看下ClassPathXmlApplicationContext类的初始化过程：

public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)throws BeansException {super(parent);setConfigLocations(configLocations);if (refresh) {refresh();}
}

refresh介绍

refresh方法的具体实现是在AbstractApplicationContext类中如下:

@Override
public void refresh() throws BeansException, IllegalStateException {//startupShutdownMonitor对象在spring环境刷新和销毁的时候都会用到，确保刷新和销毁不会同时执行synchronized (this.startupShutdownMonitor) {// 准备工作，例如记录事件，设置标志，检查环境变量等，并有留给子类扩展的位置，用来将属性加入到applicationContext中prepareRefresh();// 创建beanFactory，这个对象作为applicationContext的成员变量，可以被applicationContext拿来用,// 并且解析资源（例如xml文件），取得bean的定义，放在beanFactory中ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();// 对beanFactory做一些设置，例如类加载器、SPEL解析器、指定bean的某些类型的成员变量对应某些对象.prepareBeanFactory(beanFactory);try {// 子类扩展用，可以设置bean的后置处理器（bean在实例化之后这些后置处理器会执行）postProcessBeanFactory(beanFactory);// 执行beanFactory后置处理器（有别于bean后置处理器处理bean实例，beanFactory后置处理器处理bean定义）invokeBeanFactoryPostProcessors(beanFactory);// 将所有的bean的后置处理器排好序，但不会马上用，bean实例化之后会用到registerBeanPostProcessors(beanFactory);// 初始化国际化服务initMessageSource();// 创建事件广播器initApplicationEventMulticaster();// 空方法，留给子类自己实现的，在实例化bean之前做一些ApplicationContext相关的操作onRefresh();// 注册一部分特殊的事件监听器，剩下的只是准备好名字，留待bean实例化完成后再注册registerListeners();// 单例模式的bean的实例化、成员变量注入、初始化等工作都在此完成finishBeanFactoryInitialization(beanFactory);// applicationContext刷新完成后的处理，例如生命周期监听器的回调，广播通知等finishRefresh();}catch (BeansException ex) {logger.warn("Exception encountered during context initialization - cancelling refresh attempt", ex);// 刷新失败后的处理，主要是将一些保存环境信息的集合做清理destroyBeans();// applicationContext是否已经激活的标志，设置为falsecancelRefresh(ex);// Propagate exception to caller.throw ex;}}
}

接下来一一介绍下

1.prepareRefresh介绍

protected void prepareRefresh() {// 设置初始化开始的时间this.startupDate = System.currentTimeMillis();// 设置context的关闭状态为falsethis.closed.set(false);// 设置context的活动状态是truethis.active.set(true);if (logger.isInfoEnabled()) {logger.info("Refreshing " + this);}// Initialize any placeholder property sources in the context environment// 留个子类自己实现的空方法initPropertySources();// 验证对应的key在环境变量中是否存在，如果不存在就抛异常getEnvironment().validateRequiredProperties();// earlyApplicationEvents存放早起的一些事件。this.earlyApplicationEvents = new LinkedHashSet<ApplicationEvent>();
}

initPropertySources() 留给子类实现的方法

protected void initPropertySources() {// For subclasses: do nothing by default.
}

2.obtainFreshBeanFactory()介绍

创建了一个BeanFactory对象

/*** Tell the subclass to refresh the internal bean factory.* 子类实现* @return the fresh BeanFactory instance* @see #refreshBeanFactory()* @see #getBeanFactory()*/
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {// 子类(AbstractRefreshableApplicationContext)创建一个ConfigurableListableBeanFactory 对象refreshBeanFactory();// 获取refreshBeanFactory()实现类中创建的BeanFactory对象ConfigurableListableBeanFactory beanFactory = getBeanFactory();if (logger.isDebugEnabled()) {logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);}return beanFactory;
}

refreshBeanFactory()

该方法是子类实现的方法，在AbstractRefreshableApplicationContext类中该方法创建了ConfigurableListableBeanFactory 对象并且完成了，并赋值给了beanFactory

@Override
protected final void refreshBeanFactory() throws BeansException {// 如果BeanFactory存在就销毁if (hasBeanFactory()) {destroyBeans();closeBeanFactory();}try {DefaultListableBeanFactory beanFactory = createBeanFactory();// BeanFactory的初始化操作beanFactory.setSerializationId(getId());customizeBeanFactory(beanFactory);// 在次方法中完成了application.xml文件的解析loadBeanDefinitions(beanFactory);synchronized (this.beanFactoryMonitor) {// 创建的对象赋值给了成员变量beanFactorythis.beanFactory = beanFactory;}}catch (IOException ex) {throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);}
}

进入loadBeanDefinitions(beanFactory)方法查看

protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {// Create a new XmlBeanDefinitionReader for the given BeanFactory.XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);// Configure the bean definition reader with this context's// resource loading environment.beanDefinitionReader.setEnvironment(getEnvironment());beanDefinitionReader.setResourceLoader(this);beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));// Allow a subclass to provide custom initialization of the reader,// then proceed with actually loading the bean definitions.initBeanDefinitionReader(beanDefinitionReader);// 进入该方法查看loadBeanDefinitions(beanDefinitionReader);
}

loadBeanDefinitions(beanDefinitionReader);

protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws IOException {String[] configLocations = getConfigLocations();if (configLocations != null) {for (String configLocation : configLocations) {//继续进入 configLocation 是applicationContext.xmlreader.loadBeanDefinitions(configLocation);}}
}

进入跟踪

public int loadBeanDefinitions(String location, Set<Resource> actualResources) throws BeanDefinitionStoreException {//这是我们在前面文章中初始的ResourceLoader对象ResourceLoader resourceLoader = getResourceLoader();if (resourceLoader == null) {throw new BeanDefinitionStoreException("Cannot import bean definitions from location [" + location + "]: no ResourceLoader available");}if (resourceLoader instanceof ResourcePatternResolver) {// Resource pattern matching available.try {Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);// 此处进入int loadCount = loadBeanDefinitions(resources);if (actualResources != null) {for (Resource resource : resources) {actualResources.add(resource);}}if (logger.isDebugEnabled()) {logger.debug("Loaded " + loadCount + " bean definitions from location pattern [" + location + "]");}return loadCount;}catch (IOException ex) {throw new BeanDefinitionStoreException("Could not resolve bean definition resource pattern [" + location + "]", ex);}}else {// Can only load single resources by absolute URL.Resource resource = resourceLoader.getResource(location);int loadCount = loadBeanDefinitions(resource);if (actualResources != null) {actualResources.add(resource);}if (logger.isDebugEnabled()) {logger.debug("Loaded " + loadCount + " bean definitions from location [" + location + "]");}return loadCount;}
}

继续跟踪

public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {Assert.notNull(encodedResource, "EncodedResource must not be null");if (logger.isInfoEnabled()) {logger.info("Loading XML bean definitions from " + encodedResource.getResource());}Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();if (currentResources == null) {currentResources = new HashSet<EncodedResource>(4);this.resourcesCurrentlyBeingLoaded.set(currentResources);}if (!currentResources.add(encodedResource)) {throw new BeanDefinitionStoreException("Detected cyclic loading of " + encodedResource + " - check your import definitions!");}try {// 获取applicationContext.xml对应的字节输入流InputStream inputStream = encodedResource.getResource().getInputStream();try {InputSource inputSource = new InputSource(inputStream);if (encodedResource.getEncoding() != null) {inputSource.setEncoding(encodedResource.getEncoding());}// 将配置文件中的信息加载到定义的bean中return doLoadBeanDefinitions(inputSource, encodedResource.getResource());}finally {inputStream.close();}}catch (IOException ex) {throw new BeanDefinitionStoreException("IOException parsing XML document from " + encodedResource.getResource(), ex);}finally {currentResources.remove(encodedResource);if (currentResources.isEmpty()) {this.resourcesCurrentlyBeingLoaded.remove();}}
}

跟踪到如下代码

try {Document doc = doLoadDocument(inputSource, resource);return registerBeanDefinitions(doc, resource);
}

上面是加载bean定义的关键代码：先制作Document对象，再调用registerBeanDefinitions方法，最终会将每个bean的定义放入DefaultListableBeanFactory的beanDefinitionMap中。

getBeanFactory()

获取refreshBeanFactory()实现类中创建的BeanFactory对象

@Override
public final ConfigurableListableBeanFactory getBeanFactory() {synchronized (this.beanFactoryMonitor) {if (this.beanFactory == null) {throw new IllegalStateException("BeanFactory not initialized or already closed - " +"call 'refresh' before accessing beans via the ApplicationContext");}return this.beanFactory;}
}

3.prepareBeanFactory

BeanFactory的预准备工作

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {// 1）、设置BeanFactory的类加载器beanFactory.setBeanClassLoader(getClassLoader());// 1）、设置支持表达式解析器beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
// 2）、添加部分BeanPostProcessor【ApplicationContextAwareProcessor】beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));// 3）、设置忽略的自动装配的接口EnvironmentAware、EmbeddedValueResolverAware、xxx；// 这些接口的实现类不能通过类型来自动注入beanFactory.ignoreDependencyInterface(EnvironmentAware.class);beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);beanFactory.ignoreDependencyInterface(MessageSourceAware.class);beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
// 4）、注册可以解析的自动装配；我们能直接在任何组件中自动注入：//BeanFactory、ResourceLoader、ApplicationEventPublisher、ApplicationContext/* 其他组件中可以通过下面方式直接注册使用@autowired BeanFactory beanFactory */beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);beanFactory.registerResolvableDependency(ResourceLoader.class, this);beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);beanFactory.registerResolvableDependency(ApplicationContext.class, this);
// 5）、添加BeanPostProcessor【ApplicationListenerDetector】后置处理器，在bean初始化前后的一些工作beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
// 6）、添加编译时的AspectJ；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()));}
// 7）、给BeanFactory中注册一些能用的组件；if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {// 环境信息ConfigurableEnvironmentbeanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());}//系统属性，systemProperties【Map<String, Object>】if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());}//系统环境变量systemEnvironment【Map<String, Object>】if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());}
}

prepareBeanFactory方法就是为beanFactory做一些设置工作，传入一些后面会用到的参数和工具类，再在spring容器中创建一些bean；

4.postProcessBeanFactory

postProcessBeanFactory方法是留给子类扩展的，可以在bean实例初始化之前注册后置处理器（类似prepareBeanFactory方法中的beanFactory.addBeanPostProcessor），以子类AbstractRefreshableWebApplicationContext为例，其postProcessBeanFactory方法

protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {beanFactory.addBeanPostProcessor(new ServletContextAwareProcessor(this.servletContext, this.servletConfig));beanFactory.ignoreDependencyInterface(ServletContextAware.class);beanFactory.ignoreDependencyInterface(ServletConfigAware.class);WebApplicationContextUtils.registerWebApplicationScopes(beanFactory, this.servletContext);WebApplicationContextUtils.registerEnvironmentBeans(beanFactory, this.servletContext, this.servletConfig);
}

除了WebApplicationContextUtils类的工作之外，其余的都是和prepareBeanFactory方法中类似的处理

5.invokeBeanFactoryPostProcessors

nvokeBeanFactoryPostProcessors方法用来执行BeanFactory实例的后置处理器BeanFactoryPostProcessor的postProcessBeanFactory方法，这个后置处理器除了原生的，我们也可以自己扩展，用来对Bean的定义做一些修改，由于此时bean还没有实例化，所以不要在自己扩展的BeanFactoryPostProcessor中调用那些会触发bean实例化的方法（例如BeanFactory的getBeanNamesForType方法），源码的文档中有相关说明，不要触发bean的实例化，如果要处理bean实例请在BeanPostProcessor中进行；

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {PostProcessorRegistrationDelegate.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()));}
}

6.registerBeanPostProcessors

registerBeanPostProcessors方法的代码略多，就不在此贴出来了，简单的说，就是找出所有的bean的后置处理器(注意，是bean的后置处理器，不是beanFactory的后置处理器，bean后置处理器处理的是bean实例，beanfactory后置处理器处理的是bean的定义)，然后将这些bean的后置处理器分为三类：

实现了顺序接口Ordered.class的，先放入orderedPostProcessors集合，排序后顺序加入beanFactory的bean后处理集合中；
既没有实现Ordered.class，也没有实现PriorityOrdered.class的后置处理器，也加入到beanFactory的bean后处理集合中；
最后是实现了优先级接口PriorityOrdered.class的，排序后顺序加入beanFactory的bean后处理集合中；

registerBeanPostProcessors方法执行完毕后，beanFactory中已经保存了有序的bean后置处理器，在bean实例化之后，会依次使用这些后置处理器对bean实例来做对应的处理；

7.initMessageSource

initMessageSource方法用来准备国际化资源相关的，将实现了MessageSource接口的bean存放在ApplicationContext的成员变量中，先看是否有配置，如果有就实例化，否则就创建一个DelegatingMessageSource实例的bean

8.initApplicationEventMulticaster

spring中有事件、事件广播器、事件监听器等组成事件体系，在initApplicationEventMulticaster方法中对事件广播器做初始化，如果找不到此bean的配置，就创建一个SimpleApplicationEventMulticaster实例作为事件广播器的bean，并且保存为applicationContext的成员变量applicationEventMulticaster

/*** Initialize the ApplicationEventMulticaster.* Uses SimpleApplicationEventMulticaster if none defined in the context.* @see org.springframework.context.event.SimpleApplicationEventMulticaster*/
protected void initApplicationEventMulticaster() {//获取BeanFactoryConfigurableListableBeanFactory beanFactory = getBeanFactory();// 判断是否存在if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {// 从容器中获取ApplicationEventMulticaster对象this.applicationEventMulticaster =beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);if (logger.isDebugEnabled()) {logger.debug("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");}}else {// 初始一个SimpleApplicationEventMulticaster对象this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);// 创建的对象注册到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 + "]");}}
}

9.onRefresh

onRefresh是个空方法，留给子类自己实现的，在实例化bean之前做一些ApplicationContext相关的操作，以子类AbstractRefreshableWebApplicationContext为例，看看它的onRefresh方法

/*** Initialize the theme capability.*/
@Override
protected void onRefresh() {this.themeSource = UiApplicationContextUtils.initThemeSource(this);
}

10.registerListeners

方法名为registerListeners，看名字像是将监听器注册在事件广播器中，但实际情况并非如此，只有一些特殊的监听器被注册了，那些在bean配置文件中实现了ApplicationListener接口的类还没有实例化，所以此处只是将其name保存在广播器中，将这些监听器注册在广播器的操作是在bean的后置处理器中完成的，那时候bean已经实例化完成了，我们看代码

protected void registerListeners() {// 注册的都是特殊的事件监听器，而并非配置中的beanfor (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);}
}

11.finishBeanFactoryInitialization

finishBeanFactoryInitialization方法做了两件事：

beanFactory对象的初始化；
我们在bean配置文件中配置的那些单例的bean，都是在finishBeanFactoryInitialization方法中实例化的；

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {// Initialize conversion service for this context.// 实例化类型转换的bean，并保存在ApplicationContext中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));}// Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.// 实例化LoadTimeWeaverAware接口的bean，用于ApsectJ的类加载期织入的处理String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);for (String weaverAwareName : weaverAwareNames) {getBean(weaverAwareName);}// Stop using the temporary ClassLoader for type matching.// 确保临时的classLoader为空，临时classLoader一般被用来做类型匹配的beanFactory.setTempClassLoader(null);// Allow for caching all bean definition metadata, not expecting further changes.// 将一个标志设置为true，表示applicationContext已经缓存了所有bean的定义，这些bean的name都被保存在applicationContext的frozenBeanDefinitionNames成员变量中，相当于一个快照，记录了当前那些bean的定义已经拿到了beanFactory.freezeConfiguration();// 实例化所有还未实例化的单例beanbeanFactory.preInstantiateSingletons();
}

preInstantiateSingletons方法

public void preInstantiateSingletons() throws BeansException {if (this.logger.isDebugEnabled()) {this.logger.debug("Pre-instantiating singletons in " + this);}// Iterate over a copy to allow for init methods which in turn register new bean definitions.// While this may not be part of the regular factory bootstrap, it does otherwise work fine.List<String> beanNames = new ArrayList<String>(this.beanDefinitionNames);// Trigger initialization of all non-lazy singleton beans...for (String beanName : beanNames) {// 获取bean的定义，该定义已经和父类定义做了合并RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);// 非抽象类、是单例、非懒加载if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {//FactoryBean的处理if (isFactoryBean(beanName)) {final FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);boolean isEagerInit;if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {isEagerInit = AccessController.doPrivileged(new PrivilegedAction<Boolean>() {@Overridepublic Boolean run() {return ((SmartFactoryBean<?>) factory).isEagerInit();}}, getAccessControlContext());}else {isEagerInit = (factory instanceof SmartFactoryBean &&((SmartFactoryBean<?>) factory).isEagerInit());}if (isEagerInit) {getBean(beanName);}}else {//非FactoryBean的实例化、初始化getBean(beanName);}}}// Trigger post-initialization callback for all applicable beans...// 单例实例化完成后，如果实现了SmartInitializingSingleton接口，afterSingletonsInstantiated就会被调用，此处用到了特权控制逻辑AccessController.doPrivilegedfor (String beanName : beanNames) {Object singletonInstance = getSingleton(beanName);if (singletonInstance instanceof SmartInitializingSingleton) {final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;if (System.getSecurityManager() != null) {AccessController.doPrivileged(new PrivilegedAction<Object>() {@Overridepublic Object run() {smartSingleton.afterSingletonsInstantiated();return null;}}, getAccessControlContext());}else {smartSingleton.afterSingletonsInstantiated();}}}
}

doGetBean

protected <T> T doGetBean(final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)throws BeansException {
final String beanName = transformedBeanName(name);Object bean;

/**
2、先获取缓存中保存的单实例Bean。如果能获取到说明这个Bean之前被创建过（所有创建过的单实例Bean都会被缓存起来）
从private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(256);获取的**/Object sharedInstance = getSingleton(beanName);//如果没有获取到创建beanif (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 {//3、缓存中获取不到，开始Bean的创建对象流程；// Fail if we're already creating this bean instance:// We're assumably within a circular reference.if (isPrototypeCurrentlyInCreation(beanName)) {throw new BeanCurrentlyInCreationException(beanName);}
//  获取父beanFatory 检查这个bean是否创建了BeanFactory parentBeanFactory = getParentBeanFactory();if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {// Not found -> check parent.String nameToLookup = originalBeanName(name);if (args != null) {return (T) parentBeanFactory.getBean(nameToLookup, args);}else {   return parentBeanFactory.getBean(nameToLookup, requiredType);}}
// 4、标记当前bean已经被创建if (!typeCheckOnly) {markBeanAsCreated(beanName);}
try {// 5、获取Bean的定义信息；final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);checkMergedBeanDefinition(mbd, beanName, args);
// 6、【获取当前Bean依赖的其他Bean;如果有按照getBean()把依赖的Bean先创建出来；】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);getBean(dep); //先创建依赖的bean}}
// 启动单实例的bean的创建流程if (mbd.isSingleton()) {//获取到单实例bean后，添加到缓存中 singletonObjects（）//Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(256);sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {@Overridepublic Object getObject() throws BeansException {try {//创建Beanreturn createBean(beanName, mbd, args);}catch (BeansException ex) {destroySingleton(beanName);throw ex;}}});bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);}
// 下面部分不重要了else if (mbd.isPrototype()) {// It's a prototype -> create a new instance.Object prototypeInstance = null;try {beforePrototypeCreation(beanName);prototypeInstance = createBean(beanName, mbd, args);}finally {afterPrototypeCreation(beanName);}bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);}
else {String scopeName = mbd.getScope();final Scope scope = this.scopes.get(scopeName);if (scope == null) {throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");}try {Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() {@Overridepublic Object getObject() throws BeansException {beforePrototypeCreation(beanName);try {return createBean(beanName, mbd, args);}finally {afterPrototypeCreation(beanName);}}});bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);}catch (IllegalStateException ex) {throw new BeanCreationException(beanName,"Scope '" + scopeName + "' is not active for the current thread; consider " +"defining a scoped proxy for this bean if you intend to refer to it from a singleton",ex);}}}catch (BeansException ex) {cleanupAfterBeanCreationFailure(beanName);throw ex;}}
// Check if required type matches the type of the actual bean instance.if (requiredType != null && bean != null && !requiredType.isInstance(bean)) {try {return getTypeConverter().convertIfNecessary(bean, requiredType);}catch (TypeMismatchException ex) {if (logger.isDebugEnabled()) {logger.debug("Failed to convert bean '" + name + "' to required type '" +ClassUtils.getQualifiedName(requiredType) + "'", ex);}throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());}}return (T) bean;
}

doCreateBean方法

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)throws BeanCreationException {
// bean的包装BeanWrapper instanceWrapper = null;if (mbd.isSingleton()) {instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);}if (instanceWrapper == null) {// 1）、【创建Bean实例】利用工厂方法或者对象的构造器创建出Bean实例；instanceWrapper = createBeanInstance(beanName, mbd, args);}final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);mbd.resolvedTargetType = beanType;
// Allow post-processors to modify the merged bean definition.synchronized (mbd.postProcessingLock) {if (!mbd.postProcessed) {try {//调用MergedBeanDefinitionPostProcessor的postProcessMergedBeanDefinition(mbd, beanType, beanName);//判断是否为：MergedBeanDefinitionPostProcessor 类型的，如果是，调用方法//MergedBeanDefinitionPostProcessor 后置处理器是在bean实例换之后调用的applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);}catch (Throwable ex) {throw new BeanCreationException(mbd.getResourceDescription(), beanName,"Post-processing of merged bean definition failed", ex);}mbd.postProcessed = true;}}
//判断bean 是否为单实例的，如果是单实例的添加到缓存中boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&isSingletonCurrentlyInCreation(beanName));if (earlySingletonExposure) {if (logger.isDebugEnabled()) {logger.debug("Eagerly caching bean '" + beanName +"' to allow for resolving potential circular references");}//添加bean到缓存中addSingletonFactory(beanName, new ObjectFactory<Object>() {@Overridepublic Object getObject() throws BeansException {return getEarlyBeanReference(beanName, mbd, bean);}});}
// Initialize the bean instance.Object exposedObject = bean;try {//为bean 赋值populateBean(beanName, mbd, instanceWrapper);if (exposedObject != null) {// 4）、【Bean初始化】exposedObject = initializeBean(beanName, exposedObject, mbd);}}catch (Throwable ex) {if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {throw (BeanCreationException) ex;}else {throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);}}
if (earlySingletonExposure) {//获取单实例bean,此时已经创建好了Object earlySingletonReference = getSingleton(beanName, false);if (earlySingletonReference != null) {if (exposedObject == bean) {exposedObject = earlySingletonReference;}else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {String[] dependentBeans = getDependentBeans(beanName);Set<String> actualDependentBeans = new LinkedHashSet<String>(dependentBeans.length);for (String dependentBean : dependentBeans) {if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {actualDependentBeans.add(dependentBean);}}if (!actualDependentBeans.isEmpty()) {throw new BeanCurrentlyInCreationException(beanName,"Bean with name '" + beanName + "' has been injected into other beans [" +StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +"] in its raw version as part of a circular reference, but has eventually been " +"wrapped. This means that said other beans do not use the final version of the " +"bean. This is often the result of over-eager type matching - consider using " +"'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");}}}}
//  5）、注册实现了DisposableBean 接口Bean的销毁方法；只是注册没有去执行，容器关闭之后才去调用的try {registerDisposableBeanIfNecessary(beanName, bean, mbd);}catch (BeanDefinitionValidationException ex) {throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);}
return exposedObject;
}

populateBean()创建bean后属性赋值

//populateBean():1204, AbstractAutowireCapableBeanFactory
protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {PropertyValues pvs = mbd.getPropertyValues();
if (bw == null) {if (!pvs.isEmpty()) {throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");}else {// Skip property population phase for null instance.return;}}
// Give any InstantiationAwareBeanPostProcessors the opportunity to modify the// state of the bean before properties are set. This can be used, for example,// to support styles of field injection.boolean continueWithPropertyPopulation = true;
//赋值之前：/* 1）、拿到InstantiationAwareBeanPostProcessor后置处理器；执行处理器的postProcessAfterInstantiation()； 方法*/if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {for (BeanPostProcessor bp : getBeanPostProcessors()) {if (bp instanceof InstantiationAwareBeanPostProcessor) {InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;//执行if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {continueWithPropertyPopulation = false;break;}}}}
if (!continueWithPropertyPopulation) {return;}
if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
// autowire  按name注入if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {autowireByName(beanName, mbd, bw, newPvs);}
// autowire  按类型注入if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {autowireByType(beanName, mbd, bw, newPvs);}
pvs = newPvs;}
boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);
/*2）、拿到InstantiationAwareBeanPostProcessor后置处理器；执行 postProcessPropertyValues()； 获取到属性的值，此时还未赋值*/if (hasInstAwareBpps || needsDepCheck) {PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);if (hasInstAwareBpps) {for (BeanPostProcessor bp : getBeanPostProcessors()) {if (bp instanceof InstantiationAwareBeanPostProcessor) {InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);if (pvs == null) {return;}}}}if (needsDepCheck) {checkDependencies(beanName, mbd, filteredPds, pvs);}}
//=====赋值之前：===
//3）、应用Bean属性的值；为属性利用setter方法等进行赋值；applyPropertyValues(beanName, mbd, bw, pvs);
}

Bean初始化 initializeBean

//初始化
protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {if (System.getSecurityManager() != null) {AccessController.doPrivileged(new PrivilegedAction<Object>() {@Overridepublic Object run() {invokeAwareMethods(beanName, bean);return null;}}, getAccessControlContext());}else {//1）、【执行Aware接口方法】invokeAwareMethods(beanName, bean);执行xxxAware接口的方法//判断是否实现了 BeanNameAware\BeanClassLoaderAware\BeanFactoryAware 这些接口的bean，如果是执行相应的方法invokeAwareMethods(beanName, bean);}
Object wrappedBean = bean;if (mbd == null || !mbd.isSynthetic()) {//2）、【执行后置处理器BeanPostProcessor初始化之前】 执行所有的 BeanPostProcessor.postProcessBeforeInitialization（）;wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);}
try {//3）、【执行初始化方法】invokeInitMethods(beanName, wrappedBean, mbd);}catch (Throwable ex) {throw new BeanCreationException((mbd != null ? mbd.getResourceDescription() : null),beanName, "Invocation of init method failed", ex);}//4）、【执行后置处理器初始化之后】 执行所有的beanProcessor.postProcessAfterInitialization(result, beanName);方法if (mbd == null || !mbd.isSynthetic()) {wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);}return wrappedBean;
}

执行bean的初始化方法init
1）是否是InitializingBean接口的实现；执行接口规定的初始化；
2）是否自定义初始化方法；通过注解的方式添加了initMethod方法的，

例如： @Bean(initMethod=“init”,destroyMethod=“detory”)

//invokeInitMethods():1667, AbstractAutowireCapableBeanFactory
protected void invokeInitMethods(String beanName, final Object bean, RootBeanDefinition mbd)throws Throwable {
//1）、是否是InitializingBean接口的实现；执行接口规定的初始化 ,执行afterPropertiesSet()这个方法；boolean isInitializingBean = (bean instanceof InitializingBean);if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {if (logger.isDebugEnabled()) {logger.debug("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");}if (System.getSecurityManager() != null) {try {AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {@Overridepublic Object run() throws Exception {((InitializingBean) bean).afterPropertiesSet();return null;}}, getAccessControlContext());}catch (PrivilegedActionException pae) {throw pae.getException();}}else {//执行实现InitializingBean的afterPropertiesSet方法((InitializingBean) bean).afterPropertiesSet();}}
if (mbd != null) {//执行通过注解自定义的initMethod 方法String initMethodName = mbd.getInitMethodName();if (initMethodName != null && !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&!mbd.isExternallyManagedInitMethod(initMethodName)) {invokeCustomInitMethod(beanName, bean, mbd);}}
}

12.finishRefresh

最后一个方法是finishRefresh，这是在bean的实例化、初始化等完成后的一些操作，例如生命周期变更的回调，发送applicationContext刷新完成的广播等，展开看看

protected void finishRefresh() {// 检查是否已经配置了生命周期处理器，如果没有就new一个DefaultLifecycleProcessorinitLifecycleProcessor();// 找到所有实现了Lifecycle接口的bean，按照每个bean设置的生命周期阶段进行分组，再依次调用每个分组中每个bean的start方法，完成生命周期监听的通知getLifecycleProcessor().onRefresh();// 创建一条代表applicationContext刷新完成的事件，交给广播器去广播publishEvent(new ContextRefreshedEvent(this));// 如果配置了MBeanServer，就完成在MBeanServer上的注册LiveBeansView.registerApplicationContext(this);
}

Spring启动流程总结

Spring容器在启动的时候，先会保存所有注册进来的Bean的定义信息；
1.1 xml注册bean；
1.2 注解注册Bean；@Service、@Component、@Bean、xxx
Spring容器会合适的时机创建这些Bean
2.1用到这个bean的时候；利用getBean创建bean；创建好以后保存在容器中；
2.2统一创建剩下所有的bean的时候；finishBeanFactoryInitialization()；
后置处理器；BeanPostProcessor
每一个bean创建完成，都会使用各种后置处理器进行处理；来增强bean的功能；
AutowiredAnnotationBeanPostProcessor:处理自动注入
AnnotationAwareAspectJAutoProxyCreator:来做AOP功能；
事件驱动模型；
ApplicationListener；事件监听；
ApplicationEventMulticaster；事件派发：