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 ，比如配置

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为例子，配置如下：

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类型的。

1. @Test
2. public void test01() {
3. PersonService ps = context.getBean("personService", PersonService.class);
4. ps.sayHello();
5. String name = ps.getName();
6. System.out.println(name);
7. }

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

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. }

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

1. package com.spring.factorybean;
2. import java.lang.reflect.InvocationHandler;
3. import java.lang.reflect.Method;
4. import java.lang.reflect.Proxy;
5. import org.springframework.beans.factory.DisposableBean;
6. import org.springframework.beans.factory.FactoryBean;
7. import org.springframework.beans.factory.InitializingBean;
8. public class ZFFactoryBean implements FactoryBean<Object>, InitializingBean, DisposableBean {
9. // 被代理对象实现的接口名（在使用Proxy时需要用到，用于决定生成的代理对象类型）
10. private String interfaceName;
11. // 被代理的对象
12. private Object target;
13. // 生成的代理对象
14. private Object proxyObj;
15. public void destroy() throws Exception {
16. System.out.println("distory...");
17. }
18. public void afterPropertiesSet() throws Exception {
19. proxyObj = Proxy.newProxyInstance(this.getClass().getClassLoader(),
20. new Class[] { Class.forName(interfaceName) }, new InvocationHandler() {
21. public Object invoke(Object proxy, Method method, Object[] args)
22. throws Throwable {
23. System.out.println("method:" + method.getName());
24. System.out.println("Method before...");
25. Object result = method.invoke(target, args);
26. System.out.println("Method after...");
27. return result;
28. }
29. });
30. System.out.println("afterPropertiesSet");
31. }
32. public Object getObject() throws Exception {
33. System.out.println("getObject");
34. return proxyObj;
35. }
36. public Class<?> getObjectType() {
37. return proxyObj == null ? Object.class : proxyObj.getClass();
38. }
39. public boolean isSingleton() {
40. return true;
41. }
42. public String getInterfaceName() {
43. return interfaceName;
44. }
45. public void setInterfaceName(String interfaceName) {
46. this.interfaceName = interfaceName;
47. }
48. public Object getTarget() {
49. return target;
50. }
51. public void setTarget(Object target) {
52. this.target = target;
53. }
54. }

然后来试试：

首先这样定义bean

1. <bean id="personService" class="com.spring.service.impl.PersonServiceImpl" scope="prototype">
2. <property name="name" value="is_zhoufeng" />
3. </bean>
4. <bean id="zfPersonService" class="com.spring.factorybean.ZFFactoryBean">
5. <property name="interfaceName" value="com.spring.service.PersonService" />
6. <property name="target"  ref="personService"/>
7. </bean>

然后获取Bean，并测试。

1. @Test
2. public void test06() {
3. PersonService ps = context.getBean("zfPersonService", PersonService.class);
4. ps.sayHello();
5. String name = ps.getName();
6. System.out.println(name);
7. }

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

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

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

原文：http://blog.csdn.net/is_zhoufeng/article/details/38422549