Spring IOC源码解析(上)——Bean的加载

最新推荐文章于 2023-05-12 00:03:04 发布
最新推荐文章于 2023-05-12 00:03:04 发布
阅读量126 收藏
点赞数
分类专栏： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37604110/article/details/103191041
版权

Spring IOC源码解析

1.以XMl创建IOC运行过程

创建IOC运行过程可以分为定位，加载，注册全过程。

1.编写个xml方式获取

 ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
        Person bean = applicationContext.getBean(Person.class);
        System.out.println(bean);

2.启动测试类，可以看到ClassPathXmlApplicationContext就是入口

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gAKaEiHx-1574342383914)(/Users/laiyanxin/Library/Application Support/typora-user-images/image-20191117174546362.png)]

这里面有三步

  1. 调用父类容器的构造方法为容器设置好bean的资源加载器。
  2. 然后再调用AbstractRefreshableConfigApplicationContext里面的setConfigLocations(configLocations)方法设置 Bean 定义资源文件的定位路径
  3. 最后是AbstractApplicationContext 的 refresh ()加载 Bean 定义过程
2.获取加载资源器

调用父类容器的构造方法为容器设置好bean的资源加载器。

	public abstract class AbstractApplicationContext extends DefaultResourceLoader
		implements ConfigurableApplicationContext {

		/**
	 * Create a new AbstractApplicationContext with no parent.
	 */
	public AbstractApplicationContext() {
		this.resourcePatternResolver = getResourcePatternResolver();
	}

	/**
	 * Create a new AbstractApplicationContext with the given parent context.
	 * @param parent the parent context
	 */
	public AbstractApplicationContext(@Nullable ApplicationContext parent) {
		this();
		setParent(parent);
	}
	
	//获取一个资源加载器用于读入资源文件
	protected ResourcePatternResolver getResourcePatternResolver() {
		//为什么传入this ?
		//AbstractApplicationContext 继承 DefaultResourceLoader，因此也是一个资源加载器
		//this等于ClassPathXmlApplicationContext
		return new PathMatchingResourcePatternResolver(this);
	}
	
}
3.setConfigLocations
//解析 Bean 定义资源文件的路径，处理多个资源文件字符串数组
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;
		}
	}

从上面代码可以看出我们既可以使用一个字符串来表示多个spring bean的资源文件,也可以用字符串数组来表示.new ClassPathXmlApplicationContext(“a.xml,b.xml,…”),new ClasspathResource(newString[]{“a.xml”,”b.xml”,…}

4.refresh ()加载 Bean 定义过程

refresh ()是bean的定义最关键的一步

	@Override
	public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			// Prepare this context for refreshing.
			//调用容器准备刷新的方法，获取容器的当时时间，检查环境变量等等
			prepareRefresh();

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

			// Prepare the bean factory for use in this context.
			//为BeanFactory配置容器特性，例如类加载器、事件处理器等
			prepareBeanFactory(beanFactory);

			try {
				// Allows post-processing of the bean factory in context subclasses.
				//为容器的某些子类指定特殊的BeanPost事件处理器
				postProcessBeanFactory(beanFactory);

				// Invoke factory processors registered as beans in the context.
				//调用所有注册的BeanFactoryPostProcessor的Bean
				invokeBeanFactoryPostProcessors(beanFactory);

				// Register bean processors that intercept bean creation.
				//为BeanFactory注册BeanPost事件处理器.
				//BeanPostProcessor是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.
				//为事件传播器注册事件监听器.
				registerListeners();

				// Instantiate all remaining (non-lazy-init) singletons.
				//初始化所有剩余的单例Bean
				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.
				//销毁已创建的Bean
				destroyBeans();

				// Reset 'active' flag.
				//取消refresh操作，重置容器的同步标识.
				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();
			}
		}
	}
1.prepareRefresh();

调用容器准备刷新的方法，获取容器的当时时间，检查环境变量等等

2.obtainFreshBeanFactory()

Spring IOC 容器载入 Bean 定义资源 文件从其子类容器的 refreshBeanFactory()方法启动

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
		refreshBeanFactory();
		ConfigurableListableBeanFactory beanFactory = getBeanFactory();
		if (logger.isDebugEnabled()) {
			logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
		}
		return beanFactory;
	}

其实现主要在子类AbstractRefreshableApplicationContext

@Override
	protected final void refreshBeanFactory() throws BeansException {
        //判断是否有容器，如果有就销毁容器中的bean，关闭容器
		if (hasBeanFactory()) {
			destroyBeans();
			closeBeanFactory();
		}
		try {
            //创建IOC容器
			DefaultListableBeanFactory beanFactory = createBeanFactory();
			beanFactory.setSerializationId(getId());
			//对IOC容器进行定制化，如设置允许循环引用，允许Bean定义覆盖等等
            customizeBeanFactory(beanFactory);
            //调用载入Bean定义的方法
			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是否存在，如果存在就销毁容器中的bean，关闭容器。接着创建IOC容器，对

对IOC容器进行定制化，如设置允许循环引用，允许Bean定义覆盖等等，最后调用载入Bean定义的方法，实现方法在AbstractXmlApplicationContext

public abstract class AbstractXmlApplicationContext extends AbstractRefreshableConfigApplicationContext {

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

		
        //当Bean读取器读取Bean定义的Xml资源文件时，启用 Xml 的校验机制,允许子类提供读取器的自定义初始化
		initBeanDefinitionReader(beanDefinitionReader);
        //Bean 读取器真正实现加载的方法
		loadBeanDefinitions(beanDefinitionReader);
	}   
  
protected void initBeanDefinitionReader(XmlBeanDefinitionReader reader) {
		reader.setValidating(this.validating);
	}

	//加载Bean定义
	protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
		//获取Bean定义资源的定位
		Resource[] configResources = getConfigResources();
		if (configResources != null) {
			reader.loadBeanDefinitions(configResources);
		}
		//如果子类中获取的Bean定义资源定位为空，则获取ClassPathXmlApplicationContext构造方法中setConfigLocations方法设置的资源
		String[] configLocations = getConfigLocations();
		if (configLocations != null) {
			//Bean读取器调用其父类AbstractBeanDefinitionReader读取定位的Bean定义资源
			reader.loadBeanDefinitions(configLocations);
		}
	}
 }

上面主要操作就是创建一个新的XmlBeanDefinitionReader，设置资源加载，加载环境，校验XML，之后获取bean的定义资源定位。接下来XmlBeanDefinitionReaderd调用其父类AbstractBeanDefinitionReader读取定位的Bean定义资源

public abstract class AbstractBeanDefinitionReader implements EnvironmentCapable, BeanDefinitionReader {
    
    
	@Override
	public int loadBeanDefinitions(String... locations) throws BeanDefinitionStoreException {
		Assert.notNull(locations, "Location array must not be null");
		int counter = 0;
		for (String location : locations) {
			counter += loadBeanDefinitions(location);
		}
		return counter;
	}
    
    	@Override
	public int loadBeanDefinitions(String location) throws BeanDefinitionStoreException {
		return loadBeanDefinitions(location, null);
	}
    
    
    public int loadBeanDefinitions(String location, @Nullable Set<Resource> actualResources) throws BeanDefinitionStoreException {
		//获取在IoC容器初始化过程中设置的资源加载器 就是ClassPathXmlApplicationContext
		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 {
				//将指定位置的Bean定义资源文件解析为Spring IOC容器封装的资源
				//加载多个指定位置的Bean定义资源文件
				Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);
				//委派调用其子类XmlBeanDefinitionReader的方法，实现加载功能
				int loadCount = loadBeanDefinitions(resources);
				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 {
			//将指定位置的Bean定义资源文件解析为Spring IOC容器封装的资源
			//加载单个指定位置的Bean定义资源文件
			Resource resource = resourceLoader.getResource(location);
			//委派调用其子类XmlBeanDefinitionReader的方法，实现加载功能
			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;
	}
}

上面源码主要是 调用资源加载器的获取资源方法 resourceLoader.getResource(location)获取到要加载的资源（就是ClassPathXmlApplicationContext）。然后将指定位置的Bean定义资源文件解析为Spring IOC容器封装的资源，真正执行加载功能是其子类 XmlBeanDefinitionReader 的loadBeanDefinitions 方法

public class XmlBeanDefinitionReader extends AbstractBeanDefinitionReader {

	@Override
	public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException 		{
		//将读入的XML资源进行特殊编码处理
        return loadBeanDefinitions(new EncodedResource(resource));
	}
    
    //从指定的XML文件加载bean定义。
    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 {
       //将encodedResource获取到已经封装的resource对象并获取InputStream的IO流
			InputStream inputStream = encodedResource.getResource().getInputStream();
      try {
        //从InputStream中得到XML的解析源
				InputSource inputSource = new InputSource(inputStream);
				if (encodedResource.getEncoding() != null) {
					inputSource.setEncoding(encodedResource.getEncoding());
				}
        //真正核心原理,具体的读取过程,开始bean的加载
				return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
			}
			finally {
        //关闭从Resource中得到的IO流
				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();
			}
		}
	}
    
   //从指定的XML文件实际加载bean定义。
 protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
			throws BeanDefinitionStoreException {
		try {
			//这里做了做了对XML进行校验,然后x	ml文件转换为DOM对象，解析过程由documentLoader实现
			Document doc = doLoadDocument(inputSource, resource);
			//这里是启动对Bean定义解析的详细过程，该解析过程会用到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);
		}
	}

}

上面源码分析， 载入 Bean 定义资源文件的最后一步是将 Bean 定义资源转换为 Document 对象， 该过程
由 documentLoader 实现 ，然后开始注册registerBeanDefinitions

public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
		//创建个BeanDefinitionDocumentReader解析
		BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
		//获得容器中注册的Bean数量
		int countBefore = getRegistry().getBeanDefinitionCount();
		//解析过程入口，具体的实现过程在实现类DefaultBeanDefinitionDocumentReader
		documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
		//记录本次加载BeanDefinition数量
		return getRegistry().getBeanDefinitionCount() - countBefore;
	}

registerBeanDefinitions在DefaultBeanDefinitionDocumentReader

public class DefaultBeanDefinitionDocumentReader implements BeanDefinitionDocumentReader {
    //根据Spring DTD对Bean的定义规则解析Bean定义Document对象
	@Override
	public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
		//获得XML描述符
		this.readerContext = readerContext;
		logger.debug("Loading bean definitions");
		//获得Document的根元素
		Element root = doc.getDocumentElement();
		doRegisterBeanDefinitions(root);
	}

  //这里真正开始的进行解析
 protected void doRegisterBeanDefinitions(Element root) {
		BeanDefinitionParserDelegate parent = this.delegate;
		this.delegate = createDelegate(getReaderContext(), root, parent);

   
   //对profile进行处理
		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;
				}
			}
		}

		//在解析Bean定义之前，进行自定义的解析，留给子类实现(模版方法)
		preProcessXml(root);
		//从Document的根元素开始进行Bean定义的Document对象
		parseBeanDefinitions(root, this.delegate);
		//在解析Bean定义之后，进行自定义的解析，留给子类实现(模版方法)	
		postProcessXml(root);
		this.delegate = parent;
	}

上面过程中对profile进行处理,如果配置文件定义了profiles属性,就会去环境变量中寻找,然后在进行对xml读取

 //使用Spring的Bean规则从Document的根元素开始进行Bean定义的Document对象
	protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
		//Bean定义的Document对象使用了Spring默认的XML命名空间
		if (delegate.isDefaultNamespace(root)) {
			//获取Bean定义的Document对象根元素的所有子节点
			NodeList nl = root.getChildNodes();
			for (int i = 0; i < nl.getLength(); i++) {
				Node node = nl.item(i);
				//获得Document节点是XML元素节点
				if (node instanceof Element) {
					Element ele = (Element) node;
					//Bean定义的Document的元素节点使用的是Spring默认的XML命名空间
					if (delegate.isDefaultNamespace(ele)) {
						//使用Spring的Bean规则解析元素节点
						parseDefaultElement(ele, delegate);
					}
					else {
						//没有使用Spring默认的XML命名空间，则使用用户自定义的解//析规则解析元素节点
						delegate.parseCustomElement(ele);
					}
				}
			}
		}
		else {
			//Document的根节点没有使用Spring默认的命名空间，则使用用户自定义的
			//解析规则解析Document根节点
			delegate.parseCustomElement(root);
		}
	}

    
    //使用Spring的Bean规则解析Document元素节点
	private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
		//如果元素节点是<Import>导入元素，进行导入解析
		if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
			importBeanDefinitionResource(ele);
		}
		//如果元素节点是<Alias>别名元素，进行别名解析
		else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
			processAliasRegistration(ele);
		}
		//元素节点既不是导入元素，也不是别名元素，即普通的<Bean>元素，
		//按照Spring的Bean规则解析元素
		else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
			processBeanDefinition(ele, delegate);
		}
		else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
			// recurse
			doRegisterBeanDefinitions(ele);
		}
	}
    
    //解析Bean定义资源Document对象的普通元素
	protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
		//委托BeanDefinitionDelegate类的parseBeanDefinitionElement方法进行元素的解析
    BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
		if (bdHolder != null) {
     //当返回的dbHolder不为空的情况下若存在默认标签的子节点下再有自定义属性(重点)，还需要再次对自定义标签进行解析
     //例子<property name="test" value="test.myClass"/>
    		 //<mybean:user name="aaa"/>
 			//</bean>
			bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
			try {
				//解析完成后，需要对解析后的bdHolder进行注册，
				BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
			}
			catch (BeanDefinitionStoreException ex) {
				getReaderContext().error("Failed to register bean definition with name '" +
						bdHolder.getBeanName() + "'", ele, ex);
			}
			//发出响应事件，通知相关的监听器已经加载完这个Bean了。
			getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
		}
	}
}

上面过程首先判断是spring默认的配置还是自定义配置,这两种方式的读取及解析差别是非常大的，如果采用Spring默认的配置，Spring当然知道该怎么做，但如果是自定义的，那么就需要用户实现一些接口及配置了。对于根节点或子节点如果是默认命名空间的话采用parseDefaultElement方法进行解析，否则使用delegate.parseCustomElement方法对自定义命名空间进行解析。而判断是否默认命名空间还是自定义命名空间的办法其实是使用node.getNamespaceURI()获取命名空间，并与Spring中固定的命名空间http://www.springframework.org/schema/beans进行对比，如果一致则认为是默认，否则就认为是自定义。bean解析完，信息保存在BeanDefinition ，接下来就是 BeanDefinition 在 IOC 容器中的注册

public class BeanDefinitionReaderUtils {

	//将解析的BeanDefinitionHold注册到容器中
	public static void registerBeanDefinition(
			BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
			throws BeanDefinitionStoreException {

		//使用beanName做唯一标识注册
		String beanName = definitionHolder.getBeanName();
		//向IOC容器注册BeanDefinition
		registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());

		//如果解析的BeanDefinition有别名，向容器为其注册别名
		String[] aliases = definitionHolder.getAliases();
		if (aliases != null) {
			for (String alias : aliases) {
				registry.registerAlias(beanName, alias);
			}
		}
	}
}

从源码可以看出调用 BeanDefinitionReaderUtils 向 IOC 容器注册解析的 BeanDefinition 时， 真正完成注册功
能的是 DefaultListableBeanFactory

public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory
		implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {
    //向IOC容器注册解析的BeanDefiniton
	@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");

		//校验解析的BeanDefiniton
		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;
		//从beanDefinitionMap取出beanName
		oldBeanDefinition = this.beanDefinitionMap.get(beanName);
		if (oldBeanDefinition != null) {
			if (!isAllowBeanDefinitionOverriding()) {
			//如果beanName已经注册且在配置中bean不能够覆盖,抛出异常
				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 {
            //如果beanName不存在，在
			if (hasBeanCreationStarted()) {
				// Cannot modify startup-time collection elements anymore (for stable iteration)
				//注册的过程中需要线程同步，以保证数据的一致性
				synchronized (this.beanDefinitionMap) {
					this.beanDefinitionMap.put(beanName, beanDefinition);
					List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
					updatedDefinitions.addAll(this.beanDefinitionNames);
					updatedDefinitions.add(beanName);
					this.beanDefinitionNames = updatedDefinitions;
					if (this.manualSingletonNames.contains(beanName)) {
						Set<String> updatedSingletons = new LinkedHashSet<>(this.manualSingletonNames);
						updatedSingletons.remove(beanName);
						this.manualSingletonNames = updatedSingletons;
					}
				}
			}
			else {
				// Still in startup registration phase
				this.beanDefinitionMap.put(beanName, beanDefinition);
				this.beanDefinitionNames.add(beanName);
				this.manualSingletonNames.remove(beanName);
			}
			this.frozenBeanDefinitionNames = null;
		}

		//检查是否有同名的BeanDefinition已经在IOC容器中注册
		if (oldBeanDefinition != null || containsSingleton(beanName)) {
			//重置所有beanName对应的缓存
			resetBeanDefinition(beanName);
		}
	}
    
}

DefaultListableBeanFactory 向 IOC 容器注册解析后的 BeanDefinition，DefaultListableBeanFactory 中 使 用 一 个 HashMap 的 集 合 对 象 存 放 IOC 容 器 中 注 册 解 析 的BeanDefinition，

看到这里 Bean 定义资源文件中配置的 Bean 被解析过后， 已经注册到 IOC 容器中， 被容器管理起来， 真正
完成了 IOC 容器初始化所做的全部工作 现在 IOC 容器中已经建立了整个 Bean 的配置信息， 这些
BeanDefinition 信息已经可以使用， 并且可以被检索， IOC 容器的作用就是对这些注册的 Bean 定义
信息进行处理和维护。 这些的注册的 Bean 定义信息是 IOC 容器控制反转的基础， 正是有了这些注册的
数据， 容器才可以进行依赖注入

错觉_
关注
专栏目录
Spring的IOC容器初始化源码分析二：setConfigLocations
qq_28825857的博客
08-09 178
设置本地的配置信息，创建环境对象ConfigurableEnvironment 、处理ClassPathXmlApplicationContext传入的字符串中的占位符； setConfigLocations(configLocations); 包：package org.springframework.context.support; 类：AbstractRefres...
【Spring源码解析】SpringIOC（1）—— Bean与BeanDefinition
如切如磋，如琢如磨
09-10 491
文章目录全局掌握核心接口和类Bean与BeanDefinition 全局掌握核心接口和类 解决了关键的问题：将对象之间的关系转而用配置来管理 依赖注入 —— 依赖关系在Spring的loC容器中管理 通过把对象包装在Bean中以达到管理对象和进行额外操作的目的 Bean与BeanDefinition Bean是Spring的一等公民： Bean的本质就是java对象，只是这个对象的生命周期由容器来管理 不需要为了创建Bean而在原来的java类上添加任何额外的限制 对java对象的控制方式体现
Spring原理-bean的加载控制方式
weixin_46926189的博客
05-12 91
bena的加载控制指：根据特定情况对bean进行选择性加载以达到适用于项目的目标。
Spring 实战 二 环境与 profile + 条件化 Bean
weixin_33726943的博客
07-14 103
环境与 profile 在 spring 3.1 版本中引入环境相关的 bean 功能，需要环境来决定该创建哪个 bean 和不创建哪个 bean，spring 在运行时才会做出决策， 即同一个部署单元（可能为 war 文件）能够适应用所有的环境，无需重新构建。 使用 profile 首先需将所有的 bean 定义整理到一个或多个 profile 中，部署时确保对应的 profile 激活。 ja...
spring源码-前置篇setConfigLocations（二）
你我一起进步
08-31 412
上一篇进行了 super（）方法的解析， 本篇进入到setConfigLocations 一句话概括就是加载配置文件信息 public ClassPathXmlApplicationContext( String[] configLocations, boolean refresh, @Nullable ApplicationContext parent) throws BeansException { super(parent); setConfigLocations(con.
Spring加载流程源码
cristianoxm的博客
03-16 1533
一、从AbstractApplicationContext的体系说起 第一，从类结构设计上看， 围绕着是否需要Refresh容器衍生出两个抽象类： GenericApplicationContext： 是初始化的时候就创建容器，往后的每次refresh都不会更改 AbstractRefreshableApplicationContext：AbstractRefreshableApplicationContext及子类的每次refresh都是先清除已有(如果不存在就创建)的容器，然后再重新创建；
Spring 源码解析——IOC 源码解析（聚焦 Bean 实例化和初始化流程）（二）
Coder Yang
09-25 347
写文章不易，转载请标明出处。 同时，如果你喜欢我的文章，请关注我，让我们一起进步。 一、概述 本来是想在这篇博文中分析 Spring 解决 Bean 循环依赖的思路和源码， 但是在经过自己的梳理之后发现想讲清楚说明白这个解决的方式着实不容易，因为在它的解决代码是整个嵌入在 Bean 的实例化和初始化的代码之中的，加之上一篇博文中对于 Bean 的实例化和初始化分析比较笼统，所以打算通过这...
小读spring ioc源码（一）——整体介绍
04-07
《Spring IOC源码解析（一）——整体介绍》 在深入理解Spring框架的过程中，源码分析是不可或缺的一环。本文将对Spring的IOC（Inversion of Control，控制反转）容器的源码进行初步探讨，旨在帮助读者从整体上把握...
深入解析Spring IoC：源码与实践指南
最新发布
12-13
在深入解析Spring IoC的过程中，我们首先关注的是其核心组件——IoC（Inversion of Control，控制反转）机制。Spring框架通过IoC容器管理应用程序的组件，实现了依赖注入，使得对象之间的依赖关系由容器负责建立和...
Spring源码深度解析（3）——bean的加载
想当厨子的程序媛
02-01 409
我们从 TestChangeMethod t = (TestChangeMethod) ct.getBean(&amp;amp;amp;amp;amp;amp;quot;A&amp;amp;amp;amp;amp;amp;quot;); 开始分析。 首先我们要知道 getBean方法是哪个类中的。下面给出其类图。 这里我们看 AbstractBeanFactory 中是如何实现该方法的，该类是org.springframework.beans.factory.support;包中的类
【Spring容器初始化过程源码解析 5.1.3.RELEASE】
hha的博客
03-10 418
前言 大事发生打发斯蒂芬按时 一、基本概念介绍 啊啊啊 二、源码解析 总结
spring4.1.8初始化源码学习三部曲之二：setConfigLocations方法
weixin_40224981的博客
09-13 403
转载自： https://blog.csdn.net/boling_cavalry/article/details/80958832 本章是学习spring4.1.8初始化源码的第二篇，前一章《spring4.1.8初始化源码学习三部曲之一：AbstractApplicationContext构造方法》对AbstractApplicationContext的初始化做了分析，本章我们聚焦Class...
Bean的加载原理
小马过河
12-30 836
0. Bean 加载原理 加载过程： 通过 ResourceLoader和其子类 DefaultResourceLoader完成资源文件位置定位，实现从类路径，文件系统，url等方式定位功能，完成定位后得到 Resource对象，再交给 BeanDefinitionReader，它再委托给 BeanDefinitionParserDelegate完成bean的解析并得到 BeanDefiniti...
Spring源代码解析之四（容器的功能扩展）
fengziyu523的博客
12-12 274
容器的功能扩展 1、概述 之前的文章中BeanFactory接口以及它的默认实现类XmlBeanFactory为例进行分析，但是Spring中还提供了另一个接口ApplicationContext，用于扩展BeanFactory中现有的功能。  ApplicationContext和BeanFactory两者都是用于加载Bean的，但是相比之下，ApplicationContext提供了更多的...
Caused by: java.lang.IllegalArgumentException: Location must not be null
热门推荐
小灰~的博客
06-27 1万+
异常描述： java.lang.ExceptionInInitializerError at com.liyo.modules.sys.service.SystemService.printKeyLoadMessage(SystemService.java:570) at com.liyo.modules.sys.listener.WebContextListener.initWebApp...
Spring 配置文件加载过程
weixin_52016782的博客
09-12 1870
Spring配置文件的加载主要是在loadBeanDefinitoin方法中进行的 而这个方法又非常之复杂,我们本篇博客的目的就是详细讲解这一方法 this.loadBeanDefinitions(beanFactory); 点进去 protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException { XmlBeanDefinitio
Spring Environment 源码解析
li11359713的博客
08-04 521
总所周知，Spring IOC 是通过调用 AbstractApplicationContext.refresh() 方法进行初始化的，但是 Spring 在调用 refresh()方法之前，先会调用 AbstractRefreshableConfigApplicationContext.setConfigLocations() 方法来处理配置文件数组，解析后的配置文件地址又需要写入 Spring 的Environment，因此 Spring会在这一步通过 AbstractApplicationCon...
四、spring源码解读初始化
qq_33849244的博客
09-28 358
 4.1、什么是IOC/DI？ IOC（Inversion of Control）控制反转：所谓控制反转，就是把原先我们代码里面需要实现对象创建、依赖的代码，反转给容器来帮忙实现。那么必然的我们需要创建一个容器，同时需要一种描述来让容器知道需要创建的对象与对象的关系。这描述最具体的表现就是我们可配置的文件。   DI(Dependency Injection)依赖注入：就是指对象是被动接受依...
Spring源码深度解析：IOC容器与核心组件
在Spring源码解析的第一部分，作者着重讲解了IOC容器的启动过程，包括BeanFactory如何解析配置信息，如何创建和初始化Bean。这部分内容通常涉及到类路径扫描、BeanDefinition的注册和Bean实例化的过程。Bean...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值