FactoryBean——Spring的扩展点之一
扫描下方二维码或者微信搜索公众号
菜鸟飞呀飞，便可关注微信公众号，阅读更多Spring源码分析文章html
首先须要说明的是，FactoryBean和BeanFactory虽然名字很像，可是这二者是彻底不一样的两个概念，用途上也是天差地别。BeanFactory是一个Bean工厂，在必定程度上咱们能够简单理解为它就是咱们日常所说的Spring容器(注意这里说的是简单理解为容器)，它完成了Bean的建立、自动装配等过程，存储了建立完成的单例Bean。而FactoryBean经过名字看，咱们能够猜出它是Bean，但它是一个特殊的Bean，究竟有什么特殊之处呢？它的特殊之处在咱们平时开发过程当中又有什么用处呢？java
1. FactoryBean的用法
FactoryBean的特殊之处在于它能够向容器中注册两个Bean，一个是它自己，一个是FactoryBean.getObject()方法返回值所表明的Bean。先经过以下示例代码来感觉下FactoryBean的用处吧。spring
- 自定义一个类CustomerFactoryBean，让它实现了FactoryBean接口，重写了接口中的两个方法，在getObejct()方法中，返回了一个UserService的实例对象；在getObjectType()方法中返回了UserService.class。而后在CustomerFactoryBean添加了注解@Component注解，意思是将CustomerFactoryBean类交给Spring管理。
package com.tiantang.study.component;
import com.tiantang.study.service.UserService;
import org.springframework.beans.factory.FactoryBean;
import org.springframework.stereotype.Component;
@Component
public class CustomerFactoryBean implements FactoryBean<UserService> {
@Override
public UserService getObject() throws Exception {
return new UserService();
}
@Override
public Class<?> getObjectType() {
return UserService.class;
}
}
复制代码
- 定义了一个UserService类，在构造方法中打印了一行日志。
package com.tiantang.study.service;
public class UserService {
public UserService(){
System.out.println("userService construct");
}
}
复制代码
- 定义了一个配置类AppConfig，在类中指明了Spring须要扫描包
com.tiantang.study.component
package com.tiantang.study.config;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
@Configuration
@ComponentScan("com.tiantang.study.component")
public class AppConfig {
}
复制代码
- 启动类
public class MainApplication {
public static void main(String[] args) {
AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);
System.out.println("容器启动完成");
UserService userService = applicationContext.getBean(UserService.class);
System.out.println(userService);
Object customerFactoryBean = applicationContext.getBean("customerFactoryBean");
System.out.println(customerFactoryBean);
}
}
复制代码
- 控制台打印的结果
- 在进行源码分析以前，咱们能够先看下这两个问题：
-
- 在AppConfig类中咱们只扫描了
com.tiantang.study.component这个包下的类，按照咱们的常规理解，这个时候应该只会有CustomerFactoryBean这个类被放进Spring容器中了，UserService并无被扫描。而咱们在测试时却能够经过applicationContext.getBean(UserService.class)从容器中获取到Bean，为何？
- 在AppConfig类中咱们只扫描了
-
- 咱们知道默认状况下，在咱们没有自定义命名策略的状况下，咱们自定义的类被Spring扫描进容器后，Bean在Spring容器中的beanName默认是类名的首字母小写，因此这本次demo中，
CustomerFactoryBean类的单例对象在容器中的beanName是customerFactoryBean。因此这个时候咱们调用方法getBean(beanName)经过beanName去获取Bean，这个时候理论上应该返回的是CustomerFactoryBean类的单例对象。然而，咱们将结果打印出来，却发现，这个对象的hashCode居然和userService对象的hashCode如出一辙，这说明这两个对象是同一个对象，为何会出现这种状况呢？为何不是CustomerFactoryBean类的实例对象呢？
- 咱们知道默认状况下，在咱们没有自定义命名策略的状况下，咱们自定义的类被Spring扫描进容器后，Bean在Spring容器中的beanName默认是类名的首字母小写，因此这本次demo中，
-
- 既然经过customerFactoryBean这个beanName没法获取到CustomerFactoryBean的单例对象，那么应该怎么获取呢？
以上3个问题的答案能够用一个答案解决，那就是FactoryBean是一个特殊的Bean。咱们自定义的CustomerFactoryBean实现了FactoryBean接口，因此当CustomerFactoryBean被扫描进Spring容器时，实际上它向容器中注册了两个bean，一个是CustomerFactoryBean类的单例对象；另一个就是getObject()方法返回的对象，在demo中，咱们重写的getObject()方法中，咱们经过new UserService()返回了一个UserService的实例对象，因此咱们从容器中能获取到UserService的实例对象。若是咱们想经过beanName去获取CustomerFactoryBean的单例对象，须要在beanName前面添加一个
&符号，以下代码，这样就能根据beanName获取到原生对象了。sql
public class MainApplication {
public static void main(String[] args) {
CustomerFactoryBean rawBean = (CustomerFactoryBean) applicationContext.getBean("&customerFactoryBean");
System.out.println(rawBean);
}
}
复制代码
2. FactoryBean的源码
经过上面的示例代码，咱们知道了FactoryBean的做用，也知道该如何使用FactoryBean，那么接下来咱们就经过源码来看看FactoryBean的工做原理。缓存
- 在Spring容器启动阶段，会调用到refresh()方法，在refresh()中有调用了finishBeanFactoryInitialization()方法，最终会调用到beanFactory.preInstantiateSingletons()方法。因此咱们先看下这个方法的源码。（对refresh()方法不太熟悉的朋友，能够去看下笔者的另外两篇文章：Spring源码系列之容器启动流程 ，经过源码看Bean的建立过程）。
public void preInstantiateSingletons() throws BeansException {
// 从容器中获取到全部的beanName
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
for (String beanName : beanNames) {
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
// 在此处会根据beanName判断bean是否是一个FactoryBean，实现了FactoryBean接口的bean，会返回true
// 此时当beanName为customerFactoryBean时，会返回true，会进入到if语句中
if (isFactoryBean(beanName)) {
// 而后经过getBean()方法去获取或者建立单例对象
// 注意：在此处为beanName拼接了一个前缀：FACTORY_BEAN_PREFIX
// FACTORY_BEAN_PREFIX是一个常量字符串，即：&
// 因此在此时容器启动阶段，对于customerFactoryBean，应该是：getBean("&customerFactoryBean")
Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
// 下面这一段逻辑，是判断是否须要在容器启动阶段，就去实例化getObject()返回的对象，便是否调用FactoryBean的getObject()方法
if (bean instanceof FactoryBean) {
final FactoryBean<?> factory = (FactoryBean<?>) bean;
boolean isEagerInit;
if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
((SmartFactoryBean<?>) factory)::isEagerInit,
getAccessControlContext());
}
else {
isEagerInit = (factory instanceof SmartFactoryBean &&
((SmartFactoryBean<?>) factory).isEagerInit());
}
if (isEagerInit) {
getBean(beanName);
}
}
}
}
}
}
复制代码
- 在容器启动阶段，会先经过getBean()方法来建立CustomerFactoryBean的实例对象。若是实现了SmartFactoryBean接口，且isEagerInit()方法返回的是true，那么在容器启动阶段，就会调用getObject()方法，向容器中注册getObject()方法返回值的对象。不然，只有当第一次获取getObject()返回值的对象时，才会去回调getObject()方法。
- 在getBean()中会调用到doGetBean()方法，下面为doGetBean()精简后的源码。从源码中咱们发现，最终都会调用getObjectForBeanInstance()方法。
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType, @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
final String beanName = transformedBeanName(name);
Object bean;
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
else {
if (mbd.isSingleton()) {
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
else if (mbd.isPrototype()) {
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
else {
bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
}
}
return (T) bean;
}
复制代码
- 在getObjectForBeanInstance()方法中会先判断bean是否是FactoryBean，若是不是，就直接返回Bean。若是是FactoryBean，且name是以&符号开头，那么表示的是获取FactoryBean的原生对象，也会直接返回。若是name不是以&符号开头，那么表示要获取FactoryBean中getObject()方法返回的对象。会先尝试从FactoryBeanRegistrySupport类的factoryBeanObjectCache这个缓存map中获取，若是缓存中存在，则返回，若是不存在，则去调用getObjectFromFactoryBean()方法。getObjectForBeanInstance()方法的部分源码以下：
protected Object getObjectForBeanInstance( Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {
if (BeanFactoryUtils.isFactoryDereference(name)) {
if (beanInstance instanceof NullBean) {
return beanInstance;
}
if (!(beanInstance instanceof FactoryBean)) {
throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass());
}
}
// 若是bean不是factoryBean，那么会直接返回Bean
// 或者bean是factoryBean但name是以&特殊符号开头的,此时表示要获取FactoryBean的原生对象。
// 例如：若是name = &customerFactoryBean，那么此时会返回CustomerFactoryBean类型的bean
if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
return beanInstance;
}
// 若是是FactoryBean，那么先从cache中获取，若是缓存不存在，则会去调用FactoryBean的getObject()方法。
Object object = null;
if (mbd == null) {
// 从缓存中获取。何时放入缓存的呢？在第一次调用getObject()方法时，会将返回值放入到缓存。
object = getCachedObjectForFactoryBean(beanName);
}
if (object == null) {
FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
if (mbd == null && containsBeanDefinition(beanName)) {
mbd = getMergedLocalBeanDefinition(beanName);
}
boolean synthetic = (mbd != null && mbd.isSynthetic());
// 在getObjectFromFactoryBean()方法中最终会调用到getObject()方法
object = getObjectFromFactoryBean(factory, beanName, !synthetic);
}
return object;
}
复制代码
- getObjectFromFactoryBean()方法中，主要是经过调用doGetObjectFromFactoryBean()方法获得bean，而后对bean进行处理，最后放入缓存。并且还会针对单例bean和非单例bean作区分处理，对于单例bean，会在建立完后，将其放入到缓存中，非单例bean则不会放入缓存，而是每次都会从新建立。
protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
// 若是BeanFactory的isSingleton()方法返回值是true,表示getObject()返回值对象是单例的
if (factory.isSingleton() && containsSingleton(beanName)) {
synchronized (getSingletonMutex()) {
// 再一次判断缓存中是否存在。(双重检测机制，和平时写线程安全的代码相似)
Object object = this.factoryBeanObjectCache.get(beanName);
if (object == null) {
// 在doGetObjectFromFactoryBean()中才是真正调用getObject()方法
object = doGetObjectFromFactoryBean(factory, beanName);
Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
if (alreadyThere != null) {
object = alreadyThere;
}
else {
// 下面是进行后置处理，和普通的bean的后置处理没有任何区别
if (shouldPostProcess) {
if (isSingletonCurrentlyInCreation(beanName)) {
return object;
}
beforeSingletonCreation(beanName);
try {
object = postProcessObjectFromFactoryBean(object, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(beanName,
"Post-processing of FactoryBean's singleton object failed", ex);
}
finally {
afterSingletonCreation(beanName);
}
}
// 放入到缓存中
if (containsSingleton(beanName)) {
this.factoryBeanObjectCache.put(beanName, object);
}
}
}
return object;
}
}
// 非单例
else {
Object object = doGetObjectFromFactoryBean(factory, beanName);
if (shouldPostProcess) {
try {
object = postProcessObjectFromFactoryBean(object, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex);
}
}
return object;
}
}
复制代码
- doGetObjectFromFactoryBean()方法的逻辑比较简单，直接调用了FactoryBean的getObject()方法。部分源码以下
private Object doGetObjectFromFactoryBean(final FactoryBean<?> factory, final String beanName) throws BeanCreationException {
Object object;
if (System.getSecurityManager() != null) {
AccessControlContext acc = getAccessControlContext();
try {
object = AccessController.doPrivileged((PrivilegedExceptionAction<Object>) factory::getObject, acc);
}
catch (PrivilegedActionException pae) {
throw pae.getException();
}
}
else {
// 调用getObject()方法
object = factory.getObject();
}
return object;
}
复制代码
- Spring的代码实在是写的太好了，每一个方法几乎都复用性比较高，这就致使了老是方法中套方法，层级比较深，因此最后以一张流程图总结下FactoryBean的建立流程。
- 看完这一段的源码分析，这个时候能理解demo中打印结果了吧。
3. FactoryBean的应用场景——Spring-Mybatis插件原理
如今知道了FactoryBean的原理，那么在平时工做中，你见过哪些FactoryBean的使用场景。若是没有留意过的话，笔者在这里就拿Spring整合Mybatis的原理来举例吧。安全
- 咱们能够先回忆一下，单独使用Mybatis时，咱们须要作哪些工做。添加依赖，配置数据源，建立SqlSessionFactory，这样环境就搭建完成了。(若是有朋友记忆比较模糊的话，能够参考下官方文档：mybatis.org/mybatis-3/g…)。
- 当咱们在将Mybatis整合到Spring中时，也是添加mybatis的依赖，但还须要额外添加一个jar包：
mybatis-spring，而后是配置数据源。最后还须要一个配置，若是你是经过XML配置的话，还须要以下配置：
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="dataSource" />
</bean>
复制代码
- 若是你不是经过JavaConfig配置，那么须要进行以下配置：
@Bean
public SqlSessionFactoryBean sqlSessionFactoryBean(DataSource dataSource){
SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
sqlSessionFactoryBean.setDataSource(dataSource);
return sqlSessionFactoryBean;
}
复制代码
- 咱们发现，不管是XML仍是JavaConfig，都是向容器中注册了一个SqlSessionFactoryBean。从类名咱们就能知道这是一个FactoryBean。当咱们单独使用Mybatis时，须要建立一个SqlSessionFactory，然而当MyBatis和Spring整合时，却须要一个SqlSessionFactoryBean，因此咱们能够猜想，是否是SqlSessionFactoryBean经过FactoryBean的特殊性，向Spring容器中注册了一个SqlSessionFactory。查看SqlSessionFactoryBean的源代码发现，它果真实现了FactoryBean接口，而且重写了getObejct方法，经过getObject()方法向容器中注册了一个SqlSessionFactory。
public class SqlSessionFactoryBean implements FactoryBean<SqlSessionFactory>, InitializingBean, ApplicationListener<ApplicationEvent> {
// ...省略其余代码
public SqlSessionFactory getObject() throws Exception {
if (this.sqlSessionFactory == null) {
afterPropertiesSet();
}
return this.sqlSessionFactory;
}
}
复制代码
- sqlSessionFactory是SqlSessionFactoryBean的一个属性，它的赋值是在经过回调afterPropertiesSet()方法进行的。（由于SqlSessionFactoryBean实现了InitializingBean接口，因此在Spring初始化Bean的时候，能回调afterPropertiesSet()方法）
public void afterPropertiesSet() throws Exception {
// buildSqlSessionFactory()方法会根据mybatis的配置进行初始化。
this.sqlSessionFactory = buildSqlSessionFactory();
}
复制代码
- 在Spring和MyBatis整合时，还有另一个地方也利用到了FactoryBean。咱们在开发时，一般会经过MapperScan注解来扫描咱们Mapper文件。MapperScan注解中，添加了Import(MapperScannerRegistrar.class)，(关于Import注解的做用，能够看下笔者的另外一篇文章：mp.weixin.qq.com/s/y_2Z9m0ge…)
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Import(MapperScannerRegistrar.class)
public @interface MapperScan {
}
复制代码
- 在MapperScannerRegistrar的registerBeanDefinitions()方法中，会将咱们定义的Mapper扫描出来，解析成BeanDefinition，注意，解析成BeanDefinition后，beanClass属性再也不是咱们定义的Mapper类的class了，而是被设置成了MapperFactoryBean.class。这说明了咱们定义的每个Mapper接口，被加载进Spring后，最后都会对应一个MapperFactoryBean。
- 咱们再看看MapperFactoryBean这个类干了哪些事。下面是MapperFactoryBean类的部分源码。从源码中，咱们发现，它实现了FactoryBean接口，重写了接口中的三个方法。在getObject()方法中，经过调用
getSqlSession().getMapper(this.mapperInterface)返回了一个对象。这一行代码最终会调用到MapperProxyFactory的newInstance()方法，为每个Mapper建立一个代理对象。
public class MapperFactoryBean<T> extends SqlSessionDaoSupport implements FactoryBean<T> {
@Override
public T getObject() throws Exception {
return getSqlSession().getMapper(this.mapperInterface);
}
@Override
public Class<T> getObjectType() {
return this.mapperInterface;
}
@Override
public boolean isSingleton() {
// 返回true是为了让Mapper接口是一个单例的
return true;
}
}
复制代码
- MapperProxyFactory类的源码。最终是调用JDK的动态代理来为咱们定义的Mapper建立动态代理。(MyBatis框架就是经过动态代理实现的dao层)
public class MapperProxyFactory<T> {
protected T newInstance(MapperProxy<T> mapperProxy) {
// JDK动态代理
return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
}
public T newInstance(SqlSession sqlSession) {
final MapperProxy<T> mapperProxy = new MapperProxy<T>(sqlSession, mapperInterface, methodCache);
return newInstance(mapperProxy);
}
}
复制代码
- 这样咱们写的每个Mapper接口都会对应一个MapperFactoryBean，每个MapperFactoryBean的getObject()方法最终会采用JDK动态代理建立一个对象，因此每个Mapper接口最后都对应一个代理对象，这样就实现了Spring和MyBatis的整合。
4. mybatis-spring-boot-starter原理
在SpringBoot中整合MyBatis的原理是同样的，虽然使用的是mybatis-spring-boot-starter这个依赖，但最终的整合原理和Spring是如出一辙的。SpringBoot的最主要的功能是自动配置，和其余框架的整合原理与Spring相比几乎没变。微信
- mybatis-spring-boot-starter中，会引入mybatis-spring-boot-autoconfigure这个jar包，MyBatis的自动配置就是经过这个jar包中的MybatisAutoConfiguration类实现的。从MybatisAutoConfiguration的源码中咱们能够看到一样是经过SqlSessionFactoryBean的getObject()方法向容器中注册了一个SqlSessionBean。
@Configuration
@ConditionalOnClass({SqlSessionFactory.class, SqlSessionFactoryBean.class})
@ConditionalOnBean({DataSource.class})
@EnableConfigurationProperties({MybatisProperties.class})
@AutoConfigureAfter({DataSourceAutoConfiguration.class})
public class MybatisAutoConfiguration {
@Bean
@ConditionalOnMissingBean
public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception {
SqlSessionFactoryBean factory = new SqlSessionFactoryBean();
factory.setDataSource(dataSource);
// 省略部分代码
return factory.getObject();
}
}
复制代码
5. 总结
- 本文主要介绍了FactoryBean的做用以及使用场景。先经过demo演示了FactoryBean的用法，而后结合Spring源码分析了FactoryBean的原理。
- 接着经过源码分析了FactoryBean在Spring和MyBatis整合过程当中扮演的重要角色。一是提供一个SqlSessionFactory，二是为每个Mapper建立JDK动态代理对象。
- 最后经过一小段源码分析了SpringBoot中整合Mybatis的原理。其实和Spring整合MyBatis的原理如出一辙，因此重点是仍是Spring的源码理解。
6. 猜你喜欢
- 经过源码看Bean的建立过程
- Spring源码系列之容器启动流程
- Spring中最！最！最！重要的后置处理器！没有之一！！！
- @Import和@EnableXXX
- 手写一个Redis和Spring整合的插件
- 为何JDK的动态代理要基于接口实现而不能基于继承实现？
扫描下方二维码便可关注微信公众号
菜鸟飞呀飞，一块儿阅读更多Spring源码。mybatis
相关文章
- 1. Spring扩展点之FactoryBean接口
- 2. spring的扩展点（一）
- 3. Spring官网阅读系列（七）：容器的扩展点（FactoryBean）
- 4. Spring官网阅读（七）容器的扩展点（二）FactoryBean
- 5. Spring扩展点之BeanPostProcessor
- 6. Spring扩展点之BeanFactoryPostProcessor
- 7. spring-扩展点-BeanFactoryPostProcessor
- 8. SpringBoot扩展点之一：SpringApplicationRunListener
- 9. Spring系列之FactoryBean（一）
- 10. Spring之FactoryBean
- 更多相关文章...
- • Kotlin 扩展 - Kotlin 教程
- • Swift 扩展 - Swift 教程
- • 互联网组织的未来：剖析GitHub员工的任性之源
- • Spring Cloud 微服务实战(三) - 服务注册与发现
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
- 1. 字节跳动21届秋招运营两轮面试经验分享
- 2. Java 3 年，25K 多吗？
- 3. mysql安装部署
- 4. web前端开发中父链和子链方式实现通信
- 5. 3.1.6 spark体系之分布式计算-scala编程-scala中trait特性
- 6. dataframe2
- 7. ThinkFree在线
- 8. 在线画图
- 9. devtools热部署
- 10. 编译和链接
欢迎关注本站公众号,获取更多信息
相关文章
- 1. Spring扩展点之FactoryBean接口
- 2. spring的扩展点（一）
- 3. Spring官网阅读系列（七）：容器的扩展点（FactoryBean）
- 4. Spring官网阅读（七）容器的扩展点（二）FactoryBean
- 5. Spring扩展点之BeanPostProcessor
- 6. Spring扩展点之BeanFactoryPostProcessor
- 7. spring-扩展点-BeanFactoryPostProcessor
- 8. SpringBoot扩展点之一：SpringApplicationRunListener
- 9. Spring系列之FactoryBean（一）
- 10. Spring之FactoryBean