浅谈 SpringBean的初始化----主线逻辑 ( 一 )

曾经终败给现在 2021-10-13 00:43 393阅读 0赞

在分析Spring Bean 初始化之前，先来到 DefaultSingletonBeanRegistry 查看三个cache混个眼熟。

/** Cache of singleton objects: bean name to bean instance. */
    	private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
    
    	/** Cache of singleton factories: bean name to ObjectFactory. */
    	private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
    
    	/** Cache of early singleton objects: bean name to bean instance. */
    	private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);

Spring 提供了多种重载和getBean的方法

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NodV94aWFvYmFp_size_16_color_FFFFFF_t_70][]

当我们在执行 beanFactory.getBean("XXBean") 时，其实是在调用 AbstractBeanFactory 中的实现：

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

最终几乎所有的操作都交给doGetBean 去实现的，那下面来看看真正干干活的doGetBean

public <T> T getBean(String name, @Nullable Class<T> requiredType, @Nullable Object... args) throws BeansException {
    
    		return doGetBean(name, requiredType, args, false);
    	}
    
    	/**
    	 * 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> T doGetBean(final String name, @Nullable final Class<T> requiredType, @Nullable final Object[] args,
    			boolean typeCheckOnly) throws BeansException {
    
    		/**
    		 *  获取对应Bean的真正beanName
    		 *  怎么说？
    		 *  因为传入的name 可能是 bean的 别名 也可能是 FactoryBean的name
    		 *  解析 如下：
    		 *  如果是FactoryBean，则去掉修饰符“&”
    		 *   沿着引用链获取alias对应的最终name（从 aliasMap中获取）
    		 */
    		final String beanName = transformedBeanName(name);
    		Object bean;
    
    
    		/**
    		 *  检查 缓存或者实例工厂中 是否 有对应的bean(单例)
    		 *  为什么刚开始需要这么做？
    		 *  因为在 创建单例Bean的时候会存在依赖注入的情况。
    		 *  因而在创建bean的时候为了避免循环依赖,所以这么干
    		 *
    		 *  Spring 创建bean的时候，先去singletonObjects 中获取
    		 *  Spring创建bean的原则是不等bean创建完成就将创建bean的ObjectFactory提早曝光（将对应的ObjectFactory加入到缓存）
    		 *  一旦下一个bean创建需要依赖上一个bean，则直接使用ObjectFactory对象
    		 */
    
    		//直接尝试从缓存中获取，或者singletonfacotory中获取，
    		// 如果是从singletonFactories中获取的 且准许提前曝光 就将 获取到的Bean 放在提前曝光缓存 earlySingletonObjects
    		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.
    
    			/**
    			 *  只有在单例情况才会尝试解决循环依赖
    			 *  原型模式下如果存在 A class中有B Class,B class 中有A Class
    			 *  即满足 isPrototypeCurrentlyInCreation z则跑出循环依赖异常
    			 */
    			if (isPrototypeCurrentlyInCreation(beanName)) {
    				throw new BeanCurrentlyInCreationException(beanName);
    			}
    
    			// Check if bean definition exists in this factory.
    			// 获取parentBeanFactory实例
    			BeanFactory parentBeanFactory = getParentBeanFactory();
    			// 如果在beanDefinitionMap中（已加载的类定义）不包含目标bean，则尝试从parentBeanFactory中获取
    			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.
    					// 递归到BeanFactory中寻找
    					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这里要进行记录，即将beanName加入alreadyCreated集合中
    			if (!typeCheckOnly) {
    				markBeanAsCreated(beanName);
    			}
    
    			try {
    
    				/**
    				 *  将存储XML配置文件的GericBeanDefinition转换为RootBeanDefinition
    				 *  如果存在父bean，则同时合并父bean的相关属性
    				 */
    				final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
    
    				/**
    				 * 检查bean的类定义 ， 如果是 抽象类 则跑出异常
    				 */
    				checkMergedBeanDefinition(mbd, beanName, args);
    
    				// Guarantee initialization of beans that the current bean depends on.
    				// 加载当前bean依赖的bean
    				String[] dependsOn = mbd.getDependsOn();
    				//若存在依赖则要递归实例化依赖的bean
    				if (dependsOn != null) {
    					for (String dep : dependsOn) {
    						// 检查dep是否依赖beanName，从而导致循环依赖
    						if (isDependent(beanName, dep)) {
    							throw new BeanCreationException(mbd.getResourceDescription(), beanName,
    									"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
    						}
    						//注册
    						registerDependentBean(dep, beanName);
    						try {
    							// 缓存依赖调用
    							getBean(dep);
    						} catch (NoSuchBeanDefinitionException ex) {
    							throw new BeanCreationException(mbd.getResourceDescription(), beanName,
    									"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
    						}
    					}
    				}
    
    				// Create bean instance.
    				// 完成加载依赖的bean后，实例化mbd自身
    				if (mbd.isSingleton()) {
    					//singleton模式的创建
    					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);
    						// 创建bean ,addSingletonFactory
    						prototypeInstance = createBean(beanName, mbd, args);
    					} finally {
    						// prototypesCurrentlyInCreation 清理
    						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.
    		//检查需要的类型是否符合bean的实际类型 ,对应getBean时指定的requireType
    		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;
    	}

代码 贴了name多，看起来也有点转悠，那再来简单概括doGetBean 到底干了啥活

setp 1;

根据参数name 获取真正beanName

step2;

检查缓存/实例工厂中是否有对应的单例(getSingleton)，若存在则进行实例化并返回对象，否则继续往下执行

step3:

原型模式，循环依赖检查。

step4：

如果当前 beanFactory 中不存在目标 bean，则尝试从 parentBeanFactory 递归获取

step5：

getMergedLocalBeanDefinition（将之前解析过程返得到的 GenericBeanDefinition 对象合并为 RootBeanDefinition 对象，同事合并父类属性）

step6：

若存在依赖则要递归实例化依赖的bean

step7：

根据不同作用域对bean实例化

step8：

检查bean的类型要求，如有要求则做类型转换

step9:：

返回bean 实例。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NodV94aWFvYmFp_size_16_color_FFFFFF_t_70]: /images/20211013/ea0b76b981414465a6d1c3a2608e929e.png