企业官网建设流程全解析

1. FactoryBean的本质与设计初衷

FactoryBean是Spring框架中一个特殊的接口，它的存在打破了传统Bean实例化的单一模式。与普通Bean直接由Spring容器通过反射实例化不同，FactoryBean本质上是一个能生产对象的工厂。这种设计模式在Spring内部被广泛使用，比如AOP代理对象的创建、MyBatis的SqlSessionFactory等场景。

关键理解：FactoryBean本身是一个Bean，但它又具备工厂的能力，能够生产其他Bean实例。这种"工厂中的工厂"设计，为复杂对象的创建提供了更大的灵活性。

1.1 FactoryBean的核心方法解析

FactoryBean接口仅定义了三个方法，但每个方法都承担着重要职责：

public interface FactoryBean<T> { T getObject() throws Exception; Class<?> getObjectType(); boolean isSingleton(); }

• getObject()：这是核心方法，定义了如何创建目标对象。在实际项目中，这个方法可以包含任意复杂的初始化逻辑。
• getObjectType()：返回工厂生产的对象类型，这个类型决定了在依赖注入时如何匹配。
• isSingleton()：控制工厂生产的对象是否是单例。这个配置会直接影响Spring容器的行为。

1.2 与普通Bean的实例化对比

普通Bean的实例化过程相对简单：

1. Spring读取配置元数据（XML或注解）
2. 通过反射调用构造函数创建实例
3. 进行属性注入和初始化回调

而FactoryBean的实例化过程则更加灵活：

1. Spring先实例化FactoryBean本身
2. 调用getObject()方法获取目标对象
3. 根据isSingleton()决定是否缓存该对象

2. FactoryBean的典型使用场景

2.1 复杂对象的创建

当对象的创建过程涉及多个步骤或需要特殊处理时，FactoryBean就显示出其价值。例如数据库连接池的创建：

public class DataSourceFactoryBean implements FactoryBean<DataSource> { private String url; private String username; private String password; @Override public DataSource getObject() throws Exception { HikariConfig config = new HikariConfig(); config.setJdbcUrl(url); config.setUsername(username); config.setPassword(password); // 其他复杂配置 return new HikariDataSource(config); } // 省略其他方法 }

2.2 第三方库集成

当需要将第三方库的对象纳入Spring管理时，FactoryBean是理想的桥梁。例如集成Redis客户端：

public class RedisClientFactoryBean implements FactoryBean<RedisClient> { private String host; private int port; @Override public RedisClient getObject() throws Exception { return RedisClient.create("redis://"+host+":"+port); } // 省略其他方法 }

2.3 动态代理创建

Spring AOP的核心ProxyFactoryBean就是典型的FactoryBean实现：

<bean id="userServiceProxy" class="org.springframework.aop.framework.ProxyFactoryBean"> <property name="target" ref="userService"/> <property name="interceptorNames"> <list> <value>loggingInterceptor</value> </list> </property> </bean>

3. FactoryBean的高级应用技巧

3.1 获取FactoryBean本身

默认情况下，通过bean名称获取的是FactoryBean生产的对象。如果需要获取FactoryBean实例本身，需要在bean名称前加"&"：

// 获取生产的对象 MyObject obj = context.getBean("myFactoryBean"); // 获取FactoryBean本身 MyFactoryBean factory = (MyFactoryBean) context.getBean("&myFactoryBean");

3.2 结合SmartFactoryBean增强控制

Spring还提供了SmartFactoryBean接口，可以更精细地控制初始化行为：

public class AdvancedFactoryBean implements SmartFactoryBean<MyObject> { @Override public boolean isEagerInit() { return true; // 控制是否提前初始化 } // 其他方法实现 }

3.3 与BeanPostProcessor配合

FactoryBean可以与BeanPostProcessor结合，实现对生产对象的后处理：

public class MyFactoryBean implements FactoryBean<MyObject>, BeanPostProcessor { @Override public Object postProcessAfterInitialization(Object bean, String beanName) { if(bean instanceof MyObject) { // 对生产的对象进行处理 } return bean; } }

4. 实战中的常见问题与解决方案

4.1 循环依赖问题

当FactoryBean生产的对象又依赖其他Bean，而其他Bean又依赖该FactoryBean时，可能会形成循环依赖。解决方案：

1. 使用@Lazy延迟加载
2. 重构设计，打破循环
3. 使用setter注入替代构造器注入

4.2 类型匹配异常

由于getObjectType()返回的类型与实际生产的对象类型可能不同，容易导致类型匹配问题。建议：

@Override public Class<?> getObjectType() { return MyObject.class; // 明确返回实际生产的类型 }

4.3 生命周期管理

FactoryBean生产的对象不会自动调用Spring的生命周期回调（如@PostConstruct）。如果需要，可以手动处理：

@Override public MyObject getObject() throws Exception { MyObject obj = createObject(); // 手动调用初始化逻辑 if(obj instanceof InitializingBean) { ((InitializingBean)obj).afterPropertiesSet(); } return obj; }

5. 性能优化建议

1. 缓存策略：对于昂贵的对象创建，合理实现isSingleton()方法
2. 延迟初始化：对于不立即需要的对象，考虑实现SmartFactoryBean的isEagerInit()
3. 对象池：对于频繁创建销毁的对象，可以在getObject()中实现对象池

public class PooledFactoryBean implements FactoryBean<MyObject> { private final ObjectPool<MyObject> pool = new GenericObjectPool<>(new BasePooledObjectFactory<>() { @Override public MyObject create() throws Exception { return new MyObject(); } }); @Override public MyObject getObject() throws Exception { return pool.borrowObject(); } @Override public boolean isSingleton() { return false; // 每次获取都是新对象（从池中获取） } }

6. 源码级深度解析

Spring处理FactoryBean的核心逻辑位于AbstractBeanFactory的doGetBean方法中：

protected <T> T doGetBean(...) { // 省略其他代码 if (mbd.isSingleton()) { sharedInstance = getSingleton(beanName, () -> { try { return createBean(beanName, mbd, args); } catch (BeansException ex) { destroySingleton(beanName); throw ex; } }); bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd); } // 省略其他代码 }

关键点在于getObjectForBeanInstance方法，它会判断如果是FactoryBean就调用getObject()：

protected Object getObjectForBeanInstance( Object beanInstance, String name, String beanName, RootBeanDefinition mbd) { if (BeanFactoryUtils.isFactoryDereference(name)) { // 处理&前缀的情况 return beanInstance; } if (!(beanInstance instanceof FactoryBean)) { return beanInstance; } // 处理FactoryBean.getObject()调用 Object object = null; if (mbd == null) { object = getCachedObjectForFactoryBean(beanName); } if (object == null) { FactoryBean<?> factory = (FactoryBean<?>) beanInstance; if (mbd == null && containsBeanDefinition(beanName)) { mbd = getMergedLocalBeanDefinition(beanName); } boolean synthetic = (mbd != null && mbd.isSynthetic()); object = getObjectFromFactoryBean(factory, beanName, !synthetic); } return object; }

7. 现代Spring中的新变化

随着Spring Boot的普及，FactoryBean的使用方式也有了一些新变化：

1. 自动配置中的FactoryBean：Spring Boot的自动配置大量使用FactoryBean来简化配置
2. 条件化FactoryBean：可以结合@Conditional注解实现更灵活的Bean创建
3. 函数式注册：在Spring 5+中，可以通过编程方式注册FactoryBean：

@Configuration public class AppConfig { @Bean public FactoryBean<MyService> myService() { return new FactoryBean<>() { @Override public MyService getObject() throws Exception { return new MyServiceImpl(); } @Override public Class<?> getObjectType() { return MyService.class; } }; } }

在实际项目中，合理使用FactoryBean可以极大地提高代码的灵活性和可维护性。但也要注意不要过度使用，只有在标准Bean配置无法满足需求时才考虑使用FactoryBean。