Springframework源码解析-doGetBean源码详解

青旅半醒 2024-03-24 11:29 57阅读 0赞

#### 1. doGetBean方法源码解析 ####

protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
    			@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
    
    		/**
    		 * 通过name获取BeanName,这里不能使用name作为beanName：
    		 * 1. name可能是别名，通过方法转换为具体的实例名称
    		 * 2. name可能会以&开头，表明调用者想获取FactoryBean本身，而非FactoryBean创建bean
    		 *    FactoryBean 的实现类和其他的 bean 存储方式是一致的，即 <beanName, bean>，
    		 *    beanName 中是没有 & 这个字符的。所以我们需要将 name 的首字符 & 移除，这样才能从
    		 *    缓存里取到 FactoryBean 实例。
    		 *
    		 */
    		final String beanName = transformedBeanName(name);
    		Object bean;
    
    		// 从缓存中获取bean
    		Object sharedInstance = getSingleton(beanName);
    
    		/*
    		 * 如果 sharedInstance = null，则说明缓存里没有对应的实例，表明这个实例还没创建。
    		 *( BeanFactory 并不会在一开始就将所有的单例 bean 实例化好，而是在调用 getBean 获取bean 时再实例化，也就是懒加载)。
    		 * getBean 方法有很多重载，比如 getBean(String name, Object... args)，我们在首次获取
    		 * 某个 bean 时，可以传入用于初始化 bean 的参数数组（args），BeanFactory 会根据这些参数
    		 * 去匹配合适的构造方法构造 bean 实例。当然，如果单例 bean 早已创建好，这里的 args 就没有
    		 * 用了，BeanFactory 不会多次实例化单例 bean。
    		 */
    		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 + "'");
    				}
    			}
    
    			/*
    			 * 如果 sharedInstance 是普通的单例 bean，下面的方法会直接返回。但如果
    			 * sharedInstance 是 FactoryBean 类型的，则需调用 getObject 工厂方法获取真正的
    			 * bean 实例。如果用户想获取 FactoryBean 本身，这里也不会做特别的处理，直接返回
    			 * 即可。毕竟 FactoryBean 的实现类本身也是一种 bean，只不过具有一点特殊的功能而已。
    			 */
    			bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    		}
    
    		/*
    		 * 如果上面的条件不满足，则表明 sharedInstance 可能为空，此时 beanName 对应的 bean
    		 * 实例可能还未创建。这里还存在另一种可能，如果当前容器有父容器，beanName 对应的 bean 实例
    		 * 可能是在父容器中被创建了，所以在创建实例前，需要先去父容器里检查一下。
    		 */
    		else {
    			// BeanFactory 不缓存 Prototype 类型的 bean，无法处理该类型 bean 的循环依赖问题
                //判断是否存在循环依赖
    			if (isPrototypeCurrentlyInCreation(beanName)) {
    				throw new BeanCurrentlyInCreationException(beanName);
    			}
    
    			// 如果 sharedInstance = null，则到父容器中查找 bean 实例
    			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);
    				}
    			}
    
    			if (!typeCheckOnly) {
    				markBeanAsCreated(beanName);
    			}
    
    			try {
    				// 合并父 BeanDefinition 与子 BeanDefinition
    				final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
    				checkMergedBeanDefinition(mbd, beanName, args);
    
    				// 检查是否有 dependsOn 依赖，如果有则先初始化所依赖的 bean
    				String[] dependsOn = mbd.getDependsOn();
    				if (dependsOn != null) {
    					for (String dep : dependsOn) {
    
    						/*
    						 * 检测是否存在 depends-on 循环依赖，若存在则抛异常。比如 A 依赖 B，
    						 * B 又依赖 A，他们的配置如下：
    						 *   <bean id="beanA" class="BeanA" depends-on="beanB">
    						 *   <bean id="beanB" class="BeanB" depends-on="beanA">
    						 *
    						 * beanA 要求 beanB 在其之前被创建，但 beanB 又要求 beanA 先于它
    						 * 创建。这个时候形成了循环，对于 depends-on 循环，Spring 会直接
    						 * 抛出异常
    						 */
    
    						if (isDependent(beanName, dep)) {
    							throw new BeanCreationException(mbd.getResourceDescription(), beanName,
    									"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
    						}
    						// 注册依赖记录