关闭

Spring学习笔记——Spring中的BeanFactory与FactoryBean

标签: spring
957人阅读 评论(0) 收藏 举报
分类:

BeanFactory
BeanFactory是Spring的org.springframework.beans.factory下的一个接口,是Spring IOC所遵守的基本编程规范,他的实现类有DefaultListableBeanFactory、XmlBeanFactory、ApplicationContext等,都各自实现自己的功能。
FactoryBean
通常Spring通过反射机制利用bean的class属性来指定实现类的实例化Bean,在某些情况下实例化Bean的过程比较复杂,如果按照传统方式则需要在bean中提供大量的配置信息,而利用Spring提供了一个org.springframework.bean.factory.FactoryBean的工厂接口类,用户可以通过实现该接口定制实例化Bean的逻辑。下面是FactoryBean的源代码,注释很强大,可惜我的英语一般,简单翻译一下。

/**
 * Interface to be implemented by objects used within a {@link BeanFactory}
 * which are themselves factories. If a bean implements this interface,
 * it is used as a factory for an object to expose, not directly as a bean
 * instance that will be exposed itself.
 *
 * <p><b>NB: A bean that implements this interface cannot be used as a
 * normal bean.</b> A FactoryBean is defined in a bean style, but the
 * object exposed for bean references ({@link #getObject()} is always
 * the object that it creates.
 *
 * <p>FactoryBeans can support singletons and prototypes, and can
 * either create objects lazily on demand or eagerly on startup.
 * The {@link SmartFactoryBean} interface allows for exposing
 * more fine-grained behavioral metadata.
 *
 * <p>This interface is heavily used within the framework itself, for
 * example for the AOP {@link org.springframework.aop.framework.ProxyFactoryBean}
 * or the {@link org.springframework.jndi.JndiObjectFactoryBean}.
 * It can be used for application components as well; however,
 * this is not common outside of infrastructure code.
 *
 * <p><b>NOTE:</b> FactoryBean objects participate in the containing
 * BeanFactory's synchronization of bean creation. There is usually no
 * need for internal synchronization other than for purposes of lazy
 * initialization within the FactoryBean itself (or the like).
 *
 * @author Rod Johnson
 * @author Juergen Hoeller
 * @since 08.03.2003
 * @see org.springframework.beans.factory.BeanFactory
 * @see org.springframework.aop.framework.ProxyFactoryBean
 * @see org.springframework.jndi.JndiObjectFactoryBean
 */
public interface FactoryBean<T> {
    /**
     * Return an instance (possibly shared or independent) of the object
     * managed by this factory.
     * <p>As with a {@link BeanFactory}, this allows support for both the
     * Singleton and Prototype design pattern.
     * <p>If this FactoryBean is not fully initialized yet at the time of
     * the call (for example because it is involved in a circular reference),
     * throw a corresponding {@link FactoryBeanNotInitializedException}.
     * <p>As of Spring 2.0, FactoryBeans are allowed to return {@code null}
     * objects. The factory will consider this as normal value to be used; it
     * will not throw a FactoryBeanNotInitializedException in this case anymore.
     * FactoryBean implementations are encouraged to throw
     * FactoryBeanNotInitializedException themselves now, as appropriate.
     * @return an instance of the bean (can be {@code null})
     * @throws Exception in case of creation errors
     * @see FactoryBeanNotInitializedException
     */
    // 返回有FactoryBean创建的Bean实例,如果isSingleton为true,则该实例会放到Spring容器中
    T getObject() throws Exception;
    /**
     * Return the type of object that this FactoryBean creates,
     * or {@code null} if not known in advance.
     * <p>This allows one to check for specific types of beans without
     * instantiating objects, for example on autowiring.
     * <p>In the case of implementations that are creating a singleton object,
     * this method should try to avoid singleton creation as far as possible;
     * it should rather estimate the type in advance.
     * For prototypes, returning a meaningful type here is advisable too.
     * <p>This method can be called <i>before</i> this FactoryBean has
     * been fully initialized. It must not rely on state created during
     * initialization; of course, it can still use such state if available.
     * <p><b>NOTE:</b> Autowiring will simply ignore FactoryBeans that return
     * {@code null} here. Therefore it is highly recommended to implement
     * this method properly, using the current state of the FactoryBean.
     * @return the type of object that this FactoryBean creates,
     * or {@code null} if not known at the time of the call
     * @see ListableBeanFactory#getBeansOfType
     */
    // 返回FactoryBean创建Bean类型
    Class<?> getObjectType();
    /**
     * Is the object managed by this factory a singleton? That is,
     * will {@link #getObject()} always return the same object
     * (a reference that can be cached)?
     * <p><b>NOTE:</b> If a FactoryBean indicates to hold a singleton object,
     * the object returned from {@code getObject()} might get cached
     * by the owning BeanFactory. Hence, do not return {@code true}
     * unless the FactoryBean always exposes the same reference.
     * <p>The singleton status of the FactoryBean itself will generally
     * be provided by the owning BeanFactory; usually, it has to be
     * defined as singleton there.
     * <p><b>NOTE:</b> This method returning {@code false} does not
     * necessarily indicate that returned objects are independent instances.
     * An implementation of the extended {@link SmartFactoryBean} interface
     * may explicitly indicate independent instances through its
     * {@link SmartFactoryBean#isPrototype()} method. Plain {@link FactoryBean}
     * implementations which do not implement this extended interface are
     * simply assumed to always return independent instances if the
     * {@code isSingleton()} implementation returns {@code false}.
     * @return whether the exposed object is a singleton
     * @see #getObject()
     * @see SmartFactoryBean#isPrototype()
     */
    // 返回由FactoryBean创建的Bean实例的作用域是singleton还是prototype
    boolean isSingleton();
}

当配置文件中的class属性配置的实现类是FactoryBean时,通过getBean方法返回的不是FactoryBean本身,而是FactoryBean#getObject()方法返回的对象,相当于FactoryBean#getObject()代理了getBean
两者区别:
BeanFactory是一个factory,也就是IOC容器或对象工厂,FactoryBean是个Bean,在Spring中,所有的Bean都是由BeanFactory(IOC)来进行管理的。但对FactoryBean而言,这个Bean是一个生产或者修饰对象生成的工厂Bean,他的实现与设计模式中的工厂模式和修饰器模式类似。

1
0
查看评论

理解spring中的BeanFactory和FactoryBean的区别与联系

首先,这俩都是个接口…实现 BeanFactory 接口的类表明此类事一个工厂,作用就是配置、新建、管理 各种Bean。而 实现 FactoryBean 的类表明此类也是一个Bean,类型为工厂Bean(Spring中共有两种bean,一种为普通bean,另一种则为工厂bean)。顾名思义,它也是用...
  • joenqc
  • joenqc
  • 2017-03-26 20:51
  • 1082

BeanFactory 与 FactoryBean的区别及FactoryBean详解

原文地址:http://blog.csdn.net/is_zhoufeng/article/details/38422549 首先要分辨BeanFactory 与 FactoryBean的区别, 两个名字很像,所以容易搞混 BeanFactory: 以Factory结尾,表示它是一个...
  • u014604403
  • u014604403
  • 2016-01-14 10:37
  • 8769

spring中BeanFactory和FactoryBean的区别

spring中BeanFactory和FactoryBean的区别
  • qiesheng
  • qiesheng
  • 2017-06-06 10:13
  • 1428

关于BeanFactory,FactoryBean,ObjectFactory

在看ObjectFactoryCreatingFactoryBean这个类的意思时,被FactoryBean,BeanFactory,ObjectFactory这几个接口弄的有点蒙。现在说一下这几个接口的作用: BeanFactory:这个接口用作管理Bean的容器,Spring中生成的Bean都是...
  • hotdust
  • hotdust
  • 2016-10-10 20:15
  • 903

BeanFactory 和FactoryBean的区别

BeanFactory 和FactoryBean的区别 博客分类: Spring BeanSpringprototype  Spring的BeanFacotry是一个类工厂,使用它来创建各种类型的Bean,最主要的方法就是getBean(String beanName)...
  • ccecwg
  • ccecwg
  • 2014-05-12 16:16
  • 451

Spring BeanFactory与FactoryBean的区别及其各自的详细介绍于用法

Spring BeanFactory与FactoryBean的区别及其各自的详细介绍于用法 1. BeanFactory   BeanFactory,以Factory结尾,表示它是一个工厂类(接口),用于管理Bean的一个工厂。在Spring中,BeanFactory是IOC容器的核心接...
  • yinbucheng
  • yinbucheng
  • 2017-03-23 21:08
  • 346

Spring之FactoryBean

springAop的实现主要是通过动态代理技术。
  • is_zhoufeng
  • is_zhoufeng
  • 2014-08-07 18:13
  • 30634

Spring入门学习——使用Spring的FactoryBean创建Bean

有时候希望使用Spring的工厂Bean在Spring IoC容器中创建Bean。工厂Bean(Factory Bean)是作为创建IoC容器中其他Bean的工厂的一个Bean(拗口~)。工厂Bean主要用于实现框架机制,如(1)在JNDI中查找对象,可以使用JndiObjectFactoryBea...
  • QUITE_CGY
  • QUITE_CGY
  • 2017-04-21 10:49
  • 741

Spring中BeanFactory和FactoryBean的区别

org.springframework.beans及org.springframework.context包是Spring IoC容器的基础。BeanFactory提供的高级配置机制,使得管理任何性质的对象成为可能。ApplicationContext是BeanFactory的扩展,功能得到了进一步...
  • tanga842428
  • tanga842428
  • 2016-08-13 16:18
  • 1300

Spring BeanFactory 与 FactoryBean的区别

BeanFactory: 以Factory结尾,表示它是一个工厂类,是用于管理Bean的一个工厂 FactoryBean:以Bean结尾,表示它是一个Bean,不同于普通Bean的是:它是实现了FactoryBean<T>接口的Bean,根据该Bean的Id从BeanFactory中获取...
  • ggj20ss
  • ggj20ss
  • 2015-07-23 17:11
  • 1109
    个人资料
    • 访问:267239次
    • 积分:5158
    • 等级:
    • 排名:第6399名
    • 原创:229篇
    • 转载:11篇
    • 译文:0篇
    • 评论:50条
    博客专栏
    最新评论