讲一下beanfactory和factory bean不憋

我再详细深入地讲解一下 BeanFactory 和 FactoryBean 的区别，这次从源码层面和实际应用角度来分析：

1. 概念对比

BeanFactory

• 是什么：Spring IoC 容器的根接口
• 作用：负责 Bean 的创建、管理、依赖注入
• 定位：Spring 容器的基础设施

FactoryBean

• 是什么：一个特殊的 Bean，实现了 FactoryBean 接口
• 作用：用于创建复杂的对象，是 Bean 的工厂
• 定位：自定义 Bean 创建逻辑的工具

2. 源码分析

BeanFactory 接口（简化版）

1. public interface BeanFactory {
2. String FACTORY_BEAN_PREFIX = "&"; // 获取 FactoryBean 本身的前缀
4. Object getBean(String name) throws BeansException;
5. <T> T getBean(Class<T> requiredType) throws BeansException;
6. <T> T getBean(String name, Class<T> requiredType) throws BeansException;
7. Object getBean(String name, Object... args) throws BeansException;
8. <T> T getBean(Class<T> requiredType, Object... args) throws BeansException;
10. boolean containsBean(String name);
11. boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
12. boolean isPrototype(String name) throws NoSuchBeanDefinitionException;
13. boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;
14. boolean isTypeMatch(String name, Class<?> typeToMatch) throws NoSuchBeanDefinitionException;
15. Class<?> getType(String name) throws NoSuchBeanDefinitionException;
16. String[] getAliases(String name);
17. }

FactoryBean 接口

1. public interface FactoryBean<T> {
2. String OBJECT_TYPE_ATTRIBUTE = "factoryBeanObjectType";
4. @Nullable
5. T getObject() throws Exception; // 返回工厂生产的对象
7. @Nullable
8. Class<?> getObjectType(); // 返回对象的类型
10. default boolean isSingleton() { // 是否单例
11. return true;
12. }
13. }

3. 核心区别

4. 获取方式详解

获取 FactoryBean 创建的对象

1. ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
3. // MyFactoryBean 是一个 FactoryBean
4. MyObject obj = context.getBean("myFactoryBean"); // 返回 getObject() 的结果

获取 FactoryBean 本身

1. // 加上 "&" 前缀
2. MyFactoryBean factory = context.getBean("&myFactoryBean");

Spring 源码中的处理逻辑（AbstractBeanFactory）：

1. protected Object getObjectForBeanInstance(
2. Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {
4. // 如果是 FactoryBean 且请求的是工厂本身（以 & 开头）
5. if (BeanFactoryUtils.isFactoryDereference(name)) {
6. if (beanInstance instanceof NullBean) {
7. return beanInstance;
8. }
9. if (!(beanInstance instanceof FactoryBean)) {
10. throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass());
11. }
12. return beanInstance; // 返回 FactoryBean 本身
13. }
15. // 如果不是 FactoryBean，直接返回
16. if (!(beanInstance instanceof FactoryBean)) {
17. return beanInstance;
18. }
20. // 如果是 FactoryBean，返回其创建的对象
21. Object object = null;
22. if (mbd != null) {
23. mbd.isFactoryBean = true;
24. }
25. object = getObjectFromFactoryBean((FactoryBean<?>) beanInstance, beanName, !synthetic);
26. return object;
27. }

5. 实际应用示例

示例 1：自定义 FactoryBean 创建复杂对象

1. @Component
2. public class ConnectionFactoryBean implements FactoryBean<Connection> {
4. private String url;
5. private String username;
6. private String password;
8. public void setUrl(String url) { this.url = url; }
9. public void setUsername(String username) { this.username = username; }
10. public void setPassword(String password) { this.password = password; }
12. @Override
13. public Connection getObject() throws Exception {
14. DriverManager.getConnection(url, username, password);
15. }
17. @Override
18. public Class<?> getObjectType() {
19. return Connection.class;
20. }
22. @Override
23. public boolean isSingleton() {
24. return false; // 每次获取都创建新连接
25. }
26. }

示例 2：Spring 内置的 FactoryBean

Spring 内部大量使用 FactoryBean，例如：

SqlSessionFactoryBean（MyBatis 集成）：

1. public class SqlSessionFactoryBean implements FactoryBean<SqlSessionFactory>, InitializingBean, ApplicationListener<ApplicationEvent> {
3. @Override
4. public SqlSessionFactory getObject() throws Exception {
5. return this.sqlSessionFactory;
6. }
8. @Override
9. public Class<?> getObjectType() {
10. return this.sqlSessionFactory == null ? SqlSessionFactory.class : this.sqlSessionFactory.getClass();
11. }
12. }

使用方式：

1. @Configuration
2. public class MyBatisConfig {
4. @Bean
5. public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource) {
6. SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
7. factoryBean.setDataSource(dataSource);
8. factoryBean.setMapperLocations(new PathMatchingResourcePatternResolver()
9. .getResources("classpath:mapper/*.xml"));
10. return factoryBean;
11. }
12. }
14. // 获取 SqlSessionFactory
15. SqlSessionFactory sessionFactory = context.getBean(SqlSessionFactory.class);

6. FactoryBean 的生命周期

1. @Component
2. public class MyFactoryBean implements FactoryBean<MyObject>, InitializingBean, DisposableBean {
4. @Override
5. public void afterPropertiesSet() throws Exception {
6. System.out.println("FactoryBean 初始化");
7. }
9. @Override
10. public MyObject getObject() throws Exception {
11. System.out.println("创建 MyObject");
12. return new MyObject();
13. }
15. @Override
16. public Class<?> getObjectType() {
17. return MyObject.class;
18. }
20. @Override
21. public void destroy() throws Exception {
22. System.out.println("FactoryBean 销毁");
23. }
24. }

执行顺序：

1. FactoryBean 实例化
2. afterPropertiesSet() 执行
3. 第一次 getBean() 时调用 getObject()
4. 容器关闭时调用 destroy()

7. 常见使用场景

① 创建第三方复杂对象

1. @Component
2. public class RedisConnectionFactoryBean implements FactoryBean<RedisConnection> {
4. @Override
5. public RedisConnection getObject() throws Exception {
6. return new JedisConnectionFactory().getConnection();
7. }
9. @Override
10. public Class<?> getObjectType() {
11. return RedisConnection.class;
12. }
13. }

② 需要动态代理的对象

1. @Component
2. public class ProxyFactoryBean implements FactoryBean<Object> {
4. private Object target;
6. @Override
7. public Object getObject() throws Exception {
8. return Proxy.newProxyInstance(
9. target.getClass().getClassLoader(),
10. target.getClass().getInterfaces(),
11. new MyInvocationHandler(target)
12. );
13. }
15. @Override
16. public Class<?> getObjectType() {
17. return target.getClass();
18. }
19. }

③ 整合第三方框架

1. // Spring 整合 RabbitMQ
2. @Bean
3. public RabbitAdmin rabbitAdmin(ConnectionFactory connectionFactory) {
4. return new RabbitAdmin(connectionFactory);
5. }
7. @Bean
8. public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory) {
9. return new RabbitTemplate(connectionFactory);
10. }

8. 总结对比图

1. ┌─────────────────────────────────────────────────────────┐
2. │ Spring 容器 │
3. │ (BeanFactory) │
4. │ │
5. │ ┌─────────────────────────────────────────────────┐ │
6. │ │ 普通 Bean │ │
7. │ │ ┌─────────────────────────────────────────┐ │ │
8. │ │ │ UserService │ │ │
9. │ │ │ OrderService │ │ │
10. │ │ └─────────────────────────────────────────┘ │ │
11. │ └─────────────────────────────────────────────────┘ │
12. │ │
13. │ ┌─────────────────────────────────────────────────┐ │
14. │ │ FactoryBean（特殊 Bean） │ │
15. │ │ ┌─────────────────────────────────────────┐ │ │
16. │ │ │ SqlSessionFactoryBean │ │ │
17. │ │ │ └─> 创建 SqlSessionFactory │ │ │
18. │ │ │ │ │ │
19. │ │ │ ConnectionFactoryBean │ │ │
20. │ │ │ └─> 创建 Connection │ │ │
21. │ │ └─────────────────────────────────────────┘ │ │
22. │ └─────────────────────────────────────────────────┘ │
23. └─────────────────────────────────────────────────────────┘

一句话总结

BeanFactory 是 Spring 容器本身，负责管理所有 Bean；FactoryBean 是一个特殊的 Bean，用于创建其他 Bean。当你需要自定义复杂对象的创建逻辑时，就实现 FactoryBean 接口。

希望这次更深入的解释能帮助你更好地理解这