Spring之FactoryBean

首先要分辨BeanFactory 与 FactoryBean的区别， 两个名字很像，所以容易搞混

BeanFactory： 以Factory结尾，表示它是一个工厂类，是用于管理Bean的一个工厂

FactoryBean：以Bean结尾，表示它是一个Bean，不同于普通Bean的是：它是实现了FactoryBean<T>接 口的Bean，根据该Bean的Id从BeanFactory中获取的实际上是FactoryBean的getObject()返回的对象，而不是 FactoryBean本身， 如果要获取FactoryBean对象，可以在id前面加一个&符号来获取。

Spring中的Bean有两种。

一种是普通的bean ，比如配置

[html] view plaincopy

1. <bean id="personService" class="com.spring.service.impl.PersonServiceImpl" scope="prototype">  

2.             <property name="name" value="is_zhoufeng" />  

3.       </bean>    

那个使用BeanFactory根据id personService获取bean的时候，得到的对象就是PersonServiceImpl类型的。

另外一种就是实现了org.springframework.beans.factory.FactoryBean<T>接口的 Bean ， 那么在从BeanFactory中根据定义的id获取bean的时候，获取的实际上是FactoryBean接口中的getObject()方法返回的对 象。

以Spring提供的ProxyFactoryBean为例子，配置如下：

[html] view plaincopy

1. <bean id="personServiceByLog" class="org.springframework.aop.framework.ProxyFactoryBean">  

2.             <property name="proxyInterfaces">  

3.                 <list>  

4.                     <value>com.spring.service.PersonService</value>  

5.                 </list>  

6.             </property>  

7.             <property name="interceptorNames">  

8.                 <list>  

9.                     <value>logInteceptor</value>  

10.                     <value>ZFMethodAdvice</value>  

11.                 </list>  

12.             </property>  

13.             <property name="targetName" value="personService" />    

14.      </bean>  

那么在代码中根据personServiceByLog来获取的Bean实际上是PersonService类型的。 

[java] view plaincopy

1. @Test   

2.  public void test01() {  

3.   

4.      PersonService ps = context.getBean("personService", PersonService.class);  

5.   

6.      ps.sayHello();  

7.   

8.      String name = ps.getName();  

9.   

10.      System.out.println(name);  

11.  }  

如果要获取ProxyFactoryBean本身，可以如下

[java] view plaincopy

1. @Test   

2.  public void test04() {  

3.      ProxyFactoryBean factoryBean = context.getBean("&personServiceByLog", ProxyFactoryBean.class);  

4.      PersonService ps = (PersonService) factoryBean.getObject();  

5.      String name = ps.getName();  

6.      System.out.println(name);  

7.   

8.  }  

自己实现一个FactoryBean， 功能：用来代理一个对象，对该对象的所有方法做一个拦截，在方法调用前后都输出一行log

[java] view plaincopy

1. package com.spring.factorybean;  

2.   

3. import java.lang.reflect.InvocationHandler;  

4. import java.lang.reflect.Method;  

5. import java.lang.reflect.Proxy;  

6.   

7. import org.springframework.beans.factory.DisposableBean;  

8. import org.springframework.beans.factory.FactoryBean;  

9. import org.springframework.beans.factory.InitializingBean;  

10.   

11. public class ZFFactoryBean implements FactoryBean<Object>, InitializingBean, DisposableBean {  

12.   

13.     // 被代理对象实现的接口名（在使用Proxy时需要用到，用于决定生成的代理对象类型）  

14.     private String interfaceName;  

15.   

16.     // 被代理的对象  

17.     private Object target;  

18.   

19.     // 生成的代理对象  

20.     private Object proxyObj;  

21.   

22.     public void destroy() throws Exception {  

23.         System.out.println("distory...");  

24.     }  

25.   

26.     public void afterPropertiesSet() throws Exception {  

27.   

28.         proxyObj = Proxy.newProxyInstance(this.getClass().getClassLoader(),  

29.                                           new Class[] { Class.forName(interfaceName) }, new InvocationHandler() {  

30.   

31.                                               public Object invoke(Object proxy, Method method, Object[] args)  

32.                                                                                                               throws Throwable {  

33.                                                   System.out.println("method:" + method.getName());  

34.                                                   System.out.println("Method before...");  

35.                                                   Object result = method.invoke(target, args);  

36.                                                   System.out.println("Method after...");  

37.                                                   return result;  

38.                                               }  

39.                                           });  

40.   

41.         System.out.println("afterPropertiesSet");  

42.     }  

43.   

44.     public Object getObject() throws Exception {  

45.         System.out.println("getObject");  

46.         return proxyObj;  

47.     }  

48.   

49.     public Class<?> getObjectType() {  

50.         return proxyObj == null ? Object.class : proxyObj.getClass();  

51.     }  

52.   

53.     public boolean isSingleton() {  

54.         return true;  

55.     }  

56.   

57.     public String getInterfaceName() {  

58.         return interfaceName;  

59.     }  

60.   

61.     public void setInterfaceName(String interfaceName) {  

62.         this.interfaceName = interfaceName;  

63.     }  

64.   

65.     public Object getTarget() {  

66.         return target;  

67.     }  

68.   

69.     public void setTarget(Object target) {  

70.         this.target = target;  

71.     }  

72.   

73. }  

然后来试试：

首先这样定义bean

[java] view plaincopy

1. <bean id="personService" class="com.spring.service.impl.PersonServiceImpl" scope="prototype">  

2.             <property name="name" value="is_zhoufeng" />  

3.       </bean>    

4.         

5.       <bean id="zfPersonService" class="com.spring.factorybean.ZFFactoryBean">  

6.         <property name="interfaceName" value="com.spring.service.PersonService" />  

7.         <property name="target"  ref="personService"/>  

8.       </bean>  

然后获取Bean，并测试。

[java] view plaincopy

1. @Test   

2.  public void test06() {  

3.      PersonService ps = context.getBean("zfPersonService", PersonService.class);  

4.   

5.      ps.sayHello();  

6.   

7.      String name = ps.getName();  

8.   

9.      System.out.println(name);  

10.  }  

会发现sayHello与getName方法调用前后都有log打印。

上面的ZFBeanFactory只是模仿了ProxyFactoryBean的功能做了一个实现而已。

其实通过FactoryBean这种特点，可以实现很多有用的功能 。。。