Spring源码深度剖析（一）---ioc容器的初始化

港控/mmm° 2022-05-26 00:07 209阅读 0赞

一、Spring IOC容器概述

二、IOC容器系列的设计和实现：BeanFactory和ApplicationContext

三、IOC容器初始化过程

四、容器的其他相关特性的设计和实现

\-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

一、Spring IOC容器概述

1、ioc容器和控制反转模式

依赖反转（依赖注入）：依赖对象的获得反转了。

Spring中依赖反转的实现方式有多种方式。在spring中，IOC容器是实现这个模式的载体，他可以在对象生成或初始化时直接将数据 注入到对象中，也可以通过对象引用注入到对象数据域中的方式来注入对方法调用的依赖。这种依赖可递归，可逐层注入。

2、Spring Ioc的应用场景

Java EE开发中解耦。

二、Ioc容器系列的设计与实现：BeanFactory和ApplicationContext

1.实现了BeanFactory接口的简单容器系列，这系列只实现了容器最基本的功能。

2.ApplicationContext应用上下文，它是作为容器的高级形态而存在的。应用上下文实在基础容器的基础 上，增加了许多面向框架的东西，同时对许多应用环境做了适配。

3.BeanDefinition，Spring通过定义BeanDefinition来管理基于对Spring中应用中各种对象以及他们之间的相互依赖关系。BeanDefinition抽象了我们对Bean的定义，是让容器起作用的主要数据类型。

4.Ioc容器的设计

beanFactory结构关系图

![Center][]

package org.springframework.beans.factory;
    
    import org.springframework.beans.BeansException;
    import org.springframework.core.ResolvableType;
    
    public interface BeanFactory {
    
    	// 用户在使用容器时，可以使用转义符&来的FactoryBean本身，用来区分

// 通过容器获取的FactoryBean产生的对象和或取FactoryBean其本身
    	String FACTORY_BEAN_PREFIX = "&";
            // 通过名称或bean实例
    	Object getBean(String name) throws BeansException;
    	// 通过名称和类型类获取bean实例
    	<T> T getBean(String name, Class<T> requiredType) throws BeansException;
    	// 根据bean名称和参数来获取bean实例
    	Object getBean(String name, Object... args) throws BeansException;
    	// 根据类型获取bean实例
    	<T> T getBean(Class<T> requiredType) throws BeansException;
    	// 根据类型和参数列表来获取
    	<T> T getBean(Class<T> requiredType, Object... args) throws BeansException;
            // 让用户判断指定容器里是否包含指定名称的Bean
    	boolean containsBean(String name);
    	// 查询指定名称的Bean是否是Singleton类型的Bean，对于Singleton的属性，用户可以在Beanfinition中进行指定
    	boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
    	// 作用同上，只是判断是否是Prototype类型
    	boolean isPrototype(String name) throws NoSuchBeanDefinitionException;
    	// 查询指定名称的Bean的Classl类型是否是特定类型的Class类，这个Class可以有用户指定
    	boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;
    	// 同上
    	boolean isTypeMatch(String name, Class<?> typeToMatch) throws NoSuchBeanDefinitionException;
    	// 查询指定名称的Bean的Class类型
    	Class<?> getType(String name) throws NoSuchBeanDefinitionException;
    	//查询指定名称Bean的所有别名，这些别名都是BeanDefinition中定义的
    	String[] getAliases(String name);
    
    }

BeanDefinition结果关系图：

BeanDefinition是SpringIoc容器对用户定义好的Bean的抽象，其数据结构就是BeanDefinition。具体来说，这个BeanDefinition实际上就是POJO对象的在Ioc容器里面的抽象，通过这个BeanDefinition定义的数据结构，可以使得Ioc容器能够方便地对Bean进行管理。在下文会继续详细介绍其作用。

![20180426163414275][]

![Image 1][]

Resource关系结构图：

spring框架中资源文件的抽象，包括各种各样的文件或配置文件或者是网络上的文件。

![Image 1][]![20180426163520356][]

ResourceLoader类结构图：

Resource资源的定位是指：ResourceLoader通过统一的Resource接口来完成，这个Resouce对各种形式的BeanDefinition的使用都提供了统一接口。比如文件系统中bean定义信息可以使用FileSystemResouce来进行抽象；在类路径中Bean可以使用前面提到的ClassPathResouce等等。这个定位的过程类似于容器寻找数据的过程。

![Image 1][]![20180426163324230][]

ApplicationContext类结构图：

![Image 1][]![Image 1][]![20180426163215112][]

最后再来一张整体的Ioc模块整体的结构图：

![2018042616375749][]

三、Ioc容器的初始化

1.初始化的三个过程

第一过程是Resource定位过程。这个Resource定位指的是BeanDefinition的资源定位，它由ResourceLoader通过统一的Resource接口来完成，这个Resource对各种形式的BeanDefinition的使用都提供了统一接口。对于这些BeanDefinition的存在形式，相信大家不会陌生。比如，在文件系统中Bean定义信息可以使用FileSystemResource来进行抽象；在类路径下Bean定义信息可以使用ClassPathResource来使用，等等。这个定位的过程类似于容器在寻找数据的过程，就像用水桶里的水找到一样。

第二过程是BeanDefinition的载入。这个载入过程是把用户定义好的Bean表示成Ioc容器内部的数据结构，而这个容器内部的数据结构就是BeanDefinition。下面介绍这个数据结构的详细定义。具体来说，这个BeanDefinition实际上就是POJO对象在ioc容器中的抽象，通过这个BeanDefinition定义的数据结构，使得ioc容器能够方便地进行管理。在后面的分析中，我们会详细进行讲解。

第三过程是向Ioc容器注册这些BeanDefinition的过程。这个过程是通过调用BeanDefinitionRegistry接口的实现来完成的。这个注册过程把载入过程中解析到的BeanDefinition向Ioc容器中进行注册。通过分析，我们可以看到，在Ioc容器内部将BeanDefinition注册到一HashMap中去，Ioc容器就是通过这个HashMap来持有这些BeanDefinition数据的。

值得注意是：IOC容器的初始化和依赖注入是两个独立的过程。

2.XmlBeanFactory的初始化（基础版Ioc容器）

// 获取资源文件
            ClassPathResource resource = new ClassPathResource("spring.xml");
            // 获取Bean Factory Ioc容器；同时DefaultListableBeanFactory是BeanDefinitionRegistry的一个实现类，
            // 所以该Factory也是BeanDefinitionRegistry
            DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
            XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(factory);
            // 读取resource文件，初始化Ioc容器
            int i = reader.loadBeanDefinitions(resource);
            System.out.println(i);

3.FileSystemXmlApplicationContext（高级版的Ioc容器）

入口：

public class TestFileSystemXmlApplicationContext {
        public static void main(String[] args) {
            ApplicationContext context = new FileSystemXmlApplicationContext("D:/gyoomi/idea-workspace2/cherry/out/production/cherry/spring.xml");
            User user = context.getBean(User.class);
            Dept dept = context.getBean(Dept.class);
            System.out.println(user);
            System.out.println(dept);
        }
    }

FileSystemXmlApplicationContext入口：

public FileSystemXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)
    			throws BeansException {
                    // 设置资源加载器和资源定位
    		super(parent);
    		setConfigLocations(configLocations);
    		if (refresh) {//beanDefinition的载入及注册都是在此方法中完成的			refresh();

}
    	}

资源加载器和资源定位：

通过分析FileSystemXmlApplicationContext中的构造方法得知：

1.首先调用父类容器的构造方法super（parent）为容器设置好Bean资源加载器。

2.再然后调用父类AbstractRefreshableConfigApplicationContext的setConfigLocations(configLocations)方法设置Bean定义资源文件的定义路径。

public AbstractApplicationContext(ApplicationContext parent) {
    		this();
    		setParent(parent);
    	}

public AbstractApplicationContext() {
    		this.resourcePatternResolver = getResourcePatternResolver();//设置资源加载器
    	}

protected ResourcePatternResolver getResourcePatternResolver() {
    		return new PathMatchingResourcePatternResolver(this);//此处new出资源加载器
    	}

@Override
    	public void setParent(ApplicationContext parent) {//设置当前容器的父容器
    		this.parent = parent;
    		if (parent != null) {
    			Environment parentEnvironment = parent.getEnvironment();
    			if (parentEnvironment instanceof ConfigurableEnvironment) {
    				getEnvironment().merge((ConfigurableEnvironment) parentEnvironment);
    			}
    		}
    	}

public void setConfigLocations(String... locations) {// 设置文件资源文件
    		if (locations != null) {
    			Assert.noNullElements(locations, "Config locations must not be null");
    			this.configLocations = new String[locations.length];
    			for (int i = 0; i < locations.length; i++) {
    				this.configLocations[i] = resolvePath(locations[i]).trim();
    			}
    		}
    		else {
    			this.configLocations = null;
    		}
    	}

protected String resolvePath(String path) {
    		return getEnvironment().resolveRequiredPlaceholders(path);
    	}

3.再调用AbstractApplicationContext中refresh()方法，进行Bean的载入过程

refresh方法的作用是在创建容器之前，如果容器已经存在，则把容器销毁。以确保refresh后是新创建起来的容器。

@Override
    	public void refresh() throws BeansException, IllegalStateException {
    		synchronized (this.startupShutdownMonitor) {
    			// 调用容器的刷新方法，同时获取当前时间，并且设置同步标志
    			prepareRefresh();
    
    			// 获取BeanFactory容器
    			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();
    			}
    
    			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.
    				destroyBeans();
    
    				// Reset 'active' flag.
    				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();
    			}
    		}
    	}

protected void prepareRefresh() {
    		this.startupDate = System.currentTimeMillis();
    		this.closed.set(false);
    		this.active.set(true);
    
    		if (logger.isInfoEnabled()) {
    			logger.info("Refreshing " + this);
    		}
    
    		// Initialize any placeholder property sources in the context environment
    		initPropertySources();
    
    		// Validate that all properties marked as required are resolvable
    		// see ConfigurablePropertyResolver#setRequiredProperties
    		getEnvironment().validateRequiredProperties();
    
    		// Allow for the collection of early ApplicationEvents,
    		// to be published once the multicaster is available...
    		this.earlyApplicationEvents = new LinkedHashSet<ApplicationEvent>();
    	}

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {//调用AbstractApplicationContext中此方法
    		refreshBeanFactory(); //这里调用的子类AbstractRefreshApplicationContext的refreshBeanFactory()方法
    		ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    		if (logger.isDebugEnabled()) {
    			logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
    		}
    		return beanFactory;
    	}

@Override
    	protected final void refreshBeanFactory() throws BeansException {
    		if (hasBeanFactory()) {//销毁bean,并关闭beanFactory.
    			destroyBeans();
    			closeBeanFactory();
    		}
    		try {
    			DefaultListableBeanFactory beanFactory = createBeanFactory();// 创建beanFactory
    			beanFactory.setSerializationId(getId());
    			customizeBeanFactory(beanFactory);//对ioc容器进行定制化配置，如启动参数和注解自动装配等
    			loadBeanDefinitions(beanFactory);//载入BeanDefinition信息
    			synchronized (this.beanFactoryMonitor) {
    				this.beanFactory = beanFactory;
    			}
    		}
    		catch (IOException ex) {
    			throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
    		}
    	}

protected DefaultListableBeanFactory createBeanFactory() {//创建beanFactory的具体方法，会根据父容器，进行创建
    		return new DefaultListableBeanFactory(getInternalParentBeanFactory());
    	}

4.在调用AbstractRefreshableApplicatioinContext的loadBeanDefinitions(beanFactory)方法，载入BeanDefinition信息

，调用的是子类AbstractXmlApplicationContext中的实现方法。

@Override
    	protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
    		// 创建一个XmlBeanDefinitionReader并把它回设到传入的BeanFactory中去，用于读取beanDefiniton信息
    		XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
    
    		// Configure the bean definition reader with this context's
    		// 设置reader，为reader设置resourceLoader，因为当前类AbstarctXmlApplicationContext的祖先类AbstractApplictionContext实现了resourceLoader,所以其也是一个加载器
    		beanDefinitionReader.setEnvironment(this.getEnvironment());
    		beanDefinitionReader.setResourceLoader(this);
    		beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
    
    		// Allow a subclass to provide custom initialization of the reader,
    		// 这里开始启动BeanDefinition信息的载入过程。
    		initBeanDefinitionReader(beanDefinitionReader);
    		loadBeanDefinitions(beanDefinitionReader);
    	}

protected void initBeanDefinitionReader(XmlBeanDefinitionReader reader) {
    		reader.setValidating(this.validating);//设置xml校验
    	}

protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {//reader加载bean定义资源
    		Resource[] configResources = getConfigResources();
    		if (configResources != null) {
    			reader.loadBeanDefinitions(configResources);
    		}
    		String[] configLocations = getConfigLocations();
    		if (configLocations != null) {
    			reader.loadBeanDefinitions(configLocations);
    		}
    	}

@Override
    	public int loadBeanDefinitions(String location) throws BeanDefinitionStoreException {
    		return loadBeanDefinitions(location, null);
    	}

public int loadBeanDefinitions(String location, Set<Resource> actualResources) throws BeanDefinitionStoreException {
    		ResourceLoader resourceLoader = getResourceLoader();//获取之前设置的资源加载器
    		if (resourceLoader == null) {
    			throw new BeanDefinitionStoreException(
    					"Cannot import bean definitions from location [" + location + "]: no ResourceLoader available");
    		}
    
    		if (resourceLoader instanceof ResourcePatternResolver) {
    			// Resource pattern matching available.
    			try {
    				Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);
    				int loadCount = loadBeanDefinitions(resources);//载入bean资源
    				if (actualResources != null) {
    					for (Resource resource : resources) {
    						actualResources.add(resource);
    					}
    				}
    				if (logger.isDebugEnabled()) {
    					logger.debug("Loaded " + loadCount + " bean definitions from location pattern [" + location + "]");
    				}
    				return loadCount;
    			}
    			catch (IOException ex) {
    				throw new BeanDefinitionStoreException(
    						"Could not resolve bean definition resource pattern [" + location + "]", ex);
    			}
    		}
    		else {
    			// Can only load single resources by absolute URL.
    			Resource resource = resourceLoader.getResource(location);
    			int loadCount = loadBeanDefinitions(resource);
    			if (actualResources != null) {
    				actualResources.add(resource);
    			}
    			if (logger.isDebugEnabled()) {
    				logger.debug("Loaded " + loadCount + " bean definitions from location [" + location + "]");
    			}
    			return loadCount;
    		}
    	}

@Override
    	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;
    	}

@Override
    	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<EncodedResource>(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();
    			}
    		}
    	}

protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
    			throws BeanDefinitionStoreException {
    		try {
    			Document doc = doLoadDocument(inputSource, resource);//将xml资源文件转为Document对象
    			return registerBeanDefinitions(doc, resource);//按照spring的语法，将doc转换为容器的内部数据结构
    		}
    		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);
    		}
    	}

public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
    		BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();//用于读取BeanDefinitionDocument对象
    		int countBefore = getRegistry().getBeanDefinitionCount();//返回ioc容器已有的BeanDefinition数量
    		documentReader.registerBeanDefinitions(doc, createReaderContext(resource));//解析过程的入口
    		return getRegistry().getBeanDefinitionCount() - countBefore;
    	}

@Override
    	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) {
    		// 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;//定义了spring xml中定义的各种元素
    		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);//在解析bean之前进行自定义解析，以增强解析过程的健壮性
    		parseBeanDefinitions(root, this.delegate);//
    		postProcessXml(root);
    
    		this.delegate = parent;
    	}

protected BeanDefinitionParserDelegate createDelegate(
    			XmlReaderContext readerContext, Element root, BeanDefinitionParserDelegate parentDelegate) {
    
    		BeanDefinitionParserDelegate delegate = new BeanDefinitionParserDelegate(readerContext);
    		delegate.initDefaults(root, parentDelegate);//delegate初始化根元素
    		return delegate;
    	}

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);//解析element元素，可以看下java解析xml文件基础
    					}
    					else {
    						delegate.parseCustomElement(ele);
    					}
    				}
    			}
    		}
    		else {
    			delegate.parseCustomElement(root);
    		}
    	}

private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {//根据spring定义的不同元素类型进行解析
    		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);
    		}
    	}

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {//解bean标签元素
    		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));
    		}
    	}

public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, BeanDefinition containingBean) {
    		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) {//检查<bean>元素中所配置id,name或者别名是否重复
    			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;
    	}

public AbstractBeanDefinition parseBeanDefinitionElement(
    			Element ele, String beanName, BeanDefinition containingBean) {
    
    		this.parseState.push(new BeanEntry(beanName));
    
    		String className = null;//这里存下bean中class名字，然后载入到BeanDefinition中去，不做实例化，实例化在依赖注入的时候完成
    		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);
    			}
    			AbstractBeanDefinition bd = createBeanDefinition(className, parent);//className和parent创建BeanDefinition
    
    			parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);//对当前bean元素，配置一些属性进行设置，如配置单态属性
    			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;
    	}

public AbstractBeanDefinition parseBeanDefinitionAttributes(Element ele, String beanName,
    			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));
    
    		String dependencyCheck = ele.getAttribute(DEPENDENCY_CHECK_ATTRIBUTE);
    		bd.setDependencyCheck(getDependencyCheck(dependencyCheck));
    
    		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);
    			if (!"".equals(initMethodName)) {
    				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);
    			}

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 {
    			if (bd.getPropertyValues().contains(propertyName)) {
    				error("Multiple 'property' definitions for property '" + propertyName + "'", ele);
    				return;
    			}
    			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();
    		}
    	}

\}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;\}  
注册BeanDefinition

public static void registerBeanDefinition(//注册BeanDefinition
    			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);
    			}
    		}
    	}

@Override
    	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<String>(this.beanDefinitionNames.size() + 1);
    					updatedDefinitions.addAll(this.beanDefinitionNames);
    					updatedDefinitions.add(beanName);
    					this.beanDefinitionNames = updatedDefinitions;
    					if (this.manualSingletonNames.contains(beanName)) {
    						Set<String> updatedSingletons = new LinkedHashSet<String>(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定义资源文件中配置的Bean被解析过后，已经注册到IoC容器中，被容器管理起来，真正完成了IoC容器初始化所做的全部工作。现  在IoC容器中已经建立了整个Bean的配置信息，这些BeanDefinition信息已经可以使用，并且可以被检索，IoC容器的作用就是对这些注册的Bean定义信息进行处理和维护。这些的注册的Bean定义信息是IoC容器控制反转的基础，正是有了这些注册的数据，容器才可以进行依赖注入。

[Center]: /images/20220526/c44fedd7af4d4630b6baf41559d48d8c.png
[20180426163414275]: /images/20220526/1f6194cc6a8041c095eccb5136efa730.png
[Image 1]: 
[20180426163520356]: /images/20220526/61d94d044903450a9d1f69c27de84afc.png
[20180426163324230]: /images/20220526/1fe074c6e83140aead8db8e6e459b39c.png
[20180426163215112]: /images/20220526/ea19c1c3b5294ab88696450ae182c7ec.png
[2018042616375749]: /images/20220526/6b20f1a6963c468fbc36d35c40145f80.png