spring源码深度解析之BeanDefinition加载（上）

源码下载

spring各个版本下载地址：
https://github.com/spring-projects/spring-framework/tags

spring加载入口

spring有多种可以加载的方式，其中常见的就是下面3类

• 读取xml配置，加载spring
  ApplicationContext ac = new ClassPathXmlApplicationContext(“spring.xml”);
• 读取注解式的java配置类，加载spring
  ApplicationContext ac = new AnnotationConfigApplicationContext(myConfig.class);
• tomcat启动加载spring
  启动spring，通过ContextLoaderListener
  new XmlWebApplicationContext();

ClassPathXmlApplicationContext

先给出一下ClassPathXmlApplicationContext这个类的继承关系，从AbstractRefreshableConfigApplicationContext开始，陆陆续续实现一些接口

ClassPathXmlApplicationContext构造函数

new ClassPathXmlApplicationContext(“spring.xml”)用于加载CLASSPATH下的Spring配置文件，然后通过ac.getBean(“beanName”)就可以获取到bean实例。

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

从第二段代码看，总共就做了三件事：

• super(parent)
  super(parent)的作用是为容器设置Bean资源加载器，通过debug，可知实际是由其父类AbstractApplicationContext完成设置。
  AbstractApplicationContext.java

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

parent为null，setParent(parent)就不看了。this()就是无参构造方法，注意，从这里可以看到AbstractApplicationContext 继承了DefaultResourceLoader，所以实际上它自身也作为资源加载器。

public AbstractApplicationContext() {
		this.resourcePatternResolver = getResourcePatternResolver();
	}
	
protected ResourcePatternResolver getResourcePatternResolver() {
		return new PathMatchingResourcePatternResolver(this);
	}

PathMatchingResourcePatternResolver.java

public PathMatchingResourcePatternResolver(ResourceLoader resourceLoader) {
		Assert.notNull(resourceLoader, "ResourceLoader must not be null");
		this.resourceLoader = resourceLoader;
	}

• setConfigLocations(configLocations)
  setConfigLocations(configLocations)的作用是设置Bean定义资源文件的路径，实际是由其父类AbstractRefreshableConfigApplicationContext完成设置

public void setConfigLocations(@Nullable 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;
		}
	}

resolvePath为同一个类中将字符串解析为路径的方法

• refresh()
  这个就是整个Spring Bean加载的核心了，它是ClassPathXmlApplicationContext的父类AbstractApplicationContext的一个方法，顾名思义，用于刷新整个Spring上下文信息，定义了整个Spring上下文加载的流程。

public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			// 准备此上下文以进行刷新。
			prepareRefresh();

			// 告诉子类刷新内部bean工厂。
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

			// 准备bean工厂以在此上下文中使用。
			prepareBeanFactory(beanFactory);

			try {
				// 允许在上下文子类中对bean工厂进行后处理。
				postProcessBeanFactory(beanFactory);

				// 在上下文中调用注册为bean的工厂处理器。
				invokeBeanFactoryPostProcessors(beanFactory);

				// 注册拦截bean创建的bean处理器。
				registerBeanPostProcessors(beanFactory);

				// 初始化此上下文的消息源。
				initMessageSource();

				// 初始化此上下文的消息源。
				initApplicationEventMulticaster();

				// 在特定上下文子类中初始化其他特殊bean。
				onRefresh();

				// 检查监听器bean并注册它们。
				registerListeners();

				// 实例化所有剩余（非延迟初始化）单例。
				finishBeanFactoryInitialization(beanFactory);

				// 最后一步：发布相应的事件。
				finishRefresh();
			}

			catch (BeansException ex) {
				if (logger.isWarnEnabled()) {
					logger.warn("Exception encountered during context initialization - " +
							"cancelling refresh attempt: " + ex);
				}

				// 销毁已经创建的单例以避免悬空资源。
				destroyBeans();

				// 重置'有效'标志。
				cancelRefresh(ex);

				// 向调用者传播异常
				throw ex;
			}

			finally {
				// 从我们开始，重置Spring核心中的常见内省缓存
				// 也许再也不需要单例bean的元数据......
				resetCommonCaches();
			}
		}
	}

每个子方法的功能之后一点一点再分析，首先refresh()方法有几点是值得我们学习的：

1、方法是加锁的，这么做的原因是避免多线程同时刷新Spring上下文

2、尽管加锁可以看到是针对整个方法体的，但是没有在方法前加synchronized关键字，而使用了对象锁startUpShutdownMonitor，这样做有两个好处：

（1）refresh()方法和close()方法都使用了startUpShutdownMonitor对象锁加锁，这就保证了在调用refresh()方法的时候无法调用close()方法，反之亦然，避免了冲突

（2）另外一个好处不在这个方法中体现，但是提一下，使用对象锁可以减小了同步的范围，只对不能并发的代码块进行加锁，提高了整体代码运行的效率

3、refresh函数是一个模板方法，执行多个方法，而且提供了各(protected)方法的（默认）实现，其子类可以重写它们 。
模板方法模式： 在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类（使用protected方法）可以在不改变算法结构的情况下，重新定义算法中的某些步骤。

refresh()核心调用方法obtainFreshBeanFactory

obtainFreshBeanFactory函数调用，完成了容器初始化的最重要最基础的功能，Bean定义资源的Resource定位、载入解析和注册。

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
		refreshBeanFactory();
		return getBeanFactory();
	}

这里使用了委派设计模式，obtainFreshBeanFactory中调用了两个抽象方法，定义了obtainFreshBeanFactory的算法骨架，实际的行为交给其子类（AbstractRefreshableApplicationContext）实现
AbstractRefreshableApplicationContext.java

protected final void refreshBeanFactory() throws BeansException {
        // 如果已经有容器，销毁容器中的bean，关闭容器，以保证在refresh之后使用的是新建立起来的IoC容器
		if (hasBeanFactory()) {
			destroyBeans();
			closeBeanFactory();
		}
		try {
		    //创建IoC容器
			DefaultListableBeanFactory beanFactory = createBeanFactory();
			// 对IoC容器进行定制化，如设置启动参数，开启注解的自动装配等
			beanFactory.setSerializationId(getId());
			customizeBeanFactory(beanFactory);
			// 调用载入Bean定义的方法，这里又使用了委派模式，在当前类中只定义了抽象的loadBeanDefinitions方法，具体的实现调用子类容器
			loadBeanDefinitions(beanFactory);
			synchronized (this.beanFactoryMonitor) {
				this.beanFactory = beanFactory;
			}
		}
		catch (IOException ex) {
			throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
		}
	}

在这个方法中，先判断BeanFactory是否存在，如果存在则先销毁beans并关闭beanFactory，接着创建DefaultListableBeanFactory，并调用loadBeanDefinitions(beanFactory)装载bean使用了委派模式，在当前类中只定义了抽象的loadBeanDefinitions方法，具体的实现调用子类容器（AbstractXmlApplicationContext）
AbstractXmlApplicationContext.java

protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
		// 为给定的BeanFactory创建一个新的XmlBeanDefinitionReader
		XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);

		// 使用此上下文配置bean定义读取器
		// 资源加载环境
		beanDefinitionReader.setEnvironment(this.getEnvironment());
		beanDefinitionReader.setResourceLoader(this);
		beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));

		// Allow a subclass to provide custom initialization of the reader,
		// 继续实际加载bean定义
		initBeanDefinitionReader(beanDefinitionReader);
		loadBeanDefinitions(beanDefinitionReader);
	}

看看new XmlBeanDefinitionReader(beanFactory) 做了什么。
其实就是初始化了this.registry=DefaultListableBeanFactory*

public XmlBeanDefinitionReader(BeanDefinitionRegistry registry) {
		super(registry);
	}

protected AbstractBeanDefinitionReader(BeanDefinitionRegistry registry) {
		Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
		this.registry = registry;

		// Determine ResourceLoader to use.
		if (this.registry instanceof ResourceLoader) {
			this.resourceLoader = (ResourceLoader) this.registry;
		}
		else {
			this.resourceLoader = new PathMatchingResourcePatternResolver();
		}

		// Inherit Environment if possible
		if (this.registry instanceof EnvironmentCapable) {
			this.environment = ((EnvironmentCapable) this.registry).getEnvironment();
		}
		else {
			this.environment = new StandardEnvironment();
		}
	}

因为DefaultListableBeanFactory实现了BeanDefinitionRegistry接口，实现了AliasRegistry接口， 定义了一些对 bean的常用操作
1： 以Map的形式注册bean
2：根据beanName 删除和获取 beanDefiniation ，得到持有的beanDefiniation的数目，根据beanName 判断是否包含beanDefiniation

接着看AbstractXmlApplicationContext.loadBeanDefinitions(DefaultListableBeanFactory beanFactory) 方法，定位到最后一行loadBeanDefinitions(beanDefinitionReader)

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);
		}
	}

第8行，调用XmlBeanDefinitionReader父类AbstractBeanDefinitionReader
AbstractBeanDefinitionReader.java

public int loadBeanDefinitions(String... locations) throws BeanDefinitionStoreException {
		Assert.notNull(locations, "Location array must not be null");
		int count = 0;
		for (String location : locations) {
			count += loadBeanDefinitions(location);
		}
		return count;
	}

开始循环加载资源，继续跟踪loadBeanDefinitions方法，使用ResourceLoader将资源文件路径转换为对应的Resource文件，然后会定位到

public int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException {
		Assert.notNull(resources, "Resource array must not be null");
		int count = 0;
		for (Resource resource : resources) {
			count += loadBeanDefinitions(resource);
		}
		return count;
	}

第5行的loadBeanDefinitions方法是在XmlBeanDefinitionReader实现的
XmlBeanDefinitionReader.java

public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
		return loadBeanDefinitions(new EncodedResource(resource));
	}

加入编码格式，继续跟踪loadBeanDefinitions方法

public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
		Assert.notNull(encodedResource, "EncodedResource must not be null");
		if (logger.isTraceEnabled()) {
			logger.trace("Loading XML bean definitions from " + encodedResource);
		}

		Set 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();
			}
		}
	}

currentResources.add(encodedResource) 用Set判断，如果重复加载资源就抛出异常，主要看该方法里面的doLoadBeanDefinitions

protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
			throws BeanDefinitionStoreException {

		try {
			Document doc = doLoadDocument(inputSource, resource);
			int count = registerBeanDefinitions(doc, resource);
			if (logger.isDebugEnabled()) {
				logger.debug("Loaded " + count + " bean definitions from " + resource);
			}
			return count;
		}
		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);
		}
	}

该方法就第5、6行。
第5行就是用sax把xml解析成org.w3c.dom，具体就不跟了
第6行才是重头戏，开始注册beanDefitions，跟踪registerBeanDefinitions(doc, resource)

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

第2行，可以跟进去看，其实就是初始化一个DefaultBeanDefinitionDocumentReader
所以第4行registerBeanDefinitions在
DefaultBeanDefinitionDocumentReader.java实现。这里有个很重要的方法createReaderContext(resource)，在创建ReaderContext的同时加载了自定义标签（aop/dubbo等）的解析器，这里到下一章再分析。。。本章节只分析spring自带标签
DefaultBeanDefinitionDocumentReader.java

public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
		this.readerContext = readerContext;
		doRegisterBeanDefinitions(doc.getDocumentElement());
	}

第3行doRegisterBeanDefinitions

protected void doRegisterBeanDefinitions(Element root) {
		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);
				// We cannot use Profiles.of(...) since profile expressions are not supported
				// in XML config. See SPR-12458 for details.
				if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {
					if (logger.isDebugEnabled()) {
						logger.debug("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;
	}

第3行初始化了bean默认的解析器BeanDefinitionParserDelegate
倒数第5行parseBeanDefinitions开始解析dom，前后各有一个预留的空方法，方便以后版本扩展

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);
		}
	}

获取节点的命令空间，判断是不是spring默认的http://www.springframework.org/schema/beans，是的话就执行parseDefaultElement(ele, delegate)，用BeanDefinitionParserDelegate去解析spring自带标签；不是的话就执行parseCustomElement(ele)解析自定义标签（aop/dubbo等），下一章再分析

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加载流程。
至此BeanDefinition加载完成，那么BeanDefinition又何去何从呢？直接看processBeanDefinition(ele, delegate)

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));
		}
	}

看第7行

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);
			}
		}
	}

看第7行，还记得这个registry吗?不记得就Ctrl+F搜一下，没错它就是DefaultListableBeanFactory

DefaultListableBeanFactory.java定义很多ConcurrentHashMap，其中
beanDefinitionMap.put(beanName, beanDefinition)
而beanDefinitionNames.add(beanName) 以List形式存储beanName

至此，beanFactory初始化完毕，而这才是refresh()方法中的

ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

参考：
https://www.cnblogs.com/xrq730/p/6285358.html
https://www.cnblogs.com/xrq730/p/6285358.html
https://blog.csdn.net/benhuo931115/article/details/74611464/