SpringIOC源码解析(下)

注意，看完这篇文章需要很长很长很长时间。。。

本篇文章是SpringIOC源码解析（上）的续集，上一篇文章介绍了使用XML的方式启动Spring，然后追踪了BeanFactory容器的创建、配置文件的解析、Bean的注册等,本篇文章继续分析Bean的初始化流程





12. `finishBeanFactoryInitialization()`

前方超长篇幅预警。。。

刚才我们提到了bean还没有初始化。这个方法就是负责初始化所有的没有设置懒加载的singleton bean

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));      }        //先初始化 LoadTimeWeaverAware 类型的 Bean      String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);      for (String weaverAwareName : weaverAwareNames) {         getBean(weaverAwareName);      }       //停止使用用于类型匹配的临时类加载器      beanFactory.setTempClassLoader(null);      //冻结所有的bean定义，即已注册的bean定义将不会被修改或后处理      beanFactory.freezeConfiguration();      //初始化      beanFactory.preInstantiateSingletons();   }

上方没有解释的代码往下看吧

conversionService

这种类型的bean最实用的场景就是用来将前端传过来的参数和后端的controller方法上的参数格式转换的时候使用

例如：前端要传一个String，后端使用Date接受的时候就可以这样操作

public class StringToDateConverter implements Converter<String, Date> {
    @Override    public Date convert(String date) {        try {            return dateFormat.parse(date);        } catch (Exception e) {            e.printStackTrace();            System.out.println("日期转换失败!");            return null;        }            }}

再搞个bean

<bean id="conversionService"  class="org.springframework.context.support.ConversionServiceFactoryBean">  <property name="converters">    <list>      <bean class="cn.shiyujun.utils.StringToDateConverter"/>    </list>  </property>  </bean>

 EmbeddedValueResolver

利用EmbeddedValueResolver可以很方便的实现读取配置文件的属性

@Componentpublic class PropertiesUtil implements EmbeddedValueResolverAware {
    private StringValueResolver resolver;
    @Override    public void setEmbeddedValueResolver(StringValueResolver resolver) {        this.resolver = resolver;    }

    /**     * 获取属性时直接传入属性名称即可     */    public String getPropertiesValue(String key) {        StringBuilder name = new StringBuilder("${").append(key).append("}");        return resolver.resolveStringValue(name.toString());    }
}

初始化
敲黑板了，重点来了。。。

这里分析`beanFactory.preInstantiateSingletons()`方法

public void preInstantiateSingletons() throws BeansException {   if (this.logger.isDebugEnabled()) {      this.logger.debug("Pre-instantiating singletons in " + this);   }   // this.beanDefinitionNames 保存了所有的 beanNames   List<String> beanNames = new ArrayList<String>(this.beanDefinitionNames);
   for (String beanName : beanNames) {
      // 合并父 Bean 中的配置，主意<bean id="" class="" parent="" /> 中的 parent属性      RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
      // 不是抽象类、是单例的且不是懒加载的      if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {         // 处理 FactoryBean         if (isFactoryBean(beanName)) {            //在 beanName 前面加上“&” 符号            final FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);            // 判断当前 FactoryBean 是否是 SmartFactoryBean 的实现            boolean isEagerInit;            if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {               isEagerInit = AccessController.doPrivileged(new PrivilegedAction<Boolean>() {                  @Override                  public Boolean run() {                     return ((SmartFactoryBean<?>) factory).isEagerInit();                  }               }, getAccessControlContext());            }            else {               isEagerInit = (factory instanceof SmartFactoryBean &&                     ((SmartFactoryBean<?>) factory).isEagerInit());            }            if (isEagerInit) {
               getBean(beanName);            }         }         else {            // 不是FactoryBean的直接使用此方法进行初始化            getBean(beanName);         }      }   }

     // 如果bean实现了 SmartInitializingSingleton 接口的，那么在这里得到回调   for (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>() {               @Override               public Object run() {                  smartSingleton.afterSingletonsInstantiated();                  return null;               }            }, getAccessControlContext());         }         else {            smartSingleton.afterSingletonsInstantiated();         }      }   }}

可以看到，不管是不是FactoryBean，最后都调用了`getBean(beanName)`，继续看这个方法吧

@Overridepublic Object getBean(String name) throws BeansException {   return doGetBean(name, null, null, false);}
protected <T> T doGetBean(      final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)      throws BeansException {   // 获取beanName，处理两种情况，一个是前面说的 FactoryBean(前面带 ‘&’)，再一个这个方法是可以根据别名来获取Bean的，所以在这里是要转换成最正统的BeanName  //主要逻辑就是如果是FactoryBean就把&去掉如果是别名就把根据别名获取真实名称后面就不贴代码了   final String beanName = transformedBeanName(name);
   //最后的返回值   Object bean;
   // 检查是否已初始化   Object sharedInstance = getSingleton(beanName);  //如果已经初始化过了，且没有传args参数就代表是get，直接取出返回   if (sharedInstance != null && args == null) {      if (logger.isDebugEnabled()) {         if (isSingletonCurrentlyInCreation(beanName)) {            logger.debug("...");         }         else {            logger.debug("Returning cached instance of singleton bean '" + beanName + "'");         }      }      // 这里如果是普通Bean 的话，直接返回，如果是 FactoryBean 的话，返回它创建的那个实例对象      bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);   }
   else {      // 如果存在prototype类型的这个bean      if (isPrototypeCurrentlyInCreation(beanName)) {                throw new BeanCurrentlyInCreationException(beanName);      }
      // 如果当前BeanDefinition不存在这个bean且具有父BeanFactory      BeanFactory parentBeanFactory = getParentBeanFactory();      if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {         String nameToLookup = originalBeanName(name);      // 返回父容器的查询结果         if (args != null) {            return (T) parentBeanFactory.getBean(nameToLookup, args);         }         else {            return parentBeanFactory.getBean(nameToLookup, requiredType);         }      }
      if (!typeCheckOnly) {         // typeCheckOnly 为 false，将当前 beanName 放入一个 alreadyCreated 的 Set 集合中。         markBeanAsCreated(beanName);      }
      /*       * 到这就要创建bean了       */      try {         final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);         checkMergedBeanDefinition(mbd, beanName, args);
         // 先初始化依赖的所有 Bean， depends-on 中定义的依赖         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);            }         }
         // 如果是单例的         if (mbd.isSingleton()) {            sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {               @Override               public Object getObject() throws BeansException {                  try {                     // 执行创建 Bean，下面说                     return createBean(beanName, mbd, args);                  }                  catch (BeansException ex) {                     destroySingleton(beanName);                     throw ex;                  }               }            });            bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);         }
         // 如果是prototype         else if (mbd.isPrototype()) {            Object prototypeInstance = null;            try {               beforePrototypeCreation(beanName);               // 执行创建 Bean               prototypeInstance = createBean(beanName, mbd, args);            }            finally {               afterPrototypeCreation(beanName);            }            bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);         }
         // 如果不是 singleton 和 prototype 那么就是自定义的scope、例如Web项目中的session等类型，这里就交给自定义scope的应用方去实现         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>() {                  @Override                  public Object getObject() throws BeansException {                     beforePrototypeCreation(beanName);                     try {                        // 执行创建 Bean                        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;      }   }
   //检查bean的类型   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;}

看了上方方法我们知道了原来Spring本身只定义了两种Scope，也知道了SpringMVC的几种Scope是如何实现的了。
然后发现一开始会先判断bean存不存在，如果存在就直接返回了。如果不存在那就要接着往下看`createBean`方法了

protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {   if (logger.isDebugEnabled()) {      logger.debug("Creating instance of bean '" + beanName + "'");   }   RootBeanDefinition mbdToUse = mbd;
   // 确保 BeanDefinition 中的 Class 被加载   Class<?> resolvedClass = resolveBeanClass(mbd, beanName);   if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {      mbdToUse = new RootBeanDefinition(mbd);      mbdToUse.setBeanClass(resolvedClass);   }
   // 准备方法覆写，如果bean中定义了 <lookup-method /> 和 <replaced-method />   try {      mbdToUse.prepareMethodOverrides();   }   catch (BeanDefinitionValidationException ex) {      throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),            beanName, "Validation of method overrides failed", ex);   }
   try {      // 如果有代理的话直接返回      Object bean = resolveBeforeInstantiation(beanName, mbdToUse);      if (bean != null) {         return bean;      }   }   catch (Throwable ex) {      throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,            "BeanPostProcessor before instantiation of bean failed", ex);   }   // 创建 bean   Object beanInstance = doCreateBean(beanName, mbdToUse, args);   if (logger.isDebugEnabled()) {      logger.debug("Finished creating instance of bean '" + beanName + "'");   }   return beanInstance;}
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)      throws BeanCreationException {
   BeanWrapper instanceWrapper = null;   if (mbd.isSingleton()) {    //如果是.factoryBean则从缓存删除      instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);   }   if (instanceWrapper == null) {      // 实例化 Bean，这个方法里面才是终点，下面说      instanceWrapper = createBeanInstance(beanName, mbd, args);   }   //bean实例   final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);   //bean类型   Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);   mbd.resolvedTargetType = beanType;
   synchronized (mbd.postProcessingLock) {      if (!mbd.postProcessed) {         try {            // 循环调用实现了MergedBeanDefinitionPostProcessor接口的postProcessMergedBeanDefinition方法         // Spring对这个接口有几个默认的实现，其中大家最熟悉的一个是操作@Autowired注解的            applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);         }         catch (Throwable ex) {            throw new BeanCreationException(mbd.getResourceDescription(), beanName,                  "Post-processing of merged bean definition failed", ex);         }         mbd.postProcessed = true;      }   }
    // 解决循环依赖问题   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");      }    //当正在创建A时，A依赖B，此时通过（8将A作为ObjectFactory放入单例工厂中进行early expose，此处B需要引用A，但A正在创建，从单例工厂拿到ObjectFactory，从而允许循环依赖      addSingletonFactory(beanName, new ObjectFactory<Object>() {         @Override         public Object getObject() throws BeansException {            return getEarlyBeanReference(beanName, mbd, bean);         }      });   }
   Object exposedObject = bean;   try {      // 负责属性装配,很重要，下面说      populateBean(beanName, mbd, instanceWrapper);      if (exposedObject != null) {         // 这里是处理bean初始化完成后的各种回调，例如init-method、InitializingBean 接口、BeanPostProcessor 接口         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) {      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.");            }         }      }   }
   // 把bean注册到相应的Scope中   try {      registerDisposableBeanIfNecessary(beanName, bean, mbd);   }   catch (BeanDefinitionValidationException ex) {      throw new BeanCreationException(            mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);   }
   return exposedObject;}

到这里第一次初始化的bean也返回了，你以为就这样结束了么。不，还有几个很重要的点

 创建bean实例`createBeanInstance ()`

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {   // 确保已经加载了此 class   Class<?> beanClass = resolveBeanClass(mbd, beanName);
   // 校验类的访问权限   if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {      throw new BeanCreationException(mbd.getResourceDescription(), beanName,            "Bean class isn't public, and non-public access not allowed: " + beanClass.getName());   }      if (mbd.getFactoryMethodName() != null)  {      // 采用工厂方法实例化      return instantiateUsingFactoryMethod(beanName, mbd, args);   }
  //是否第一次   boolean resolved = false;  //是否采用构造函数注入   boolean autowireNecessary = false;   if (args == null) {      synchronized (mbd.constructorArgumentLock) {         if (mbd.resolvedConstructorOrFactoryMethod != null) {            resolved = true;            autowireNecessary = mbd.constructorArgumentsResolved;         }      }   }   if (resolved) {      if (autowireNecessary) {         return autowireConstructor(beanName, mbd, null, null);      }      else {         // 无参构造函数         return instantiateBean(beanName, mbd);      }   }
   // 判断是否采用有参构造函数   Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);   if (ctors != null ||         mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||         mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args))  {      // 构造函数依赖注入      return autowireConstructor(beanName, mbd, ctors, args);   }
   // 调用无参构造函数   return instantiateBean(beanName, mbd);}

选一个无参的构造看一下吧

protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {   try {      Object beanInstance;      final BeanFactory parent = this;      if (System.getSecurityManager() != null) {         beanInstance = AccessController.doPrivileged(new PrivilegedAction<Object>() {            @Override            public Object run() {
               return getInstantiationStrategy().instantiate(mbd, beanName, parent);            }         }, getAccessControlContext());      }      else {         // 具体实例化的实现，往下看         beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);      }      BeanWrapper bw = new BeanWrapperImpl(beanInstance);      initBeanWrapper(bw);      return bw;   }   catch (Throwable ex) {      throw new BeanCreationException(            mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);   }}

public Object instantiate(RootBeanDefinition bd, String beanName, BeanFactory owner) {
   // 如果不存在方法覆写，那就使用 java 反射进行实例化，否则使用 CGLIB,   if (bd.getMethodOverrides().isEmpty()) {      Constructor<?> constructorToUse;      synchronized (bd.constructorArgumentLock) {         constructorToUse = (Constructor<?>) bd.resolvedConstructorOrFactoryMethod;         if (constructorToUse == null) {            final Class<?> clazz = bd.getBeanClass();            if (clazz.isInterface()) {               throw new BeanInstantiationException(clazz, "Specified class is an interface");            }            try {               if (System.getSecurityManager() != null) {                  constructorToUse = AccessController.doPrivileged(new PrivilegedExceptionAction<Constructor<?>>() {                     @Override                     public Constructor<?> run() throws Exception {                        return clazz.getDeclaredConstructor((Class[]) null);                     }                  });               }               else {                  constructorToUse = clazz.getDeclaredConstructor((Class[]) null);               }               bd.resolvedConstructorOrFactoryMethod = constructorToUse;            }            catch (Throwable ex) {               throw new BeanInstantiationException(clazz, "No default constructor found", ex);            }         }      }      // 利用构造方法进行实例化      return BeanUtils.instantiateClass(constructorToUse);   }   else {      // 存在方法覆写，利用 CGLIB 来完成实例化，需要依赖于 CGLIB 生成子类，这里就不展开了      return instantiateWithMethodInjection(bd, beanName, owner);   }}

 bean属性注入`populateBean ()`

protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {   // bean的所有属性   PropertyValues pvs = mbd.getPropertyValues();
   if (bw == null) {      if (!pvs.isEmpty()) {         throw new BeanCreationException(               mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");      }      else {         return;      }   }

   boolean continueWithPropertyPopulation = true;   if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {      for (BeanPostProcessor bp : getBeanPostProcessors()) {         if (bp instanceof InstantiationAwareBeanPostProcessor) {            InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;            // 如果返回 false，代表不需要进行后续的属性设值，也不需要再经过其他的 BeanPostProcessor 的处理            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);
      // 通过名字找到所有属性值，如果是 bean 依赖，先初始化依赖的 bean。记录依赖关系      if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {         autowireByName(beanName, mbd, bw, newPvs);      }
      // 通过类型装配。复杂一些      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);
   if (hasInstAwareBpps || needsDepCheck) {      PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);      if (hasInstAwareBpps) {         for (BeanPostProcessor bp : getBeanPostProcessors()) {            if (bp instanceof InstantiationAwareBeanPostProcessor) {               InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;               // 这里就是上方曾经提到过得对@Autowired处理的一个BeanPostProcessor了               // 它会对所有标记@Autowired、@Value 注解的属性进行设值               pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);               if (pvs == null) {                  return;               }            }         }      }      if (needsDepCheck) {         checkDependencies(beanName, mbd, filteredPds, pvs);      }   }   // 设置 bean 实例的属性值   applyPropertyValues(beanName, mbd, bw, pvs);}

getBean这一块就搞完了

13. `finishRefresh()`

protected void finishRefresh() {      //看名字就知道了，清理刚才一系列操作使用到的资源缓存      clearResourceCaches();
      // 初始化LifecycleProcessor      initLifecycleProcessor();
      // 这个方法的内部实现是启动所有实现了Lifecycle接口的bean      getLifecycleProcessor().onRefresh();
      //发布ContextRefreshedEvent事件      publishEvent(new ContextRefreshedEvent(this));
      // 检查spring.liveBeansView.mbeanDomain是否存在，有就会创建一个MBeanServer      LiveBeansView.registerApplicationContext(this);   }

14. `resetCommonCaches()`
最后一步还是清除缓存

15. `refresh()`总结
上方以及之前的一篇文章，用了这么长的篇幅把整个`refresh()`方法的细节给梳理清楚，这里再把刚开始看的懵懵的`refresh() `方法贴一下
```

public void refresh() throws BeansException, IllegalStateException {    synchronized (this.startupShutdownMonitor) {
      // 记录容器的启动时间、标记“已启动”状态、检查环境变量      prepareRefresh();
      // 初始化BeanFactory容器、注册BeanDefinition      ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
      // 设置 BeanFactory 的类加载器，添加几个 BeanPostProcessor，手动注册几个特殊的 bean      prepareBeanFactory(beanFactory);
      try {         // 扩展点         postProcessBeanFactory(beanFactory);         // 调用 BeanFactoryPostProcessor 各个实现类的 postProcessBeanFactory(factory) 方法         invokeBeanFactoryPostProcessors(beanFactory);
         // 注册 BeanPostProcessor 的实现类         registerBeanPostProcessors(beanFactory);
         // 初始化MessageSource         initMessageSource();
         // 初始化事件广播器         initApplicationEventMulticaster();
         // 扩展点         onRefresh();
         // 注册事件监听器         registerListeners();

         // 初始化所有的 singleton beans         finishBeanFactoryInitialization(beanFactory);
         // 广播事件         finishRefresh();      }
      catch (BeansException ex) {         if (logger.isWarnEnabled()) {            logger.warn("Exception encountered during context initialization - " +                  "cancelling refresh attempt: " + ex);         }
         // 销毁已经初始化的的Bean         destroyBeans();
         // 设置 'active' 状态         cancelRefresh(ex);
         throw ex;      }
      finally {         // 清除缓存         resetCommonCaches();      }   }}

 总结

至此，本文到此结束。鉴于XML方式比较简单、通俗易懂，所以本文基于XML的方式大致介绍了SpringIOC的启动流程、稍微深入的讲解了Bean容器的创建以及Bean的初始化过程。这也是作者第一次阅读开源框架的源码，如文章有错误之处还请您费心指出。

鉴于现在比较流行SpringBoot和SpringCloud，下篇文章将会从基于注解的方向分析SpringIOC

不得不看

1.SpringCloud系列博客汇总

2.为啥一线大厂面试必问Redis，有啥好问的？

3.Java多线程面试必备基础知识汇总

4.Java集合源码分析汇总

5.Linux常用命令汇总

6.JVM系列文章汇总

7.MySQL系列文章汇总

8.RabbitMQ系列文章汇总