Spring源码分析（二）（IoC容器的实现）（3）

青旅半醒 2022-04-15 07:18 187阅读 0赞

### BeanDefinition的载入和解析 ###

这个载入过程，相当于把定义的BeanDefinition在IoC容器中转化成一个Spring内部表示的数据结构的过程。IoC容器对Bean的管理和依赖注入功能的实现，是通过对其持有的BeanDefinition进行各种相关操作来完成的。这些BeanDefinition数据在IoC容器中通过一个HashMap来保持和维护。如果需要提高IoC容器的性能和容量，可以自己做一些扩展。

下面，从DefauItListaleBeanFactory 的设计入手，看看IoC 容器是怎样完成BeanDefinition载入的。在开始分析之前，先回到IoC容器的初始化入口，也就是看一下refresh方法。这个方法的最初是在FileSystemXmlApplicationContext的构造函数中被调用的，它的调用标志着容器初始化的开始，这些初始化对象就是BeanDefinition数据，初始化入口如代码如下：

public FileSystemXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)
                throws BeansException {
    
            super(parent);
            setConfigLocations(configLocations);//设置此应用程序上下文的配置位置。如果没有设置，实现可能会在适当的时候使用默认值。
            if (refresh) {
                refresh();//AbstractApplicationContext的refresh
            }
        }

对容器的启动来说， refresh是一个很重要的方法，下面介绍一下它的实现。该方法在AbstractApplicationContext类（它FileSystemXmlApplicationContext的基类）中找到．它详细地描述了整个AppIicationContext 的初始化过程，比如BeanFactory 的更新，MessageSource和PostProcessor的注册，等等。

public void refresh() throws BeansException, IllegalStateException {
    		synchronized (this.startupShutdownMonitor) {
    			// Prepare this context for refreshing.
    			prepareRefresh();
    
    			// Tell the subclass to refresh the internal bean factory.
    			//这里是在子类中启动refreshBeanFactory()的地方
    			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.
    				//设置BeanFactory的后置处理
    				postProcessBeanFactory(beanFactory);
    
    				// Invoke factory processors registered as beans in the context.
    				//调用BeanFactory的后置处理器，这些后置处理器是在Bean定义中向容器注册的
    				invokeBeanFactoryPostProcessors(beanFactory);
    
    				// Register bean processors that intercept bean creation.
    				//注册Bean的后处理器，在Bean创建过程中调用
    				registerBeanPostProcessors(beanFactory);
    
    				// Initialize message source for this context.
    				//对上下文的消息源进行初始化
    				initMessageSource();
    
    				// Initialize event multicaster for this context.
    				//初始化上下文中的事件机制
    				initApplicationEventMulticaster();
    
    				// Initialize other special beans in specific context subclasses.
    				//初始化其他的特殊bean
    				onRefresh();
    
    				// Check for listener beans and register them.
    				//检查监听Bean并且将这些Bean向容器注册
    				registerListeners();
    
    				// Instantiate all remaining (non-lazy-init) singletons.
    				//实例化所有的(non-lazy-init)单例
    				finishBeanFactoryInitialization(beanFactory);
    
    				// Last step: publish corresponding event.
    				//发布容器事件，结束Refresh过程
    				finishRefresh();
    			}
    
    			catch (BeansException ex) {
    				if (logger.isWarnEnabled()) {
    					logger.warn("Exception encountered during context initialization - " +
    							"cancelling refresh attempt: " + ex);
    				}
    
    				// Destroy already created singletons to avoid dangling resources.
    				//为防止Bean资源占用在异常处理中，销毁已经在前面过程中生成的单例bean
    				destroyBeans();
    
    				// Reset 'active' flag.
    				//重置'active'标志
    				cancelRefresh(ex);
    
    				// Propagate exception to caller.
    				throw ex;
    			}
    
    			finally {
    				// Reset common introspection caches in Spring's core, since we
    				// might not ever need metadata for singleton beans anymore...
    				resetCommonCaches();
    			}
    		}
    	}

进入到AbstractRefreshableApplicationContext的refreshBeanFactory()方注中，在这个方法中创建了BeanFactory。在创建loC容器前，如果已经有容器存在，那么需要把已有的容器销毁和关闭，保证在refresh以后使用的是新建立起来的IoC容器。这么看来，这个refresh非常像重启动容器，就像重启动计算机那样。在建立好当前的IoC容器以后，开始了对容器的初始化过程，比如BeanDefinition的载入。具体交互过程如：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NTk4MDEx_size_16_color_FFFFFF_t_70][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NTk4MDEx_size_16_color_FFFFFF_t_70 1][]

首先从AbstractRefreshableApplicationContext的refreshBeanFactory开始了解这个Bean定义信息载入的过程。

protected final void refreshBeanFactory() throws BeansException {
    		if (hasBeanFactory()) {
    			destroyBeans();
    			closeBeanFactory();
    		}
    		try {
    			//创建IoC容器，这里用的是DefaultListableBeanFactory
    			DefaultListableBeanFactory beanFactory = createBeanFactory();
    			beanFactory.setSerializationId(getId());
    			customizeBeanFactory(beanFactory);
    			//启动对Bena的载入
    			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实际上是一个抽象方法，它实际的载入过程发生在AbstractRefreshableApplicationContext的子类AbstractXmlApplicationContext中的实现，在这个loadBeanDefinitions中，初始化了读取器XmlBeanDefinitionReader ，然后把这个读取器在IoC容器中设置好（过程和编程式使用XmlBeanFactory是类似的），最后是启动读取器来完成BeanDefinition在IoC容器中的载入，如代码所示。

protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
    		// Create a new XmlBeanDefinitionReader for the given BeanFactory.
    		//创建XmlBeanDefinitionReader并通过回调设置到BeanFactory中去，
    		// 创建BeanFactory的过程可以参考上下文对编程式使用IoC容器相关分析，这里也是使用的DefaultListableBeanFactory
    		XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
    
    		// Configure the bean definition reader with this context's
    		// resource loading environment.
    		beanDefinitionReader.setEnvironment(this.getEnvironment());
    		//在这里设置XmlBeanDefinitionReader，为XmlDefinitionReader配ResourceLoader,因为DefaultResourceLoader是父类，所以this可以直接被使用
    		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.
    		//这是启动Bean定义信息载入的过程
    		initBeanDefinitionReader(beanDefinitionReader);
    		loadBeanDefinitions(beanDefinitionReader);
    	}
    
    	protected Resource[] getConfigResources() {
    		return null;
    	}

接着就是loadBeanDefinitions调用的地方，首先得到BeanDefinition信息的Resource定位，然后直接调用XmlBeanDefinitionReader来读取，具体的载入过程是委托给BeanDefinitionReader完成的。因为这里的BeanDefinition是通过XML文件定义的，所以这里使用XmlBeanDefinitionReader来载入BeanDefinition到容器中，如代码所示。

protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
    		//以Resource的方式获得配置文件的资源
    		Resource[] configResources = getConfigResources();
    		if (configResources != null) {
    			reader.loadBeanDefinitions(configResources);
    		}
    		//以String的方式获得配置文件的资源
    		String[] configLocations = getConfigLocations();
    		if (configLocations != null) {
    			reader.loadBeanDefinitions(configLocations);
    		}
    	}

通过以上对实现原理的分析，我们可以看到，在初始化FileSystmXmlApplicationContext的过程中是通过调用IoC容器的refresh来启动整个BeanDefinition的载入过程的，这个初始化是通过定义的XmlBeanDefinitionReader来完成的。同时，我们也知道实际使用的IoC容器是DefuItListabIeBeanfactory ，具体的Resource载入在XmlBeanDefinitionRcader读入BeanDefinition时实现。因为Spring可以对应不同形式的BeanDefinition. 由于这里使用的是XML 方式的定义，所以需要使用XmlBeanDefinitionReader 。如果使用了其他的BeanDefinition方式，就需要使用其他种类的BeanDefinitionReader来完成数据的载入工作。在XmlBeanDefinitionReader的实现中可以看到，是在reader.loadBeanDefinitions 中开始进行BeanDefinition的载入的，而这时XmlBeanDefinitionReader的父类AbstractBeanDefinitionReader已经为BeanDefinition的载入做好了准备，如代码所示。

public int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException {
    		//如果Resource为空则停止BeanDefinition的载入
    		//然后启动载入BeanDefinition的过程，这个过程会遍历整个Resource集合所包含的BeanDefinition信息
    		Assert.notNull(resources, "Resource array must not be null");
    		int counter = 0;
    		for (Resource resource : resources) {
    			counter += loadBeanDefinitions(resource);
    		}
    		return counter;
    	}

这里调用的是loadBeanDefinitions(Resourceres）方法， 但这个方法在AbstractBeanDefinitionReader类里是没有实现的，它是一个接口方法，具体的实现在XmlBeanDefinitionReader中。在读取器中，需要得到代表XML文件的Resource ，因为这个Resource对象封装了对XML文件的I/O操作，所以读取器可以在打开I/O流后得到XML的文件对象。有了这个文件对象以后，就可以按照Spring的Bean定义规则来对这个XML的文档树进行解析了．这个解析是交给BeanDefinitionParserDelegate来完成的，看起来实现脉络很清楚。具体可以参考代码实现，如代码所示。

//调用入口
    	public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
    		return loadBeanDefinitions(new EncodedResource(resource));
    	}
    
    
            //载入xml形式的BeanDefinition的地方
    	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);
    		}
    
    		Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();
    		if (currentResources == null) {
    			currentResources = new HashSet<EncodedResource>(4);
    			this.resourcesCurrentlyBeingLoaded.set(currentResources);
    		}
    		if (!currentResources.add(encodedResource)) {
    			throw new BeanDefinitionStoreException(
    					"Detected cyclic loading of " + encodedResource + " - check your import definitions!");
    		}
    		try {
    			//这里得到xml文件，并得到IO的InputSource准备进行读取
    			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();
    			}
    		}
    	}
    
    
    	//具体读取过程在doLoadBeanDefinitions方法中，这是从特定的XML文件中实际载入BeanDefinition的地方
    	protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
    			throws BeanDefinitionStoreException {
    		try {
    			//这里取得XML文件的Document对象，这个解析过程是由doLoadDocument完成的这个
    			// doLoadDocument是DefaultDocumentLoader，在定义documentLoader的地方创建
    			Document doc = doLoadDocument(inputSource, resource);
    			//这里启动的是对BeanDefinition解析的详细过程，这个解析会使用到Spring的Bean配置规则。
    			return registerBeanDefinitions(doc, resource);
    		}
    		catch (BeanDefinitionStoreException ex) {
    			throw ex;
    		}
    		catch (SAXParseException ex) {
    			throw new XmlBeanDefinitionStoreException(resource.getDescription(),
    					"Line " + ex.getLineNumber() + " in XML document from " + resource + " is invalid", ex);
    		}
    		catch (SAXException ex) {
    			throw new XmlBeanDefinitionStoreException(resource.getDescription(),
    					"XML document from " + resource + " is invalid", ex);
    		}
    		catch (ParserConfigurationException ex) {
    			throw new BeanDefinitionStoreException(resource.getDescription(),
    					"Parser configuration exception parsing XML from " + resource, ex);
    		}
    		catch (IOException ex) {
    			throw new BeanDefinitionStoreException(resource.getDescription(),
    					"IOException parsing XML document from " + resource, ex);
    		}
    		catch (Throwable ex) {
    			throw new BeanDefinitionStoreException(resource.getDescription(),
    					"Unexpected exception parsing XML document from " + resource, ex);
    		}
    	}

按照Spring的Bean语义要求，对BeanDefinion进行解析并转化为容器内部数据结构的，这个过程是在registerBeanDefinitions(doc, resource）中完成的。具体的过程是由BeanDefinitionDocumentReader来完成的， 这个registerBeanDefinition还对载人的Bean的数量进行了统计。具体过程如代码所示:

public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
    		//这里得到BeanDefinitionDocumentReader来对XML的BeanDefinition进行解析
    		BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
    		int countBefore = getRegistry().getBeanDefinitionCount();
    		//具体解析过程在这个registerBeanDefinitions中完成
    		documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
    		return getRegistry().getBeanDefinitionCount() - countBefore;
    	}

BeanDefinition的载入分成两部分，首先通过调用XML的解析器得到document对象，但这些document对象并没有按照Spring的Bean规则进行解析。在完成通用的XML解析以后，才是按照Spring的Bean规则进行解析的地方，这个按照Spring的Bean规则进行解析的过程是在documentReader中实现的。这里使用的documentReader是默认设置好的  DefaultBeanDefinitionDocumentReader。这个DefaultBeanDefinitionDocumentReader的创建是在后面的方法中完成的，然后再完成BeanDefinition的处理，处理的结果由BeanDefinitionHolder对象来持有。这个BeanDefinitionHolder除了持有BeanDefinition对象外，还持有其他与BeanDefinition的使用相关的信息，比如Bean 的名字、别名集合等。这个BeanDefinitionHolder的生成是通过对Document文档树的内容进行解析来完成的，可以看到这个解析过程是由BeanDefinitionParserDelegate来实现（具体在processBeanDefinition方法中实现）的，同时这个解析是与Spring对BeanDefinition的配置规则紧密相关的。具体的实现原理如代码所示。

创建BeanDefinitionDocumentReader

protected BeanDefinitionDocumentReader createBeanDefinitionDocumentReader() {
    		return BeanDefinitionDocumentReader.class.cast(BeanUtils.instantiateClass(this.documentReaderClass));
    	}
    
    
    	public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
    		//这里得到BeanDefinitionDocumentReader来对XML的BeanDefinition进行解析
    		BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
    		int countBefore = getRegistry().getBeanDefinitionCount();
    		//具体解析过程在这个registerBeanDefinitions中完成
    		documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
    		return getRegistry().getBeanDefinitionCount() - countBefore;
    	}
    
    	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;
    	}
    
    
    
    
    	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);
    		}
    	}
    
    
    	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);
    		}
    	}
    
    	//这是处理BeanDefinition的地方，具体委托给BeanDefinitionParserDelegate来完成，ele对应Spring BeanDefinition中定义的XML元素
    	protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
    		//BeanDefinitionHolder是BeanDefinition对象的封装类，封装了BeanDefinition的名字和别名。用它来完成向IoC容器的注册。
    		//得到这个BeanDefinitionHolder就意味着BeanDefinition是通过BeanDefinitionParserDelegate对XML元素的信息按照Spring的Bean规则进行解析得到的
    		BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
    		if (bdHolder != null) {
    			bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
    			try {
    				// Register the final decorated instance.
    				//这里是向IoC容器注册解析得到BeanDefinition的地方
    				BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
    			}
    			catch (BeanDefinitionStoreException ex) {
    				getReaderContext().error("Failed to register bean definition with name '" +
    						bdHolder.getBeanName() + "'", ele, ex);
    			}
    			// Send registration event.
    			//在BeanDefinition向IoC容器注册完以后发送消息
    			getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
    		}
    	}

具体的Spring BeanDefinition的解析是在BeanDefinitionParserDelegate中完成的。这个类里包含了对各种Spring Bean定义规则的处理。在这里会看到对那些熟悉的BeanDefinition定义的处理，比如id 、name 、aliase等属性元素。把这些元素的值从XML文件相应的元素的属性中读取出来以后，设置到生成的BeanDefinitionHolder中去。这些属性的解析还是比较简单的。对于其他元素配置的解析，比如各种Bean的属性配置，通过一个较为复杂的解析过程，这个过程是由parseBeanDefinitionElement来完成的。解析完成以后，会把解析结果放到BeanDefinition对象中并设置到BeanDefinitionHolder中去，如代码所示：

public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, BeanDefinition containingBean) {
    		//这里取得<bean>元素中定义的id、name和aliase属性的值
    		String id = ele.getAttribute(ID_ATTRIBUTE);
    		String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);
    
    		List<String> aliases = new ArrayList<String>();
    		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);
    		}
    		//这个方法会引发对Bean元素的详细解析
    		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元素进行解析的过程，也就是BeanDefinition依据XML的 bean标签定义被创建的过程。这个BeanDefinition可以看成是对 bean标签定义的抽象，如图所示。（Alt+7）

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NTk4MDEx_size_16_color_FFFFFF_t_70 2][]

这个数据对象中封装的数据大多都是与 <bean>定义相关的，也有很多在定义Bean时看到的那些Spring标记，比如常见的init-method 、destroy-method 、factory-method ， 等等，这个BeanDefinition数据类型是非常重要的，它封装了很多基本数据，这些基本数据都是IoC容器需要的。有了这些基本数据， IoC容器才能对Bean配置进行处理， 才能实现相应的容器特性。

下面介绍下对BeanDefinition定义元素的处理：

public AbstractBeanDefinition parseBeanDefinitionElement(
    			Element ele, String beanName, BeanDefinition containingBean) {
    
    		this.parseState.push(new BeanEntry(beanName));
    		//这里只读取定义的<bean>中设置的class名字，然后载入到BeanDefinition中去，只是做个记录，
    		//并不涉及对象的实例化过程，对象的实例化实际上是在依赖注入时完成的
    		String className = null;
    		if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
    			className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
    		}
    
    		try {
    			String parent = null;
    			if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
    				parent = ele.getAttribute(PARENT_ATTRIBUTE);
    			}
    			//这里生成需要的BeanDefinition对象，为Bean定义信息的载入做准备
    			AbstractBeanDefinition bd = createBeanDefinition(className, parent);
    			//这里对当前的Bean元素进行属性解析，并设置description的信息
    			parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
    			bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));
    			//从名字可以看到这是对各种<bean>元素的信息进行解析的地方
    			parseMetaElements(ele, bd);
    			parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
    			parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
    			//解析<bean>的构造函数设置
    			parseConstructorArgElements(ele, bd);
    			//解析<bean>的property设置
    			parsePropertyElements(ele, bd);
    			parseQualifierElements(ele, bd);
    
    			bd.setResource(this.readerContext.getResource());
    			bd.setSource(extractSource(ele));
    
    			return bd;
    		}
    		//下面这些异常时配置Bean出现问题时经常看到的，这些检查是在createBeanDefinition时进行的，
    		// 会检查Bean的class设计是否正确，比如这个类是否能找到
    		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;
    	}

上面是具体生成BeanDefinition的地方。举一个对property进行解析的例子来完成对整个BeanDefinition载入过程的分析，还是在类BeanDefinitionParserDelegate的代码中， 一层一层地对BeanDefinition中的定义进行解析，比如从属性元素集合到具体的每一个属性元素，然后才是对具体的属性值的处理。根据解析结果，对这些属性值的处理会被封装成PropertyValue对象并设置到BeanDefinition对象中去，如代码所示。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NTk4MDEx_size_16_color_FFFFFF_t_70 3][]

//便利所有Bean元素下定义的property元素
    	public void parsePropertyElements(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, PROPERTY_ELEMENT)) {
    				//判断是property元素后对该property元素进行解析的过程
    				parsePropertyElement((Element) node, bd);
    			}
    		}
    	}
    
    
    
    	public void parsePropertyElement(Element ele, BeanDefinition bd) {
    		//获取property的名字
    		String propertyName = ele.getAttribute(NAME_ATTRIBUTE);
    		if (!StringUtils.hasLength(propertyName)) {
    			error("Tag 'property' must have a 'name' attribute", ele);
    			return;
    		}
    		this.parseState.push(new PropertyEntry(propertyName));
    		try {
    			//如果同一个Bean中已经有同名的property存在，则不进行解析，直接返回。
    			//所以说如果同一个Bean中由同名的property设置，那么起作用的只有第一个
    			if (bd.getPropertyValues().contains(propertyName)) {
    				error("Multiple 'property' definitions for property '" + propertyName + "'", ele);
    				return;
    			}
    			//这是解析property值的地方，返回的对象对应bean定义的property属性设置的解析结果，
    			// 这个解析结果会封装到PropertyValue对象中，然后设置到BeanDefinitionHolder中去
    			Object val = parsePropertyValue(ele, bd, propertyName);
    			PropertyValue pv = new PropertyValue(propertyName, val);
    			parseMetaElements(ele, pv);
    			pv.setSource(extractSource(ele));
    			bd.getPropertyValues().addPropertyValue(pv);
    		}
    		finally {
    			this.parseState.pop();
    		}
    	}
    
    
    
    	//这里取得property元素的值，也许是个list或其他
    	public Object parsePropertyValue(Element ele, BeanDefinition bd, String propertyName) {
    		String elementName = (propertyName != null) ?
    						"<property> element for property '" + propertyName + "'" :
    						"<constructor-arg> element";
    
    		// Should only have one child element: ref, value, list, etc.
    		NodeList nl = ele.getChildNodes();
    		Element subElement = null;
    		for (int i = 0; i < nl.getLength(); i++) {
    			Node node = nl.item(i);
    			if (node instanceof Element && !nodeNameEquals(node, DESCRIPTION_ELEMENT) &&
    					!nodeNameEquals(node, META_ELEMENT)) {
    				// Child element is what we're looking for.
    				if (subElement != null) {
    					error(elementName + " must not contain more than one sub-element", ele);
    				}
    				else {
    					subElement = (Element) node;
    				}
    			}
    		}
    		//这里判断property的属性，是ref还是value，不允许同时是ref和value
    		boolean hasRefAttribute = ele.hasAttribute(REF_ATTRIBUTE);
    		boolean hasValueAttribute = ele.hasAttribute(VALUE_ATTRIBUTE);
    		if ((hasRefAttribute && hasValueAttribute) ||
    				((hasRefAttribute || hasValueAttribute) && subElement != null)) {
    			error(elementName +
    					" is only allowed to contain either 'ref' attribute OR 'value' attribute OR sub-element", ele);
    		}
    		//如果是ref，创建一个ref的数据对象RuntimeBeanReference，这个对象封装了ref的信息
    		if (hasRefAttribute) {
    			String refName = ele.getAttribute(REF_ATTRIBUTE);
    			if (!StringUtils.hasText(refName)) {
    				error(elementName + " contains empty 'ref' attribute", ele);
    			}
    			RuntimeBeanReference ref = new RuntimeBeanReference(refName);
    			ref.setSource(extractSource(ele));
    			return ref;
    		}
    		//如果是value，创建一个value的数据对象TypedStringValue，这个对象封装了value的信息
    		else if (hasValueAttribute) {
    			TypedStringValue valueHolder = new TypedStringValue(ele.getAttribute(VALUE_ATTRIBUTE));
    			valueHolder.setSource(extractSource(ele));
    			return valueHolder;
    		}
    		//如果还有子元素，触发对子元素的解析
    		else if (subElement != null) {
    			return parsePropertySubElement(subElement, bd);
    		}
    		else {
    			// Neither child element nor "ref" or "value" attribute found.
    			error(elementName + " must specify a ref or value", ele);
    			return null;
    		}
    	}

这里是对property子元素的解析过程， Array 、List 、Set 、Map 、Prop等各种元素都会在这里进行解析，生成对应的数据对象，比如ManagedList 、ManagedArray 、ManagedSet等。这些Managed类是Spring对具体的BeanDefinition的数据封装。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NTk4MDEx_size_16_color_FFFFFF_t_70 4][]

下面以对Property的元素进行解析的过程为例，通过它的实现来说明具体的解析过程是怎样完成的，如代码所示：

对属性元素进行解析：

public Object parsePropertySubElement(Element ele, BeanDefinition bd, String defaultValueType) {
    		if (!isDefaultNamespace(ele)) {
    			return parseNestedCustomElement(ele, bd);
    		}
    		else if (nodeNameEquals(ele, BEAN_ELEMENT)) {
    			BeanDefinitionHolder nestedBd = parseBeanDefinitionElement(ele, bd);
    			if (nestedBd != null) {
    				nestedBd = decorateBeanDefinitionIfRequired(ele, nestedBd, bd);
    			}
    			return nestedBd;
    		}
    		else if (nodeNameEquals(ele, REF_ELEMENT)) {
    			// A generic reference to any name of any bean.
    			String refName = ele.getAttribute(BEAN_REF_ATTRIBUTE);
    			boolean toParent = false;
    			if (!StringUtils.hasLength(refName)) {
    				// A reference to the id of another bean in the same XML file.
    				refName = ele.getAttribute(LOCAL_REF_ATTRIBUTE);
    				if (!StringUtils.hasLength(refName)) {
    					// A reference to the id of another bean in a parent context.
    					refName = ele.getAttribute(PARENT_REF_ATTRIBUTE);
    					toParent = true;
    					if (!StringUtils.hasLength(refName)) {
    						error("'bean', 'local' or 'parent' is required for <ref> element", ele);
    						return null;
    					}
    				}
    			}
    			if (!StringUtils.hasText(refName)) {
    				error("<ref> element contains empty target attribute", ele);
    				return null;
    			}
    			RuntimeBeanReference ref = new RuntimeBeanReference(refName, toParent);
    			ref.setSource(extractSource(ele));
    			return ref;
    		}
    		else if (nodeNameEquals(ele, IDREF_ELEMENT)) {
    			return parseIdRefElement(ele);
    		}
    		else if (nodeNameEquals(ele, VALUE_ELEMENT)) {
    			return parseValueElement(ele, defaultValueType);
    		}
    		else if (nodeNameEquals(ele, NULL_ELEMENT)) {
    			// It's a distinguished null value. Let's wrap it in a TypedStringValue
    			// object in order to preserve the source location.
    			TypedStringValue nullHolder = new TypedStringValue(null);
    			nullHolder.setSource(extractSource(ele));
    			return nullHolder;
    		}
    		else if (nodeNameEquals(ele, ARRAY_ELEMENT)) {
    			return parseArrayElement(ele, bd);
    		}
    		else if (nodeNameEquals(ele, LIST_ELEMENT)) {
    			return parseListElement(ele, bd);
    		}
    		else if (nodeNameEquals(ele, SET_ELEMENT)) {
    			return parseSetElement(ele, bd);
    		}
    		else if (nodeNameEquals(ele, MAP_ELEMENT)) {
    			return parseMapElement(ele, bd);
    		}
    		else if (nodeNameEquals(ele, PROPS_ELEMENT)) {
    			return parsePropsElement(ele);
    		}
    		else {
    			error("Unknown property sub-element: [" + ele.getNodeName() + "]", ele);
    			return null;
    		}
    	}

下面看看List这样的属性配置是怎样被解析的，依然是在BeanDefinitionParscrDelegate中，返回的是一个List对象，这个List是Spring定义的ManagedList，作为封装List这类配置定义的数据封装，如代码所示：

public List<Object> parseListElement(Element collectionEle, BeanDefinition bd) {
    		String defaultElementType = collectionEle.getAttribute(VALUE_TYPE_ATTRIBUTE);
    		NodeList nl = collectionEle.getChildNodes();
    		ManagedList<Object> target = new ManagedList<Object>(nl.getLength());
    		target.setSource(extractSource(collectionEle));
    		target.setElementTypeName(defaultElementType);
    		target.setMergeEnabled(parseMergeAttribute(collectionEle));
    		//具体的List元素的解析过程
    		parseCollectionElements(nl, target, bd, defaultElementType);
    		return target;
    	}
    
    
    
    	protected void parseCollectionElements(
    			NodeList elementNodes, Collection<Object> target, BeanDefinition bd, String defaultElementType) {
    		//遍历所有的元素节点，并判断其类型是否为Element
    		for (int i = 0; i < elementNodes.getLength(); i++) {
    			Node node = elementNodes.item(i);
    			if (node instanceof Element && !nodeNameEquals(node, DESCRIPTION_ELEMENT)) {
    				//加入target中，target是一个ManagedList，同时触发对下一层子元素的解析过程，这是一个递归的调用
    				target.add(parsePropertySubElement((Element) node, bd, defaultElementType));
    			}
    		}
    	}

经过这样逐层地解析，我们在XML文件中定义的BeanDefinition就被整个载入到了IoC容器中，并在容器中建立了数据映射。在IoC容器中建立了对应的数据结构，或者说可以看成是POJO对象在loC容器中的抽象，这些数据结构可以以AbstractBeanDefinition为入口，让IoC容器执行索引、查询和操作。简单的POJO操作背后其实蕴含着一个复杂的抽过程，经过以上的载入过程， IoC容器大致完成了管理Bean对象的数据准备工作（或者说是初始化过程）。但是，重要的依赖注入实际上在这个时候还没有发生，现在，在IoC 容器BeanDefinition 中存在的还只是一些静态的配置信息。严格地说，这时候的容器还没有完全起作用，要完全发挥容器的作用，还需完成数据向容器的注册。

### BeanDefinition在IoC容器中的注册 ###

前面已经分析过BeanDefinition在IoC容器中载入和解析的过程。在这些动作完成以后，用户定义的BeanDefinition信息已经在IoC容器内建立起了自己的数据结构以及相应的数据表示，但此时这些数据还不能供IoC容器直接使用，需要在IoC容器中对这些BeanDefinition数据进行注册。这个注册为IoC容器提供了更友好的使用方式，在DefaultListableBeanFactory中，是通过一个HashMap 来持有载入的BeanDefinition 的，这个HashMap 的定义在DefaultListableBeanFactory中可以看到，如下所示:

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NTk4MDEx_size_16_color_FFFFFF_t_70 5][]

将解析得到的BeanDefinition 向IoC容器中的beanDefinitionMap注册的过程是在载入BeanDefinition完成后进行的，注册的调用过程如图所示。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NTk4MDEx_size_16_color_FFFFFF_t_70 6][]

在DefaultListableBeanFactoryr和实现了BeanDefinitionRegistry的接口，这个接口的实现完成BeanDefinition向容器的注册。这个注册过程不复杂，就是把解析得到的BeanDefinition设置到JhashMap中去。需要注意的是，如果遇到同名的BeanDefinition ， 进行处理的时候需要依据allowBeanDefin itionOverriding的配置来完成。具体的实现如代码所示。

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
            BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
            if (bdHolder != null) {
                bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
    
                try {
                    BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, this.getReaderContext().getRegistry());
                } catch (BeanDefinitionStoreException var5) {
                    this.getReaderContext().error("Failed to register bean definition with name '" + bdHolder.getBeanName() + "'", ele, var5);
                }
    
                this.getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
            }
    
        }
    
    	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);
    			}
    		}
    	}
    
    
    	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属性中的methodOverrides进行校验，
    				// 校验 methodOverrides是否与工厂方法并存或者methodOverrides对应的方法是否存在
    				((AbstractBeanDefinition) beanDefinition).validate();
    			}
    			catch (BeanDefinitionValidationException ex) {
    				throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
    						"Validation of bean definition failed", ex);
    			}
    		}
    
    		BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
    		// 处理注册已经注册的beanName情况
    		if (existingDefinition != null) {
    			// 如果对应的beanName已经注册且在配置中配置了bean不允许被覆盖，则抛出异常。
    			if (!isAllowBeanDefinitionOverriding()) {
    				throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
    						"Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName +
    						"': There is already [" + existingDefinition + "] bound.");
    			}
    			else if (existingDefinition.getRole() < beanDefinition.getRole()) {
    				// e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
    				if (logger.isWarnEnabled()) {
    					logger.warn("Overriding user-defined bean definition for bean '" + beanName +
    							"' with a framework-generated bean definition: replacing [" +
    							existingDefinition + "] with [" + beanDefinition + "]");
    				}
    			}
    			else if (!beanDefinition.equals(existingDefinition)) {
    				if (logger.isInfoEnabled()) {
    					logger.info("Overriding bean definition for bean '" + beanName +
    							"' with a different definition: replacing [" + existingDefinition +
    							"] with [" + beanDefinition + "]");
    				}
    			}
    			else {
    				if (logger.isDebugEnabled()) {
    					logger.debug("Overriding bean definition for bean '" + beanName +
    							"' with an equivalent definition: replacing [" + existingDefinition +
    							"] with [" + beanDefinition + "]");
    				}
    			}
    			this.beanDefinitionMap.put(beanName, beanDefinition);
    		}
    		else {
    			if (hasBeanCreationStarted()) {
    				// Cannot modify startup-time collection elements anymore (for stable iteration)
    				//注册过程需要synchronized，保证数据的一致性
    				synchronized (this.beanDefinitionMap) {
    					//添加到beanDefinitionMap中
    					this.beanDefinitionMap.put(beanName, beanDefinition);
    					List<String> updatedDefinitions = new ArrayList<String>(this.beanDefinitionNames.size() + 1);
    					updatedDefinitions.addAll(this.beanDefinitionNames);
    					updatedDefinitions.add(beanName);
    					//按注册顺序列出bean定义名称,进行覆盖
    					this.beanDefinitionNames = updatedDefinitions;
    					//beanName名称相同的情况
    					if (this.manualSingletonNames.contains(beanName)) {
    						Set<String> updatedSingletons = new LinkedHashSet<String>(this.manualSingletonNames);
    						//删除并新增，这也就是为什么beanName相同情况下后者会把前者覆盖
    						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 (existingDefinition != null || containsSingleton(beanName)) {
    			resetBeanDefinition(beanName);
    		}
    	}

完成了BeanDefinition的注册，就完成了IoC容器的初始化过程。此时，在使用的IoC容器DefaultListableBeanFactory中已经建立了整个Bean的配置信息，而且这些BeanDefinition 已经可以被容器检索和使用了， 它们都在beanDefinitionMap里被检索和使用。 容器的作用就是对这些信息进行处理和维护。这些信息是容器建立依赖反转的基础，有了这些基础数据， 下面我们看一下在IoC容器中，依赖注入是怎样完成的。

参考《SPRING技术内幕》

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NTk4MDEx_size_16_color_FFFFFF_t_70]: /images/20220415/5821a9ff4576469bad7310b8720ec2d6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NTk4MDEx_size_16_color_FFFFFF_t_70 1]: /images/20220415/ade9d8b69b4b4a7a9dcc0635b6921e8f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NTk4MDEx_size_16_color_FFFFFF_t_70 2]: /images/20220415/b10cfa86cad54fd1960de64e05d9e2ea.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NTk4MDEx_size_16_color_FFFFFF_t_70 3]: /images/20220415/0a12847d7c004b278877b09b439c0ef0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NTk4MDEx_size_16_color_FFFFFF_t_70 4]: /images/20220415/6cbaebf4d1c84ddab1a9bda6807b5e97.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NTk4MDEx_size_16_color_FFFFFF_t_70 5]: /images/20220415/65a0c9c58d4749b2902f9cb90b5eaaeb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NTk4MDEx_size_16_color_FFFFFF_t_70 6]: /images/20220415/bcca9872412c4681912ce4e1ff8003f3.png