本文主要介紹什麼是FactoryBean技術？爲什麼使用FactoryBean？使用FactoryBean的好處？目前優秀的框架有哪些用到了FactoryBean？如果想要了解FactoryBean的源碼請移步：Spring中FactoryBean源碼分析（最詳細）。
1. FactoryBean的介紹：
FactoryBean從字面意思上理解是工廠bean，他可以生成某一個類型Bean實例，它最大的一個作用是：可以讓我們自定義Bean的創建過程。
一般情況下，Spring通過反射機制利用<bean>的class屬性指定實現類實例化Bean，在某些情況下，實例化Bean過程比較複雜，如果按照傳統的方式，則需要在<bean>中提供大量的配置信息。配置方式的靈活性是受限的，這時採用編碼的方式可能會得到一個簡單的方案。Spring爲此提供了一個org.springframework.bean.factory.FactoryBean的工廠類接口，用戶可以通過實現該接口定製實例化Bean的邏輯。FactoryBean接口對於Spring框架來說佔用重要的地位，Spring自身就提供了70多個FactoryBean的實現。它們隱藏了實例化一些複雜Bean的細節，給上層應用帶來了便利。
我們先來看一下FactoryBean這個接口：
public interface FactoryBean<T> {
String OBJECT_TYPE_ATTRIBUTE = "factoryBeanObjectType";
//返回對象實例
@Nullable
T getObject() throws Exception;
//bean的Class類型
@Nullable
Class<?> getObjectType();
//true是單例，false是非單例，可以看出默認爲單例的
default boolean isSingleton() {
return true;
}
}
可以看到FactoryBean是一個泛型類，而且只有三個方法，如果你想要的類是一個單例，那麼只需要實現兩個方法就可以了，getObject方法返回一個對象的實例，getObjectType方法返回對象的Class類型。
看下面一個例子：
package com.luban.factoryBean;
@Component("schoolFactory")
public class SchoolFactoryBean implements FactoryBean {
@Override
public Object getObject() throws Exception {
return new School();
}
@Override
public Class<?> getObjectType() {
return School.class;
}
@Override
public boolean isSingleton() {
return true;
}
}
@Configuration
@ComponentScan("com.luban.factoryBean")
public class Config {
}
public class Test {
public static void main(String[] args) {
AnnotationConfigApplicationContext contextnew = new AnnotationConfigApplicationContext(Config.class);
School school = (School) contextnew.getBean("schoolFactory");
System.out.println(school);
SchoolFactoryBean schoolFactoryBean = (SchoolFactoryBean) contextnew.getBean("&schoolFactory");
System.out.println(schoolFactoryBean);
}
}
打印結果：
com.luban.School@3834d63f
com.luban.factoryBean.SchoolFactoryBean@1ae369b7
可以看到我們在SchoolFactoryBean類上面標註了schoolFactory的名稱，當我們去容器中取schoolFactory的時候，他是School類型的了，從這可以看出在獲取FactoryBean的時候，其實返回的是通過getObject拿到的值，如果想要獲取SchoolFactoryBean類本身，需要加上在前面加上“&”符號才能獲取SchoolFactoryBean本身。
現在對於FactoryBean有了基本的認識，可能會覺得這樣做毫無意思啊，爲什麼要使用FactoryBean包裹一層呢，這樣不就麻煩了嗎？
2. FactoryBean的作用：
關於爲什麼使用FactoryBean，下面給出幾點原因：
一：如果實例化一個Bean的過程比較複雜，如果按照傳統的方式，則需要在<bean>中提供大量的配置信息，而這些信息還是我們不需要去關注的，我們只想要創建一個bean，不想知道這個bean是經過多麼複雜的流程創建出來的，這個我們不關心，這是就可以使用FactoryBean來把一些配置信息、依賴項進行封裝在內部，這樣就可以很簡單的實例化一個bean。
二：和第三方框架的整合，首先在第三方框架內部是不會出現像@Component這樣的註解（因爲如果使用了@Component註解，就依賴了Spring），在和Spring進行整合的時候，就需要將第三方的類以註解或者是XML的形式放到Spring容器中去，往往第三方類都有一個非常重要的類，我們只需要將這個類注入到Spring就可以了，不過這個類想要正常工作可能會依賴其他的，（爲什麼需要依賴其他的類，想一想單一性原則），所以我們在Spring中想注入這個類，就需要先知道它依賴的其他類，可以其他類還會有依賴，這樣做就太麻煩了，所以第三方框架可以寫一個FactoryBean類，提供一個簡單和Spring進行整合的入口（爲什麼是第三方框架自己寫，畢竟框架是他寫的，他比我們清楚這個），我們只需要將這個FactoryBean類以註解或XML的格式放到容器就可以了。
3. MyBatis對FactoryBean的使用：
對於MyBatis熟悉的同學都知道，MyBatis在和Spring進行整合的時候需要在XML中配置SqlSessionFactory，
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="dataSource" />
<property name="mapperLocations" value="classpath*:sample/config/mappers/**/*.xml" />
</bean>
或者是你使用的是SpringBoot項目整合MyBatis你沒有看到你自己有寫SqlSessionFactory，但是你不寫有人幫你寫了，在MybatisAutoConfiguration類中又這麼一個@bean註解：
@Bean
@ConditionalOnMissingBean
public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception {
SqlSessionFactoryBean factory = new SqlSessionFactoryBean();//使用SqlSessionFactoryBean來創建的SqlSessionFactory
factory.setDataSource(dataSource);
factory.setVfs(SpringBootVFS.class);
if (StringUtils.hasText(this.properties.getConfigLocation())) {
factory.setConfigLocation(this.resourceLoader.getResource(this.properties.getConfigLocation()));
}
applyConfiguration(factory);
if (this.properties.getConfigurationProperties() != null) {
factory.setConfigurationProperties(this.properties.getConfigurationProperties());
}
if (!ObjectUtils.isEmpty(this.interceptors)) {
factory.setPlugins(this.interceptors);
}
if (this.databaseIdProvider != null) {
factory.setDatabaseIdProvider(this.databaseIdProvider);
}
if (StringUtils.hasLength(this.properties.getTypeAliasesPackage())) {
factory.setTypeAliasesPackage(this.properties.getTypeAliasesPackage());
}
if (this.properties.getTypeAliasesSuperType() != null) {
factory.setTypeAliasesSuperType(this.properties.getTypeAliasesSuperType());
}
if (StringUtils.hasLength(this.properties.getTypeHandlersPackage())) {
factory.setTypeHandlersPackage(this.properties.getTypeHandlersPackage());
}
if (!ObjectUtils.isEmpty(this.typeHandlers)) {
factory.setTypeHandlers(this.typeHandlers);
}
if (!ObjectUtils.isEmpty(this.properties.resolveMapperLocations())) {
factory.setMapperLocations(this.properties.resolveMapperLocations());
}
Set<String> factoryPropertyNames = Stream
.of(new BeanWrapperImpl(SqlSessionFactoryBean.class).getPropertyDescriptors()).map(PropertyDescriptor::getName)
.collect(Collectors.toSet());
Class<? extends LanguageDriver> defaultLanguageDriver = this.properties.getDefaultScriptingLanguageDriver();
if (factoryPropertyNames.contains("scriptingLanguageDrivers") && !ObjectUtils.isEmpty(this.languageDrivers)) {
// Need to mybatis-spring 2.0.2+
factory.setScriptingLanguageDrivers(this.languageDrivers);
if (defaultLanguageDriver == null && this.languageDrivers.length == 1) {
defaultLanguageDriver = this.languageDrivers[0].getClass();
}
}
if (factoryPropertyNames.contains("defaultScriptingLanguageDriver")) {
// Need to mybatis-spring 2.0.2+
factory.setDefaultScriptingLanguageDriver(defaultLanguageDriver);
}
return factory.getObject();
}
再次簡單說明一下，this.properties就是你在application.yaml或者是application.properties中配置的關於MyBatis的信息都會被保存this.properties保存其他。
我們以SpringBoot整合MyBatis爲例進行說明，看下圖：
你可以配置關於MyBatis的相關信息，但是你不用每一個環境變量、依賴項都配置，只需要配置你感興趣的，然後關於其他的配置都會在factory.getObject()中由MyBatis自行去配置。
那麼我們看一下SqlSessionFactoryBean的源碼：
public class SqlSessionFactoryBean
implements FactoryBean<SqlSessionFactory>, InitializingBean, ApplicationListener<ApplicationEvent> {
//已省略無關代碼
@Override
public SqlSessionFactory getObject() throws Exception {
if (this.sqlSessionFactory == null) {
afterPropertiesSet();
}
return this.sqlSessionFactory;
}
@Override
public void afterPropertiesSet() throws Exception {
notNull(dataSource, "Property 'dataSource' is required");
notNull(sqlSessionFactoryBuilder, "Property 'sqlSessionFactoryBuilder' is required");
state((configuration == null && configLocation == null) || !(configuration != null && configLocation != null),
"Property 'configuration' and 'configLocation' can not specified with together");
this.sqlSessionFactory = buildSqlSessionFactory();
}
protected SqlSessionFactory buildSqlSessionFactory() throws Exception {
final Configuration targetConfiguration;
XMLConfigBuilder xmlConfigBuilder = null;
if (this.configuration != null) {
targetConfiguration = this.configuration;
if (targetConfiguration.getVariables() == null) {
targetConfiguration.setVariables(this.configurationProperties);
} else if (this.configurationProperties != null) {
targetConfiguration.getVariables().putAll(this.configurationProperties);
}
} else if (this.configLocation != null) {
xmlConfigBuilder = new XMLConfigBuilder(this.configLocation.getInputStream(), null, this.configurationProperties);
targetConfiguration = xmlConfigBuilder.getConfiguration();
} else {
LOGGER.debug(
() -> "Property 'configuration' or 'configLocation' not specified, using default MyBatis Configuration");
targetConfiguration = new Configuration();
Optional.ofNullable(this.configurationProperties).ifPresent(targetConfiguration::setVariables);
}
Optional.ofNullable(this.objectFactory).ifPresent(targetConfiguration::setObjectFactory);
Optional.ofNullable(this.objectWrapperFactory).ifPresent(targetConfiguration::setObjectWrapperFactory);
Optional.ofNullable(this.vfs).ifPresent(targetConfiguration::setVfsImpl);
if (hasLength(this.typeAliasesPackage)) {
scanClasses(this.typeAliasesPackage, this.typeAliasesSuperType).stream()
.filter(clazz -> !clazz.isAnonymousClass()).filter(clazz -> !clazz.isInterface())
.filter(clazz -> !clazz.isMemberClass()).forEach(targetConfiguration.getTypeAliasRegistry()::registerAlias);
}
if (!isEmpty(this.typeAliases)) {
Stream.of(this.typeAliases).forEach(typeAlias -> {
targetConfiguration.getTypeAliasRegistry().registerAlias(typeAlias);
LOGGER.debug(() -> "Registered type alias: '" + typeAlias + "'");
});
}
if (!isEmpty(this.plugins)) {
Stream.of(this.plugins).forEach(plugin -> {
targetConfiguration.addInterceptor(plugin);
LOGGER.debug(() -> "Registered plugin: '" + plugin + "'");
});
}
if (hasLength(this.typeHandlersPackage)) {
scanClasses(this.typeHandlersPackage, TypeHandler.class).stream().filter(clazz -> !clazz.isAnonymousClass())
.filter(clazz -> !clazz.isInterface()).filter(clazz -> !Modifier.isAbstract(clazz.getModifiers()))
.forEach(targetConfiguration.getTypeHandlerRegistry()::register);
}
if (!isEmpty(this.typeHandlers)) {
Stream.of(this.typeHandlers).forEach(typeHandler -> {
targetConfiguration.getTypeHandlerRegistry().register(typeHandler);
LOGGER.debug(() -> "Registered type handler: '" + typeHandler + "'");
});
}
if (!isEmpty(this.scriptingLanguageDrivers)) {
Stream.of(this.scriptingLanguageDrivers).forEach(languageDriver -> {
targetConfiguration.getLanguageRegistry().register(languageDriver);
LOGGER.debug(() -> "Registered scripting language driver: '" + languageDriver + "'");
});
}
Optional.ofNullable(this.defaultScriptingLanguageDriver)
.ifPresent(targetConfiguration::setDefaultScriptingLanguage);
return this.sqlSessionFactoryBuilder.build(targetConfiguration);
}
}
這個配置簡直是太麻煩了，而現在呢，我們只需要配置我們感興趣的，其他的交給MyBatis自己寫的FactoryBean就可以了，現在我們知道了FactoryBean的重要性了吧。