【Review】Spring源码分析之bean加载

川长思鸟来 2022-09-09 06:18 245阅读 0赞

### 1、背景 ###

IOC容器，是Spring的两大特性之一。作为容器，他可以方便地管理bean，以及bean与bean之间的依赖关系。

本篇文章，主要从源码角度介绍在ioc容器中，bean的加载流程。

### 2、源码 ###

#### (1)容器的重要接口/类 ####

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAeXlzeA_size_20_color_FFFFFF_t_70_g_se_x_16]

#### (2) Bean Definition ####

入口：XmlBeanFactory 构造函数中调用 XmlBeanDefinitionReader的loadBeanDefinitions(resource)

**大致分为三个步骤：  
验证xml文件的正确性；  
加载xml，转为Document对象；  
注册bean定义。**

public XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory) throws BeansException { 
    		super(parentBeanFactory);
    		this.reader.loadBeanDefinitions(resource);
    	}
    
    protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
    			throws BeanDefinitionStoreException { 
    			//加载xml，转为Document对象
    			Document doc = doLoadDocument(inputSource, resource);
    			//注册bean定义
    			return registerBeanDefinitions(doc, resource);
    }

以下是注册bean定义的详细代码，可以看到，最后返回了BeanDefinition对象。

public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException { 
    		BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
    		int countBefore = getRegistry().getBeanDefinitionCount();
    		documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
    		return getRegistry().getBeanDefinitionCount() - countBefore;
    	}
    	public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) { 
    		this.readerContext = readerContext;
    		logger.debug("Loading bean definitions");
    		Element root = doc.getDocumentElement();
    		doRegisterBeanDefinitions(root);
    	}
    	protected void doRegisterBeanDefinitions(Element root) { 
    	        preProcessXml(root);
    			parseBeanDefinitions(root, this.delegate);
    			postProcessXml(root);
    	}
    protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) { 
    		if (delegate.isDefaultNamespace(root)) { 
    			NodeList nl = root.getChildNodes();
    			for (int i = 0; i < nl.getLength(); i++) { 
    				Node node = nl.item(i);
    				if (node instanceof Element) { 
    					Element ele = (Element) node;
    					if (delegate.isDefaultNamespace(ele)) { 
    						parseDefaultElement(ele, delegate);
    					}
    					else { 
    						delegate.parseCustomElement(ele);
    					}
    				}
    			}
    		}
    		else { 
    			delegate.parseCustomElement(root);
    		}
    	}
    public BeanDefinition parseCustomElement(Element ele) { 
    		return parseCustomElement(ele, null);
    	}
    
    	public BeanDefinition parseCustomElement(Element ele, BeanDefinition containingBd) { 
    		String namespaceUri = getNamespaceURI(ele);
    		NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
    		if (handler == null) { 
    			error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", ele);
    			return null;
    		}
    		return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
    	}

#### (3) Bean Loading–normal ####

以AbstractBeanFactory的getBean()为例：

**获取beanName；  
尝试从缓存中获取（单例模式下）；  
合并bean定义，merge；  
实例化；  
填充属性；  
初始化。**

public Object getBean(String name) throws BeansException { 
            return doGetBean(name, null, null, false);
        }
    
        protected <T> T doGetBean(
                final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
                throws BeansException { 
            //获取beanName
            final String beanName = transformedBeanName(name);
            Object bean;
    
            //尝试从缓存中获取
            Object sharedInstance = getSingleton(beanName);
            if (sharedInstance != null && args == null) { 
                bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
            }else { 
                ......
    
                //合并bean定义
                final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
                checkMergedBeanDefinition(mbd, beanName, args);
    
                //处理bean依赖
                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);
                        }
                    }
    
                //创建bean实例，根据不同的scope
                if (mbd.isSingleton()) { 
                sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() { 
                            @Override
                            public Object getObject() throws BeansException { 
                                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, new ObjectFactory<Object>() { 
                                @Override
                                public Object getObject() throws BeansException { 
                                    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;
                }
    
    
            }
            return (T) bean;
    
    
        }

我们继续看createBean()方法的细节。

protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException { 
      		Object beanInstance = doCreateBean(beanName, mbdToUse, args);
    		return beanInstance;
    }
    
    protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args){ 
    	//实例化bean.
    		BeanWrapper instanceWrapper = null;
    		if (mbd.isSingleton()) { 
    			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
    		}
    		if (instanceWrapper == null) { 
    			instanceWrapper = createBeanInstance(beanName, mbd, args);
    		}
    		final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
    		Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
    		mbd.resolvedTargetType = beanType;
    
    		// Allow post-processors to modify the merged bean definition.
    		synchronized (mbd.postProcessingLock) { 
    			if (!mbd.postProcessed) { 
    					applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
    				mbd.postProcessed = true;
    			}
    		}
    
    		// Eagerly cache singletons to be able to resolve circular references
    		// even when triggered by lifecycle interfaces like BeanFactoryAware.
    		boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
    				isSingletonCurrentlyInCreation(beanName));
    		if (earlySingletonExposure) { 
    			addSingletonFactory(beanName, new ObjectFactory<Object>() { 
    				@Override
    				public Object getObject() throws BeansException { 
    					return getEarlyBeanReference(beanName, mbd, bean);
    				}
    			});
    		}
    
    		//【重要！！！】初始化bean 实例
    		Object exposedObject = bean;
    		    //填充属性
    			populateBean(beanName, mbd, instanceWrapper);
    			if (exposedObject != null) { 
    				exposedObject = initializeBean(beanName, exposedObject, mbd);
    			}
    	
    		if (earlySingletonExposure) { 
    			Object earlySingletonReference = getSingleton(beanName, false);
    			if (earlySingletonReference != null) { 
    				if (exposedObject == bean) { 
    					exposedObject = earlySingletonReference;
    				}
    				else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) { 
    					String[] dependentBeans = getDependentBeans(beanName);
    					Set<String> actualDependentBeans = new LinkedHashSet<String>(dependentBeans.length);
    					for (String dependentBean : dependentBeans) { 
    						if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) { 
    							actualDependentBeans.add(dependentBean);
    						}
    					}
    				}
    			}
    		}
    
    		//注册bean
    		try { 
    			registerDisposableBeanIfNecessary(beanName, bean, mbd);
    		}
    		catch (BeanDefinitionValidationException ex) { 
    			throw new BeanCreationException(
    					mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
    		}
    
    		return exposedObject;
    }

//实例化bean
    protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) { 
    		try { 
    			Object beanInstance;
    			final BeanFactory parent = this;
    			if (System.getSecurityManager() != null) { 
    				beanInstance = AccessController.doPrivileged(new PrivilegedAction<Object>() { 
    					@Override
    					public Object run() { 
    						return getInstantiationStrategy().instantiate(mbd, beanName, parent);
    					}
    				}, getAccessControlContext());
    			}
    			else { 
    				beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
    			}
    			BeanWrapper bw = new BeanWrapperImpl(beanInstance);
    			initBeanWrapper(bw);
    			return bw;
    		}
    		catch (Throwable ex) { 
    			throw new BeanCreationException(
    					mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
    		}
    	}
    	public Object instantiate(RootBeanDefinition bd, String beanName, BeanFactory owner) { 
    	if (bd.getMethodOverrides().isEmpty()) { 
    		//通过构造函数实例化bean
    		Constructor<?> constructorToUse;
    		Constructor<?> constructorToUse;
    			synchronized (bd.constructorArgumentLock) { 
    				constructorToUse = (Constructor<?>) bd.resolvedConstructorOrFactoryMethod;
    				if (constructorToUse == null) { 
    					final Class<?> clazz = bd.getBeanClass();
    					if (clazz.isInterface()) { 
    						throw new BeanInstantiationException(clazz, "Specified class is an interface");
    					}
    					try { 
    						if (System.getSecurityManager() != null) { 
    							constructorToUse = AccessController.doPrivileged(new PrivilegedExceptionAction<Constructor<?>>() { 
    								@Override
    								public Constructor<?> run() throws Exception { 
    									return clazz.getDeclaredConstructor((Class[]) null);
    								}
    							});
    						}
    						else { 
    							constructorToUse =	clazz.getDeclaredConstructor((Class[]) null);
    						}
    						bd.resolvedConstructorOrFactoryMethod = constructorToUse;
    					}
    					catch (Throwable ex) { 
    						throw new BeanInstantiationException(clazz, "No default constructor found", ex);
    					}
    				}
    			}
    			return BeanUtils.instantiateClass(constructorToUse);
    	}else { 
    	  return instantiateWithMethodInjection(bd, beanName, owner);
    	}
    }
    //填充属性
    	protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) { 
       ......
    if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
    				mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) { 
    			MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
    
    			// Add property values based on autowire by name if applicable.
    			if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) { 
    				autowireByName(beanName, mbd, bw, newPvs);
    			}
    
    			// Add property values based on autowire by type if applicable.
    			if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) { 
    				autowireByType(beanName, mbd, bw, newPvs);
    			}
    
    			pvs = newPvs;
    		}
    	......
    	applyPropertyValues(beanName, mbd, bw, pvs);
    }

#### (4) Bean Loading–FactoryBean ####

在(3)中，我们介绍了普通bean加载的流程。但有时候，对于一个有复杂的定义的bean，如果扔通过上述方式创建bean，就会比较繁琐了。Spring提供了工厂类来处理这种情况，即FactoryBean。

实现了FactoryBean接口的bean，在加载时，容器会进行判断，若要加载的bean是FactoryBean类型的，就会根据其定义，创建一个新的bean，并将新的bean返回。

源码分析，以\*\*DefaultListableBeanFactory类的getBean(Class)\*\*为例。

public <T> T getBean(Class<T> requiredType, Object... args) throws BeansException { 
            NamedBeanHolder<T> namedBean = resolveNamedBean(requiredType, args);
            if (namedBean != null) { 
                return namedBean.getBeanInstance();
            }
            BeanFactory parent = getParentBeanFactory();
            if (parent != null) { 
                return parent.getBean(requiredType, args);
            }
            throw new NoSuchBeanDefinitionException(requiredType);
        }
    
    
        private <T> NamedBeanHolder<T> resolveNamedBean(Class<T> requiredType, Object... args) throws BeansException { 
          //根据类型加载beanName
          String[] candidateNames = getBeanNamesForType(requiredType);
    
          ......
          //根据获取到的beanName加载bean
          getBean();
        }

private String[] doGetBeanNamesForType(ResolvableType type, boolean includeNonSingletons, boolean allowEagerInit) { 
            List<String> result = new ArrayList<String>();
    
            //校验所有bean的定义
            for (String beanName : this.beanDefinitionNames) { 
                // Only consider bean as eligible if the bean name
                // is not defined as alias for some other bean.
                if (!isAlias(beanName)) { 
                       //为了方便查看，把try catch去掉了
    
                       //获取根的bean定义
                        RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
                        // Only check bean definition if it is complete.
                        if (!mbd.isAbstract() && (allowEagerInit ||
                                ((mbd.hasBeanClass() || !mbd.isLazyInit() || isAllowEagerClassLoading())) &&
                                        !requiresEagerInitForType(mbd.getFactoryBeanName()))) { 
    
                            // 【重要！！！】判断是否是FactoryBean类型
                            boolean isFactoryBean = isFactoryBean(beanName, mbd);
                            BeanDefinitionHolder dbd = mbd.getDecoratedDefinition();
                            boolean matchFound =
                                    (allowEagerInit || !isFactoryBean ||
                                            (dbd != null && !mbd.isLazyInit()) || containsSingleton(beanName)) &&
                                    (includeNonSingletons ||
                                            (dbd != null ? mbd.isSingleton() : isSingleton(beanName))) &&
                                    isTypeMatch(beanName, type);
                            if (!matchFound && isFactoryBean) { 
    
                                // 如果是FactoryBean，修改BeanName，加上"&"前缀。
                                beanName = FACTORY_BEAN_PREFIX + beanName;
                                matchFound = (includeNonSingletons || mbd.isSingleton()) && isTypeMatch(beanName, type);
                            }
                            if (matchFound) { 
                                result.add(beanName);
                            }
                    }
                }
            }
    
            // 校验已注册的实例
            for (String beanName : this.manualSingletonNames) { 
                    //和上述的处理类似
                    // In case of FactoryBean, match object created by FactoryBean.
                    if (isFactoryBean(beanName)) { 
                        if ((includeNonSingletons || isSingleton(beanName)) && isTypeMatch(beanName, type)) { 
                            result.add(beanName);
                            // Match found for this bean: do not match FactoryBean itself anymore.
                            continue;
                        }
                        // In case of FactoryBean, try to match FactoryBean itself next.
                        beanName = FACTORY_BEAN_PREFIX + beanName;
                    }
                    // Match raw bean instance (might be raw FactoryBean).
                    if (isTypeMatch(beanName, type)) { 
                        result.add(beanName);
                    }
            }
    
            return StringUtils.toStringArray(result);
        }
    
    
    
        protected boolean isFactoryBean(String beanName, RootBeanDefinition mbd) { 
            Class<?> beanType = predictBeanType(beanName, mbd, FactoryBean.class);
            return (beanType != null && FactoryBean.class.isAssignableFrom(beanType));
        }

附：  
bean加载的详细流程图（图源网络）  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAeXlzeA_size_20_color_FFFFFF_t_70_g_se_x_16 1]

### 3、小结 ###

*  容器的bean和FactoryBean：  
    大多数框架、容器、工具类，都会提供至少两种模式。一是适用于一般情况的处理方式，另一类是用户自定义模式，方便扩展和适用其他场景。
 *  Spring中用于存储bean定义的map和BeanUtils  
    虽然做一件事的流程很复杂，但最根本的实现方式是很简单的。要深入研究，也要大胆设想，然后去验证。分清主次，剔除一些细节的问题，会更方便的掌握主要逻辑。
 *  populateBean()中的ByName/ByType，判断是否单例等  
    看源码时，一定要和实践结合起来，分析思考。不要孤立。

[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAeXlzeA_size_20_color_FFFFFF_t_70_g_se_x_16]: /images/20220829/4d47314c00944b9cb5974eb34c7197bb.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAeXlzeA_size_20_color_FFFFFF_t_70_g_se_x_16 1]: /images/20220829/f446970d84d24822827a16ea7383d30d.png