Spring的IOC容器创建源码分析

Spring的IOC源码分析

IOC简介：

• IOC是一个容器
• 容器启动的时候创建所有的单实例对象
• 我们可以直接从容器中获取这些对象

SpringIOC要解决的问题

1.IOC的启动过程？启动期间都做了什么？（什么时候创建了所有的单实例bean）

2.IOC是如何创建这些单实例bean，并如何管理的？到底保存在了哪里？

我们从HelloWorld开始，调试每个方法的作用

ApplicationContext ioc = new ClassPathXmlApplicationContext(“bean.xml”);

1.ClassPathXmlApplicationContext构造器

此时调用的构造器

public ClassPathXmlApplicationContext(String configLocation) throws BeansException {
    this(new String[] {configLocation}, true, null);
}

在构造器中调用了三个参数的构造器
    
public ClassPathXmlApplicationContext(
   String[] configLocations, boolean refresh, @Nullable ApplicationContext parent) 
    throws BeansException {
    
	//使用给定的父上下文创建新的AbstractApplicationContext  我们这里传的null  所以没有
    super(parent);
    setConfigLocations(configLocations);  //设置配置文件位置
    if (refresh) {
        refresh();        //所有单实例bean创建完成（重要）
    }
}

然后我们主要来看一下它调用的父抽象类AbstractApplicationContext的refresh（）方法

public void refresh() throws BeansException, IllegalStateException {
    
    //同步锁，保证多线程情况下IOC容器只会被创建一次
   synchronized (this.startupShutdownMonitor) {
	 
       //做一些初始化的准备工作
      prepareRefresh();

      //告诉子类刷新内部bean工厂
      ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

      //准备BeanFactory以供在此上下文中使用
      prepareBeanFactory(beanFactory);

      try {
         //做一些预备工作以及一些设定  我们不用管它
         postProcessBeanFactory(beanFactory);

         invokeBeanFactoryPostProcessors(beanFactory);

         registerBeanPostProcessors(beanFactory);

         initMessageSource();

         initApplicationEventMulticaster();

         // 专门留给子类的 ，是一个空方法
         onRefresh();

         // 注册监听器
         registerListeners();

         // 初始化所有的没有懒加载的单实例bean（重要）
         finishBeanFactoryInitialization(beanFactory);

         //最后一步：发布相应的事件
         finishRefresh();
      }

      catch (BeansException ex) {
         if (logger.isWarnEnabled()) {
            logger.warn("Exception encountered during context initialization - " +
                  "cancelling refresh attempt: " + ex);
         }

         //捕捉到BeansException异常就销毁已经创建的单实例bean以避免悬空资源
         destroyBeans();

         //重置活动标志.
         cancelRefresh(ex);

         throw ex;
      }

      finally {
         // Reset common introspection caches in Spring's core, since we
         // might not ever need metadata for singleton beans anymore...
         resetCommonCaches();
      }
   }
}

主要一步finishBeanFactoryInitialization(beanFactory);方法初始化了所有的单实例bean

进入AbstractApplicationContext类：

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));
   }

   //如果没有bean后处理程序，则注册一个默认的嵌入式值解析器 不管它
   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();
}

接着跟进 DefaultListableBeanFactory类：bean工厂调用beanFactory.preInstantiateSingletons()方法创建bean

public void preInstantiateSingletons() throws BeansException {
   if (logger.isTraceEnabled()) {
      logger.trace("Pre-instantiating singletons in " + this);
   }

   //拿到所有要创建的bean名字
   List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

   //按照顺序创建bean
   for (String beanName : beanNames) {
       
       //拿到bean的定义信息（详细信息，类型啊，scope啊，是否懒加载啊）
      RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
       
       //bean不是抽象的，并且不是单实例的，并且不是懒加载的 才创建
      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 {
             //不是实现了FactoryBean接口的bean，在这里创建（重要）
            getBean(beanName);
         }
      }
   }

   //为所有适用的bean触发初始化后回调
   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();
         }
      }
   }
}

来到AbstractBeanFactory类的getBean(beanName);方法

它里面重载的所有getBean（）方法都会调用四个参数的doGetBean（）方法

public Object getBean(String name) throws BeansException {
   return doGetBean(name, null, null, false);
}

doGetBean方法

protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
      @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {

    //先得到要创建的bean名字
   final String beanName = transformedBeanName(name);
   Object bean;

   //先从缓存里检查已经注册的单实例bean里有没有，第一次创建bean是没有的
   Object sharedInstance = getSingleton(beanName);
   if (sharedInstance != null && args == null) {
      if (logger.isTraceEnabled()) {
         if (isSingletonCurrentlyInCreation(beanName)) {
            logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
                  "' that is not fully initialized yet - a consequence of a circular reference");
         }
         else {
            logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
         }
      }
      bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
   }

   else {
      // 检查是否多例，若已经创建过，则失败
      if (isPrototypeCurrentlyInCreation(beanName)) {
         throw new BeanCurrentlyInCreationException(beanName);
      }

      // 拿到父工厂，这里为空，用自己的工厂
      BeanFactory parentBeanFactory = getParentBeanFactory();
      if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
         // Not found -> check parent.
         String nameToLookup = originalBeanName(name);
         if (parentBeanFactory instanceof AbstractBeanFactory) {
            return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
                  nameToLookup, requiredType, args, typeCheckOnly);
         }
         else if (args != null) {
            // Delegation to parent with explicit args.
            return (T) parentBeanFactory.getBean(nameToLookup, args);
         }
         else if (requiredType != null) {
            // No args -> delegate to standard getBean method.
            return parentBeanFactory.getBean(nameToLookup, requiredType);
         }
         else {
            return (T) parentBeanFactory.getBean(nameToLookup);
         }
      }
	 //我们传过来的  false
      if (!typeCheckOnly) {
          //标志一下bean将被创建
         markBeanAsCreated(beanName);
      }

      try {
          //获取当前bean的总合并信息
         final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
         checkMergedBeanDefinition(mbd, beanName, args);

         //拿到当前bean所依赖的所有bean
         String[] dependsOn = mbd.getDependsOn();
         if (dependsOn != null) {
             //循环创建当前bean所需要依赖的bean  
            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 {
                   //创建所要依赖的bean
                  getBean(dep);
               }
               catch (NoSuchBeanDefinitionException ex) {
                  throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                        "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
               }
            }
         }

         // 没有所需要依赖的bean就创建bean实例（重要）
         if (mbd.isSingleton()) {

            sharedInstance = getSingleton(beanName, () -> {
               try {
                  return createBean(beanName, mbd, args);
               }
               catch (BeansException ex) {
                  // Explicitly remove instance from singleton cache: It might have been put there
                  // eagerly by the creation process, to allow for circular reference resolution.
                  // Also remove any beans that received a temporary reference to the bean.
                  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, () -> {
                  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 && !requiredType.isInstance(bean)) {
      try {
         T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
         if (convertedBean == null) {
            throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
         }
         return convertedBean;
      }
      catch (TypeMismatchException ex) {
         if (logger.isTraceEnabled()) {
            logger.trace("Failed to convert bean '" + name + "' to required type '" +
                  ClassUtils.getQualifiedName(requiredType) + "'", ex);
         }
         throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
      }
   }
   return (T) bean;
}

DefaultSingletonBeanRegistry类

//IOC容器之一 :保存单实例bean的容器
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);

getSingleton（）方法

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
   Assert.notNull(beanName, "Bean name must not be null");
   synchronized (this.singletonObjects) {
       
       //先从容器中看看能不能将beanget出来   若没有  就创建
      Object singletonObject = this.singletonObjects.get(beanName);
      if (singletonObject == null) {
         if (this.singletonsCurrentlyInDestruction) {
            throw new BeanCreationNotAllowedException(beanName,
                  "Singleton bean creation not allowed while singletons of this factory are in destruction " +
                  "(Do not request a bean from a BeanFactory in a destroy method implementation!)");
         }
         if (logger.isDebugEnabled()) {
            logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
         }
         beforeSingletonCreation(beanName);
         boolean newSingleton = false;
         boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
         if (recordSuppressedExceptions) {
            this.suppressedExceptions = new LinkedHashSet<>();
         }
         try {
             
            //利用反射创建bean（重要）
            singletonObject = singletonFactory.getObject();
            newSingleton = true;
         }
         catch (IllegalStateException ex) {
            // Has the singleton object implicitly appeared in the meantime ->
            // if yes, proceed with it since the exception indicates that state.
            singletonObject = this.singletonObjects.get(beanName);
            if (singletonObject == null) {
               throw ex;
            }
         }
         catch (BeanCreationException ex) {
            if (recordSuppressedExceptions) {
               for (Exception suppressedException : this.suppressedExceptions) {
                  ex.addRelatedCause(suppressedException);
               }
            }
            throw ex;
         }
         finally {
            if (recordSuppressedExceptions) {
               this.suppressedExceptions = null;
            }
            afterSingletonCreation(beanName);
         }
         if (newSingleton) {
             //向容器中添加创建的bean（重要）
            addSingleton(beanName, singletonObject);
         }
      }
      return singletonObject;
   }
}

最后把创建的bean添加到map中

protected void addSingleton(String beanName, Object singletonObject) {
   synchronized (this.singletonObjects) {
      //创建好的对象保存在map中
      this.singletonObjects.put(beanName, singletonObject);
      this.singletonFactories.remove(beanName);
      this.earlySingletonObjects.remove(beanName);
      this.registeredSingletons.add(beanName);
   }
}

取bean的时候就是这个方法：直接从容器中拿到

@Override
@Nullable
public Object getSingleton(String beanName) {
   return getSingleton(beanName, true);
}

即创建单实例bean和获取都在一个方法中，即AbstractBeanFactory的doGetBean（）方法

BeanFactory和ApplicationContext的区别

ApplicationContext是BeanFactory的子接口

BeanFactory：bean工厂接口，负责创建bean实例，容器里保存的所有单例bean其实是一个map

​ 是spring最底层的接口，

ApplicationContext：是容器接口，更多的负责容器功能的实现（可以基于BeanFactory创建好的对象之上完成强大的功能）

​ 容器可以从map中获取这个bean，并且aop，DI也在ApplicationContext接口的实现里，是留给我们程序员使用的IOC 容器接口