1、前言
面试官：“看过Spring源码吧，简单说说Spring中BeanFactory和FactoryBean的区别是什么？”
大神仙：“BeanFactory是bean工厂，FactoryBean是工厂bean”。
这么回答，等于面试官问你Spring是什么，你回答这个单词翻译叫春天。
2、ChitGPT的回答
首先看下C知道（ChitGPT）的回答
没错，基本上已经给出了答案。
那么接下来，我们来详细看下他们分别是什么。
3、什么是BeanFactory?
其实BeanFactory回答是bean工厂也没毛病，确实是。但是却没回答到本质。
我们知道，Spring其中一个核心功能就是IoC。Spring创建bean，使用的是经典的工厂模式，那么这一系列的bean工厂，就是IoC容器或称为对象工厂。
我们先来看下Spring源码中对于BeanFactory的注释：
/**
* // 访问Spring bean容器的根接口
* The root interface for accessing a Spring bean container.
*
* ......
*
* // 这个接口是由拥有许多bean定义的对象实现的，每个bean定义都由一个String名称唯一标识。
* // 根据bean定义，工厂将返回包含对象的独立实例(原型设计模式)，或者返回单个共享实例(单例设计模式的高级替代方案，在单例设计模式中，
* // 实例在工厂范围内是单例)。将返回哪种类型的实例取决于bean工厂配置。
* <p>This interface is implemented by objects that hold a number of bean definitions,
* each uniquely identified by a String name. Depending on the bean definition,
* the factory will return either an independent instance of a contained object
* (the Prototype design pattern), or a single shared instance (a superior
* alternative to the Singleton design pattern, in which the instance is a
* singleton in the scope of the factory). Which type of instance will be returned
* depends on the bean factory configuration: the API is the same. Since Spring
* 2.0, further scopes are available depending on the concrete application
* context (e.g. "request" and "session" scopes in a web environment).
*
* ......
*
* // 通常，BeanFactory将加载存储在配置源(如XML文档)中的bean定义，并使用{@code org.springframework。Beans}包来配置bean。
* // 但是，实现可以直接在Java代码中返回它根据需要创建的Java对象。对于如何存储定义没有限制:LDAP、RDBMS、XML、属性文件等等。
* // 鼓励实现支持bean之间的引用(依赖注入)。
* <p>Normally a BeanFactory will load bean definitions stored in a configuration
* source (such as an XML document), and use the {@code org.springframework.beans}
* package to configure the beans. However, an implementation could simply return
* Java objects it creates as necessary directly in Java code. There are no
* constraints on how the definitions could be stored: LDAP, RDBMS, XML,
* properties file, etc. Implementations are encouraged to support references
* amongst beans (Dependency Injection).
*
* ......
* // Bean工厂实现应该尽可能支持标准的Bean生命周期接口。完整的初始化方法集及其标准顺序为：
* <p>Bean factory implementations should support the standard bean lifecycle interfaces
* as far as possible. The full set of initialization methods and their standard order is:
* <ol>
* <li>BeanNameAware's {@code setBeanName}
* <li>BeanClassLoaderAware's {@code setBeanClassLoader}
* <li>BeanFactoryAware's {@code setBeanFactory}
* <li>EnvironmentAware's {@code setEnvironment}
* <li>EmbeddedValueResolverAware's {@code setEmbeddedValueResolver}
* <li>ResourceLoaderAware's {@code setResourceLoader}
* (only applicable when running in an application context)
* <li>ApplicationEventPublisherAware's {@code setApplicationEventPublisher}
* (only applicable when running in an application context)
* <li>MessageSourceAware's {@code setMessageSource}
* (only applicable when running in an application context)
* <li>ApplicationContextAware's {@code setApplicationContext}
* (only applicable when running in an application context)
* <li>ServletContextAware's {@code setServletContext}
* (only applicable when running in a web application context)
* <li>{@code postProcessBeforeInitialization} methods of BeanPostProcessors
* <li>InitializingBean's {@code afterPropertiesSet}
* <li>a custom {@code init-method} definition
* <li>{@code postProcessAfterInitialization} methods of BeanPostProcessors
* </ol>
*
* <p>On shutdown of a bean factory, the following lifecycle methods apply:
* <ol>
* <li>{@code postProcessBeforeDestruction} methods of DestructionAwareBeanPostProcessors
* <li>DisposableBean's {@code destroy}
* <li>a custom {@code destroy-method} definition
* </ol>
*
* @author Rod Johnson
* @author Juergen Hoeller
* @author Chris Beams
* @since 13 April 2001
* @see BeanNameAware#setBeanName
* @see BeanClassLoaderAware#setBeanClassLoader
* @see BeanFactoryAware#setBeanFactory
* @see org.springframework.context.EnvironmentAware#setEnvironment
* @see org.springframework.context.EmbeddedValueResolverAware#setEmbeddedValueResolver
* @see org.springframework.context.ResourceLoaderAware#setResourceLoader
* @see org.springframework.context.ApplicationEventPublisherAware#setApplicationEventPublisher
* @see org.springframework.context.MessageSourceAware#setMessageSource
* @see org.springframework.context.ApplicationContextAware#setApplicationContext
* @see org.springframework.web.context.ServletContextAware#setServletContext
* @see org.springframework.beans.factory.config.BeanPostProcessor#postProcessBeforeInitialization
* @see InitializingBean#afterPropertiesSet
* @see org.springframework.beans.factory.support.RootBeanDefinition#getInitMethodName
* @see org.springframework.beans.factory.config.BeanPostProcessor#postProcessAfterInitialization
* @see org.springframework.beans.factory.config.DestructionAwareBeanPostProcessor#postProcessBeforeDestruction
* @see DisposableBean#destroy
* @see org.springframework.beans.factory.support.RootBeanDefinition#getDestroyMethodName
*/
public interface BeanFactory {
......
}可以看到，BeanFactory是一个接口类，且是最顶层的一个接口类，其中定义了IoC容器的基本功能规范，用来更好的管理（或者说约束）实现类对于bean的管理，如实例化，定位，配置对应以及创建对象间依赖等。
BeanFactory有三个比较重要的接口子类：AutowireCapableBeanFactory，ListableBeanFactory，HierarchicalBeanFactory。BeanFactory有一个默认的实现类是DefaultListableBeanFactory。
在Spring中，DefaultListableBeanFactory被作为一个默认的IoC容器来使用。
来看下类图：
简化一下：
- AutowireCapableBeanFactory：表示Bean的自动装配规则
- ListableBeanFactory：表示Bean可列表化
- HierarchicalBeanFactory：表示Bean有继承关系
这三个接口共同定义了Bean的集合，Bean之间的关系，以及Bean的行为。而BeanFactory是IoC容器最基本的接口类。
再来看下BeanFactory源码内容：
public interface BeanFactory {
// 对FactoryBean的转义定义，因为如果使用bean的名字检索FactoryBean得到的对象是工厂生成的对象，
// 如果需要得到工厂本身，需要转义
String FACTORY_BEAN_PREFIX = "&";
// 根据bean的名字，获取在IOC容器中得到bean实例
Object getBean(String var1) throws BeansException;
// 根据bean的名字和Class类型来得到bean实例，增加了类型安全验证机制。
<T> T getBean(String var1, Class<T> var2) throws BeansException;
Object getBean(String var1, Object... var2) throws BeansException;
<T> T getBean(Class<T> var1) throws BeansException;
<T> T getBean(Class<T> var1, Object... var2) throws BeansException;
<T> ObjectProvider<T> getBeanProvider(Class<T> var1);
<T> ObjectProvider<T> getBeanProvider(ResolvableType var1);
// 提供对bean的检索，看看是否在IOC容器有这个名字的bean
boolean containsBean(String var1);
// 根据bean名字得到bean实例，并同时判断这个bean是不是单例
boolean isSingleton(String var1) throws NoSuchBeanDefinitionException;
boolean isPrototype(String var1) throws NoSuchBeanDefinitionException;
boolean isTypeMatch(String var1, ResolvableType var2) throws NoSuchBeanDefinitionException;
boolean isTypeMatch(String var1, Class<?> var2) throws NoSuchBeanDefinitionException;
// 得到bean实例的Class类型
@Nullable
Class<?> getType(String var1) throws NoSuchBeanDefinitionException;
// 得到bean的别名，如果根据别名检索，那么其原名也会被检索出来
String[] getAliases(String var1);
}
在BeanFactory中只对IoC容器的基本行为做了定义，通过实现该接口可以实现不同的Bean检索方法。在Spring中也提供了许多IoC容器的实现，如GenericApplicationContext，ClassPathXmlApplicationContext等。
但是在Spring中，是不允许我们直接使用BeanFactory的，他给我们提供了ApplicationContext接口继承BeanFactory接口，同时进行了很多扩展：如实现国际化（实现MessageSource接口），访问资源（实现ResourcePatternResolver接口），支持应用事件（实现ApplicationEventPublisher接口）。
以下为ApplicationContext子类继承图：
4、什么是FactoryBean？
FactoryBean是一个工厂Bean。也是一个接口，该接口提供了一个工厂方法，用来返回其他Bean实例。
来看下注释：
/**
* // 由{@link BeanFactory}中使用的对象实现的接口，这些对象本身就是单个对象的工厂。
* // 如果一个bean实现了这个接口，那么它将被用作要公开的对象的工厂，而不是直接用作将自己公开的bean实例。
* Interface to be implemented by objects used within a {@link BeanFactory} which
* are themselves factories for individual objects. If a bean implements this
* interface, it is used as a factory for an object to expose, not directly as a
* bean instance that will be exposed itself.
*
* // 注意:实现该接口的bean不能作为普通bean使用。
* // FactoryBean是以bean风格定义的，但是为bean引用公开的对象({@link #getObject()})始终是它创建的对象。
* <p><b>NB: A bean that implements this interface cannot be used as a normal bean.</b>
* A FactoryBean is defined in a bean style, but the object exposed for bean
* references ({@link #getObject()}) is always the object that it creates.
* ......
*
* // 该接口在框架本身中被大量使用，例如用于AOP {@link org.springframework.jndi.JndiObjectFactoryBean}。
* // 它也可以用于定制组件;但是，这只在基础结构代码中常见。
* <p>This interface is heavily used within the framework itself, for example for
* the AOP {@link org.springframework.aop.framework.ProxyFactoryBean} or the
* {@link org.springframework.jndi.JndiObjectFactoryBean}. It can be used for
* custom components as well; however, this is only common for infrastructure code.
* ......
*
* // 最后，FactoryBean对象参与了包含BeanFactory的bean创建的同步。
* // 除了在FactoryBean本身(或类似)内进行惰性初始化之外，通常不需要内部同步。
* <p>Finally, FactoryBean objects participate in the containing BeanFactory's
* synchronization of bean creation. There is usually no need for internal
* synchronization other than for purposes of lazy initialization within the
* FactoryBean itself (or the like).
*
* @author Rod Johnson
* @author Juergen Hoeller
* @since 08.03.2003
* @param <T> the bean type
* @see org.springframework.beans.factory.BeanFactory
* @see org.springframework.aop.framework.ProxyFactoryBean
* @see org.springframework.jndi.JndiObjectFactoryBean
*/
public interface FactoryBean<T> {
......
}但从官方给的注释上也能看出，FactoryBean其实就是个Bean，是在IoC容器的基础上给Bean的实现加上了一个简单的工厂模式和装饰模式，是一个用于生产Bean对象的工厂Bean。用户通过实现该接口，可以通过getObject()方法获取对象。
public interface FactoryBean<T> {
// 获取容器管理的对象实例
@Nullable
T getObject() throws Exception;
// 获取Bean工厂创建的对象类型
@Nullable
Class<?> getObjectType();
// Bean工厂创建的对象是否单例模式，
// 如果是，则整个容器中只有一个实例对象，每次请求都返回同一个实例对象
default boolean isSingleton() {
return true;
}
}5、小结
BeanFactory：文章来源：https://www.toymoban.com/news/detail-418517.html
- 是所有Spring中IoC容器的顶级接口，为Spring的容器定义了一套规范，并提供像getBean()方法从容器中获取Bean实例；
- 负责生产和管理Bean的一个工厂；
- 在产生Bean实例的同时，还提供了DI的能力；
FactoryBean：文章来源地址https://www.toymoban.com/news/detail-418517.html
- 实际上就是个bean，相当于普通的Bean的实现加上了简单工厂模式和装饰模式；
- 动态生成某一个类别的Bean实例；
- getObject() 获取的是FactoryBean的getObject()返回的对象，而不是FactoryBean本身，如果要获取FactoryBean对象，需要在id前加一个&；
到了这里，关于【Spring源码】 BeanFactory和FactoryBean是什么？的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！
