[spring6: BeanFactory & FactoryBean & ObjectFactory]-傻傻分不清

BeanFactory

BeanFactory 是 Spring 的最基础容器接口，定义了获取、查询、判断 Bean 的核心方法，是 IoC 容器的根本抽象。

public interface BeanFactory {

	String FACTORY_BEAN_PREFIX = "&";

	char FACTORY_BEAN_PREFIX_CHAR = '&';
	
	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;

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

	String[] getAliases(String name);

}

FactoryBean

FactoryBean 是一种特殊的 Bean，本身受 Spring 管理，但容器注入时返回的是其 getObject() 生成的对象，使用 &beanName 可获取其自身。

public interface FactoryBean<T> {

	String OBJECT_TYPE_ATTRIBUTE = "factoryBeanObjectType";

	@Nullable
	T getObject() throws Exception;
	
	@Nullable
	Class<?> getObjectType();

	default boolean isSingleton() {
		return true;
	}

}

SmartFactoryBean

SmartFactoryBean 是对 FactoryBean 的扩展，提供是否为原型（isPrototype()）和是否应被容器提前初始化（isEagerInit()）的控制能力。

public interface SmartFactoryBean<T> extends FactoryBean<T> {

	default boolean isPrototype() {
		return false;
	}

	default boolean isEagerInit() {
		return false;
	}
}

实现类名称	功能与用途简介
AbstractEntityManagerFactoryBean	JPA 的 EntityManagerFactory 抽象工厂，实现 JPA 相关工厂 Bean 的基类。
AbstractFactoryBean	Spring FactoryBean 的基础抽象实现，简化自定义 FactoryBean 开发。
AbstractServiceLoaderBasedFactoryBean	基于 Java ServiceLoader 加载服务的抽象工厂 Bean。
AbstractSingletonProxyFactoryBean	创建单例代理对象的抽象工厂，用于生成代理 Bean。
CacheProxyFactoryBean	创建缓存代理对象，如对缓存操作的代理封装。
ConcurrentMapCacheFactoryBean	创建基于并发 ConcurrentMap 的缓存实例。
ConnectorServerFactoryBean	JMX 连接器服务的工厂 Bean，负责创建 JMX 连接服务器。
ContentNegotiationManagerFactoryBean	创建内容协商管理器，支持根据请求头等内容协商返回的格式。
ConversionServiceFactoryBean	创建 Spring 类型转换服务 ConversionService 的工厂 Bean。
CronTriggerFactoryBean	Quartz 定时任务中基于 Cron 表达式的触发器工厂。
DateTimeFormatterFactoryBean	Java 8 时间格式化器的工厂 Bean。
EmbeddedDatabaseFactoryBean	嵌入式数据库（如 H2、HSQLDB、Derby）实例的创建工厂。
FieldRetrievingFactoryBean	通过反射机制获取某个字段值的工厂 Bean。
ForkJoinPoolFactoryBean	创建 Java ForkJoinPool 线程池实例。
FormattingConversionServiceFactoryBean	创建支持格式化的类型转换服务。
FreeMarkerConfigurationFactoryBean	FreeMarker 模板引擎配置的工厂 Bean。
GsonFactoryBean	创建 Gson JSON 序列化/反序列化工具实例。
Jackson2ObjectMapperFactoryBean	创建 Jackson 的 ObjectMapper 实例，负责 JSON 处理。
JCacheManagerFactoryBean	JCache 缓存管理器的工厂 Bean。
JndiObjectFactoryBean	从 JNDI 中查找并获取对象的工厂 Bean。
JobDetailFactoryBean	Quartz 作业详情 Bean 的工厂。
JtaTransactionManagerFactoryBean	创建 JTA 事务管理器的工厂 Bean。
ListFactoryBean	创建 List 集合 Bean。
LocalConnectionFactoryBean	本地数据库连接工厂 Bean。
LocalContainerEntityManagerFactoryBean	基于容器的 JPA EntityManagerFactory 工厂 Bean。
LocalEntityManagerFactoryBean	本地 JPA EntityManagerFactory 工厂 Bean。
LocalSessionFactoryBean	Hibernate SessionFactory 的工厂 Bean。
MapFactoryBean	创建 Map 集合 Bean。
MBeanProxyFactoryBean	创建 JMX MBean 代理 Bean。
MBeanServerConnectionFactoryBean	获取 JMX MBeanServerConnection 的工厂 Bean。
MBeanServerFactoryBean	创建 JMX MBeanServer 实例。
MethodInvokingFactoryBean	通过反射调用某个方法，并将其结果作为 Bean。
MethodInvokingJobDetailFactoryBean	Quartz 中调用方法的 JobDetail 工厂 Bean。
MethodLocatingFactoryBean	查找方法反射对象的工厂 Bean。
ObjectFactoryCreatingFactoryBean	创建 Spring ObjectFactory 实例。
PropertiesFactoryBean	加载 Properties 文件并生成对应 Bean。
PropertyPathFactoryBean	通过路径访问 Bean 属性的工厂。
ProviderCreatingFactoryBean	创建 JSR-330 Provider 的工厂 Bean。
ProxyFactoryBean	创建动态代理 Bean，支持 AOP 相关功能。
ResourceAdapterFactoryBean	创建 JCA 资源适配器实例。
ScheduledExecutorFactoryBean	创建 ScheduledExecutorService 线程池。
SchedulerFactoryBean	Quartz Scheduler 的工厂 Bean。
ScopedProxyFactoryBean	创建作用域代理 Bean，如 session、request 作用域代理。
ServiceFactoryBean	通过接口生成服务 Bean 的工厂。
ServiceListFactoryBean	创建服务列表 Bean。
ServiceLoaderFactoryBean	基于 Java ServiceLoader 的服务加载工厂。
ServiceLocatorFactoryBean	创建服务定位器（Service Locator）工厂。
ServletContextAttributeFactoryBean	获取 ServletContext 属性的工厂 Bean。
ServletContextParameterFactoryBean	获取 ServletContext 参数的工厂 Bean。
ServletServerContainerFactoryBean	创建 Servlet 容器相关 Bean。
SetFactoryBean	创建 Set 集合 Bean。
SharedEntityManagerBean	共享 JPA EntityManager 的 Bean。
SimpleTriggerFactoryBean	Quartz 简单触发器的工厂 Bean。
SortedResourcesFactoryBean	对资源集合进行排序的工厂 Bean。
TaskExecutorFactoryBean	创建 TaskExecutor 线程池。
ThreadPoolExecutorFactoryBean	创建标准 ThreadPoolExecutor 线程池。
TransactionProxyFactoryBean	创建事务代理 Bean。
WebSocketContainerFactoryBean	创建 WebSocket 容器的工厂 Bean。
YamlMapFactoryBean	加载 YAML 文件并转换成 Map Bean。
YamlPropertiesFactoryBean	加载 YAML 文件并转换成 Properties Bean。

ObjectFactory

ObjectFactory 提供了一个延迟获取目标对象实例的统一接口。

@FunctionalInterface
public interface ObjectFactory<T> {
	T getObject() throws BeansException;
}

ObjectProvider

ObjectProvider 是一个功能更强大的 ObjectFactory，支持延迟获取、按条件筛选、多实例迭代和安全获取单个或唯一 Bean 的灵活依赖注入接口。

public interface ObjectProvider<T> extends ObjectFactory<T>, Iterable<T> {

	Predicate<Class<?>> UNFILTERED = (clazz -> true);

	@Override
	default T getObject() throws BeansException {
		Iterator<T> it = iterator();
		if (!it.hasNext()) {
			throw new NoSuchBeanDefinitionException(Object.class);
		}
		T result = it.next();
		if (it.hasNext()) {
			throw new NoUniqueBeanDefinitionException(Object.class, 2, "more than 1 matching bean");
		}
		return result;
	}

	default T getObject(Object... args) throws BeansException {
		throw new UnsupportedOperationException("Retrieval with arguments not supported -" +
				"for custom ObjectProvider classes, implement getObject(Object...) for your purposes");
	}

	@Nullable
	default T getIfAvailable() throws BeansException {
		try {
			return getObject();
		}
		catch (NoUniqueBeanDefinitionException ex) {
			throw ex;
		}
		catch (NoSuchBeanDefinitionException ex) {
			return null;
		}
	}

	default T getIfAvailable(Supplier<T> defaultSupplier) throws BeansException {
		T dependency = getIfAvailable();
		return (dependency != null ? dependency : defaultSupplier.get());
	}

	default void ifAvailable(Consumer<T> dependencyConsumer) throws BeansException {
		T dependency = getIfAvailable();
		if (dependency != null) {
			dependencyConsumer.accept(dependency);
		}
	}

	@Nullable
	default T getIfUnique() throws BeansException {
		try {
			return getObject();
		}
		catch (NoSuchBeanDefinitionException ex) {
			return null;
		}
	}

	default T getIfUnique(Supplier<T> defaultSupplier) throws BeansException {
		T dependency = getIfUnique();
		return (dependency != null ? dependency : defaultSupplier.get());
	}
	
	default void ifUnique(Consumer<T> dependencyConsumer) throws BeansException {
		T dependency = getIfUnique();
		if (dependency != null) {
			dependencyConsumer.accept(dependency);
		}
	}

	@Override
	default Iterator<T> iterator() {
		return stream().iterator();
	}

	default Stream<T> stream() {
		throw new UnsupportedOperationException("Element access not supported - " +
				"for custom ObjectProvider classes, implement stream() to enable all other methods");
	}
	
	default Stream<T> orderedStream() {
		return stream().sorted(OrderComparator.INSTANCE);
	}

	default Stream<T> stream(Predicate<Class<?>> customFilter) {
		return stream(customFilter, true);
	}

	default Stream<T> orderedStream(Predicate<Class<?>> customFilter) {
		return orderedStream(customFilter, true);
	}

	default Stream<T> stream(Predicate<Class<?>> customFilter, boolean includeNonSingletons) {
		if (!includeNonSingletons) {
			throw new UnsupportedOperationException("Only supports includeNonSingletons=true by default");
		}
		return stream().filter(obj -> customFilter.test(obj.getClass()));
	}

	default Stream<T> orderedStream(Predicate<Class<?>> customFilter, boolean includeNonSingletons) {
		if (!includeNonSingletons) {
			throw new UnsupportedOperationException("Only supports includeNonSingletons=true by default");
		}
		return orderedStream().filter(obj -> customFilter.test(obj.getClass()));
	}

}