作者： 一字馬胡
轉載標志 【2017-12-28】
更新日志
| 日期 | 更新內容 | 備注 |
|---|---|---|
| 2017-12-28 | 創建分析文檔 | Spring源碼分析系列文章（一） |
前言
Spring源碼分析是一個系列，源碼是Spring 4.X，本系列主要分析Spring的代碼執行流程，過于細節的內容將不會涉及太多，主要是為了理清Spring的執行流程，比如Bean的解析是如何進行的，解析完成之后是如何進行加載的等等，對于在Bean的解析過程中涉及的一些細節很大可能不會在本系列的分析中找到，本系列的每一篇文章都是基于Spring源碼的某條主要線索來進行，因為Spring的設計很復雜，并且它是一個工業級的優秀框架，所以未免會進行非常細節的考慮，如果想了解Spring源碼中的某個細節，需要自行去研讀源碼來尋求答案，本系列的文章可以為那些希望對Spring的源碼進行更為深度剖析的讀者提供源碼分析的思路，以至于不會在分析源碼的時候迷失在復雜環繞的分支中找不到位置。
還需要說明的一點是，本系列文章都會包含大量的源碼，有些源碼將包含完整的方法內容，而有些會僅僅提供一條類似于：Class#method的索引，讀者可以根據這些索引在源碼中找到相應的位置，然后繼續分析下去。對于一些方法，本系列的文章內容中出現的源碼可能是經過處理的，比如會將異常處理的代碼去掉，以及那些無關主要流程的代碼去掉，留下那些和分析主線有關的代碼，這樣做的好處是可以避免貼出大量代碼的困擾，并且可以使得每一個方法看起來都是清晰明了的，有助于理解正在分析的流程。
從例子出發
下面是一個使用Spring的簡單例子，這個例子需要有一個model類，一個Spring xml配置文件，以及一個使用Spring的入口類：
public class ModelA {
private int value;
private String str;
@Override
public String toString() {
return "[" + value + ":" + str + "]";
}
public void setValue(int value) {
this.value = value;
}
public void setStr(String str) {
this.str = str;
}
}
public class BaseXmlDemo {
public static void main(String[] args) {
String file = "applicationContext.xml";
ApplicationContext context = new ClassPathXmlApplicationContext(file);
ModelA modelA = (ModelA) context.getBean("modelA");
System.out.println(modelA);
}
}
================Spring xml ============
<bean id="modelA" class="io.spring.ModelA">
<property name="value" value="1993"/>
<property name="str" value="hello"/>
</bean>
本文Spring源碼分析的主題是Spring bean的解析，所謂bean的解析就是將我們的xml文件中的bean解析出來，上面的入口看到使用的是ClassPathXmlApplicationContext來獲取ApplicationContext，所以，本次分析的入口也就從ClassPathXmlApplicationContext類中相應的構造函數開始。首先是調用了下面的構造函數：
public ClassPathXmlApplicationContext(String configLocation) throws BeansException {
this(new String[] {configLocation}, true, null);
}
public ClassPathXmlApplicationContext(
String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)
throws BeansException {
super(parent);
setConfigLocations(configLocations);
if (refresh) {
refresh();
}
}
如果害怕迷失在源碼中，可以選擇一個我們關注的角色來跟蹤代碼，比如我們在bean解析分析的時候，首要關注的應該是我們傳遞進去的xml文件，所以可以在源碼中跟蹤我們傳遞的文件到底到了哪里，然后進行了什么操作。在上面的第二個構造函數中，首先一個比較關系的方法調用是setConfigLocations，這是將我們的xml文件保存起來了，bean的解析來源就是這個xml文件（所以可以看到底是哪個類在什么時候get了這個location）。當然，在這個構造函數中最為重要的一個方法調用是refresh方法，跟蹤進去之后發現到達了AbstractApplicationContext#refresh()，下面是該方法的細節：
AbstractApplicationContext#refresh()
@Override
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// Prepare this context for refreshing.
prepareRefresh();
// Tell the subclass to refresh the internal bean factory.
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// Prepare the bean factory for use in this context.
prepareBeanFactory(beanFactory);
try {
// Allows post-processing of the bean factory in context subclasses.
postProcessBeanFactory(beanFactory);
// Invoke factory processors registered as beans in the context.
invokeBeanFactoryPostProcessors(beanFactory);
// Register bean processors that intercept bean creation.
registerBeanPostProcessors(beanFactory);
// Initialize message source for this context.
initMessageSource();
// Initialize event multicaster for this context.
initApplicationEventMulticaster();
// Initialize other special beans in specific context subclasses.
onRefresh();
// Check for listener beans and register them.
registerListeners();
// Instantiate all remaining (non-lazy-init) singletons.
finishBeanFactoryInitialization(beanFactory);
// Last step: publish corresponding event.
finishRefresh();
}
}
}
這個方法中調用了大量的方法，但是現在我關系的只有一個：obtainFreshBeanFactory，下面是該方法的細節：
AbstractApplicationContext#obtainFreshBeanFactory
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
refreshBeanFactory();
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
if (logger.isDebugEnabled()) {
logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
}
return beanFactory;
}
在這個方法里需要注意的方法調用是refreshBeanFactory，下面展示了某個refreshBeanFactory方法的實現細節：
AbstractRefreshableApplicationContext#refreshBeanFactory
protected final void refreshBeanFactory() throws BeansException {
if (hasBeanFactory()) {
destroyBeans();
closeBeanFactory();
}
try {
DefaultListableBeanFactory beanFactory = createBeanFactory();
beanFactory.setSerializationId(getId());
customizeBeanFactory(beanFactory);
loadBeanDefinitions(beanFactory);
synchronized (this.beanFactoryMonitor) {
this.beanFactory = beanFactory;
}
}
catch (IOException ex) {
throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
}
}
在這個方法需要關系的是loadBeanDefinitions：
AbstractXmlApplicationContext#loadBeanDefinitions
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
// Create a new XmlBeanDefinitionReader for the given BeanFactory.
XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
// Configure the bean definition reader with this context's
// resource loading environment.
beanDefinitionReader.setEnvironment(this.getEnvironment());
beanDefinitionReader.setResourceLoader(this);
beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
// Allow a subclass to provide custom initialization of the reader,
// then proceed with actually loading the bean definitions.
initBeanDefinitionReader(beanDefinitionReader);
loadBeanDefinitions(beanDefinitionReader);
}
在這個方法內，首先new了一個XmlBeanDefinitionReader對象，根據名字可以猜測這個XmlBeanDefinitionReader對象的作用是實際進行xml文件讀取并且進行解析的對象，后面再看具體是什么功能。還需要注意的是在new XmlBeanDefinitionReader對象的時候傳遞了當前的beanFactory，也就是說new出來的XmlBeanDefinitionReader其實是作為當前beanFactory的puppet而存在的，后續任何對該XmlBeanDefinitionReader的操作都會或多或少和我們設置的beanFactory有關。
然后，我們需要關系的一個方法調用是loadBeanDefinitions：
AbstractXmlApplicationContext#loadBeanDefinitions
protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
Resource[] configResources = getConfigResources();
if (configResources != null) {
reader.loadBeanDefinitions(configResources);
}
String[] configLocations = getConfigLocations();
if (configLocations != null) {
reader.loadBeanDefinitions(configLocations);
}
}
好吧，前面埋下的伏筆這里終于用上了，前面提到我們需要關系的是我們傳遞的xml文件到底是被誰以及到底是在什么時候進行get的，這里可以看到loadBeanDefinitions這個方法調用了getConfigResources來獲取了我們傳遞的xml文件。為了降低分析源碼的復雜度，我們假設第一個if是true，那么就會調用reader.loadBeanDefinitions進行解析操作。這個reader就是上面我們分析的那個new出來的XmlBeanDefinitionReader。按照猜測，下面應該開始進行xml的解析了吧？
AbstractBeanDefinitionReader#loadBeanDefinitions
public int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException {
Assert.notNull(resources, "Resource array must not be null");
int counter = 0;
for (Resource resource : resources) {
counter += loadBeanDefinitions(resource);
}
return counter;
}
很遺憾的是開始沒有開始進行xml解析，但是我們發現這個方法中調用了一個同名的方法loadBeanDefinitions，下面來看看這個方法的細節：
XmlBeanDefinitionReader#loadBeanDefinitions
public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
return loadBeanDefinitions(new EncodedResource(resource));
}
public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
Assert.notNull(encodedResource, "EncodedResource must not be null");
if (logger.isInfoEnabled()) {
logger.info("Loading XML bean definitions from " + encodedResource.getResource());
}
Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();
if (currentResources == null) {
currentResources = new HashSet<>(4);
this.resourcesCurrentlyBeingLoaded.set(currentResources);
}
if (!currentResources.add(encodedResource)) {
throw new BeanDefinitionStoreException(
"Detected cyclic loading of " + encodedResource + " - check your import definitions!");
}
try {
InputStream inputStream = encodedResource.getResource().getInputStream();
try {
InputSource inputSource = new InputSource(inputStream);
if (encodedResource.getEncoding() != null) {
inputSource.setEncoding(encodedResource.getEncoding());
}
return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
}
finally {
inputStream.close();
}
}
catch (IOException ex) {
throw new BeanDefinitionStoreException(
"IOException parsing XML document from " + encodedResource.getResource(), ex);
}
finally {
currentResources.remove(encodedResource);
if (currentResources.isEmpty()) {
this.resourcesCurrentlyBeingLoaded.remove();
}
}
}
就算走到這里，還是沒有開始看到實際解析bean的細節，但是我們可以發現又一個關鍵的方法調用doLoadBeanDefinitions，下面是這個方法的實現細節：
XmlBeanDefinitionReader#doLoadBeanDefinitions
protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
throws BeanDefinitionStoreException {
Document doc = doLoadDocument(inputSource, resource);
return registerBeanDefinitions(doc, resource);
}
走到這里，終于看到了我們想要看到的一點內容，那就是Document，這個Document對象是通過調用方法doLoadDocument來獲取到的，大概的意思就是將xml加載到內容，并且解析成一個Document對象，后續的解析將基于該Document對象。前面那個doLoadDocument方法的細節就不分析了，直接看我們比較關心的registerBeanDefinitions方法：
XmlBeanDefinitionReader#registerBeanDefinitions
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;
}
這個方法中主要的流程代碼是documentReader.registerBeanDefinitions，接著看這個方法的細節：
DefaultBeanDefinitionDocumentReader#registerBeanDefinitions
public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
this.readerContext = readerContext;
logger.debug("Loading bean definitions");
Element root = doc.getDocumentElement();
doRegisterBeanDefinitions(root);
}
繼續關注該方法中的關鍵方法調用：doRegisterBeanDefinitions
DefaultBeanDefinitionDocumentReader.doRegisterBeanDefinitions
protected void doRegisterBeanDefinitions(Element root) {
// Any nested <beans> elements will cause recursion in this method. In
// order to propagate and preserve <beans> default-* attributes correctly,
// keep track of the current (parent) delegate, which may be null. Create
// the new (child) delegate with a reference to the parent for fallback purposes,
// then ultimately reset this.delegate back to its original (parent) reference.
// this behavior emulates a stack of delegates without actually necessitating one.
BeanDefinitionParserDelegate parent = this.delegate;
this.delegate = createDelegate(getReaderContext(), root, parent);
if (this.delegate.isDefaultNamespace(root)) {
String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
if (StringUtils.hasText(profileSpec)) {
String[] specifiedProfiles = StringUtils.tokenizeToStringArray(
profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);
if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {
if (logger.isInfoEnabled()) {
logger.info("Skipped XML bean definition file due to specified profiles [" + profileSpec +
"] not matching: " + getReaderContext().getResource());
}
return;
}
}
}
preProcessXml(root);
parseBeanDefinitions(root, this.delegate);
postProcessXml(root);
this.delegate = parent;
}
主要看最后的三個方法調用，分別代表在進行bean解析之前的以及之后的一些處理，主要看parseBeanDefinitions方法調用：
DefaultBeanDefinitionDocumentReader#parseBeanDefinitions
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);
}
}
從某種意義上來說，該方法是一個facade，從這個方法開始才是真正進行bean解析的內容，解析會分成默認標簽的解析以及自定義標簽的解析，關于Spring自定義標簽的相關內容，可以參考文章淺析Spring自定義標簽的使用，本文將主要關注默認標簽的解析流程，涉及自定義標簽的解析的內容可以自行研讀相關代碼，入口在上面的這個parseBeanDefinitions方法中的delegate.parseCustomElement(root)代碼，默認標簽的解析調用的方法是parseDefaultElement，下面來看這個方法的實現細節：
DefaultBeanDefinitionDocumentReader#parseDefaultElement
private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
importBeanDefinitionResource(ele);
}
else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
processAliasRegistration(ele);
}
else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
processBeanDefinition(ele, delegate);
}
else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
// recurse
doRegisterBeanDefinitions(ele);
}
}
走到這里已經可以很清晰后續的流程了，默認標簽這么幾個：
- import
- alias
- bean
- beans
為了避免重復分析代碼，挑選其中我們最常用的bean標簽來進行后續流程的分析，如果是解析bean標簽，會調用processBeanDefinition方法來進行，下面來看該方法的實現細節：
DefaultBeanDefinitionDocumentReader.processBeanDefinition
/**
* Process the given bean element, parsing the bean definition
* and registering it with the registry.
*/
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
if (bdHolder != null) {
bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
try {
// Register the final decorated instance.
BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
}
catch (BeanDefinitionStoreException ex) {
getReaderContext().error("Failed to register bean definition with name '" +
bdHolder.getBeanName() + "'", ele, ex);
}
// Send registration event.
getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
}
}
該方法的第一個方法調用很值得關注，delegate.parseBeanDefinitionElement，下面來先看看該方法的實現細節：
BeanDefinitionParserDelegate#parseBeanDefinitionElement
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele) {
return parseBeanDefinitionElement(ele, null);
}
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) {
String id = ele.getAttribute(ID_ATTRIBUTE);
String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);
List<String> aliases = new ArrayList<>();
if (StringUtils.hasLength(nameAttr)) {
String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
aliases.addAll(Arrays.asList(nameArr));
}
String beanName = id;
if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {
beanName = aliases.remove(0);
if (logger.isDebugEnabled()) {
logger.debug("No XML 'id' specified - using '" + beanName +
"' as bean name and " + aliases + " as aliases");
}
}
if (containingBean == null) {
checkNameUniqueness(beanName, aliases, ele);
}
AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
if (beanDefinition != null) {
if (!StringUtils.hasText(beanName)) {
try {
if (containingBean != null) {
beanName = BeanDefinitionReaderUtils.generateBeanName(
beanDefinition, this.readerContext.getRegistry(), true);
}
else {
beanName = this.readerContext.generateBeanName(beanDefinition);
// Register an alias for the plain bean class name, if still possible,
// if the generator returned the class name plus a suffix.
// This is expected for Spring 1.2/2.0 backwards compatibility.
String beanClassName = beanDefinition.getBeanClassName();
if (beanClassName != null &&
beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() &&
!this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) {
aliases.add(beanClassName);
}
}
if (logger.isDebugEnabled()) {
logger.debug("Neither XML 'id' nor 'name' specified - " +
"using generated bean name [" + beanName + "]");
}
}
catch (Exception ex) {
error(ex.getMessage(), ele);
return null;
}
}
String[] aliasesArray = StringUtils.toStringArray(aliases);
return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
}
return null;
}
這個方法相對較長，看起來很復雜，來看看到底該方法干了什么：
- 獲取bean的name和id以及aliases等屬性
- 檢測是否名字重復了，也就是說我們的bean的id是不能重復的。具體檢測是否重復的方法是checkNameUniqueness，具體的細節可以看該方法的實現細節
- 調用parseBeanDefinitionElement獲取該bean的AbstractBeanDefinition
- 根據上面這些信息來組裝出一個BeanDefinitionHolder返回
下面來看一下parseBeanDefinitionElement這個方法的具體實現細節：
BeanDefinitionParserDelegate#parseBeanDefinitionElement
public AbstractBeanDefinition parseBeanDefinitionElement(
Element ele, String beanName, @Nullable BeanDefinition containingBean) {
this.parseState.push(new BeanEntry(beanName));
String className = null;
if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
}
String parent = null;
if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
parent = ele.getAttribute(PARENT_ATTRIBUTE);
}
try {
AbstractBeanDefinition bd = createBeanDefinition(className, parent);
parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));
parseMetaElements(ele, bd);
parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
parseConstructorArgElements(ele, bd);
parsePropertyElements(ele, bd);
parseQualifierElements(ele, bd);
bd.setResource(this.readerContext.getResource());
bd.setSource(extractSource(ele));
return bd;
}
catch (ClassNotFoundException ex) {
error("Bean class [" + className + "] not found", ele, ex);
}
catch (NoClassDefFoundError err) {
error("Class that bean class [" + className + "] depends on not found", ele, err);
}
catch (Throwable ex) {
error("Unexpected failure during bean definition parsing", ele, ex);
}
finally {
this.parseState.pop();
}
return null;
}
獲取className以及parent信息，然后根據className和parent構造出一個AbstractBeanDefinition，調用的方法是createBeanDefinition，細節如下：
BeanDefinitionReaderUtils#createBeanDefinition
public static AbstractBeanDefinition createBeanDefinition(
@Nullable String parentName, @Nullable String className, @Nullable ClassLoader classLoader) throws ClassNotFoundException {
GenericBeanDefinition bd = new GenericBeanDefinition();
bd.setParentName(parentName);
if (className != null) {
if (classLoader != null) {
bd.setBeanClass(ClassUtils.forName(className, classLoader));
}
else {
bd.setBeanClassName(className);
}
}
return bd;
}
接著分別調用了一些關鍵方法來解析bean的相關內容，比如parseBeanDefinitionAttributes、parseMetaElements、parseConstructorArgElements，首先來看parseBeanDefinitionAttributes：
BeanDefinitionParserDelegate#parseBeanDefinitionAttributes
public AbstractBeanDefinition parseBeanDefinitionAttributes(Element ele, String beanName,
@Nullable BeanDefinition containingBean, AbstractBeanDefinition bd) {
if (ele.hasAttribute(SINGLETON_ATTRIBUTE)) {
error("Old 1.x 'singleton' attribute in use - upgrade to 'scope' declaration", ele);
}
else if (ele.hasAttribute(SCOPE_ATTRIBUTE)) {
bd.setScope(ele.getAttribute(SCOPE_ATTRIBUTE));
}
else if (containingBean != null) {
// Take default from containing bean in case of an inner bean definition.
bd.setScope(containingBean.getScope());
}
if (ele.hasAttribute(ABSTRACT_ATTRIBUTE)) {
bd.setAbstract(TRUE_VALUE.equals(ele.getAttribute(ABSTRACT_ATTRIBUTE)));
}
String lazyInit = ele.getAttribute(LAZY_INIT_ATTRIBUTE);
if (DEFAULT_VALUE.equals(lazyInit)) {
lazyInit = this.defaults.getLazyInit();
}
bd.setLazyInit(TRUE_VALUE.equals(lazyInit));
String autowire = ele.getAttribute(AUTOWIRE_ATTRIBUTE);
bd.setAutowireMode(getAutowireMode(autowire));
if (ele.hasAttribute(DEPENDS_ON_ATTRIBUTE)) {
String dependsOn = ele.getAttribute(DEPENDS_ON_ATTRIBUTE);
bd.setDependsOn(StringUtils.tokenizeToStringArray(dependsOn, MULTI_VALUE_ATTRIBUTE_DELIMITERS));
}
String autowireCandidate = ele.getAttribute(AUTOWIRE_CANDIDATE_ATTRIBUTE);
if ("".equals(autowireCandidate) || DEFAULT_VALUE.equals(autowireCandidate)) {
String candidatePattern = this.defaults.getAutowireCandidates();
if (candidatePattern != null) {
String[] patterns = StringUtils.commaDelimitedListToStringArray(candidatePattern);
bd.setAutowireCandidate(PatternMatchUtils.simpleMatch(patterns, beanName));
}
}
else {
bd.setAutowireCandidate(TRUE_VALUE.equals(autowireCandidate));
}
if (ele.hasAttribute(PRIMARY_ATTRIBUTE)) {
bd.setPrimary(TRUE_VALUE.equals(ele.getAttribute(PRIMARY_ATTRIBUTE)));
}
if (ele.hasAttribute(INIT_METHOD_ATTRIBUTE)) {
String initMethodName = ele.getAttribute(INIT_METHOD_ATTRIBUTE);
bd.setInitMethodName(initMethodName);
}
else if (this.defaults.getInitMethod() != null) {
bd.setInitMethodName(this.defaults.getInitMethod());
bd.setEnforceInitMethod(false);
}
if (ele.hasAttribute(DESTROY_METHOD_ATTRIBUTE)) {
String destroyMethodName = ele.getAttribute(DESTROY_METHOD_ATTRIBUTE);
bd.setDestroyMethodName(destroyMethodName);
}
else if (this.defaults.getDestroyMethod() != null) {
bd.setDestroyMethodName(this.defaults.getDestroyMethod());
bd.setEnforceDestroyMethod(false);
}
if (ele.hasAttribute(FACTORY_METHOD_ATTRIBUTE)) {
bd.setFactoryMethodName(ele.getAttribute(FACTORY_METHOD_ATTRIBUTE));
}
if (ele.hasAttribute(FACTORY_BEAN_ATTRIBUTE)) {
bd.setFactoryBeanName(ele.getAttribute(FACTORY_BEAN_ATTRIBUTE));
}
return bd;
}
可以很清楚的知道該方法到底在干什么，具體內容就不再贅述了，讀一遍就知道具體的實現內容了，接著看parseMetaElements：
BeanDefinitionParserDelegate#parseMetaElements
public void parseMetaElements(Element ele, BeanMetadataAttributeAccessor attributeAccessor) {
NodeList nl = ele.getChildNodes();
for (int i = 0; i < nl.getLength(); i++) {
Node node = nl.item(i);
if (isCandidateElement(node) && nodeNameEquals(node, META_ELEMENT)) {
Element metaElement = (Element) node;
String key = metaElement.getAttribute(KEY_ATTRIBUTE);
String value = metaElement.getAttribute(VALUE_ATTRIBUTE);
BeanMetadataAttribute attribute = new BeanMetadataAttribute(key, value);
attribute.setSource(extractSource(metaElement));
attributeAccessor.addMetadataAttribute(attribute);
}
}
}
最后是parseConstructorArgElements：
BeanDefinitionParserDelegate#parseConstructorArgElements
/**
* Parse constructor-arg sub-elements of the given bean element.
*/
public void parseConstructorArgElements(Element beanEle, BeanDefinition bd) {
NodeList nl = beanEle.getChildNodes();
for (int i = 0; i < nl.getLength(); i++) {
Node node = nl.item(i);
if (isCandidateElement(node) && nodeNameEquals(node, CONSTRUCTOR_ARG_ELEMENT)) {
parseConstructorArgElement((Element) node, bd);
}
}
}
這里面又調用看了一個重要的方法parseConstructorArgElement，該方法很簡單但是很長，所以在此不再貼出來了，可以跟蹤進去看看到底該方法實現了些什么內容，以及到底是怎么實現的。其他的parseXXX方法就不再贅述了，點到為止。全部的parseXXX方法調用可以參考下面的代碼：
現在回到processBeanDefinition方法，接著分析接下來的流程。執行完 delegate.parseBeanDefinitionElement(ele)之后獲取到了一個BeanDefinitionHolder對象，接著來分析一個關鍵的方法BeanDefinitionReaderUtils.registerBeanDefinition，下面是它的實現細節：
BeanDefinitionReaderUtils#registerBeanDefinition
public static void registerBeanDefinition(
BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
throws BeanDefinitionStoreException {
// Register bean definition under primary name.
String beanName = definitionHolder.getBeanName();
registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
// Register aliases for bean name, if any.
String[] aliases = definitionHolder.getAliases();
if (aliases != null) {
for (String alias : aliases) {
registry.registerAlias(beanName, alias);
}
}
}
然后獲取到了beanName，然后調用了BeanDefinitionRegistry對象的register方法進行bean注冊，需要知道的一點是，走到這里，我們的bean已經解析完成了，也就是說，我們在xml里面配置的bean已經被解析好了，并且已經放到了內存中了，當然現在還需要將解析好的bean注冊到Spring容器中去，下面來繼續分析接下來的流程：
DefaultListableBeanFactory#registerBeanDefinition
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
throws BeanDefinitionStoreException {
Assert.hasText(beanName, "Bean name must not be empty");
Assert.notNull(beanDefinition, "BeanDefinition must not be null");
if (beanDefinition instanceof AbstractBeanDefinition) {
try {
((AbstractBeanDefinition) beanDefinition).validate();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
"Validation of bean definition failed", ex);
}
}
BeanDefinition oldBeanDefinition;
oldBeanDefinition = this.beanDefinitionMap.get(beanName);
if (oldBeanDefinition != null) {
if (!isAllowBeanDefinitionOverriding()) {
throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
"Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName +
"': There is already [" + oldBeanDefinition + "] bound.");
}
else if (oldBeanDefinition.getRole() < beanDefinition.getRole()) {
// e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
if (this.logger.isWarnEnabled()) {
this.logger.warn("Overriding user-defined bean definition for bean '" + beanName +
"' with a framework-generated bean definition: replacing [" +
oldBeanDefinition + "] with [" + beanDefinition + "]");
}
}
else if (!beanDefinition.equals(oldBeanDefinition)) {
if (this.logger.isInfoEnabled()) {
this.logger.info("Overriding bean definition for bean '" + beanName +
"' with a different definition: replacing [" + oldBeanDefinition +
"] with [" + beanDefinition + "]");
}
}
else {
if (this.logger.isDebugEnabled()) {
this.logger.debug("Overriding bean definition for bean '" + beanName +
"' with an equivalent definition: replacing [" + oldBeanDefinition +
"] with [" + beanDefinition + "]");
}
}
this.beanDefinitionMap.put(beanName, beanDefinition);
}
else {
if (hasBeanCreationStarted()) {
// Cannot modify startup-time collection elements anymore (for stable iteration)
synchronized (this.beanDefinitionMap) {
this.beanDefinitionMap.put(beanName, beanDefinition);
List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
updatedDefinitions.addAll(this.beanDefinitionNames);
updatedDefinitions.add(beanName);
this.beanDefinitionNames = updatedDefinitions;
if (this.manualSingletonNames.contains(beanName)) {
Set<String> updatedSingletons = new LinkedHashSet<>(this.manualSingletonNames);
updatedSingletons.remove(beanName);
this.manualSingletonNames = updatedSingletons;
}
}
}
else {
// Still in startup registration phase
this.beanDefinitionMap.put(beanName, beanDefinition);
this.beanDefinitionNames.add(beanName);
this.manualSingletonNames.remove(beanName);
}
this.frozenBeanDefinitionNames = null;
}
if (oldBeanDefinition != null || containsSingleton(beanName)) {
resetBeanDefinition(beanName);
}
}
這個方法的意思大概是，檢測是否已經有同名的bean被注冊過了，如果被注冊過了那么就要拋出異常，因為Spring不支持同名bean存在。中間通過了大量的判斷，如果順利的話，這個bean會被存儲到一個map中去，這個map的定義如下：
/** Map of bean definition objects, keyed by bean name */
private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);
key是beanName，value就是解析好的BeanDefinition。到此，Spring源碼解析中關于bean解析的內容就梳理完了，主要分析了bean標簽的解析，自定義標簽的解析并沒有涉及，但是給出了參考鏈接可以參考，標簽頁給出了分析自定義標簽解析的入口，可以根據入口繼續進行自定義標簽的解析流程分析。
本文粗線條的描述了Spring源碼中關于bean解析的分析，沒有涉及太多細節的內容，但是骨干清晰，可以清晰明了的理解Spring中bean的解析過程，包括如何將xml文件加載到內存中去，并且如何將xml文件內容進行解析，分成自定義標簽和默認標簽的解析，默認標簽的解析比如bean、import等，通讀全文，可以快速打通bean解析的全過程，中間雖然沒有涉及太多細節的內容，并且都是挑選了全鏈路中的某條分支來進行分析，但是這樣可以快速理清Spring的bean解析過程，后續會逐步完善該過程，逐步加入一些涉及細節的內容，來深度解析bean解析過程中的某些需要注意的點，以及bean解析過程和其他模塊之間的交互關系等內容。
