Spring揭秘读书笔记三 bean的scope与FactoryBean

本书可作为王富强所著<<Spring揭秘>>一书的读书笔记

第四章 BeanFactory的xml之旅

bean的scope

scope有时被翻译为"作用域",scope用来声明容器中的对象所应该处的限定场景或者说该对象的存活时间，即容器在对象进入其相应的scope之前，生成并装配这些对象，在该对象不再处于这些scope的限定之后，容器通常会销毁这些对象。

scope共有5个,singleton,prototype,request,session,global session

前两个是通用的,中间三个只是在web系统中才才用到,最后一个global session只有应用在基于portlet的Web应用程序中才有意义，它映射到portlet的global范围的session。

我们可以通过使用<bean>的singleton或者scope属性来指定相应对象的scope，其中，scope属性只能在 SD格式的文档声明中使用，类似于如下代码所演示的形式：

DTD:

<bean id="mockObject1" class="...MockBusinessObject" singleton="false"/>

XSD:

<bean id="mockObject2" class="...MockBusinessObject" scope="prototype"/>

singleton

singleton:容器中只有一个对象,谁要都是这个一个。只有容器不销毁或者退出,她就一直存在。

配置情况,因为scope默认的就是singleton,下面三种方式效果一样。



<bean id="mockObject1" class="...MockBusinessObject"/>



<bean id="mockObject1" class="...MockBusinessObject" singleton="true"/>



< bean id="mockObject1" class="...MockBusinessObject" scope="singleton"/>

prototype

prototype:每次请求都是一个新的对象。而且,一旦这个新的对象给了请求方,那么容器就不在持有对这个对象的引用。就像嫁出去的姑娘,泼出去的水,娘家以后不管了。

配置方式:



<bean id="mockObject1" class="...MockBusinessObject" singleton="false"/>



<bean id="mockObject1" class="...MockBusinessObject" scope="prototype"/>

request

request:和prototype没什么区别,在web情况下每来一个请求,分配一个实例。

配置方式

<bean id="requestProcessor" class="...RequestProcessor" scope="request"/>

session

session:对于放到session中的信息,可以将scope设置为session,它除了比request更长的存活时间外,其他方面没什么区别。

配置方式:

<bean id="userPreferences" class="com.foo.UserPreferences" scope="session"/>

工厂方法与FactoryBean

我们看下面的代码:

public class Foo
{
  private BarInterface barInstance;
  public Foo()    {
     // 我们应该避免这样做
     // instance = new BarInterfaceImpl();
  }
  // ...
}

为什么要避免这么做?

因为接口与实现类之间有了耦合。

有了耦合咋了,为什么就不能有耦合。

如果我不想用BarInterfaceImpl,先换成Bar2InterfaceImpl。

上面的方法就是得改Foo类的编码,如果n个类中都有instance = new BarInterfaceImpl(); 那么我岂不是得要改n处。

另一方面,如果实现类(例如barInstance)是来自外部jar包的,你没办法把它纳入spring的管理范围,哪有如何?

为之奈何?

工厂方法

public class Foo { 

  private BarInterface barInterface;
  public Foo() {
    // barInterface = BarInterfaceFactory.getInstance();
    // 或者
    // barInterface = new BarInterfaceFactory().getInstance();
  }
   ...
}

这样一来,Foo直接依赖于BarInterfaceFactory。如果产品有了变化,我只用改工厂,而不用"告诉"每一个使用者产品改变了。

静态工厂方式

public class StaticBarInterfaceFactory {
  public static BarInterface getInstance()   {
   return new BarInterfaceImpl();
  }
}

Foo中的BarInterface有对应的get/set方法。

要想通过静态工厂把BarInterfaceImpl注入到Foo中,我们可以这样

xml如下:

<bean id="foo" class="...Foo">
  <property name="barInterface">
   <ref bean="bar"/>
  </property>
</bean> 

<bean id="bar" class="...StaticBarInterfaceFactory" factory-method="getInstance"/>

bean中有了factory-method,就说明这个类并不是使用默认的构造方法产生的,而是使用getInstance方法。再换句话说,bar这个bean最后的返回不是StaticBarInterfaceFactory,而是getInstance这个方法的返回值。

如果getInstacne需要参数呢?例如:

public class StaticBarInterfaceFactory {
  public static BarInterface getInstance(Foobar foobar) {
   return new BarInterfaceImpl(foobar);
  }
}

xml如下:

<bean id="foo" class="...Foo">
  <property name="barInterface">
   <ref bean="bar"/>
  </property>
</bean> 

<bean id="bar" class="...StaticBarInterfaceFactory" factory-method="getInstance">
  <constructor-arg>
   <ref bean="foobar"/>
  </constructor-arg>
</bean> 

<bean id="foobar" class="...FooBar"/>

只有bar中的constructor-arg下的参数是给getInstance用的,而不是StaticBarInterfaceFactory。(另一方面,静态工厂也没有显示的构造方法呀)

非静态工厂方式

public class NonStaticBarInterfaceFactory {
	public BarInterface getInstance() {
		 return new BarInterfaceImpl();
	}
	...
}

因为工厂方法为非静态的，我们只能通过某个NonStaticBarInterfaceFactory实例来调用该方法（哦，错了，是容器来调用），那么也就有了如下的配置内容：

<bean id="foo" class="...Foo">
  <property name="barInterface">
   <ref bean="bar"/>
  </property>
</bean> 

<bean id="barFactory" class="...NonStaticBarInterfaceFactory"/>
<bean id="bar" factory-bean="barFactory" factory-method="getInstance"/>

bar这个bean,中有factory-bean这个属性,就是告诉容器,bar=barFactory.getInstance();

如果barFactoy的getinstance也需要参数呢?

同样使用:<constructor-arg>

FactoryBean

上面写的工厂方法还有一个替代方法,就是FactoryBean

FactoryBean是Spring容器提供的一种可以扩展容器对象实例化逻辑的接口，请不要将其与容器名称BeanFactory相混淆。FactoryBean，其主语是Bean，定语为Factory，也就是说，它本身与其他注册到容器的对象一样，只是一个Bean而已，只不过，这种类型的Bean本身就是生产对象的工厂（Factory）。

我们先看看FactoryBean的签名。

public interface FactoryBean {
  Object getObject() throws Exception;
  Class getObjectType(); //如果不能确定返回的类型,getObjectType就返回null
  boolean isSingleton();
}

完全能看懂,没有压力呀。

如果我们想每次得到的日期都是第二天，可以使用如下的代码

import org.joda.time.DateTime;
import org.springframework.beans.factory.FactoryBean; 

public class NextDayDateFactoryBean implements FactoryBean { 

  public Object getObject() throws Exception {
   return new DateTime().plusDays(1);
  } 

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

  public boolean isSingleton() {
   return false;
  } 

}

要使用NextDayDateFactoryBean，只需要如下这样将其注册到容器即可：

<bean id="nextDayDateDisplayer" class="...NextDayDateDisplayer">
  <property name="dateOfNextDay">
   <ref bean="nextDayDate"/>
  </property>
</bean> 

<bean id="nextDayDate" class="...NextDayDateFactoryBean">
</bean>

从xml配置上似乎和以前没有什么差别,但是nextDayDateDisplayer里的属性dateOfNextDay并不是NextDayDateFactoryBean而是NextDayDateFactoryBean中getObject方法返回的对象。

public class NextDayDateDisplayer {
  private DateTime dateOfNextDay;
  // 相应的setter方法
  // ...
}

如果一定要取得FactoryBean本身的话，可以通过在bean定义的id之前加前缀&来达到目的。

Object nextDayDate = container.getBean("nextDayDate");
assertTrue(nextDayDate instanceof DateTime);
Object factoryBean = container.getBean("&nextDayDate");
assertTrue(factoryBean instanceof FactoryBean);
assertTrue(factoryBean instanceof NextDayDateFactoryBean); 

Object factoryValue = ((FactoryBean)factoryBean).getObject();
assertTrue(factoryValue instanceof DateTime);
assertNotSame(nextDayDate, factoryValue);
ssertEquals(  ((DateTime)nextDayDate).getDayOfYear(),
			((DateTime)factoryValue).getDayOfYear()   );

感谢glt