Spring-IOC源码解读2-容器的初始化过程
1. IOC容器的初始化过程：IOC容器的初始化由refresh()方法启动，这个启动包括：BeanDifinition的Resource定位，加载和注册三个过程。初始化的过程不包含Bean依赖注入的实现。
- 第一个过程是Resource的定位过程。这个Resource的定位指的是BeanDefinition的资源定位，它由ResourceLoader通过统一的Resource接口完成。
- 第二个过程是BeanDefinition的载入，这个过程是把用户定义好的Bean表示为容器的内部数据结构（即BeanDefinition）
- 第三个过程是向IOC容器注册这些BeanDefinition的过程。
2. 下面我们以ClassPathXmlApplicationContext 为例分析这个ApplicationContext的实现，使用的spring版本是3.0.2版本。首先看下我们测试的代码和配置文件：
- 2.1：javaBean的定义
public class Person {
private String name;
private int age;
private int sex;
private Dog dog;
private List<Address> addressList;
}
public class Dog {
private String dogName;
}
public class Address {
private String type;
private String city;
}
- 2. 2beans.xml文件定义：
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://www.springframework.org/schema/beans"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<!-- person对象 -->
<bean id="person" class="com.pepper.spring.model.Person" >
<property name="name" value="pepper" />
<property name="age" value="24" />
<property name="sex" value="1" />
<property name="dog" ref="dog" />
<property name="addressList">
<list>
<ref bean="home"/>
<ref bean="work"/>
</list>
</property>
</bean>
<!-- person对象的Dog属性 -->
<bean id="dog" class="com.pepper.spring.model.Dog">
<property name="dogName" value="Edward" />
</bean>
<!-- person对象AddressList属性的两个值 -->
<bean id="home" class="com.pepper.spring.model.Address">
<property name="type" value="home" />
<property name="city" value="SX" />
</bean>
<bean id="work" class="com.pepper.spring.model.Address">
<property name="type" value="work" />
<property name="city" value="SZ" />
</bean>
</beans>
- 2.3. 容器启动类：
public class TestSpring {
public static final String BEAN_CONFIG_FILE = "E:/workspace_selflearn/read-spring/src/spring-beans.xml";
public static final String BEAN_CONFIG_CLASS = "spring-beans.xml";
public static void main(String[] args) {
testApplicationContext();
}
//使用XmlBeanFactory
public static void testBeanFactory() {
Resource res = new ClassPathResource(BEAN_CONFIG_CLASS);
BeanFactory fac = new XmlBeanFactory(res);
Person p = fac.getBean("person", Person.class);
System.out.println(p);
}
//使用ApplicationContext
public static void testApplicationContext() {
ApplicationContext ac = null;
// ac = new FileSystemXmlApplicationContext(BEAN_CONFIG_FILE);
ac = new ClassPathXmlApplicationContext(BEAN_CONFIG_CLASS);
Person p = ac.getBean("person", Person.class);
System.out.println(p);
}
}
3. 我们先看下ClassPathXmlApplicationContext类的定义:
public class ClassPathXmlApplicationContext extends AbstractXmlApplicationContext {
private Resource[] configResources;
public ClassPathXmlApplicationContext() {
}
public ClassPathXmlApplicationContext(ApplicationContext parent) {
super(parent);
}
// configLocation对象表示BeanDefinition所在的文件路径
public ClassPathXmlApplicationContext(String configLocation) throws BeansException {
this(new String[] {configLocation}, true, null);
}
// Spring支持传入多个BeanDefinition配置文件
public ClassPathXmlApplicationContext(String... configLocations) throws BeansException {
this(configLocations, true, null);
}
// 此构造方法除了包含配置文件路径，还允许指定想要使用的父类IOC容器
public ClassPathXmlApplicationContext(String[] configLocations, ApplicationContext parent) throws BeansException {
this(configLocations, true, parent);
}
public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh) throws BeansException {
this(configLocations, refresh, null);
}
//对象的初始化过程中，调用refresh()方法启动BeanDefinition的载入过程
public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)throws BeansException {
super(parent);
setConfigLocations(configLocations);
if (refresh) {
refresh();
}
}
public ClassPathXmlApplicationContext(String[] paths, Class clazz) throws BeansException {
this(paths, clazz, null);
}
public ClassPathXmlApplicationContext(String[] paths, Class clazz, ApplicationContext parent) throws BeansException {
super(parent);
Assert.notNull(paths, "Path array must not be null");
Assert.notNull(clazz, "Class argument must not be null");
this.configResources = new Resource[paths.length];
for (int i = 0; i < paths.length; i++) {
this.configResources[i] = new ClassPathResource(paths[i], clazz);
}
refresh();
}
//获取资源配置文件
@Override
protected Resource[] getConfigResources() {
return this.configResources;
}
}
容器启动的时候会调用ClassPathXmlApplicationContext的构造方法，在这个构造方法中会调用refresh()方法，这个方法十分重要，这是我们分析容器初始化过程中至关重要的一个接口，我们后面分析的Bean的载入，解析，注册都是以这个方法作为入口开始的。
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// Prepare this context for refreshing.准备上下文
prepareRefresh();
// Tell the subclass to refresh the internal bean factory.通知子类刷新内部的bean工厂
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// Prepare the bean factory for use in this context.准备beanfactory来使用这个上下文.做一些准备工作，例如classloader，beanfactoryPostProcessor等
prepareBeanFactory(beanFactory);
try {
// Allows post-processing of the bean factory in context subclasses.在子类上下文中允许beanfactory进行后置处理
postProcessBeanFactory(beanFactory);
// Invoke factory processors registered as beans in the context.调用工厂处理器作为bean注册到上下文中
invokeBeanFactoryPostProcessors(beanFactory);
// Register bean processors that intercept bean creation.开始注册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.检查监听器bean并注册
registerListeners();
// Instantiate all remaining (non-lazy-init) singletons.实例化所有的剩余的singleton的bean
finishBeanFactoryInitialization(beanFactory);
// Last step: publish corresponding event.最后一步，发布应用
finishRefresh();
}
catch (BeansException ex) {
// Destroy already created singletons to avoid dangling resources.
destroyBeans();
// Reset 'active' flag.
cancelRefresh(ex);
// Propagate exception to caller.
throw ex;
}
}
}
