Spring中的BeanFactory类

一、BeanFactory 是什么？

BeanFactory 是 Spring 框架中最顶层的 IoC（Inversion of Control）容器接口，位于 org.springframework.beans.factory 包下。它是 Spring 管理 Bean 生命周期、依赖注入和配置元数据的核心入口。

根据 Spring 官方 Javadoc 的描述：

The root interface for accessing a Spring bean container. This is the basic client view of a bean container;

直译过来就是：BeanFactory 是访问 Spring Bean 容器的根接口，是容器对外暴露的最基础视图。

Bean的源码：

java 复制代码

public interface BeanFactory {

	String FACTORY_BEAN_PREFIX = "&";

	Object getBean(String name) throws BeansException;

	<T> T getBean(String name, Class<T> requiredType) throws BeansException;

	Object getBean(String name, Object... args) throws BeansException;

	<T> T getBean(Class<T> requiredType) throws BeansException;
	
	<T> T getBean(Class<T> requiredType, Object... args) throws BeansException;

	<T> ObjectProvider<T> getBeanProvider(Class<T> requiredType);
	
	<T> ObjectProvider<T> getBeanProvider(ResolvableType requiredType);

	boolean containsBean(String name);

	boolean isSingleton(String name) throws NoSuchBeanDefinitionException;

	boolean isPrototype(String name) throws NoSuchBeanDefinitionException;

	boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;


	boolean isTypeMatch(String name, Class<?> typeToMatch) throws NoSuchBeanDefinitionException;


	@Nullable
	Class<?> getType(String name) throws NoSuchBeanDefinitionException;


	String[] getAliases(String name);

}

从这些方法可以看出，其核心职责包括：

根据名称或类型获取 Bean 实例（getBean()）
判断容器是否包含某个 Bean（containsBean()）
获取 Bean 的作用域、是否单例等元信息
采用懒加载策略(只有在首次调用 getBean() 时才会实例化 Bean)

值得注意的是，BeanFactory本身并不负责 Bean 的创建过程，而是提供一个统一的访问入口。真正的 Bean 创建、依赖注入、生命周期管理由其实现类完成。

二、BeanFactory 的接口体系结构

BeanFactory接口继承体系

java 复制代码

BeanFactory
├── HierarchicalBeanFactory          // 支持父子容器层级结构
├── ListableBeanFactory              // 支持枚举容器中所有 Bean
├── AutowireCapableBeanFactory       // 支持自动装配（可用于非 Spring 管理对象）
└── ConfigurableBeanFactory          // 支持配置（如设置父工厂、类加载器等）
     └── ConfigurableListableBeanFactory

1. ListableBeanFactory

提供按类型或名称获取多个Bean的方法，可以将容器中的Bean全部取出

java 复制代码

public interface ListableBeanFactory extends BeanFactory {
    // 按类型获取所有Bean
    String[] getBeanNamesForType(Class<?> type);
    
    // 按类型获取所有Bean，包含子类
    String[] getBeanNamesForType(Class<?> type, boolean includeNonSingletons, boolean allowEagerInit);
    
    // 按类型获取所有Bean实例
    <T> Map<String, T> getBeansOfType(Class<T> type) throws BeansException;
    
    // 获取所有Bean定义的名称
    String[] getBeanDefinitionNames();
    
    // 获取Bean定义的数量
    int getBeanDefinitionCount();
}

2. HierarchicalBeanFactory

支持分层Bean工厂，允许有父工厂：

java 复制代码

public interface HierarchicalBeanFactory extends BeanFactory {

    // 获取父工厂
    BeanFactory getParentBeanFactory();
    
    // 判断是否包含指定名称的Bean（包括父工厂）
    boolean containsLocalBean(String name);
}

3. ConfigurableBeanFactory

提供配置功能：如设置 ClassLoader、BeanPostProcessor、作用域注册等。

java 复制代码

public interface ConfigurableBeanFactory extends HierarchicalBeanFactory, SingletonBeanRegistry {
    // 设置Bean类加载器
    void setBeanClassLoader(ClassLoader beanClassLoader);
    
    // 设置临时类加载器
    void setTempClassLoader(ClassLoader tempClassLoader);
    
    // 设置Bean后处理器
    void addBeanPostProcessor(BeanPostProcessor beanPostProcessor);
    
    // 销毁单例Bean
    void destroySingletons();
}

SingletonBeanRegistry 提供对单例 Bean 的注册和销毁能力，是实现单例模式的关键接口。

4. AutowireCapableBeanFactory

允许对任意 Java 对象执行 Spring 的依赖注入（即使该对象不是由 Spring 容器创建的）。常用于集成第三方库。

java 复制代码

public interface AutowireCapableBeanFactory extends BeanFactory {
    // 创建Bean实例
    Object createBean(Class<?> beanClass) throws BeansException;
    
    // 自动装配Bean属性
    void autowireBean(Object existingBean) throws BeansException;
    
    // 应用Bean后处理器
    Object initializeBean(Object existingBean, String beanName) throws BeansException;
    
    // 销毁Bean
    void destroyBean(Object existingBean);
}

三、BeanFactory 的核心实现体系

虽然 BeanFactory 是接口，但 Spring 提供了多个实现类，其中最重要的是：

1. DefaultListableBeanFactory

这是BeanFactory最常用的实现类，实现了ListableBeanFactory、ConfigurableBeanFactory等接口：

java 复制代码

public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory
        implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {
    
    // Bean定义的存储
    private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);
    
    // Bean名称的存储顺序
    private final List<String> beanDefinitionNames = new ArrayList<>(256);
    
    // 省略其他实现...
}

这是Spring 内部最核心、最完整的BeanFactory 实现，也是ApplicationContext（如 ClassPathXmlApplicationContext）内部实际使用的工厂。

内部维护 BeanDefinition 注册表（Map<String, BeanDefinition>）
支持依赖解析、循环依赖处理（通过三级缓存）、作用域管理等完整功能

2. XmlBeanFactory（已过时）

基于XML配置文件的Bean工厂实现，现在已被ClassPathXmlApplicationContext等替代：

java 复制代码

public class XmlBeanFactory extends DefaultListableBeanFactory {
    private final XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(this);
    
    public XmlBeanFactory(Resource resource) throws BeansException {
        this(resource, null);
    }
    
    public XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory) throws BeansException {
        super(parentBeanFactory);
        this.reader.loadBeanDefinitions(resource);
    }
}

官方建议改用ClassPathXmlApplicationContext，因其提供了更完整的生命周期管理和事件机制。

3. 其他轻量级实现

StaticListableBeanFactory：手动注册 Bean 实例，适用于测试或简单场景
SimpleJndiBeanFactory：从 JNDI 查找 Bean（主要用于传统 Java EE 环境）

另外还有两个抽象实现类

AbstractBeanFactory

关键职责：

实现了单例Bean的缓存机制
实现了 ConfigurableBeanFactory 接口的大部分通用逻辑。
提供了 getBean() 方法的主干流程（模板方法模式），但将具体实例化、依赖解析等委托给子类。

重要方法：

java 复制代码

public Object getBean(String name) throws BeansException {
    return doGetBean(name, null, null, false);
}
protected <T> T doGetBean(...) { ... } // 模板方法，子类需实现 createBean()

AbstractAutowireCapableBeanFactory

定位：在 AbstractBeanFactory 基础上，增加了自动装配（Autowiring）和 Bean 生命周期管理能力。

关键职责：

实现了AutowireCapableBeanFactory 接口
提供完整的 Bean 创建流程：实例化 → 属性填充 → 初始化逻辑执行（创建Bean的核心三个步骤）。
实现循环依赖的核心逻辑（通过三级缓存）。
典型子类：DefaultListableBeanFactory

核心方法

java 复制代码

protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)

四、小结

BeanFactory 是规范（接口契约）
AbstractBeanFactory 定义了流程（模板方法）
AbstractAutowireCapableBeanFactory 提供了核心实现骨架（Bean 创建、依赖注入、生命周期）
DefaultListableBeanFactory 是功能完整的最终实现（注册表 + 所有能力）