Spring源码系列：BeanFactory的建立

Spring的Ioc容器其实就是一个bean的关系网，依赖于core，bean，context三个组件来构建的。在spring中最核心的就是对于bean的管理。而bean又依托于咱们的容器。本文将从顶层分析一下spring中beanFactory的具体建立过程，为后续的bean的生命周期提供一个基础。

BeanFactory的继承体系

从上图能够看到，BeanFactory有三个子类：

• ListableBeanFactory
• HierarchicalBeanFactory
• AutowireCapableBeanFactory

（上述三个类的子类体系小伙伴们能够本身对着源码看下，实在太多）

看下上图中最底层的DefaultListableBeanFactory类的定义：

public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable 复制代码

这个其实就是BeanFactory的默认实现类，它直接或者间接的实现了全部的接口。其实在看spring源码的时候都会遇到相似的设计模式，对于某一个具体的功能，一般都会定义不少层的接口，层层包装，层层委托。这种作法的好处就是，对于不一样的场合都会有特定的接口；这样一来就能够在spring内部对对象的传递和转化操做都会有一些访问限制。

例如ListableBeanFactory接口表示这些Bean是可列表的，而HierarchicalBeanFactory表示的是这些Bean是有继承关系的，也就是每一个Bean有可能有父Bean。AutowireCapableBeanFactory接口定义Bean的自动装配规则。这四个接口共同定义了Bean的集合、Bean之间的关系、以及Bean行为。

BeanFactory的建立

在以前的文章中说过了容器的刷新过程。BeanFactory的建立也在wac.refresh()方法中。具体看下究竟是经过哪些子类来完成的：

// 通知子类刷新内部的bean工厂。
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
复制代码

1.AbstractApplicationContext中的obtainFreshBeanFactory

下面是obtainFreshBeanFactory的方法逻辑：

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
    //这个是具体建立的方法，由子类实现
	refreshBeanFactory();
	//获取BeanFactory实例对象（ConfigurableListableBeanFactory类型的）
	ConfigurableListableBeanFactory beanFactory = getBeanFactory();
	if (logger.isDebugEnabled()) {
		logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
	}
	return beanFactory;
}
复制代码

refreshBeanFactory并未有具体的实现逻辑，这个方法主要是经过委托给子类的refreshBeanFactory方法来实现，在AbstractApplicationContext中refreshBeanFactory是一个抽象模板方法：

protected abstract void refreshBeanFactory() throws BeansException, IllegalStateException;
复制代码

2.refreshBeanFactory方法(AbstractRefreshableApplicationContext类中)：

下面只注释与beanFactory建立相关的代码

protected final void refreshBeanFactory() throws BeansException {
    //是否已经有BeanFactory了
    if (hasBeanFactory()) {
        //销毁原有的Bean
    	destroyBeans();
    	//关闭工厂
    	closeBeanFactory();
    }
    try {
        //建立一个新的beanFactory
    	DefaultListableBeanFactory beanFactory = createBeanFactory();
    	beanFactory.setSerializationId(getId());
    	customizeBeanFactory(beanFactory);
    	loadBeanDefinitions(beanFactory);
    	synchronized (this.beanFactoryMonitor) {
    		this.beanFactory = beanFactory;
    	}
    }
    catch (IOException ex) {
    	throw new ApplicationContextException("I/O error parsing bean definition 
    	source for " + getDisplayName(), ex);
    }
}
复制代码

这个方法是实现执行这个上下文的底层bean工厂的实际刷新，若是有的话以前有BeanFactory存在，则关闭之前的bean工厂。并为上下文生命周期的下一个阶段初始化一个新鲜的bean工厂。

3.createBeanFactory(AbstractRefreshableApplicationContext类中)

protected DefaultListableBeanFactory createBeanFactory() {
	return new DefaultListableBeanFactory(getInternalParentBeanFactory());
}
复制代码

这个方法就是为当前上下文建立一个内部的bean工厂。每次调用refresh()方法是都会建立尝试建立。默认实现是建立一个DefaultListableBeanFactory。并经过getInternalParentBeanFactory（）获取内部bean工厂来做为父级bean工厂。能够在子类中重写，例如自定义DefaultListableBeanFactory的设置。

getInternalParentBeanFactory（AbstractApplicationContext类中）

protected BeanFactory getInternalParentBeanFactory() {
	return (getParent() instanceof ConfigurableApplicationContext) ?
	((ConfigurableApplicationContext) getParent()).getBeanFactory() : getParent();
}
复制代码

4.DefaultListableBeanFactory的构造函数

/** * 经过给定的父类建立一个新的DefaultListableBeanFactory容器 * @param parentBeanFactory the parent BeanFactory */
public DefaultListableBeanFactory(BeanFactory parentBeanFactory) {
	super(parentBeanFactory);
}
复制代码

super(parentBeanFactory)调用的是AbstractAutowireCapableBeanFactory的构造函数

/** * 经过给定的父类构建新的AbstractAutowireCapableBeanFactory * @param parentBeanFactory parent bean factory, or {@code null} if none */
public AbstractAutowireCapableBeanFactory(BeanFactory parentBeanFactory) {
	this();
	//设置父工厂
	setParentBeanFactory(parentBeanFactory);
}
复制代码

this(),仍是AbstractAutowireCapableBeanFactory的构造函数：

/** * 构建一个新的AbstractAutowireCapableBeanFactory. */
public AbstractAutowireCapableBeanFactory() {
	super();
	ignoreDependencyInterface(BeanNameAware.class);
	ignoreDependencyInterface(BeanFactoryAware.class);
	ignoreDependencyInterface(BeanClassLoaderAware.class);
}
复制代码

super() ; AbstractBeanFactory的构造函数

/** * 构建一个新的AbstractBeanFactory. */
public AbstractBeanFactory() {
}
复制代码