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

首先要分辨BeanFactory 與 FactoryBean的區別， 兩個名字很像，所以容易搞混

BeanFactory： 以Factory結尾，表示它是一個工廠類，是用於管理Bean的一個工廠

FactoryBean：以Bean結尾，表示它是一個Bean，不同於普通Bean的是：它是實現了FactoryBean<T>介面的Bean，根據該Bean的Id從BeanFactory中獲取的實際上是FactoryBean的getObject()返回的物件，而不是FactoryBean本身， 如果要獲取FactoryBean物件，可以在id前面加一個&符號來獲取。

Spring中的Bean有兩種。

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

1. <beanid="personService"class="com.spring.service.impl.PersonServiceImpl"scope="prototype">
2.             <propertyname="name"value="is_zhoufeng"/>
3.       </bean>

另外一種就是實現了org.springframework.beans.factory.FactoryBean<T>介面的Bean ， 那麼在從BeanFactory中根據定義的id獲取bean的時候，獲取的實際上是FactoryBean介面中的getObject()方法返回的物件。

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

1. <beanid="personServiceByLog"class="org.springframework.aop.framework.ProxyFactoryBean">
2.             <propertyname="proxyInterfaces">
3.                 <list>
4.                     <value>com.spring.service.PersonService</value>
5.                 </
   list>
6.             </property>
7.             <propertyname="interceptorNames">
8.                 <list>
9.                     <value>logInteceptor</value>
10.                     <value>ZFMethodAdvice</value>
11.                 </list>
12.             </property>
13.             <propertyname="targetName"value="personService"/>
14.      </bean>

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

1. @Test
2.  publicvoid 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. publicclass ZFFactoryBean implements FactoryBean<Object>, InitializingBean, DisposableBean {  
9.     // 被代理物件實現的介面名（在使用Proxy時需要用到，用於決定生成的代理物件型別）
10.     private String interfaceName;  
11.     // 被代理的物件
12.     private Object target;  
13.     // 生成的代理物件
14.     private Object proxyObj;  
15.     publicvoid destroy() throws Exception {  
16.         System.out.println("distory...");  
17.     }  
18.     publicvoid 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.     publicboolean isSingleton() {  
40.         returntrue;  
41.     }  
42.     public String getInterfaceName() {  
43.         return interfaceName;  
44.     }  
45.     publicvoid setInterfaceName(String interfaceName) {  
46.         this.interfaceName = interfaceName;  
47.     }  
48.     public Object getTarget() {  
49.         return target;  
50.     }  
51.     publicvoid 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>  

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

上面的ZFBeanFactory只是模仿了ProxyFactoryBean的功能做了一個實現而已。

其實通過FactoryBean這種特點，可以實現很多有用的功能 。。。