用FactoryBean让Spring配置动起来

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

  代码

clearcase/" target="_blank" >cccccc width="90%" align=center bgColor=#e7e9e9 border=1>
/**
* 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>

  就这么简单。

原文转自:http://www.ltesting.net