使用 FactoryBean 让你的 spring 配置动起来

看到不少朋友讨论 spring 配置时认为 spring 配置中只能静态的设置一些参数(典型情况如数据库配置, 定时器配置等)导致不方便, 其实 spring 已经提供了非常便利的方式来实现动态配置, 我们要做的只是实现一个自己的 FactoryBean , 来看一下 FactoryBean 接口的定义

/**
 * Interface to be implemented by objects used within a BeanFactory
 * that are themselves factories. If a bean implements this interface,
 * it is used as a factory, not directly as a bean.
 *
 * <p><b>NB: A bean that implements this interface cannot be used
 * as a normal bean.</b> A FactoryBean is defined in a bean style,
 * but the object exposed for bean references is always the object
 * that it creates.
 *
 * <p>FactoryBeans can support singletons and prototypes, and can
 * either create objects lazily on demand or eagerly on startup.
 *
 * <p>This interface is heavily used within the framework, for
 * example for the AOP ProxyFactoryBean or JndiObjectFactoryBean.
 * It can be used for application components, but this is not common
 * outside of infrastructure code.
 *
 * @author Rod Johnson
 * @author Juergen Hoeller
 * @since 08.03.2003
 * @see org.springframework.beans.factory.BeanFactory
 * @see org.springframework.aop.framework.ProxyFactoryBean
 * @see org.springframework.jndi.JndiObjectFactoryBean
 */
public interface FactoryBean {

	/**
	 * Return an instance (possibly shared or independent) of the object
	 * managed by this factory. As with a BeanFactory, this allows
	 * support for both the Singleton and Prototype design pattern.
	 * <p>If this method returns <code>null</code>, the factory will consider
	 * the FactoryBean as not fully initialized and throw a corresponding
	 * FactoryBeanNotInitializedException.
	 * @return an instance of the bean (should not be <code>null</code>;
	 * a <code>null</code> value will be considered as an indication of
	 * incomplete initialization)
	 * @throws Exception in case of creation errors
	 * @see FactoryBeanNotInitializedException
	 */
	Object getObject() throws Exception;

	/**
	 * Return the type of object that this FactoryBean creates, or <code>null</code>
	 * if not known in advance. This allows to check for specific types
	 * of beans without instantiating objects, for example on autowiring.
	 * <p>For a singleton, this should try to avoid singleton creation
	 * as far as possible; it should rather estimate the type in advance.
	 * For prototypes, returning a meaningful type here is advisable too.
	 * <p>This method can be called <i>before</i> this FactoryBean has
	 * been fully initialized. It must not rely on state created during
	 * initialization; of course, it can still use such state if available.
	 * <p><b>NOTE:</b> Autowiring will simply ignore FactoryBeans that return
	 * <code>null</code> here. Therefore it is highly recommended to implement
	 * this method properly, using the current state of the FactoryBean.
	 * @return the type of object that this FactoryBean creates,
	 * or <code>null</code> if not known at the time of the call
	 * @see ListableBeanFactory#getBeansOfType
	 */
	Class getObjectType();

	/**
	 * Is the bean managed by this factory a singleton or a prototype?
	 * That is, will <code>getObject()</code> always return the same object
	 * (a reference that can be cached)?
	 * <p><b>NOTE:</b> If a FactoryBean indicates to hold a singleton object,
	 * the object returned from <code>getObject()</code> might get cached
	 * by the owning BeanFactory. Hence, do not return <code>true</code>
	 * unless the FactoryBean always exposes the same reference.
	 * <p>The singleton status of the FactoryBean itself will generally
	 * be provided by the owning BeanFactory; usually, it has to be
	 * defined as singleton there.
	 * @return if this bean is a singleton
	 * @see #getObject()
	 */
	boolean isSingleton();

}

看了以后发现, FactoryBean 用于在 spring 容器中创建其他的 Bean, 我们平时用得最多的 JndiObjectFactoryBean, hibernate 的 LocalSessionFactoryBean 都是 FactoryBean 的具体实现, 既然如此, 读取动态配置就变得易如反掌了, 假如我们要实现动态读取数据库配置的功能, 拿使用率最高的 BasicDatasource 为例, 简单的实现一个  BasicDatasource FactoryBean 如下即可

public class BasicDataSourceFactoryBean implements FactoryBean {

	public Object getObject() throws Exception {
		BasicDataSource dataSource = new BasicDataSource();
		
		// 读取外部配置, 设置到 dataSource 中 ...
		
		return dataSource;
	}

	public Class getObjectType() {
		return BasicDataSource.class;
	}

	public boolean isSingleton() {
		return true;
	}

}

然后在 spring 中如此声明

<bean id="dataSource" class="BasicDataSourceFactoryBean ">
   ... 你的配置来源
</bean> 

就这么简单

自己定义FactoryBean！要求其对外接口一致，且其重用性强！
多数情况下，非较模块化的功能，不会自己定义FactoryBean！
松散的结构（非高内聚）频繁使用FB，会导致注入泛滥！难以管理！
一般情况下，好像FactoryBean多用于框架！

另，对于未纳入spring的framework而言，可以被轻松并入spring管理，做一个独一无二的生产管理者！

org.springframework.aop.target.dynamic.AbstractRefreshableTargetSource;
org.springframework.aop.target.HotSwappableTargetSource;

和标题比较匹配的应该是BeanFactoryPostProcessor和BeanPostProcessor

这是两个很大很大的Aspect，一切尽在掌握。。。

没有看明白,// 读取外部配置, 设置到 dataSource 中 ...,这和在spring中创建一个bean时配置属性有什么不同啊？通过设置一个BasicDataSource ，再refbean不可以吗？

通常的设置方式是这样

	<bean id="system.datasource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
		<property name="driverClassName" value="${jdbc.driverClassName}" />
		<property name="url" value="${jdbc.url}"/>
		<property name="username" value="${jdbc.username}"/>
		<property name="password" value="${jdbc.password}"/>
	</bean>

虽然可以从 properties 等文件读取, 但还是有一定的局限性, 使用 FactoryBean 可以从任意来源读取, 当然这只是个示例，　一般数据库的配置都是固定的，　只是为了说明这种用法

简单易懂!

还是没有体会到楼主的深意啊，惭愧。

要把某某框架与Spring集成的时候就很依赖FactoryBean，比如要读入JBossRules的规则文件，生成一个RuleBase,就可以用FB返回一个RuleBase，而JBoss Seam中貌似没有类似机制，只好自己又包了一个叫org...seam.RuleBase的物体。

好文章，解决了我的一个历史问题

我希望jms动态的读取值设定jmsListenerContainer的messageSelector属性（因为系统登录者是无法事先确定的）
我原先是用一个丑陋的静态方法作为bean的属性的来源，在代码里设定值以后，然后再刷新spingContext

但还不知道能否在spring配置文件里写条件表达式启动时动态设值，可以做到像rails那样简单的设定一个环境变量从而启动不同的运行配置环境，博主请指教。