Spring 源码之核心加载方法(2) BeanFactory 创建

发表于 更新于 分类于

2. AbstractApplicationContext#obtainFreshBeanFactory

定位: org.springframework.context.support.AbstractApplicationContext#obtainFreshBeanFactory

1
2
3
4
5
6
7
8
9
/**
 * 告诉子类刷新内部 bean 工厂
 */
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
	// 初始化 BeanFactory, 并进行XML文件读取，并将获取的 BeanFactory 记录在当前实体的属性中
	refreshBeanFactory();
	// 返回当前实体的 beanFactory 属性
	return getBeanFactory();
}

AbstractRefreshableApplicationContext#refreshBeanFactory

定位: org.springframework.context.support.AbstractRefreshableApplicationContext#refreshBeanFactory

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
/**
 * 此实现执行此上下文的底层bean工厂的实际刷新，关闭前一个bean工厂（如果有的话），并为上下文生命周期的下一个阶段初始化一个新的bean工厂。
 * @throws BeansException
 */
@Override
protected final void refreshBeanFactory() throws BeansException {
   // 判断是否存在 BeanFactory, 存在则销毁所有Beans，并且关闭BeanFactory
   // 目的是避免重复加载BeanFactory
   if (hasBeanFactory()) {
      // 如果实例化了BeanFactory，则先销毁所有的单例Bean
      destroyBeans();
      // 关闭BeanFactory，也就是将beanFactory的值置为null
      closeBeanFactory();
   }
   try {
      // 创建具体的 beanFactory，这里创建的是 DefaultListableBeanFactory
      DefaultListableBeanFactory beanFactory = createBeanFactory();
      // 为了序列化指定id，可以从id反序列化到beanFactory对象
      beanFactory.setSerializationId(getId());
      // 定制beanFactory，设置相关属性，包括是否允许覆盖同名称的不同定义的对象以及循环依赖
      // 有默认实现, 钩子方法
      customizeBeanFactory(beanFactory);
      // 加载配置文件(执行 xml, groovy 和注解方式)并生成 BeanDefinitions
      // 初始化 XmlBeanDefinitionReader, 并进行XML文件读取及解析, 默认命名空间的解析, 自定义标签的解析
      loadBeanDefinitions(beanFactory);
      synchronized (this.beanFactoryMonitor) {
         this.beanFactory = beanFactory;
      }
   }
   catch (IOException ex) {
      throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
   }
}

AbstractRefreshableApplicationContext#createBeanFactory

定位: org.springframework.context.support.AbstractRefreshableApplicationContext#createBeanFactory

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
// 创建一个默认 内部bean 工厂
protected DefaultListableBeanFactory createBeanFactory() {
   return new DefaultListableBeanFactory(getInternalParentBeanFactory());
}
public DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory
		implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {
    public DefaultListableBeanFactory(@Nullable BeanFactory parentBeanFactory) {
		super(parentBeanFactory);
	}
}
public AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
		implements AutowireCapableBeanFactory {
    public AbstractAutowireCapableBeanFactory(@Nullable BeanFactory parentBeanFactory) {
		this();
		setParentBeanFactory(parentBeanFactory);
	}
    public AbstractAutowireCapableBeanFactory() {
		super();
		// 依赖项检查和自动装配时忽略的依赖项接口
		ignoreDependencyInterface(BeanNameAware.class);
		ignoreDependencyInterface(BeanFactoryAware.class);
		ignoreDependencyInterface(BeanClassLoaderAware.class);
	}
}
AbstractRefreshableApplicationContext#customizeBeanFactory

定位: org.springframework.context.support.AbstractRefreshableApplicationContext#customizeBeanFactory

用于给子类提供一个自由配置的机会，默认实现:

1
2
3
4
5
6
7
8
9
10
11
12
protected void customizeBeanFactory(DefaultListableBeanFactory beanFactory) {
	// 如果属性allowBeanDefinitionOverriding不为空，设置给beanFactory对象相应属性，是否允许覆盖同名称的不同定义的对象
	// 默认false，不允许覆盖
	if (this.allowBeanDefinitionOverriding != null) {
		beanFactory.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
	}
	// 如果属性allowCircularReferences不为空，设置给beanFactory对象相应属性，是否允许bean之间存在循环依赖
	// 默认false，不允许循环引用
	if (this.allowCircularReferences != null) {
		beanFactory.setAllowCircularReferences(this.allowCircularReferences);
	}
}