Spring的FactoryBean接口理解

ゝ一纸荒年。 2021-12-19 16:41 371阅读 0赞

1.Spring中有两种类型的Bean，一种是普通Bean，另一种是工厂Bean，即FactoryBean，这两种Bean都被容器管理，但工厂Bean跟普通Bean不同，其返回的对象不是指定类的一个实例，其返回的是该FactoryBean的getObject方法所返回的对象。在Spring框架内部，有很多地方有FactoryBean的实现类，它们在很多应用如(Spring的AOP、ORM、事务管理)及与其它第三框架(hibernate丶mybatis丶jpa…)集成时都有体现

FactoryBean的继承实现体系:

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

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

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

spring中的Bean有两种。

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

[html] view plain copy




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


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

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

[html] view plain copy



com.spring.service.PersonService




logInteceptor
ZFMethodAdvice

那么在代码中根据personServiceByLog来获取的Bean实际上是PersonService类型的。
[java] view plain copy
@Test
public void test01() { 

  1.  PersonService ps = context.getBean("personServiceByLog", PersonService.class);    
  3.  ps.sayHello();    
  5.  String name = ps.getName();    
  7.  System.out.println(name);

}

如果要获取ProxyFactoryBean本身，可以如下
[java] view plain copy
@Test
public void test04() {
ProxyFactoryBean factoryBean = context.getBean(“&personServiceByLog”, ProxyFactoryBean.class);
PersonService ps = (PersonService) factoryBean.getObject();
String name = ps.getName();
System.out.println(name);

}

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

[java] view plain copy
package com.spring.factorybean;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.FactoryBean;
import org.springframework.beans.factory.InitializingBean;

public class ZFFactoryBean implements FactoryBean, InitializingBean, DisposableBean { 

  1. // 被代理对象实现的接口名（在使用Proxy时需要用到，用于决定生成的代理对象类型）    
  2. private String interfaceName;    
  4. // 被代理的对象    
  5. private Object target;    
  7. // 生成的代理对象    
  8. private Object proxyObj;    
  10. public void destroy() throws Exception \{    
  11.     System.out.println("distory...");    
  12. \}    
  14. public void afterPropertiesSet() throws Exception \{    
  16.     proxyObj = Proxy.newProxyInstance(this.getClass().getClassLoader(),    
  17.                                       new Class\[\] \{ Class.forName(interfaceName) \}, new InvocationHandler() \{    
  19.                                           public Object invoke(Object proxy, Method method, Object\[\] args)    
  20.                                                                                                           throws Throwable \{    
  21.                                               System.out.println("method:" + method.getName());    
  22.                                               System.out.println("Method before...");    
  23.                                               Object result = method.invoke(target, args);    
  24.                                               System.out.println("Method after...");    
  25.                                               return result;    
  26.                                           \}    
  27.                                       \});    
  29.     System.out.println("afterPropertiesSet");    
  30. \}    
  32. public Object getObject() throws Exception \{    
  33.     System.out.println("getObject");    
  34.     return proxyObj;    
  35. \}    
  37. public Class<?> getObjectType() \{    
  38.     return proxyObj == null ? Object.class : proxyObj.getClass();    
  39. \}    
  41. public boolean isSingleton() \{    
  42.     return true;    
  43. \}    
  45. public String getInterfaceName() \{    
  46.     return interfaceName;    
  47. \}    
  49. public void setInterfaceName(String interfaceName) \{    
  50.     this.interfaceName = interfaceName;    
  51. \}    
  53. public Object getTarget() \{    
  54.     return target;    
  55. \}    
  57. public void setTarget(Object target) \{    
  58.     this.target = target;    
  59. \}

}

然后来试试：
首先这样定义bean

[java] view plain copy 



  1.   <bean id="zfPersonService" class="com.spring.factorybean.ZFFactoryBean">    
  2.     <property name="interfaceName" value="com.spring.service.PersonService" />    
  3.     <property name="target"  ref="personService"/>    
  4.   </bean>

然后获取Bean，并测试。
[java] view plain copy
@Test
public void test06() {
PersonService ps = context.getBean(“zfPersonService”, PersonService.class); 

  1.  ps.sayHello();    
  3.  String name = ps.getName();    
  5.  System.out.println(name);

}

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

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

其实通过FactoryBean这种特点，可以实现很多有用的功能 。。。
-——————————
作者：shadow_zed
来源：CSDN
原文：https://blog.csdn.net/shadow\_zed/article/details/72550765
版权声明：本文为博主原创文章，转载请附上博文链接！

发表评论

表情：
评论列表 （有 0 条评论，371人围观）

还没有评论，来说两句吧...

相关阅读