关于javascript:Spring-的-BeanFactory-和-FactoryBean-傻傻分不清

ApplicationContext接口，它由BeanFactory接口派生而来。

ApplicationContext蕴含BeanFactory的所有性能，通常倡议比BeanFactory优先。

BeanFactory和FactoryBean的区别
BeanFactory是接口，提供了OC容器最根本的模式，给具体的IOC容器的实现提供了标准，FactoryBean也是接口，为IOC容器中Bean的实现提供了更加灵便的形式，FactoryBean在IOC容器的根底上给Bean的实现加上了一个简略工厂模式和装璜模式(如果想理解装璜模式参考：润饰者模式(装璜者模式，Decoration) 咱们能够在getObject()办法中灵便配置。其实在Spring源码中有很多FactoryBean的实现类.

区别：BeanFactory是个Factory，也就是IOC容器或对象工厂，FactoryBean是个Bean。在Spring中，所有的Bean都是由BeanFactory(也就是IOC容器)来进行治理的。

但对FactoryBean而言，这个Bean不是简略的Bean，而是一个能生产或者润饰对象生成的工厂Bean,它的实现与设计模式中的工厂模式和润饰器模式相似。

1、BeanFactory
BeanFactory，以Factory结尾，示意它是一个工厂类(接口)，它负责生产和治理bean的一个工厂。在Spring中，BeanFactory是IOC容器的外围接口，它的职责包含：实例化、定位、配置应用程序中的对象及建设这些对象间的依赖。

BeanFactory只是个接口，并不是IOC容器的具体实现，然而Spring容器给出了很多种实现，如 DefaultListableBeanFactory、XmlBeanFactory、ApplicationContext等，其中XmlBeanFactory就是罕用的一个，该实现将以XML形式形容组成利用的对象及对象间的依赖关系。XmlBeanFactory类将持有此XML配置元数据，并用它来构建一个齐全可配置的零碎或利用。

都是附加了某种性能的实现。它为其余具体的IOC容器提供了最根本的标准，例如DefaultListableBeanFactory,XmlBeanFactory,ApplicationContext 等具体的容器都是实现了BeanFactory，再在其根底之上附加了其余的性能。

BeanFactory和ApplicationContext就是spring框架的两个IOC容器，当初个别应用ApplicationnContext，其岂但蕴含了BeanFactory的作用，同时还进行更多的扩大。

BeanFacotry是spring中比拟原始的Factory。如XMLBeanFactory就是一种典型的BeanFactory。

原始的BeanFactory无奈反对spring的许多插件，如AOP性能、Web利用等。ApplicationContext接口,它由BeanFactory接口派生而来。

ApplicationContext蕴含BeanFactory的所有性能，通常倡议比BeanFactory优先

ApplicationContext以一种更向面向框架的形式工作以及对上下文进行分层和实现继承，ApplicationContext包还提供了以下的性能：

MessageSource, 提供国际化的音讯拜访

资源拜访，如URL和文件

事件流传

载入多个（有继承关系）上下文，使得每一个上下文都专一于一个特定的档次，比方利用的web层;

在不应用spring框架之前，咱们的service层中要应用dao层的对象，不得不在service层中new一个对象。

存在的问题：层与层之间的依赖。service层要用dao层对象须要配置到xml配置文件中，至于对象是怎么创立的，关系是怎么组合的都交给了spring框架去实现。

形式1、

Resource resource = new FileSystemResource(“beans.xml”);
BeanFactory factory = new XmlBeanFactory(resource);
形式2、

ClassPathResource resource = new ClassPathResource(“beans.xml”);
BeanFactory factory = new XmlBeanFactory(resource);
形式3、

ApplicationContext context = new ClassPathXmlApplicationContext(new String[] {“applicationContext.xml”, “applicationContext-part2.xml”});
BeanFactory factory = (BeanFactory) context;
根本就是这些了，接着应用getBean(String beanName)办法就能够获得bean的实例；BeanFactory提供的办法及其简略，仅提供了六种办法供客户调用：

boolean containsBean(String beanName) 判断工厂中是否蕴含给定名称的bean定义，若有则返回true

Object getBean(String) 返回给定名称注册的bean实例。依据bean的配置状况，如果是singleton模式将返回一个共享实例，否则将返回一个新建的实例，如果没有找到指定bean,该办法可能会抛出异样。

Object getBean(String, Class) 返回以给定名称注册的bean实例，并转换为给定class类型。

Class getType(String name) 返回给定名称的bean的Class,如果没有找到指定的bean实例，则排除NoSuchBeanDefinitionException异样

boolean isSingleton(String) 判断给定名称的bean定义是否为单例模式

String[] getAliases(String name) 返回给定bean名称的所有别名

package org.springframework.beans.factory;
import org.springframework.beans.BeansException;
public interface BeanFactory {

String FACTORY_BEAN_PREFIX = "&";
Object getBean(String name) throws BeansException;
<T> T getBean(String name, Class<T> requiredType) throws BeansException;
<T> T getBean(Class<T> requiredType) throws BeansException;
Object getBean(String name, Object... args) throws BeansException;
boolean containsBean(String name);
boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
boolean isPrototype(String name) throws NoSuchBeanDefinitionException;
boolean isTypeMatch(String name, Class<?> targetType) throws NoSuchBeanDefinitionException;
Class<?> getType(String name) throws NoSuchBeanDefinitionException;
String[] getAliases(String name);

}

2、FactoryBean
个别状况下，Spring通过反射机制利用的class属性指定实现类实例化Bean，在某些状况下，实例化Bean过程比较复杂，如果依照传统的形式，则须要在中提供大量的配置信息。配置形式的灵活性是受限的，这时采纳编码的形式可能会失去一个简略的计划。

Spring为此提供了一个org.springframework.bean.factory.FactoryBean的工厂类接口，用户能够通过实现该接口定制实例化Bean的逻辑。bean 为什么默认单例？举荐看下。关注微信公众号：Java技术栈，在后盾回复：spring，能够获取我整顿的 N 篇 Spring 教程，都是干货。

FactoryBean接口对于Spring框架来说占用重要的位置，Spring本身就提供了70多个FactoryBean的实现。它们暗藏了实例化一些简单Bean的细节，给下层利用带来了便当。

从Spring3.0开始，FactoryBean开始反对泛型，即接口申明改为FactoryBean的模式以Bean结尾，示意它是一个Bean，不同于一般Bean的是：它是实现了FactoryBean接口的Bean，依据该Bean的ID从BeanFactory中获取的实际上是FactoryBean的getObject()返回的对象，而不是FactoryBean自身，如果要获取FactoryBean对象，请在id后面加一个&符号来获取。

例如本人实现一个FactoryBean，性能：用来代理一个对象，对该对象的所有办法做一个拦挡，在调用前后都输入一行LOG，模拟ProxyFactoryBean的性能。

/**

my factory bean<p>
代理一个类，拦挡该类的所有办法，在办法的调用前后进行日志的输入
@author daniel.zhao
*
*/

public class MyFactoryBean implements FactoryBean<Object>, InitializingBean, DisposableBean {

private static final Logger logger = LoggerFactory.getLogger(MyFactoryBean.class);
private String interfaceName;
private Object target;
private Object proxyObj;
@Override
public void destroy() throws Exception {
    logger.debug("destroy......");
}
@Override
public void afterPropertiesSet() throws Exception {
    proxyObj = Proxy.newProxyInstance(
            this.getClass().getClassLoader(),
            new Class[] { Class.forName(interfaceName) },
            new InvocationHandler() {
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            logger.debug("invoke method......" + method.getName());
            logger.debug("invoke method before......" + System.currentTimeMillis());
            Object result = method.invoke(target, args);
            logger.debug("invoke method after......" + System.currentTimeMillis());
            return result; }
    });
    logger.debug("afterPropertiesSet......");
}

@Override
public Object getObject() throws Exception {
    logger.debug("getObject......");
    return proxyObj;
}

@Override
public Class<?> getObjectType() {
    return proxyObj == null ? Object.class : proxyObj.getClass();
}

@Override
public boolean isSingleton() {
    return true;
}

public String getInterfaceName() {
    return interfaceName;
}

public void setInterfaceName(String interfaceName) {
    this.interfaceName = interfaceName;
}

public Object getTarget() {
    return target;
}

public void setTarget(Object target) {
    this.target = target;
}

public Object getProxyObj() {
    return proxyObj;
}

public void setProxyObj(Object proxyObj) {
    this.proxyObj = proxyObj;
}

}
XML-Bean配置如下

<bean id=”fbHelloWorldService” class=”com.ebao.xxx.MyFactoryBean”>
<property name=”interfaceName” value=”com.ebao.xxx.HelloWorldService” />
<property name=”target” ref=”helloWorldService” />
</bean>
Junit Test class

@RunWith(JUnit4ClassRunner.class)
@ContextConfiguration(classes = { MyFactoryBeanConfig.class })
public class MyFactoryBeanTest {

@Autowired
private ApplicationContext context;
/**
 * 测试验证FactoryBean原理，代理一个servcie在调用其办法的前后，打印日志亦可作其余解决
 * 从ApplicationContext中获取自定义的FactoryBean
 * context.getBean(String beanName) ---> 最终获取到的Object是FactoryBean.getObejct(),
 * 应用Proxy.newInstance生成service的代理类
 */
@Test
public void testFactoryBean() {
    HelloWorldService helloWorldService = (HelloWorldService) context.getBean("fbHelloWorldService");
    helloWorldService.getBeanName();
    helloWorldService.sayHello();
}

}
FactoryBean是一个接口，当在IOC容器中的Bean实现了FactoryBean后，通过getBean(String BeanName)获取到的Bean对象并不是FactoryBean的实现类对象，而是这个实现类中的getObject()办法返回的对象。要想获取FactoryBean的实现类，就要getBean(&BeanName)，在BeanName之前加上&。

package org.springframework.beans.factory;
public interface FactoryBean<T> {

T getObject() throws Exception;
Class<?> getObjectType();
boolean isSingleton();

}
在该接口中还定义了以下3个办法：

TgetObject()：返回由FactoryBean创立的Bean实例，如果isSingleton()返回true，则该实例会放到Spring容器中单实例缓存池中；

booleanisSingleton()：返回由FactoryBean创立的Bean实例的作用域是singleton还是prototype；

ClassgetObjectType()：返回FactoryBean创立的Bean类型。

当配置文件中的class属性配置的实现类是FactoryBean时，通过getBean()办法返回的不是FactoryBean自身，而是FactoryBean#getObject()办法所返回的对象，相当于FactoryBean#getObject()代理了getBean()办法。例：如果应用传统形式配置上面Car的时，Car的每个属性别离对应一个元素标签。

package com.baobaotao.factorybean;

public   class  Car  {
    private   int maxSpeed ;
    private  String brand ;
    private   double price ;
    public   int  getMaxSpeed ()   {
        return   this . maxSpeed ;
    }
    public   void  setMaxSpeed ( int  maxSpeed )   {
        this . maxSpeed = maxSpeed;
    }
    public  String getBrand ()   {
        return   this . brand ;
    }
    public   void  setBrand ( String brand )   {
        this . brand = brand;
    }
    public   double  getPrice ()   {
        return   this . price ;
    }
    public   void  setPrice ( double  price )   {
        this . price = price;
   }

}
如果用FactoryBean的形式实现就灵便点，下例通过逗号宰割符的形式一次性的为Car的所有属性指定配置值：

package com.baobaotao.factorybean;
import org.springframework.beans.factory.FactoryBean;
public class CarFactoryBean implements FactoryBean<Car> {

private  String carInfo ;
public  Car getObject ()   throws  Exception {
    Car car = new  Car () ;
    String [] infos = carInfo .split ( "," ) ;
    car.setBrand ( infos [ 0 ]) ;
    car.setMaxSpeed ( Integer. valueOf ( infos [ 1 ])) ;
    car.setPrice ( Double. valueOf ( infos [ 2 ])) ;
    return  car;
}
public  Class<Car> getObjectType ()   {
    return  Car. class;
}
public   boolean  isSingleton ()   {
    return   false ;
}
public  String getCarInfo ()   {
    return   this . carInfo ;
}

// 承受逗号宰割符设置属性信息
public   void  setCarInfo ( String carInfo )   {
    this . carInfo = carInfo;
}

}
有了这个CarFactoryBean后，就能够在配置文件中应用上面这种自定义的配置形式配置CarBean了：

<bean d=”car”class=”com.baobaotao.factorybean.CarFactoryBean”
P:carInfo=”法拉利,400,2000000″/>
当调用getBean(“car”)时，Spring通过反射机制发现CarFactoryBean实现了FactoryBean的接口，这时Spring容器就调用接口办法CarFactoryBean#getObject()办法返回。

如果心愿获取CarFactoryBean的实例，则须要在应用getBean(beanName)办法时在beanName前显示的加上”&”前缀：如getBean(“&car”);

上面是一个利用FactoryBean的例子

<beans xmlns=”http://www.springframework.org/schema/beans”

         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xmlns:context="http://www.springframework.org/schema/context"
         xmlns:aop="http://www.springframework.org/schema/aop"
         xmlns:tx="http://www.springframework.org/schema/tx"
         xsi:schemaLocation="http://www.springframework.org/schema/beans
                 http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
                 http://www.springframework.org/schema/context
                 http://www.springframework.org/schema/context/spring-context-3.0.xsd
                 http://www.springframework.org/schema/aop
                 http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
                 http://www.springframework.org/schema/tx
                 http://www.springframework.org/schema/tx/spring-tx-3.0.xsd">

<property name="type" value="student" />

</bean>
</beans>
FactoryBean的实现类

import org.springframework.beans.factory.FactoryBean;

/**

@author 作者 wangbiao
@parameter
@return
*/

public class FactoryBeanPojo implements FactoryBean{

private String type;

@Override
public Object getObject() throws Exception {
    if("student".equals(type)){
        return new Student();
    }else{
        return new School();
    }

}

@Override
public Class getObjectType() {
    return School.class;
}

@Override
public boolean isSingleton() {
    return true;
}

public String getType() {
    return type;
}

public void setType(String type) {
    this.type = type;
}

}
一般的bean

/**

@author 作者 wangbiao
@parameter
@return
*/

public class School {

private String schoolName;
private String address;
private int studentNumber;
public String getSchoolName() {
    return schoolName;
}
public void setSchoolName(String schoolName) {
    this.schoolName = schoolName;
}
public String getAddress() {
    return address;
}
public void setAddress(String address) {
    this.address = address;
}
public int getStudentNumber() {
    return studentNumber;
}
public void setStudentNumber(int studentNumber) {
    this.studentNumber = studentNumber;
}
@Override
public String toString() {
    return "School [schoolName=" + schoolName + ", address=" + address
            + ", studentNumber=" + studentNumber + "]";
}

}
测试类

import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.spring.bean.FactoryBeanPojo;

/**

@author 作者 wangbiao
@parameter
@return
*/

public class FactoryBeanTest {

public static void main(String[] args){
    String url = "com/spring/config/BeanConfig.xml";
    ClassPathXmlApplicationContext cpxa = new ClassPathXmlApplicationContext(url);
    Object school= cpxa.getBean("factoryBeanPojo");
    FactoryBeanPojo factoryBeanPojo= (FactoryBeanPojo) cpxa.getBean("&factoryBeanPojo");
    System.out.println(school.getClass().getName());
    System.out.println(factoryBeanPojo.getClass().getName());
}

}
输入的后果：

十一月 16, 2016 10:28:24 上午 org.springframework.context.support.AbstractApplicationContext prepareRefresh
INFO: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@1e8ee5c0: startup date [Wed Nov 16 10:28:24 CST 2016]; root of context hierarchy
十一月 16, 2016 10:28:24 上午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
INFO: Loading XML bean definitions from class path resource [com/spring/config/BeanConfig.xml]
十一月 16, 2016 10:28:24 上午 org.springframework.beans.factory.support.DefaultListableBeanFactory preInstantiateSingletons
INFO: Pre-instantiating singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@35b793ee: defining beans [student,school,factoryBeanPojo]; root of factory hierarchy
com.spring.bean.Student
com.spring.bean.FactoryBeanPojo
从后果上能够看到当从IOC容器中获取FactoryBeanPojo对象的时候，用getBean(String BeanName)获取确实是Student对象，能够看到在FactoryBeanPojo中的type属性设置为student的时候，会在getObject()办法中返回Student对象。

所以说从IOC容器获取实现了FactoryBean的实现类时，返回的却是实现类中的getObject办法返回的对象，要想获取FactoryBean的实现类，得在getBean(String BeanName)中的BeanName之前加上&,写成getBean(String &BeanName)。

最初
如果你感觉此文对你有一丁点帮忙，点个赞。或者能够退出我的开发交换群：1025263163互相学习，咱们会有业余的技术答疑解惑

如果你感觉这篇文章对你有点用的话，麻烦请给咱们的开源我的项目点点star: https://gitee.com/ZhongBangKe…不胜感激！

JAVA学习手册：https://doc.crmeb.com
技术交换论坛：https://q.crmeb.com

关于javascript:Spring-的-BeanFactory-和-FactoryBean-傻傻分不清

评论

发表回复取消回复

更多文章

DDN HPC 存储硬件架构设计深度分析

探秘IO500：从Lustre并行文件系统出发，开启HPC存储性能新征程

苹果iOS打包的ipa应用无法安装？一篇文章带你了解可能的原因及排查方法

图解Golang：从零开始实现简易版过期LRU缓存

关于javascript:Spring-的-BeanFactory-和-FactoryBean-傻傻分不清

评论

发表回复 取消回复

更多文章

DDN HPC 存储硬件架构设计深度分析

探秘IO500：从Lustre并行文件系统出发，开启HPC存储性能新征程

苹果iOS打包的ipa应用无法安装？一篇文章带你了解可能的原因及排查方法

图解Golang：从零开始实现简易版过期LRU缓存

发表回复取消回复