Spring 核心类-XMLBeanDefinitionReader 加载解析bean

XML 配置文件的读取时Spring中重要的功能,因为Spring的大部分功能都是以配置作为切入点的,那么我们可以从XMLBeanDefinitionReader中梳理一下资源文件读取、解析即注册的大致脉络。


BeanDefinition 的加载、解析、注册过程

Spring 核心类-XMLBeanDefinitionReader 加载解析bean_第1张图片

	/**
	 * 用XMLBeanDefinitionReader 加载配置文件
	 */
	@Test
	public void useXMLBeanDefinitionReaderLoadXML() {
		DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
		XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(factory);
		reader.loadBeanDefinitions("spring/applicationContext-test.xml");
		UserServiceImpl userService = factory.createBean(UserServiceImpl.class);
		userService.getUserInfo();
	}

Bean的获取与创建:

Spring 核心类-XMLBeanDefinitionReader 加载解析bean_第2张图片

源码分析:

protected  T doGetBean(
			final String name, final Class requiredType, final Object[] args, boolean typeCheckOnly)
			throws BeansException {
		//提取对用的beanName
		final String beanName = transformedBeanName(name);
		Object bean;	
		//检查缓存中或实例工厂中是否有对应的实例
		//为什么首先会使用这段代码呢?
		//因为在创建单例bean的时候会存在依赖注入的情况,而在创建依赖的时候为了避免循环依赖		
		//Spring 创建bean的原则是不等bean创建完成就会将创建bean的ObjectFactory提早曝光
		// 也就是将ObjectFactory 加入到缓存中,一旦下个bean创建时候需要依赖上个bean则直接使用ObjectFactory
		//直接尝试从缓存中获取或者singletonFactories中的ObjectFactory中获取
		Object sharedInstance = getSingleton(beanName);
		if (sharedInstance != null && args == null) {
			bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
		}
		else {
			// 检查循环依赖
			if (isPrototypeCurrentlyInCreation(beanName)) {
				throw new BeanCurrentlyInCreationException(beanName);
			}		
			try {
			 //将存储XML配置文件 的GerbericBeanDefinition 转换为 RootBeanDefinition,如果是指定BeanName 是子Bean的话同时会 合并父类的相关属性
				final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
				checkMergedBeanDefinition(mbd, beanName, args);

				// Guarantee initialization of beans that the current bean depends on.
				String[] dependsOn = mbd.getDependsOn();
				
				//若存在依赖则需要递归实例化依赖的bean
				if (dependsOn != null) {
					for (String dependsOnBean : dependsOn) {
						if (isDependent(beanName, dependsOnBean)) {
							throw new BeanCreationException(mbd.getResourceDescription(), beanName,
									"Circular depends-on relationship between '" + beanName + "' and '" + dependsOnBean + "'");
						}
						registerDependentBean(dependsOnBean, beanName);
						getBean(dependsOnBean);
					}
				}
				// singleton 模式的创建
				if (mbd.isSingleton()) {
					sharedInstance = getSingleton(beanName, new ObjectFactory() {
						@Override
						public Object getObject() throws BeansException {
							try {
								return createBean(beanName, mbd, args);
							}
						}
					});
					bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
				}
				else if (mbd.isPrototype()) {
					// It's a prototype -> create a new instance.
					Object prototypeInstance = null;
					try {
						beforePrototypeCreation(beanName);
						prototypeInstance = createBean(beanName, mbd, args);
					}
					finally {
						afterPrototypeCreation(beanName);
					}
					bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
				}
				else {
					String scopeName = mbd.getScope();
					final Scope scope = this.scopes.get(scopeName);
					if (scope == null) {
						throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
					}
					try {
						Object scopedInstance = scope.get(beanName, new ObjectFactory() {
							@Override
							public Object getObject() throws BeansException {
								beforePrototypeCreation(beanName);
								try {
									return createBean(beanName, mbd, args);
								}
								finally {
									afterPrototypeCreation(beanName);
								}
							}
						});
						bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
					}
				}
			}
		}
		// Check if required type matches the type of the actual bean instance.
		if (requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) {
			try {
				return getTypeConverter().convertIfNecessary(bean, requiredType);
			}
		}
		return (T) bean;
	}
	 
  
  加载的过程如下:

    1.转换对应的beanName,传入的参数name可以是beanName 或者是别名,也可能是FactiryBean。

    2.尝试从缓存中加载单例
        单例在spring的同一个容器只会被创建一次,后续再获取bean,就直接从单例缓存中获取了,当然这里也只是尝试加载, 首先尝试从缓存中加载如果加载不成功则再次从singleFactories 中加载。因为在创建单例。
        bean的时候会存在依赖注入的情况,而在创建依赖的时候味蕾避免循环依赖,在spring中创建bean的原则是不等bean创建完成就会将创建bean的ObjectFactory提早曝光加入到缓存中,一旦下一个bean创建时候,主要依赖上一个bean则直接使用ObjectFactory.
3.bean的实例化
      如果从缓存中得到了bean的原始状态,则需要对bean进行实例化。缓存中记录的只是最原始的bean状态, 并不一定是我们最终想要的bean,举个例子,加入我们队工厂bean进行处理,那么这里得到的其实就是工厂bean的初始状态,但是我们真正需要的是工厂bean中定义的factory-method方法返回的bean,而getObjectForBeanInstance 就是完成这个工作的。   
4. 原型模式的依赖检查
       只有在单例情况下才会尝试解决循环依赖,如果存在A中又B的属性,B中有A的属性,那么当依赖注入的时候,就会产生但A还未创建完的时候因为对于B的创建再次返回创建A,造成循环依赖,     
5.检测parentBeanFactory
       从代码 上看,如果缓存中没有数据的话直接转到父类工厂上去加载了。
 6.将存储XML配置文件的GernerBeanDefinition 转换为RootBeanDeffinition
         因为从XML配置文件的中读取到的Bean信息时存储在GernericBeanDefinniton中的,但是所有的Bean后续处理都是针对于RootBeanDefiniton的,所以这里需要进行一个转换,转换的同时如果父类bean不为空的话,则会一并合并父类的属性。      
7.寻找依赖
         因为bean的初始化过程中很可能会用到某些属性,而某些属性很可能是动态配置的,并且配置成依赖于其他 的bean,那么这个时候就有必要先加载 依赖的bean,所以,在Spring的加载顺序中,在初始化某一个bean的时候首先会初始化这个
         bean所对应的依赖。
8.针对不同的scope进行bean 的创建
    在Spring中存在着不同的scope,其中默认的是singleton,但是还有些其他的配置诸如prototype、request之类的。在这个过程中,Spring会根据不同的配置进行不同的初始化策略。
        
 
      

 ApplicationContext 获取Bean的过程:


Spring 核心类-XMLBeanDefinitionReader 加载解析bean_第3张图片

你可能感兴趣的:(Spring)