Spring源码阅读

参考资料：spring源码深度解析
Spring版本：Spring-4.3.5-RELEASE

吐槽下，老外写的东西真晕啊，像亲妈一样啰啰嗦嗦帮你考虑了各种情况，然后最好还不忘加一句：
如果你不满意，还可以拓展！！！

1.spring 核心代码

1.1 核心流程初始化过程

非常清晰的模板方法，每一个步骤封装成一个具体的函数进行代理，职责清晰明了；

@Override
public void refresh() throws BeansException, IllegalStateException {
   synchronized (this.startupShutdownMonitor) {
      //预热，做准备工作
      prepareRefresh();
 
      // Tell the subclass to refresh the internal bean factory.
      //获取内部的bean factory
      ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
 
      // Prepare the bean factory for use in this context.
      //预热beanFactory
      prepareBeanFactory(beanFactory);
 
      try {
         // Allows post-processing of the bean factory in context subclasses.
         postProcessBeanFactory(beanFactory);
 
         // Invoke factory processors registered as beans in the context.
         //beanFactory在上下文中注册bean，核心的代码就在这里
         invokeBeanFactoryPostProcessors(beanFactory);
 
         // Register bean processors that intercept bean creation.
         // bean创建的时候拦截并注册bean处理器，这里只创建处理器，真正的创建是在getBean(..)方法里
         registerBeanPostProcessors(beanFactory);
 
         // Initialize message source for this context.
         // 用于支持国际化，比如一些日志的国际化匹配等；
         initMessageSource();
 
         // 为上下文初始化消息传播工具
         initApplicationEventMulticaster();
 
         // Initialize other special beans in specific context subclasses.
         // 钩子方法：额外的beans处理方法
         onRefresh();
 
         // Check for listener beans and register them.
         // 注册监听器
         registerListeners();
 
         // Instantiate all remaining (non-lazy-init) singletons.
         // 实例化非延时加载的bean单例
         finishBeanFactoryInitialization(beanFactory);
 
         // Last step: publish corresponding event.
         // push beans创建完成的消息
         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();
      }
   }
}

1.2 spring 类加载的基本类spring DefaultListableBeanFactory UML示意图：

image.png

1.3 spring bean 创建过程

• 转换beanName
• 尝试从缓存中获取单例
• bean本身的实例化
• 原型模式依赖检测
• parentBeanFactory 检测
• 将gernerecBeanDefinition 转换成 RootBeanDefination
• 寻找依赖
• 根据scope 初始化(init)对应的bean
• 类型转换

/**
 * Return an instance, which may be shared or independent, of the specified bean.
 * @param name the name of the bean to retrieve
 * @param requiredType the required type of the bean to retrieve
 * @param args arguments to use when creating a bean instance using explicit arguments
 * (only applied when creating a new instance as opposed to retrieving an existing one)
 * @param typeCheckOnly whether the instance is obtained for a type check,
 * not for actual use
 * @return an instance of the bean
 * @throws BeansException if the bean could not be created
 */
@SuppressWarnings("unchecked")
protected  T doGetBean(
      final String name, final Class requiredType, final Object[] args, boolean typeCheckOnly)
      throws BeansException {
 
   //转换beanName，我们知道在spring中，bean factory的名称都是类似于 &org.springframework.boot.autoconfigure.internalCachingMetadataReaderFactory
   //因此获取的时候需要进行转换
   final String beanName = transformedBeanName(name);
   Object bean;
 
   // Eagerly check singleton cache for manually registered singletons.
   // 尝试从缓存中获取单例
   Object sharedInstance = getSingleton(beanName);
   if (sharedInstance != null && args == null) {
      if (logger.isDebugEnabled()) {
         if (isSingletonCurrentlyInCreation(beanName)) {
            logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
                  "' that is not fully initialized yet - a consequence of a circular reference");
         }
         else {
            logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
         }
      }
      //实例化
      bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
   }
 
   else {
      // Fail if we're already creating this bean instance:
      // We're assumably within a circular reference.
      // 检测当前依赖的类是否正在创建，如果是，则抛出异常
      if (isPrototypeCurrentlyInCreation(beanName)) {
         throw new BeanCurrentlyInCreationException(beanName);
      }
 
      // Check if bean definition exists in this factory.
      // 如果bean配置不存在则只能去父工厂找
      BeanFactory parentBeanFactory = getParentBeanFactory();
      if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
         // Not found -> check parent.
         String nameToLookup = originalBeanName(name);
         if (args != null) {
            // Delegation to parent with explicit args.
            return (T) parentBeanFactory.getBean(nameToLookup, args);
         }
         else {
            // No args -> delegate to standard getBean method.
            return parentBeanFactory.getBean(nameToLookup, requiredType);
         }
      }
 
      if (!typeCheckOnly) {
     
         markBeanAsCreated(beanName);
      }
 
      try {
         //转换并合并BeanDefinition属性
         final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
         checkMergedBeanDefinition(mbd, beanName, args);
 
         // Guarantee initialization of beans that the current bean depends on.
         // 原型模式的bean需要循环检测依赖  防止出现A->B->A 的循环依赖情况出现
         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);
            }
         }
 
         // Create bean instance.
         // 创建bean实例
         if (mbd.isSingleton()) {
            sharedInstance = getSingleton(beanName, new ObjectFactory