BeanFactory和FactoryBean直面翻译过来的意思是“Bean”工厂和工厂“Bean”，其中"bean"在spring中的意思是类的实例，也就是说这两个类分别是实例工厂和工厂实例。
既然都和工厂有关那么我们先来聊一下工厂模式。
工厂模式的作用
工厂模式是用来创建不同但是类型相关的对象，它可以封装对象复杂的创建过程，将对象的创建和使用分离，让代码更加清晰。举个例子：
public class RuleConfigSource {
public RuleConfig load(String ruleConfigFilePath) {
String ruleConfigFileExtension = getFileExtension(ruleConfigFilePath);
IRuleConfigParser parser = null;
if ("json".equalsIgnoreCase(ruleConfigFileExtension)) {
parser = new JsonRuleConfigParser();
} else if ("xml".equalsIgnoreCase(ruleConfigFileExtension)) {
parser = new XmlRuleConfigParser();
} else if ("yaml".equalsIgnoreCase(ruleConfigFileExtension)) {
parser = new YamlRuleConfigParser();
} else if ("properties".equalsIgnoreCase(ruleConfigFileExtension)) {
parser = new PropertiesRuleConfigParser();
} else {
throw new InvalidRuleConfigException( "Rule config file format is not supported: " + ruleConfigFilePath);
}
String configText = getFileText(ruleConfigFilePath);
RuleConfig ruleConfig = parser.parse(configText);
return ruleConfig;
}
private String getFileExtension(String filePath) {
//...解析文件名获取扩展名，比如rule.json，返回json
return "json";
}
private String getFileText(String filePath) {
String fileText = "";
//...解析文件内容
return fileText;
}
}
为了让代码更清晰，类的职责更单一我们来使用工厂模式：
public class RuleConfigSource {
public RuleConfig load(String ruleConfigFilePath) {
String ruleConfigFileExtension = getFileExtension(ruleConfigFilePath);
IRuleConfigParser parser = RuleConfigParserFactory.createParser(ruleConfigFileExtension);
if (parser == null) {
throw new InvalidRuleConfigException( "Rule config file format is not supported: " + ruleConfigFilePath);
}
String configText = getFileText(ruleConfigFilePath);
RuleConfig ruleConfig = parser.parse(configText);
return ruleConfig;
}
private String getFileExtension(String filePath) {
//...解析文件名获取扩展名，比如rule.json，返回json
return "json";
}
private String getFileText(String filePath) {
String fileText = "";
//...解析文件内容
return fileText;
}
}
public class RuleConfigParserFactory {
public static IRuleConfigParser createParser(String configFormat) {
IRuleConfigParser parser = null;
if ("json".equalsIgnoreCase(configFormat)) {
parser = new JsonRuleConfigParser();
} else if ("xml".equalsIgnoreCase(configFormat)) {
parser = new XmlRuleConfigParser();
} else if ("yaml".equalsIgnoreCase(configFormat)) {
parser = new YamlRuleConfigParser();
} else if ("properties".equalsIgnoreCase(configFormat)) {
parser = new PropertiesRuleConfigParser();
}
return parser;
}
}
我们通过一个工厂类RuleConfigParserFactory来创建我们所需要的对象，调用者可以不关心实例的创建过程，这让我们的项目更加“解耦”了。这个例子我们可以具体点叫它“简单工厂模式”，因为它足够的简单，除此之外还有“工厂方法模式”和“抽象工厂模式”。他们都是为了解决同样的问题。
工厂模式可以解决很多的问题，但是于此同时它也带来了一些问题。假如项目很大，有很多的实例需要用工厂创建，并且创建时机和类型都不尽相同。这个时候假如使用的工厂模式（即使是抽象工厂模式），整个项目就会充斥着各种工厂类，而且各个工厂内部又会充斥着各种判断语句，这样反倒让项目更加难以维护了。
这个时候更高级的工厂模式就站出来了，他不需要创建很多的工厂类就可以帮助我们创建各种实例，还可以管理对象的生命周期。这就是“DI容器（Dependency Injection Container）”，也可以叫做依赖注入容器。
其实标题上写的“Spring框架中的BeanFactory“就是一个牛逼哄哄的DI容器的核心接口。
Spring框架中的BeanFactory
Spring的核心是IOC容器，而Spring容器最基本的接口就是BeanFactory。BeanFactory负责配置、创建、管理Bean，它定义了getBean()、containsBean()等管理Bean的通用方法。
public interface BeanFactory {
/**
* Used to dereference a {@link FactoryBean} instance and distinguish it from
* beans created by the FactoryBean. For example, if the bean named
* {@code myJndiObject} is a FactoryBean, getting {@code &myJndiObject}
* will return the factory, not the instance returned by the factory.
*/
String FACTORY_BEAN_PREFIX = "&";
/**
* Return an instance, which may be shared or independent, of the specified bean.
*/
Object getBean(String name) throws BeansException;
/**
* Return an instance, which may be shared or independent, of the specified bean.
*/
T getBean(String name, Class requiredType) throws BeansException;
/**
* Return an instance, which may be shared or independent, of the specified bean.
*/
Object getBean(String name, Object... args) throws BeansException;
/**
* Return the bean instance that uniquely matches the given object type, if any.
*/
T getBean(Class requiredType) throws BeansException;
/**
* Return an instance, which may be shared or independent, of the specified bean.
*/
T getBean(Class requiredType, Object... args) throws BeansException;
/**
* Does this bean factory contain a bean definition or externally registered singleton
*/
boolean containsBean(String name);
/**
* Is this bean a shared singleton? That is, will {@link #getBean} always
* return the same instance?
*/
boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
/**
* Is this bean a prototype? That is, will {@link #getBean} always return
* independent instances?
*/
boolean isPrototype(String name) throws NoSuchBeanDefinitionException;
/**
* Check whether the bean with the given name matches the specified type.
*/
boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;
/**
* Check whether the bean with the given name matches the specified type.
*/
boolean isTypeMatch(String name, Class typeToMatch) throws NoSuchBeanDefinitionException;
/**
* Determine the type of the bean with the given name. More specifically,
* determine the type of object that {@link #getBean} would return for the given name.
*/
Class getType(String name) throws NoSuchBeanDefinitionException;
/**
* Return the aliases for the given bean name, if any.
*/
String[] getAliases(String name);
}
它还有几个关键的子接口：
- HierarchicalBeanFactory接口：在继承BeanFactory的基础上，提供父容器的访问功能
- ListableBeanFactory接口：在继承BeanFactory的基础上，提供了批量获取Bean的方法
- ConfigurableBeanFactory接口：在继承HierarchicalBeanFactory的基础上，提供了配置管理功能
- AutowireCapableBeanFactory接口：在继承BeanFactory的基础上，提供了Bean的自动装配功能
-
ConfigurableListableBeanFactory接口：继承了上述的所有接口，增加了类加载器，类型转化，属性编辑等功能
Beanfactory类关系图
他们最终的实现都是DefaultListableBeanFactory，也可以说DefaultListableBeanFactory就是IOC容器的实现。
可以总结一下BeanFactor接口是Spring中工厂的顶层规范，是IOC容器的核心接口，它的实现是DefaultListableBeanFactory。
Spring框架中的FactoryBean
FactoryBean虽然名字和BeanFactory很像，但是在spring中的地位和BeanFactory完全不能比。FactoryBean只是被SpringIOC容器管理的一类Bean的接口规范。可以这么讲Spring容器可以管理两类bean，一类是普通的bean，像我们在项目中定义的userServcice这类可以直接为业务做事的bean就是普通bean。另一类就是实现了FactoryBean接口的工厂bean，他只做一件事就是生产普通bean。可以把他理解成"spring的黄埔军校"，他不直接上战场打仗，他为战场培养（生产）合格和军官。
那就很奇怪了，spring容器BeanFactory不就是一个大工厂吗，它本身不就可以生产bean吗？为啥还要先有一个实现FactoryBean接口的工厂bean呢？原因很简单，因为有这一类的bean需要复杂的配置才能生产。拿上面“黄埔军校”来举例，也就是说培养一个合格的军官去打赢一场仗并非那么简单，首先需要有一个好学校。
我们来看一个例子：
@Bean
public SqlSessionFactory getSqlSessionFactory (@Qualifier ("dataCenterDbDataSource") DataSource dataSource) throws Exception
{
SqlSessionFactoryBean bean = new SqlSessionFactoryBean(); //创建一个FactoryBean
//配置数据源
bean.setDataSource (dataSource);
// 分页插件
PageHelper pageHelper = new PageHelper ();
Properties properties = new Properties ();
// false: pageNum<1和大于总页数时，返回空;true: pageNum<1返回第一页，大于总页数返回最后一页
properties.setProperty ("reasonable", "false");
properties.setProperty ("supportMethodsArguments", "true");
properties.setProperty ("returnPageInfo", "check");
properties.setProperty ("params", "count=countSql");
pageHelper.setProperties (properties);
// 添加插件
bean.setPlugins (new Interceptor[]{ pageHelper });
List resources = new ArrayList ();
PathMatchingResourcePatternResolver pathMatchingResourcePatternResolver = new PathMatchingResourcePatternResolver ();
resources.addAll (Arrays.asList (pathMatchingResourcePatternResolver.getResources ("classpath:mybatis/*.xml")));
bean.setMapperLocations (resources.toArray (new Resource[resources.size()]));
bean.getObject ().getConfiguration ().setMapUnderscoreToCamelCase (true);
return bean.getObject ();
}
这个是spring整合mybatis(操作数据库框架)的一段很常见的代码，其中SqlSessionFactoryBean就继承了FactoryBean接口，它就是一个名副其实的工厂bean。它为我们配置好了SqlSessionFactory这个工厂的所有设施，让这个工厂去生产SqlSession再去操作数据库。
我们再看一下FactoryBean这个接口
public interface FactoryBean {
/**
* Return an instance (possibly shared or independent) of the object
* managed by this factory.
*/
T getObject() throws Exception;
/**
* Return the type of object that this FactoryBean creates
*/
Class getObjectType();
/**
* Is the object managed by this factory a singleton?
*/
boolean isSingleton();
}
这个接口非常简单，如果我们也需要一个工厂bean直接实现这三个方法就可以了。
举个例子，例如我们要一个生产UserService的工厂，首先定义一个UserServiceFactoryBean
public class UserServiceFactoryBean implements FactoryBean {
private UserService userService;
//定义一个配置userService的入口
public void setConfig(Conf conf){
userService.setConf(conf);
}
@Override
public UserService getObject() throws Exception {
return userService;
}
@Override
public Class getObjectType() {
return UserService.class;
}
@Override
boolean isSingleton() {
return true;
}
}
然后再配置进spring容器就可以了
@Configuration
public class ItemConfig {
@Bean
public UserService getUserService(Conf conf) throws Exception {
UserServiceFactoryBean factoryBean = new UserServiceFactoryBean();
factoryBean.setConf(conf)
return factoryBean.getObject();
}
}
使用的时候跟直接创建的bean一样用就可以了
@Service
public class Test1 {
@Autowired
private UserService userService;
@Test
public void test() {
userService.sayHello();
}
}
这里需要解释一下，不同于上面mybatis的SqlSessionFactoryBean这个例子。SqlSessionFactoryBean并没有直接去生产SqlSession这个对象，而是生产了SqlSessionFactory这个工厂对象。这个是因为mybatis是一个独立于spring的框架，它的内部实现需要SqlSessionFactory这个工厂才能使用SqlSession的功能，并没有向调用者直接开放SqlSession这个类的使用（这个设计思想叫做迪米特法则）。其实SqlSessionFactoryBean这个类的全称应该叫SqlSessionFactoryFactoryBean，假如SqlSession这个类的是spring的一部分，那就不会再有SqlSessionFactory这个工厂类了。