前言
FactoryBean 是 Spring 框架中的一个高级特性，它允许开发者通过自定义的方式控制对象的创建过程。当需要编写复杂的初始化逻辑，而这些逻辑不适合直接放在类的构造函数或初始化方法中时，FactoryBean 提供了一个很好的解决方案。通过实现 FactoryBean 接口，可以在一个单独的方法（通常是 getObject()）中封装所有的初始化逻辑，并将这个逻辑的结果（即对象实例）返回给 Spring 容器。
FactoryBean 接口定义了三个关键方法：
T getObject(): 返回由该工厂创建的对象的实例。boolean isSingleton(): 指定返回的实例是否为单例。Class<?> getObjectType(): 返回getObject()方法返回的对象类型。
Spring 框架内部广泛使用 FactoryBean，提供了超过50个 FactoryBean 的实现，用于创建和配置各种复杂的对象。
下面基于 UserService 类，通过几个实战案例来展示 FactoryBean 的不同用法。
class UserService {
public void save() {
System.out.println("save user ...") ;
}
}基本用法
在这个例子中，我们创建了一个简单的 UserServiceFactoryBean，用于创建 UserService 的实例。
@Component
public class UserServiceFactoryBean implements FactoryBean<UserService> {
@Override
public UserService getObject() throws Exception {
return new UserService();
}
@Override
public Class<?> getObjectType() {
return UserService.class;
}
@Override
public boolean isSingleton() {
return true; // 默认返回单例
}
}使用方式：
代码语言：javascript复制@Resource
private UserService userService; // 直接注入
// 或者通过 ApplicationContext 获取
ApplicationContext context = ...;
UserService us = context.getBean(UserService.class);创建多例对象
将 isSingleton() 方法返回 false，以创建多例对象。
@Override
public boolean isSingleton() {
return false; // 返回非单例
}此时，每次通过 Spring 容器获取的 UserService 实例都将是新的,以下两个Controller中注入的UserService将是两个不同的对象:
@Component
public class UserController {
@Resource
private UserService userService ;
}
@Component
public class CommonService {
@Resource
private UserService userService ;
}创建代理
使用 FactoryBean 创建代理对象是一种常见用法，尤其是在需要为对象添加横切关注点（如日志、事务管理等）时。
@Override
public PersonService getObject() throws Exception {
ProxyFactory factory = new ProxyFactory(new UserService());
factory.addAdvice(new MethodInterceptor() {
@Override
public Object invoke(MethodInvocation invocation) throws Throwable {
System.out.println("Before method call");
Object result = invocation.proceed();
System.out.println("After method call");
return result;
}
});
return (UserService) factory.getProxy();
}获取原始 FactoryBean
有时候，可能需要获取 FactoryBean 本身而不是它创建的对象。
// 通过类型获取
UserServiceFactoryBean factoryBean = context.getBean(UserServiceFactoryBean.class);
// 或者通过名称获取，添加 '&' 前缀
UserServiceFactoryBean factoryBeanByName = context.getBean("&userServiceFactoryBean");利用 SPI 获取对象
Spring 提供的 ServiceFactoryBean 和 ServiceListFactoryBean 可以方便地用于基于 SPI 机制的服务加载。
@Configuration
public class AppConfig {
@Bean
public ServiceFactoryBean<DAO> daoFactoryBean() {
ServiceFactoryBean<DAO> fb = new ServiceFactoryBean<>();
fb.setServiceType(Partition.class);
return fb;
}
}在 META-INF/services 目录下创建与 Partition 接口全限定名对应的文件，列出所有实现类的全限定名。Spring 将加载并实例化这些实现类，并通过 daoFactoryBean 提供访问。
com.diguobobo.helper.IdPartition
com.diguobobo.helper.DatePratition容器中注入Partition时，将得到这里的第一个IdPartition实例。
ServiceListFactoryBean获取所有SPI对象
如果你需要获取 SPI 接口的所有实现，而不是单个实现，可以使用 ServiceListFactoryBean。这个 Bean 工厂会返回一个包含所有 SPI 实现的列表。配置方式与 ServiceFactoryBean 类似，但返回的将是一个列表，而不是单个对象。
代码语言：javascript复制@Configuration
public class AppConfig {
@Bean
public ServiceListFactoryBean<DAO> daoListFactoryBean() {
ServiceListFactoryBean<DAO> fb = new ServiceListFactoryBean<>();
fb.setServiceType(Partition.class);
return fb;
}
}
// 使用时注入List<Partition>
@Autowired
private List<Partition> daos;FactoryBean应用场景
1. 延迟初始化
默认情况下，Spring容器中的Bean会在容器启动时进行初始化。但是，通过FactoryBean，你可以控制对象的创建时机，直到真正需要该对象时才进行创建。这可以通过在FactoryBean中实现特定的逻辑来延迟调用getObject()方法实现。
2. 依赖注入的高级用法
FactoryBean允许开发者在依赖注入过程中进行更精细的控制。例如，你可以根据特定的条件动态地选择不同的Bean实例进行注入，或者根据环境变量、配置属性等动态地创建Bean实例。
3. 集成第三方库
当需要将第三方库中的对象集成到Spring容器中时，如果这些对象的创建过程比较复杂或者不符合Spring的默认Bean创建规则，你可以通过实现FactoryBean来封装这些复杂的创建逻辑。这样，就可以像使用其他Spring Bean一样使用这些第三方库中的对象了。
4. 自定义作用域
虽然FactoryBean本身并不直接提供作用域的定义（作用域通常由Spring容器管理），但你可以通过FactoryBean来控制对象的创建过程，从而实现自定义作用域的效果。例如，可以通过FactoryBean来管理具有自定义生命周期的对象，如数据库连接、网络会话等。
5. 工厂方法的封装
有时可能需要使用某个类的静态工厂方法来创建对象实例。虽然Spring支持通过@Bean注解来引用静态工厂方法，但实现FactoryBean提供了一种更加封装和灵活的方式来处理这种情况。你可以在FactoryBean中实现调用静态工厂方法的逻辑，并将FactoryBean本身注册为Spring容器中的Bean。
6. 与AOP集成
FactoryBean可以与Spring的AOP（面向切面编程）功能集成，用于在对象创建过程中应用横切关注点（如事务管理、日志记录等）。虽然通常这些横切关注点会应用在Bean的方法调用上，但通过在FactoryBean中实现特定的逻辑，你也可以在对象创建过程中应用这些关注点。
7. 复杂依赖的解耦
复杂的应用中，Bean之间可能存在复杂的依赖关系。通过实现FactoryBean，你可以将这些复杂的依赖关系封装在FactoryBean内部，从而简化Bean之间的依赖关系。这样，其他Bean只需要依赖于FactoryBean创建的实例，而不需要关心这些实例背后的复杂创建逻辑和依赖关系。
