factorybean 聲明_FactoryBean的作用

Spring 中有兩種類型的Bean，一種是普通Bean，另一種是工廠Bean 即 FactoryBean。FactoryBean跟普通Bean不同，其傳回的對象不是指定類的一個執行個體，而是該FactoryBean的getObject方法所傳回的對象。建立出來的對象是否屬于單例由isSingleton中的傳回決定。

後期文章會首發于本專欄，歡迎關注JAVA進階進階​zhuanlan.zhihu.com

一般情況下，Spring通過反射機制利用的class屬性指定實作類執行個體化Bean，在某些情況下，執行個體化Bean過程比較複雜，如果按照傳統的方式，則需要在中提供大量的配置資訊。配置方式的靈活性是受限的，這時采用編碼的方式可能會得到一個簡單的方案。Spring為此提供了一個org.springframework.bean.factory.FactoryBean的工廠類接口，使用者可以通過實作該接口定制執行個體化Bean的邏輯。FactoryBean接口對于Spring架構來說占用重要的地位，Spring自身就提供了70多個FactoryBean的實作。它們隐藏了執行個體化一些複雜Bean的細節，給上層應用帶來了便利。從Spring3.0開始，FactoryBean開始支援泛型，即接口聲明改為FactoryBean的形式

FactoryBean接口定義以Bean結尾，表示它是一個Bean，不同于普通Bean的是：它是實作了FactoryBean接口的Bean，根據該Bean的ID從BeanFactory中擷取的實際上是FactoryBean的getObject()傳回的對象，而不是FactoryBean本身，如果要擷取FactoryBean對象，請在id前面加一個&符号來擷取。

FactoryBean接口定義

package org.springframework.beans.factory;

public interface FactoryBean {

T getObject() throws Exception;

Class> getObjectType();

boolean isSingleton();

}

應用場景

FactoryBean 通常是用來建立比較複雜的bean，一般的bean 直接用xml配置即可，但如果一個bean的建立過程中涉及到很多其他的bean 和複雜的邏輯，用xml配置比較困難，這時可以考慮用FactoryBean。

很多開源項目在內建Spring 時都使用到FactoryBean，比如 MyBatis3 提供 mybatis-spring項目中的 org.mybatis.spring.SqlSessionFactoryBean：

public class SqlSessionFactoryBean implements FactoryBean, InitializingBean, ApplicationListener {

private static final Log LOGGER = LogFactory.getLog(SqlSessionFactoryBean.class);

...

public SqlSessionFactory getObject() throws Exception {

if (this.sqlSessionFactory == null) {

this.afterPropertiesSet();

}

return this.sqlSessionFactory;

}

...

}

下面看一下具體的源碼：

AbstractBeanFactory通過getBean向IoC容器擷取被管理的Bean：

AbstractBeanFactory的getBean相關方法的源碼如下：

protected T doGetBean(String name, Class requiredType, final Object[] args, boolean typeCheckOnly) throws BeansException {

final String beanName = this.transformedBeanName(name);

Object sharedInstance = this.getSingleton(beanName);

Object bean;

if (sharedInstance != null && args == null) {

if (this.logger.isDebugEnabled()) {

if (this.isSingletonCurrentlyInCreation(beanName)) {

this.logger.debug("Returning eagerly cached instance of singleton bean '" + beanName + "' that is not fully initialized yet - a consequence of a circular reference");

} else {

this.logger.debug("Returning cached instance of singleton bean '" + beanName + "'");

}

}

bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, (RootBeanDefinition)null);

} else {

if (this.isPrototypeCurrentlyInCreation(beanName)) {

throw new BeanCurrentlyInCreationException(beanName);

}

BeanFactory parentBeanFactory = this.getParentBeanFactory();

if (parentBeanFactory != null && !this.containsBeanDefinition(beanName)) {

String nameToLookup = this.originalBeanName(name);

if (args != null) {

return parentBeanFactory.getBean(nameToLookup, args);

}

return parentBeanFactory.getBean(nameToLookup, requiredType);

}

if (!typeCheckOnly) {

this.markBeanAsCreated(beanName);

}

try {

final RootBeanDefinition mbd = this.getMergedLocalBeanDefinition(beanName);

this.checkMergedBeanDefinition(mbd, beanName, args);

String[] dependsOn = mbd.getDependsOn();

String[] var11;

if (dependsOn != null) {

var11 = dependsOn;

int var12 = dependsOn.length;

for(int var13 = 0; var13 < var12; ++var13) {

String dependsOnBean = var11[var13];

if (this.isDependent(beanName, dependsOnBean)) {

throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Circular depends-on relationship between '" + beanName + "' and '" + dependsOnBean + "'");

}

this.registerDependentBean(dependsOnBean, beanName);

this.getBean(dependsOnBean);

}

}

if (mbd.isSingleton()) {

sharedInstance = this.getSingleton(beanName, new ObjectFactory() {

public Object getObject() throws BeansException {

try {

return AbstractBeanFactory.this.createBean(beanName, mbd, args);

} catch (BeansException var2) {

AbstractBeanFactory.this.destroySingleton(beanName);

throw var2;

}

}

});

bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, mbd);

} else if (mbd.isPrototype()) {

var11 = null;

Object prototypeInstance;

try {

this.beforePrototypeCreation(beanName);

prototypeInstance = this.createBean(beanName, mbd, args);

} finally {

this.afterPrototypeCreation(beanName);

}

bean = this.getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);

} else {

String scopeName = mbd.getScope();

Scope scope = (Scope)this.scopes.get(scopeName);

if (scope == null) {

throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");

}

try {

Object scopedInstance = scope.get(beanName, new ObjectFactory() {

public Object getObject() throws BeansException {

AbstractBeanFactory.this.beforePrototypeCreation(beanName);

Object var1;

try {

var1 = AbstractBeanFactory.this.createBean(beanName, mbd, args);

} finally {

AbstractBeanFactory.this.afterPrototypeCreation(beanName);

}

return var1;

}

});

bean = this.getObjectForBeanInstance(scopedInstance, name, beanName, mbd);

} catch (IllegalStateException var21) {

throw new BeanCreationException(beanName, "Scope '" + scopeName + "' is not active for the current thread; consider " + "defining a scoped proxy for this bean if you intend to refer to it from a singleton", var21);

}

}

} catch (BeansException var23) {

this.cleanupAfterBeanCreationFailure(beanName);

throw var23;

}

}

if (requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) {

try {

return this.getTypeConverter().convertIfNecessary(bean, requiredType);

} catch (TypeMismatchException var22) {

if (this.logger.isDebugEnabled()) {

this.logger.debug("Failed to convert bean '" + name + "' to required type [" + ClassUtils.getQualifiedName(requiredType) + "]", var22);

}

throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());

}

} else {

return bean;

}

}

我們可以看到，無論是直接取單例的bean，還是建立單例、多例、自定義生命周期的bean，都會經過bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);這個方法，我們現在就來看看這裡到底是做了什麼。

protected Object getObjectForBeanInstance(Object beanInstance, String name, String beanName, RootBeanDefinition mbd) {

if (BeanFactoryUtils.isFactoryDereference(name) && !(beanInstance instanceof FactoryBean)) {

throw new BeanIsNotAFactoryException(this.transformedBeanName(name), beanInstance.getClass());

} else if (beanInstance instanceof FactoryBean && !BeanFactoryUtils.isFactoryDereference(name)) {

Object object = null;

if (mbd == null) {

object = this.getCachedObjectForFactoryBean(beanName);

}

if (object == null) {

FactoryBean> factory = (FactoryBean)beanInstance;

if (mbd == null && this.containsBeanDefinition(beanName)) {

mbd = this.getMergedLocalBeanDefinition(beanName);

}

boolean synthetic = mbd != null && mbd.isSynthetic();

object = this.getObjectFromFactoryBean(factory, beanName, !synthetic);

}

return object;

} else {

return beanInstance;

}

}

這裡有必要單獨說一下解引用：

Dereference(解引用)：一個在C/C++中應用的比較多術語，在C++中，“*”是解引用符号，“&”是引用符号。

解引用：變量所指向的是所引用對象的本身資料，而不是對象的記憶體位址。

上面的代碼可以看到，對于大多數bean的getBean，一般走到第二步就傳回了，也就是說我們建立的Bean對象就是想要的bean，但對于FactoryBean的建立，如果是對記憶體位址的引用，那麼取到的是它生産的bean，而不是它本身。是以我們繼續看怎麼取到生産的對象的：

FactoryBeanRegistrySupport類的getObjectFromFactoryBean方法

protected Object getObjectFromFactoryBean(FactoryBean> factory, String beanName, boolean shouldPostProcess) {

if (factory.isSingleton() && this.containsSingleton(beanName)) {

synchronized(this.getSingletonMutex()) {

Object object = this.factoryBeanObjectCache.get(beanName);

if (object == null) {

object = this.doGetObjectFromFactoryBean(factory, beanName);

Object alreadyThere = this.factoryBeanObjectCache.get(beanName);

if (alreadyThere != null) {

object = alreadyThere;

} else {

if (object != null && shouldPostProcess) {

try {

object = this.postProcessObjectFromFactoryBean(object, beanName);

} catch (Throwable var9) {

throw new BeanCreationException(beanName, "Post-processing of FactoryBean's singleton object failed", var9);

}

}

this.factoryBeanObjectCache.put(beanName, object != null ? object : NULL_OBJECT);

}

}

return object != NULL_OBJECT ? object : null;

}

} else {

Object object = this.doGetObjectFromFactoryBean(factory, beanName);

if (object != null && shouldPostProcess) {

try {

object = this.postProcessObjectFromFactoryBean(object, beanName);

} catch (Throwable var11) {

throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", var11);

}

}

return object;

}

}

doGetObjectFromFactoryBean：

private Object doGetObjectFromFactoryBean(final FactoryBean> factory, String beanName) throws BeanCreationException {

Object object;

try {

if (System.getSecurityManager() != null) {

AccessControlContext acc = this.getAccessControlContext();

try {

object = AccessController.doPrivileged(new PrivilegedExceptionAction() {

public Object run() throws Exception {

return factory.getObject();

}

}, acc);

} catch (PrivilegedActionException var6) {

throw var6.getException();

}

} else {

object = factory.getObject();

}

} catch (FactoryBeanNotInitializedException var7) {

throw new BeanCurrentlyInCreationException(beanName, var7.toString());

} catch (Throwable var8) {

throw new BeanCreationException(beanName, "FactoryBean threw exception on object creation", var8);

}

if (object == null && this.isSingletonCurrentlyInCreation(beanName)) {

throw new BeanCurrentlyInCreationException(beanName, "FactoryBean which is currently in creation returned null from getObject");

} else {

return object;

}

}

第一個方法就是區分單例還是多例，第二個方法是真真的調用getObject的方法獲得FactoryBean生産的對象。從代碼中可以看到，具體産生Bean的地方時這個getObject方法，Spring為這個FactoryBean提供了70多個實作，比如Poxy、JDNI、RMI等等。

我這兒整理了比較全面的JAVA相關的面試資料，

需要領取面試資料的同學，請加群：473984645