在Spring框架中，BeanFactory 和 FactoryBean 是两个不同但相关的概念。它们各自有不同的用途和工作方式。
BeanFactory
BeanFactory 是Spring IoC容器的核心接口，它提供了配置框架和基本功能来管理任何类型的对象。BeanFactory 本身是一个工厂，用于创建和管理Spring中的Bean。它负责读取Bean定义，并根据这些定义实例化、配置以及管理Bean的生命周期。
- 主要职责：创建和管理Bean。
- 实现类：常见的实现类有
DefaultListableBeanFactory和XmlBeanFactory（已废弃）等。 - 使用场景：当你需要一个轻量级的IoC容器时，可以使用
BeanFactory。不过，在大多数情况下，推荐使用更强大的ApplicationContext，它是BeanFactory的子接口，提供了更多的企业级功能。
FactoryBean
FactoryBean 是Spring提供的一个接口，用于自定义复杂的对象创建过程。如果一个Bean实现了 FactoryBean 接口，那么Spring会调用它的 getObject() 方法来获取最终要注入到其他Bean中的对象。这使得你可以控制Bean的创建逻辑，例如，你可以返回一个代理对象或者进行一些复杂的初始化操作。
- 主要职责：自定义复杂对象的创建逻辑。
- 方法：
T getObject()：返回由这个工厂Bean创建的对象。Class<?> getObjectType()：返回由getObject()返回的对象类型。boolean isSingleton()：指定由getObject()返回的对象是否为单例。
- 使用场景：当你需要对Bean的创建过程有更多的控制时，可以实现
FactoryBean接口。例如，创建JNDI数据源、代理对象等。
区别总结
-
目的：
BeanFactory是Spring的IoC容器，用来管理和创建所有的Bean。FactoryBean是一个特殊的Bean，它自己定义了如何创建和管理一个具体的Bean。
-
作用：
BeanFactory用于创建和管理所有的Bean，包括那些普通的Bean和实现了FactoryBean的Bean。FactoryBean用于创建特定的Bean，通常用于复杂的对象创建逻辑。
-
获取对象的方式：
- 从
BeanFactory获取Bean时，直接返回的是Bean实例。 - 从
BeanFactory获取实现了FactoryBean的Bean时，返回的是FactoryBean的getObject()方法的结果，而不是FactoryBean实例本身。如果需要获取FactoryBean实例，可以在Bean ID前加上&符号，如&myFactoryBean。
- 从
通过理解这两个概念的区别，你可以更好地利用Spring框架的功能来满足应用程序的需求。如果你的应用中有复杂的对象创建需求，考虑使用 FactoryBean；而对于一般的依赖注入和Bean管理，BeanFactory 或 ApplicationContext 就足够了。
示例代码
为了更好地理解 BeanFactory 和 FactoryBean 的区别，我们可以分别通过代码示例来说明它们的使用方式。
BeanFactory 示例
首先，我们创建一个简单的Spring配置类和一个普通的Bean。然后，我们将使用 BeanFactory 来获取这个Bean。
定义一个简单的Bean
public class SimpleBean {
public void sayHello() {
System.out.println("Hello, I am a simple bean!");
}
}创建Spring配置类
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class AppConfig {
@Bean
public SimpleBean simpleBean() {
return new SimpleBean();
}
}使用BeanFactory获取Bean
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class MainApp {
public static void main(String[] args) {
// 创建BeanFactory
DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
// 使用AnnotationConfigApplicationContext加载配置类
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
context.refresh();
// 从BeanFactory中获取Bean
SimpleBean simpleBean = (SimpleBean) context.getBean("simpleBean");
simpleBean.sayHello();
// 关闭上下文
context.close();
}
}在这个例子中，我们使用了 DefaultListableBeanFactory 作为 BeanFactory 实现，并通过 AnnotationConfigApplicationContext 加载配置类来管理Bean。然后，我们从 BeanFactory 中获取 SimpleBean 并调用其方法。
FactoryBean 示例
接下来，我们创建一个实现了 FactoryBean 接口的类，该类将返回一个代理对象。
定义一个接口
public interface MyService {
void doSomething();
}实现接口
public class MyServiceImpl implements MyService {
@Override
public void doSomething() {
System.out.println("Doing something in MyServiceImpl");
}
}创建一个FactoryBean
import org.springframework.beans.factory.FactoryBean;
public class MyServiceFactoryBean implements FactoryBean<MyService> {
private final MyService myService;
public MyServiceFactoryBean(MyService myService) {
this.myService = myService;
}
@Override
public MyService getObject() throws Exception {
return (MyService) Proxy.newProxyInstance(
getClass().getClassLoader(),
new Class<?>[]{MyService.class},
(proxy, method, args) -> {
System.out.println("Before method call");
Object result = method.invoke(myService, args);
System.out.println("After method call");
return result;
});
}
@Override
public Class<?> getObjectType() {
return MyService.class;
}
@Override
public boolean isSingleton() {
return true;
}
}创建Spring配置类
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class AppConfig {
@Bean
public MyServiceImpl myServiceImpl() {
return new MyServiceImpl();
}
@Bean
public MyServiceFactoryBean myServiceFactoryBean(MyServiceImpl myServiceImpl) {
return new MyServiceFactoryBean(myServiceImpl);
}
}使用ApplicationContext获取FactoryBean创建的对象
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class MainApp {
public static void main(String[] args) throws Exception {
// 创建ApplicationContext
ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
// 从ApplicationContext中获取FactoryBean创建的对象
MyService myService = context.getBean(MyServiceImpl.class);
myService.doSomething();
// 获取FactoryBean本身
MyServiceFactoryBean factoryBean = (MyServiceFactoryBean) context.getBean("&myServiceFactoryBean");
System.out.println("FactoryBean: " + factoryBean);
//从FactoryBean中获取对象（已经实现动态代理）
myService = factoryBean.getObject();
myService.doSomething();
// 关闭上下文
((AnnotationConfigApplicationContext) context).close();
}
}在这个例子中，MyServiceFactoryBean 实现了 FactoryBean 接口，并且返回了一个代理对象。当我们从 ApplicationContext 中获取 MyService 类型的Bean时，实际上得到的是由 MyServiceFactoryBean 创建的代理对象。如果需要获取 FactoryBean 本身，可以通过在Bean ID前加上 & 符号来实现。
通过这两个示例，你可以看到 BeanFactory 和 FactoryBean 在Spring中的不同用途和工作方式。BeanFactory 是用于管理和创建所有Bean的基础容器，而 FactoryBean 则提供了自定义复杂对象创建逻辑的能力。
