Spring中的FactoryBean

转自：http://www.01yun.com/Java/20130429/387009.html

Spring中的FactoryBean

1、概述

Spring中有两种类型的Bean：一种是普通的JavaBean；另一种就是工厂Bean（FactoryBean），这两种Bean都受Spring的IoC容器管理，但它们之间却有一些区别。

2、详述

普通的JavaBean不再多说，我们将其定义好，然后在配置文件中定义并配置其依赖关系，就可以通过IoC容器的getBean获取到。

那么FactoryBean呢？

FactoryBean跟普通Bean不同，通过BeanFactory类的getBean方法直接获取到的并不是该FactoryBean的实例，而是该FactoryBean中方法getObject返回的对象。但我们可以通过其它途径获取到该FactoryBean的实例，方法就是在通过getBean方法获取实例时在参数name前面加上“&”符号即可，比如com.zyh.spring3.hello.MyFactoryBean类是一个工厂Bean，其定义如下：

如果我们使用beanFactory.getBean("myFactoryBean")获取Bean实例，获取到的将是MyFactoryBean类中定义的getObject方法返回的对象；但是如果我们使用beanFactory.getBean("&myFactoryBean")方法获取到的却是MyFactoryBean类的实例。

这个获取工厂Bean实例的前缀符号定义在BeanFactory接口中，如下所示：package org.springframework.beans.factory;

import org.springframework.beans.BeansException;

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

* myJndiObject is a FactoryBean, getting &myJndiObject

* will return the factory, not the instance returned by the factory.

*/

String FACTORY_BEAN_PREFIX = "&";

Object getBean(String name) throws BeansException;

// 省略其它一些代码

}

自定义FactoryBean需要实现Spring定义的FactoryBean接口。

3、示例

下面以一个小例子来验证。

1、定义一个FactoryBean

package com.zyh.spring3.hello;

import java.util.Date;

import org.springframework.beans.factory.BeanNameAware;

import org.springframework.beans.factory.FactoryBean;

public class MyFactoryBean implements FactoryBean,BeanNameAware {

private String name;

@Override

public Date getObject() throws Exception {

return new Date();

}

@Override

public Class<> getObjectType() {

return Date.class;

}

@Override

public boolean isSingleton() {

return false;

}

public void sayName() {

System.out.println("My name is " + this.name);

}

@Override

public void setBeanName(String name) {

this.name = name;

}

}

2、在XML文件中配置

3、写个测试方法

@Test

public void testFactoryBean() {

DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();

beanFactory.addBeanPostProcessor(new MyInstantiationAwareBeanPostProcessor());

Resource resource = new ClassPathResource("helloworld.xml");

XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(beanFactory);

reader.loadBeanDefinitions(resource);

Date now = (Date) beanFactory.getBean("myFactoryBean");

System.out.println(now);

MyFactoryBean factoryBean = (MyFactoryBean) beanFactory.getBean("&myFactoryBean");

factoryBean.sayName();

}则可以看到程序正常，且输出内容为：

Tue Oct 23 18:37:29 CST 2012

My name is myFactoryBean

4、源码分析

下面从源码的角度分析一下FactoryBean的实现原理。

首先看一下默认IoC容器DefaultListableBeanFactory的继承关系图和FactoryBean的getObject方法最终被调用的方法调用关系图：

继承关系：

调用关系：

其实FactoryBean对于IoC容器来说与普通的JavaBean也是没什么区别的，同样在容器的管理之下，配置上也没什么区别，唯一不同的就是FactoryBean需要实现Spring定义的FactoryBean接口，并实现其中的getObject方法。既然没什么不同，那也就说明FactoryBean实例其实也是在IoC容器中，只不过我们在获取目标Bean的时候需要判断是返回FactoryBean本身还是调用其getObject方法，将其返回对象返回，这里用作判断的依据就是&符号。

1、getBean方法

我们通过getBean(String name)方法获取Bean的时候，其实调用的是抽象IoC容器AbstractBeanFacotry中的getBean方法，源码如下（去掉了一些无关紧要的代码）：

public Object getBean(String name) throws BeansException {

return doGetBean(name, null, null, false);

}

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

throws BeansException {

final String beanName = transformedBeanName(name);

Object bean;

// Eagerly check singleton cache for manually registered singletons.

Object sharedInstance = getSingleton(beanName);

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

if (logger.isDebugEnabled()) {

// 省略日志代码

}

bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);

} else {

// 省略部分代码

// Create bean instance.

if (mbd.isSingleton()) {

sharedInstance = getSingleton(beanName, new ObjectFactory() {

public Object getObject() throws BeansException {

try {

return createBean(beanName, mbd, args);

} catch (BeansException ex) {

// catch code

}

}

});

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

} else if (mbd.isPrototype()) {

// It's a prototype -> create a new instance.

Object prototypeInstance = null;

try {

beforePrototypeCreation(beanName);

prototypeInstance = createBean(beanName, mbd, args);

} finally {

afterPrototypeCreation(beanName);

}

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

} else {

String scopeName = mbd.getScope();

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

if (scope == null) {

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

}

try {

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

public Object getObject() throws BeansException {

beforePrototypeCreation(beanName);

try {

return createBean(beanName, mbd, args);

} finally {

afterPrototypeCreation(beanName);

}

}

});

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

} catch (IllegalStateException ex) {

// 省略部分代码

}

}

}

// 省略部分代码

return (T) bean;

}

上面的代码中，首先调用了一个方法transformedBeanName，并以name为参数，其实这个方法中又调用了另外的方法最终调用到BeanFactoryUtils中的工具方法transformedBeanName，这个方法的作用是将判断name是否含有&符号，如果有则将其去掉并将结果返回。由此可见，即使我们传入带有&符号的name最终一样会将其去掉，&不过是个标志。

protected String transformedBeanName(String name) {

return canonicalName(BeanFactoryUtils.transformedBeanName(name));

}

// BeanFactoryUtils中的工具方法transformedBeanName

public static String transformedBeanName(String name) {

Assert.notNull(name, "'name' must not be null");

String beanName = name;

while (beanName.startsWith(BeanFactory.FACTORY_BEAN_PREFIX)) {

beanName = beanName.substring(BeanFactory.FACTORY_BEAN_PREFIX.length());

}

return beanName;

}

对参数name处理后，程序拿着处理结果（可能是去掉&符号或未作处理的name，此时改称beanName）去IoC容器查找目标Bean（也可能是新创建Bean实例），得到的Bean则有可能是普通的JavaBean也可能是FactoryBean，然后进入到下一步处理。

2、getObjectForBeanInstance方法

由上面两段代码可以看到，不论是何种情况，程序最终会调用到getObjectForBeanInstance这个方法，而这个方法同样是定义在AbstractBeanFactory这个抽象容器类中：protected Object getObjectForBeanInstance(Object beanInstance, String name, String beanName, RootBeanDefinition mbd) {

// Don't let calling code try to dereference the factory if the bean isn't a factory.

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

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

}

// Now we have the bean instance, which may be a normal bean or a FactoryBean.

// If it's a FactoryBean, we use it to create a bean instance, unless the

// caller actually wants a reference to the factory.

// 如果这里不是对FactoryBean的调用(不是FactoryBean或者beanName是以&开头表示取FactoryBean实例)，则结束处理，直接返回

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

return beanInstance;

}

Object object = null;

if (mbd == null) {

object = getCachedObjectForFactoryBean(beanName);

}

if (object == null) {

// Return bean instance from factory.

FactoryBean<> factory = (FactoryBean<>) beanInstance;

// Caches object obtained from FactoryBean if it is a singleton.

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

mbd = getMergedLocalBeanDefinition(beanName);

}

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

// 这里从FactoryBean中得到最终的Bean

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

}

return object;

}上面这段代码显示，如果判断当前得到的Bean不是FactoryBean或者通过getBean方法传进来的name是以&开头，则直接返回当前得到的Bean。也就是说如果我们以getBean("&beanName")方法来获取FactoryBean的实例，在此就直接返回了，其中BeanFactoryUtils.isFactoryDereference(name)方法用来判断我们传入的name是否以&符号开头，该方法定义如下：

public static boolean isFactoryDereference(String name) {

return (name != null && name.startsWith(BeanFactory.FACTORY_BEAN_PREFIX));

}

如果该Bean是FactoryBean实例并且我们的目标不是获取FactoryBean的实例，而是要获取该FactoryBean通过getObject方法生成的对象，则继续往下处理，程序进入到getObjectFromFactoryBean(factory, beanName, !synthetic)方法。

3、getObjectFromFactoryBean方法

getObjectFromFactoryBean方法定义在IoC容器的父类FactoryBeanRegistrySupport中，在该方法执行过程中，随后又调用了同类中的doGetObjectFromFactoryBean这个具体处理方法，其定义如下：

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

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

synchronized (getSingletonMutex()) {

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

if (object == null) {

object = doGetObjectFromFactoryBean(factory, beanName, shouldPostProcess);

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

}

return (object != NULL_OBJECT object : null);

}

}

else {

return doGetObjectFromFactoryBean(factory, beanName, shouldPostProcess);

}

}

private Object doGetObjectFromFactoryBean(final FactoryBean factory, final String beanName, final boolean shouldPostProcess)

throws BeanCreationException {

Object object;

try {

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

AccessControlContext acc = getAccessControlContext();

try {

object = AccessController.doPrivileged(new PrivilegedExceptionAction() {

public Object run() throws Exception {

return factory.getObject();

}

}, acc);

} catch (PrivilegedActionException pae) {

throw pae.getException();

}

} else {

object = factory.getObject(); // 这里调用的就是FactoryBean接口中的getObject方法

}

}

// 省略部分catch语句及其后续处理语句

return object;

}

这里返回的已经是作为工厂的FactoryBean生产的产品了，而不再是FactoryBean本身了。

4、源码分析总结

从上面几段Spring源码分析可以得知，Spring首先对传入getBean方法的参数name作处理，如果带有&符号，则将其去掉，否则什么也不做。然后通过处理后的name得到Bean的实例（从缓存中获取或者直接创建），该实例可能是普通的JavaBean实例也可能是FactoryBean实例，此时我们会分析处理前的name是否有&符号及该Bean是否为FactoryBean，有以下可能的处理分支：

A、如果处理前的name带有&前缀(表示要取FactoryBean的实例而非其getObject方法返回的对象)或者当前得到的实例并非FactoryBean实例，则在得到Bean实例后直接返回；

B、剩下的情况就是处理前的name不带有&符号，并且当前取得的Bean是FactoryBean实例，那么去调用该FactoryBean的getObject方法，并将得到的对象返回。

Spring很大，并且越来越大，我要慢慢地啃...

转载请保留出处：http://www.01yun.com/Java/20130429/387009.html