33、深入解析spring技术$3

通过BeanDefinitionParserDelegate完成对资源文件的解析与载入，资源文件在IoC容器中创建了相应数据，但是这些数据还不能直接供IoC使用，需要在DefaultListableBeanFactory中进行注册；在31章图2中，这个类实现了BeanDefinitionRegistry接口，这个接口完成BeanDefinition向BeanFactory中注册；

在上章最后执行：

BeanDefinitionReaderUtils.registerBeanDefinition( BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)throws BeanDefinitionStoreException {
		String beanName = definitionHolder.getBeanName();
		registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());

调用DefaultListableBeanFactory.registerBeanDefinition()这个方法，完成注册；

@Override
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)throws BeanDefinitionStoreException {
	...  ....
	resetBeanDefinition(beanName);
}

通过上面的方法完成BeanDefinition的注册，完成了refresh()的obtainFreshBeanFactory()方法，同时，DefaultListableBeanFactory中注册了整个bean的配置信息，所以这些配置信息就可以供IoC使用；

 

$3、依赖注入

在BeanFactory这个基本IOC容器中，定义了4个获取bean的方法getBean();下面来解析getBean的实现：

DefaultListableBeanFactory的基类AbstractBeanFactory.getBean()

@Override
public Object getBean(String name) throws BeansException {
	return doGetBean(name, null, null, false);
}
@Override
public <T> T getBean(String name, Class<T> requiredType) throws BeansException {
	return doGetBean(name, requiredType, null, false);
}
@Override
public Object getBean(String name, Object... args) throws BeansException {
	return doGetBean(name, null, args, false);
}
public <T> T getBean(String name, Class<T> requiredType, Object... args) throws BeansException {
	return doGetBean(name, requiredType, args, false);
}

都调用了doGetBean方法，在doGetBean中会调用AbstractAutowireCapableBeanFactory.createBean-->doCreateBean-->createBeanInstance(beanName, mbd, args);populateBean(beanName, mbd, instanceWrapper);

createBeanInstance会根据传递进来class=“”的参数创建一个实例，populateBean将要注入的属性值给予赋值；

 

到这里 有必要对容器的创建、资源的定位、载入、注册(注入)、容器的销毁 梳理一下：

比如 ApplicationContext  ac = new FileSystemXmlApplicationContext("e:/jsL/beans.xml");

1、首先会来到FileSystemXmlApplicationContext的构造方法中，并传递一个绝对资源文件地址；

      super(null);

      setConfigLocations(configLocations);   //将文件地址赋值给configLocations这个属性

      refresh();

 2、执行refresh()这个方法会来到AbstractApplicationContext这个类中，这个类是FileSystemXmlApplicationContext的基类；

       prepareRefresh();   //准备刷新，

      ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();    //获得全新的beanFactory，调用loadBeanDefinitions()载入资源

    (关键方法：refreshBeanFactory();loadBeanDefinitions(beanFactory);)

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 {
	if (hasBeanFactory()) {
		destroyBeans();
		closeBeanFactory();
	}
	try {
		DefaultListableBeanFactory beanFactory = createBeanFactory();
		beanFactory.setSerializationId(getId());
		customizeBeanFactory(beanFactory);
		loadBeanDefinitions(beanFactory);           //加载资源
		synchronized (this.beanFactoryMonitor) {
			this.beanFactory = beanFactory;     //替换了beanFactory；
		}
	}
	catch (IOException ex) {
		throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
	}
}
@Override
protected void cancelRefresh(BeansException ex) {
	synchronized (this.beanFactoryMonitor) {
		if (this.beanFactory != null)
			this.beanFactory.setSerializationId(null);
	}
	super.cancelRefresh(ex);
}
@Override
protected final void closeBeanFactory() {
	synchronized (this.beanFactoryMonitor) {
		this.beanFactory.setSerializationId(null);
		this.beanFactory = null;
	}
}
protected final boolean hasBeanFactory() {
	synchronized (this.beanFactoryMonitor) {
		return (this.beanFactory != null);
	}
}

@Override
public final ConfigurableListableBeanFactory getBeanFactory() {  //获得新的beanFactory
	synchronized (this.beanFactoryMonitor) {
		if (this.beanFactory == null) {
			throw new IllegalStateException("BeanFactory not initialized or already closed - " +
				"call 'refresh' before accessing beans via the ApplicationContext");
		}
		return this.beanFactory;
	}
}
@Override
protected void assertBeanFactoryActive() {
}
protected DefaultListableBeanFactory createBeanFactory() {
	return new DefaultListableBeanFactory(getInternalParentBeanFactory());
}

protected void customizeBeanFactory(DefaultListableBeanFactory beanFactory) {
	if (this.allowBeanDefinitionOverriding != null) {
		beanFactory.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
	}
	if (this.allowCircularReferences != null) {
		beanFactory.setAllowCircularReferences(this.allowCircularReferences);
	}
}
protected abstract void loadBeanDefinitions(DefaultListableBeanFactory beanFactory)
		throws BeansException, IOException;
}

    prepareBeanFactory(beanFactory);  //bean是ConfigurableListableBeanFactory的实例；

beanFactory.setBeanClassLoader(getClassLoader());
beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));

     //配置标准容器特性，如类加载器，后置处理器：post-processors  ,等

     postProcessBeanFactory(beanFactory); 

     invokeBeanFactoryPostProcessors(beanFactory);

     //将使用上一步添加的后置处理器。

    registerBeanPostProcessors(beanFactory);     //注册  后置处理器

protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
	PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
}
找了老半天都没找到PostProcessorRegistrationDelegate在哪里声明的。

 

重点是loadBeanDefinitions(beanFactory)方法；结合第$2章学习；