Sprin中bean的创建过程

Spring源码

SpringAOP的源码底层实现

都是基于动态代理实现的。

IOC源码

IOC：

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

SpringIOC：

• ioc容器的启动过程？启动期间都做了什么？（什么时候创建所有的单实例bean）
• ioc是如何创建这些单实例bean，并如何管理的，到底保存在了哪里

测试代码

package com.hfwas;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @ClassName SourceTest
 * @Description
 * @Author hfwas
 * @Date:2021/10/7 1:44 下午
 * @Version: 1.0
 **/
public class SourceTest {
    private static ApplicationContext applicationContext = null;
    public static void main(String[] args) {
        applicationContext = new ClassPathXmlApplicationContext("io.xml");
        Object person01 = applicationContext.getBean("person01");
        System.out.println(person01);
    }
}

SpringIOC容器启动创建bean

进入到ClassPathXmlApplicationContext

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

都执行的是ClassPathXmlApplicationContext这个拥有三个参数的构造方法。

// refresh传的默认是true,ApplicationContext传的默认是null
public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, @Nullable ApplicationContext parent) throws BeansException {
    super(parent);
    this.setConfigLocations(configLocations);
    // 方法方形，单实例bean创建。
    if (refresh) {
      	// 单实例bean创建的重点关注点
        this.refresh();
    }

}

refresh方法

public void refresh() throws BeansException, IllegalStateException {
    synchronized(this.startupShutdownMonitor) {
        this.prepareRefresh();
        // spring解析xml配置文件将要创建的所有bean的配置信息保存起来，观看spring对xml的解析
      	//获取BeanFactory；默认实现是DefaultListableBeanFactory，在创建容器的时候创建的
        ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
        // BeanFactory的预准备工作（BeanFactory进行一些设置，比如context的类加载器，BeanPostProcessor和XXXAware自动装配等）
        this.prepareBeanFactory(beanFactory);

        try {
           	// BeanFactory准备工作完成后进行的后置处理工作
          	// BeanFactory的后置处理器
            this.postProcessBeanFactory(beanFactory);
          	// 执行BeanFactoryPostProcessor的方法；
            this.invokeBeanFactoryPostProcessors(beanFactory);
            // 注册BeanPostProcessor（Bean的后置处理器），在创建bean的前后等执行
          	this.registerBeanPostProcessors(beanFactory);
            // 支持国际化功能的，暂时不看
            this.initMessageSource();
          	// 初始化事件派发器
            this.initApplicationEventMulticaster();
            // 留给子类的。在特殊的子类中初始化一些特殊的bean。如创建Tomcat，Jetty等WEB服务器
            this.onRefresh();
            // 注册监听器。注册应用的监听器。就是注册实现了ApplicationListener接口的监听器bean，这些监听器是注册到ApplicationEventMulticaster中的
            this.registerListeners();
            // 初始化所有单实例bean的地方。初始化所有剩下的非懒加载的单例bean
            this.finishBeanFactoryInitialization(beanFactory);
          	// 完成context的刷新。主要是调用LifecycleProcessor的onRefresh()方法，并且发布事件（ContextRefreshedEvent）
            this.finishRefresh();
        } catch (BeansException var9) {
            if (this.logger.isWarnEnabled()) {
                this.logger.warn("Exception encountered during context initialization - cancelling refresh attempt: " + var9);
            }

            this.destroyBeans();
            this.cancelRefresh(var9);
            throw var9;
        } finally {
            this.resetCommonCaches();
        }

    }
}

进入this.finishBeanFactoryInitialization方法。

进入到this.finishBeanFactoryInitialization方法，这个方法是属于AbstractApplicationContext抽象类的。

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
    if (beanFactory.containsBean("conversionService") && beanFactory.isTypeMatch("conversionService", ConversionService.class)) {
        beanFactory.setConversionService((ConversionService)beanFactory.getBean("conversionService", ConversionService.class));
    }

    if (!beanFactory.hasEmbeddedValueResolver()) {
        beanFactory.addEmbeddedValueResolver((strVal) -> {
            return this.getEnvironment().resolvePlaceholders(strVal);
        });
    }

    String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
    String[] var3 = weaverAwareNames;
    int var4 = weaverAwareNames.length;

    for(int var5 = 0; var5 < var4; ++var5) {
        String weaverAwareName = var3[var5];
        this.getBean(weaverAwareName);
    }

    beanFactory.setTempClassLoader((ClassLoader)null);
    beanFactory.freezeConfiguration();
    
    // 初始化所有单实例bean:重点
    beanFactory.preInstantiateSingletons();
}

进入到beanFactory.preInstantiateSingletons();方法

beanFactory.preInstantiateSingletons()方法属于DefaultListableBeanFactory类。DefaultListableBeanFactory：bean工厂，创建bean的

@Override
	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) {
      // 根据beanid获取到bean的定义信息   
			RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
      // 判断bean不是抽象的 且 是单例的 且bean不是懒加载的
			if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
        // 判断bean是否是有继承factoryBean的工厂bean创建的bean
				if (isFactoryBean(beanName)) {
					Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
					if (bean instanceof FactoryBean) {
						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);
						}
					}
				}
        // 不是有继承自factoryBean的bean创建的bean，执行此方法。是重点关注的方法
				else {
          // 创建bean的细节
					getBean(beanName);
				}
			}
		}

		// Trigger post-initialization callback for all applicable beans...
		for (String beanName : beanNames) {
			Object singletonInstance = getSingleton(beanName);
			if (singletonInstance instanceof SmartInitializingSingleton) {
				SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
				if (System.getSecurityManager() != null) {
					AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
						smartSingleton.afterSingletonsInstantiated();
						return null;
					}, getAccessControlContext());
				}
				else {
					smartSingleton.afterSingletonsInstantiated();
				}
			}
		}
	}

进入getBean(beanName);方法。

getBean(beanName)方法是属于AbstractBeanFactory抽象类的。getBean方法都会调用doGetBean的四个参数的构造方法。

public Object getBean(String name) throws BeansException {
    return this.doGetBean(name, (Class)null, (Object[])null, false);
}

doGetBean方法代码：

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

   String beanName = transformedBeanName(name);
   Object bean;

   // 先从已经注册的所有单实例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 {
      // 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.
      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);
         }
      }
			
      // 类型检查。如果bean已经被创建，标记为已经创建
      if (!typeCheckOnly) {
         markBeanAsCreated(beanName);
      }

      try {
         RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
         checkMergedBeanDefinition(mbd, beanName, args);

         // Guarantee initialization of beans that the current bean depends on.
         // 拿到创建当前bean之前需要提前创建的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);
               try {
                 	// 如果当前bean创建需要依赖其他bean，先创建被依赖的bean.调用getbena方法创建
                  getBean(dep);
               }
               catch (NoSuchBeanDefinitionException ex) {
                  throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                        "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
               }
            }
         }

         // Create bean instance.创建bean实例
         // 如果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();
            if (!StringUtils.hasLength(scopeName)) {
               throw new IllegalStateException("No scope name defined for bean ´" + beanName + "'");
            }
            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;
}

getSingleton(String beanName, boolean allowEarlyReference) 方法

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
        Assert.notNull(beanName, "Bean name must not be null");
        synchronized(this.singletonObjects) {
          	// 根据beanname从singletonObjects获取bean，第一次是没有的。为空
            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 (this.logger.isDebugEnabled()) {
                    this.logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
                }
								// 在bean创建之间一些操作。
                this.beforeSingletonCreation(beanName);
                boolean newSingleton = false;
                boolean recordSuppressedExceptions = this.suppressedExceptions == null;
                if (recordSuppressedExceptions) {
                    this.suppressedExceptions = new LinkedHashSet();
                }

                try {
                  	// 从Factory获取对象。调用的是传进来的singletonFactory的getObject方法。返回的是当前bean名称对应的实例信息。
                    singletonObject = singletonFactory.getObject();
                    newSingleton = true;
                } catch (IllegalStateException var16) {
                    singletonObject = this.singletonObjects.get(beanName);
                    if (singletonObject == null) {
                        throw var16;
                    }
                } catch (BeanCreationException var17) {
                    BeanCreationException ex = var17;
                    if (recordSuppressedExceptions) {
                        Iterator var8 = this.suppressedExceptions.iterator();

                        while(var8.hasNext()) {
                            Exception suppressedException = (Exception)var8.next();
                            ex.addRelatedCause(suppressedException);
                        }
                    }

                    throw ex;
                } finally {
                    if (recordSuppressedExceptions) {
                        this.suppressedExceptions = null;
                    }

                    this.afterSingletonCreation(beanName);
                }

                if (newSingleton) {
                  	// 创建好的对象会保存在map当中
                    this.addSingleton(beanName, singletonObject);
                }
            }

            return singletonObject;
        }
    }

存储创建的bean,根据bean name->bean实例信息

使用ConcurrentHashMap数据结构来存储。key:beanname,value:bean实例信息

/** Cache of singleton objects: bean name to bean instance. */
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);

addSingleton方法。会把创建好的bean信息存入singletonObjects

protected void addSingleton(String beanName, Object singletonObject) {
    synchronized(this.singletonObjects) {
      	// 会把当前创建好的bean信息放入singletonObjects中。
      	// singletonObjects是一个map集合
        // 按照beanname -> bean实例信息
        this.singletonObjects.put(beanName, singletonObject);
        this.singletonFactories.remove(beanName);
        this.earlySingletonObjects.remove(beanName);
        this.registeredSingletons.add(beanName);
    }
}

至此bean的创建过程就完成了。

BeanFactory和ApplicationContext的区别：

ApplicationContext是BeanFactory的字接口；

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

​ spring自底层的接口；

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

​ 容器可以从map获取这个bena,并且aop,di,在ApplicationContext接口的下这些类里面。

BeanFactory：最底层的接口，ApplicationContext留给程序员使用的ioc容器接口；ApplicationContext是BeanFactory的字接口；