说说Spring中的BeanFactory和FactoryBean的区别

直接区别

直面意思：Bean工厂、工厂Bean。

BeanFactory，以Factory结尾，表示它是一个工厂类(接口)，用于管理Bean的一个工厂。在Spring中，BeanFactory是IOC容器的核心接口，它的职责包括：实例化、定位、配置应用程序中的对象及建立这些对象间的依赖。

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

BeanFacotry

BeanFactory定义了IOC容器的最基本形式，并提供了IOC容器应遵守的的最基本的接口，也就是Spring IOC所遵守的最底层和最基本的编程规范。

Spring代码中，BeanFactory只是个接口，并不是IOC容器的具体实现，但是Spring容器给出了很多种实现，如 DefaultListableBeanFactory、XmlBeanFactory、ApplicationContext等，都是附加了某种功能的实现。

public interface BeanFactory {
    // 该常量用来区分是获取FactoryBean还是FactoryBean的createBean创建的实例.如果&开始则获取FactoryBean;否则获取createBean创建的实例.
    // 备注，此常量课时定义在BeanFactory里面的哟，因为它属于Bean工厂的处理机制~~~
    String FACTORY_BEAN_PREFIX = "&";
    
    //==========获取bean,这边可以实现单例,原型
    Object getBean(String name) throws BeansException;
    <T> T getBean(String name, Class<T> requiredType) throws BeansException;
    Object getBean(String name, Object... args) throws BeansException;
    <T> T getBean(Class<T> requiredType) throws BeansException;
    <T> T getBean(Class<T> requiredType, Object... args) throws BeansException;    
    // ======== 
    <T> ObjectProvider<T> getBeanProvider(Class<T> requiredType);
    <T> ObjectProvider<T> getBeanProvider(ResolvableType requiredType);    
    //判断是否包含Bean。此处有个陷阱：这边不管类是否抽象类,懒加载,是否在容器范围内,只要符合都返回true,所以这边true,**不一定能从getBean获取实例**
    boolean containsBean(String name);    
       / =============是否是单例 类型匹配的一些判断
    boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
    boolean isPrototype(String name) throws NoSuchBeanDefinitionException;
    boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;
    boolean isTypeMatch(String name, Class<?> typeToMatch) throws NoSuchBeanDefinitionException;
    
    // 获取Bean的类型、别名等等
    @Nullable
    Class<?> getType(String name) throws NoSuchBeanDefinitionException;
    String[] getAliases(String name);

}

在Spring中，所有的Bean都是由BeanFactory(也就是IOC容器)来进行管理的。但对FactoryBean而言，这个Bean不是简单的Bean，而是一个能生产或者修饰对象生成的工厂Bean，它的实现与设计模式中的工厂模式和修饰器模式类似。

BeanFacotry是spring中比较原始的Factory。如XMLBeanFactory就是一种典型的BeanFactory。原始的BeanFactory无法支持spring的许多插件，如AOP功能、Web应用等。ApplicationContext接口,它由BeanFactory接口派生而来。

ApplicationContext包含BeanFactory的所有功能，通常建议比BeanFactory优先。

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

MessageSource, 提供国际化的消息访问
资源访问，如URL和文件
事件传播
载入多个（有继承关系）上下文，使得每一个上下文都专注于一个特定的层次，比如应用的web层；

常见的初始化例子：

Resource resource = new FileSystemResource("beans.xml");
BeanFactory factory = new XmlBeanFactory(resource);

ClassPathResource resource = new ClassPathResource("beans.xml");
BeanFactory factory = new XmlBeanFactory(resource);

ApplicationContext context = new ClassPathXmlApplicationContext(new String[] {"applicationContext.xml", "applicationContext-part2.xml"});
BeanFactory factory = (BeanFactory) context;

分析了从BeanFactory到ConfigurableListableBeanFactory接口的概要功能：

BeanFactory -> SpringIoC容器顶级接口，定义了对单个bean的获取，对bean的作用域判断，获取bean类型，获取bean别名的功能
ListableBeanFactory -> 扩展了BeanFactory接口,并提供了对bean的枚举能力
HierarchicalBeanFactory -> 扩展了BeanFactory接口,并提供了访问父容器的能力
AutowireCapableBeanFactory -> 扩展了BeanFactory接口,并提供了自动装配能力
ConfigurableBeanFactory -> 扩展了HierarchicalBeanFactory，并提供了对容器的配置能力
ConfigurableListableBeanFactory -> 扩展了ListableBeanFactory, AutowireCapableBeanFactory, ConfigurableBeanFactory接口,并提供了忽略依赖,自动装配判断,冻结bean的定义,枚举所有bean名称的功能

FactoryBean

这是个特殊的 Bean ，它是个工厂 Bean，可以产生 Bean 的 Bean。

一般情况下，Spring通过反射机制利用<bean>的class属性指定实现类实例化Bean，在某些情况下，实例化Bean过程比较复杂，如果按照传统的方式，则需要在<bean>中提供大量的配置信息。

这样，配置方式的灵活性是受限的，这时采用编码的方式可能会得到一个简单的方案。Spring为此提供了一个org.springframework.bean.factory.FactoryBean的工厂类接口，用户可以通过实现该接口定制实例化Bean的逻辑。

FactoryBean接口对于Spring框架来说占用重要的地位，Spring自身就提供了70多个FactoryBean的实现。

第三方框架要继承进Spring，往往就是通过实现FactoryBean来集成的。比如MyBatis的SqlSessionFactoryBean、RedisRepositoryFactoryBean、EhCacheManagerFactoryBean等等。

当然，我们也可以自己手动来实现一个FactoryBean，用来代理一个对象。从而可以很方便的在对象前后都做出对应的操作，比如输出一句日志：

/**
 * 自己实现一个FactoryBean 生产出来的对象的前后都输出一个日志
 * <p>
 * InitializingBean：初始化完成后执行操作
 * DisposableBean：销毁后做出对应操作
 */
public class MyFactoryBean implements FactoryBean<Object> {

    private static final Logger logger = LoggerFactory.getLogger(MyFactoryBean.class);
    private Class<?> interfaceClazz; //实现的接口的全类名
    private Object target; //该接口的实现类
    private Object proxyObj;

    public MyFactoryBean(Class<?> interfaceClazz, Object target) {
        this.interfaceClazz = interfaceClazz;
        this.target = target;
        this.proxyObj = Proxy.newProxyInstance(
                this.getClass().getClassLoader(),
                new Class[]{interfaceClazz}, //默认必须实现这个接口
                (proxy, method, args) -> {
                    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;
                });
    }

    @Override
    public Object getObject() {
        return proxyObj; //返回这个代理对象 而不是new直接new出来的对象
    }

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

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

有了这个工厂Bean，我们出去的Bean都将是代理Bean。

main方法单元测试：

public static void main(String[] args) {
    MyFactoryBean factoryBean = new MyFactoryBean(UserService.class, new UserServiceImpl());

    UserService userService = (UserService) factoryBean.getObject();
    System.out.println(userService.sayHello());
}

private interface UserService {
    String sayHello();
}

private static class UserServiceImpl implements MyFactoryBean.UserService {

    @Override
    public String sayHello() {
    	return "hello world";
    }
}

控制台输出：

16:17:05.330 [main] DEBUG com.fsx.single.temp.MyFactoryBean - invoke method......sayHello
16:17:05.334 [main] DEBUG com.fsx.single.temp.MyFactoryBean - invoke method before......1545121025334
16:17:05.334 [main] DEBUG com.fsx.single.temp.MyFactoryBean - invoke method after......1545121025334
hello world

ObjectFactory

通过接口内容来看，两者都是属于工厂模式用来创建对象使用的。

先来看个例子：

@Configuration
public class RootConfig {

    @Bean
    public FactoryBean myFactoryBean() {
        return new MyFactoryBean();
    }

    @Bean
    public ObjectFactory myObjectFactory() {
        return new MyObjectFactory();
    }

    public static class MyFactoryBean implements FactoryBean<Daughter> {

        @Override
        public Daughter getObject() throws Exception {
            return new Daughter();
        }

        @Override
        public Class<?> getObjectType() {
            return Daughter.class;
        }
    }

    public static class MyObjectFactory implements ObjectFactory<Son> {

        @Override
        public Son getObject() throws BeansException {
            return new Son();
        }
    }

}


    @Autowired
    private ApplicationContext applicationContext;
    @Autowired
    private RootConfig.MyFactoryBean myFactoryBean;
    @Autowired
    private RootConfig.MyObjectFactory myObjectFactory;
    @Autowired
    private Daughter daughter;
    //@Autowired //这里son不能直接注入，但是上面的daughter可以，因为它是FactoryBean，Spring在Bean初始化时会对其进行支持处理
    //private Son son;

    @ResponseBody
    @GetMapping("/hello")
    public String helloGet() throws Exception {
        // 这里注意一下：ApplicationContext是可以直接注入的，可谓非常的方便（至于原因：原理的博文里有说）
        System.out.println(applicationContext); //WebApplicationContext for namespace 'dispatcher-servlet': s ...
        System.out.println(applicationContext.getParent()); //Root WebApplicationContext: startup date [Tue Mar 05

        //========================================
        System.out.println(myFactoryBean); //com.fsx.config.RootConfig$MyFactoryBean@1f8bccbb
        // 这样子，我们是能拿到一个对象的。但需要注意：每get一次，就是new了一个新的
        System.out.println(myObjectFactory.getObject()); //com.fsx.bean.Son@309e3495
        System.out.println(daughter); //com.fsx.bean.Daughter@6cb10346

        // 需要注意的是：单独自己去get的话，出来的都是不同的对象（因此此工厂Bean，Spring又没有增强，所以铁定会执行方法体）
        System.out.println(myFactoryBean.getObject() == myFactoryBean.getObject()); //false
        System.out.println(myObjectFactory.getObject() == myObjectFactory.getObject()); //false
        return "hello...Get";
    }

从上面的现象打印值的不同，可以看出FactoryBean和ObjectFactory最直接的区别。

ObjectFactory则只是一个普通的对象工厂接口。在查看AbstractBeanFacotry的doGetBean(…) 部分的源码时，可以看到spring对ObjectFactory的应用之一就是，将创建对象的步骤封装到ObjectFactory中交给自定义的Scope来选择是否需要创建对象来灵活的实现scope。

两者的区别：

FactoryBean的着重于自定义创建对象过程，由BeanFactory通过FactoryBean来获取目标对象，而如果是isSingleton返回true的话，spring会利用单例缓存来缓存通过FactoryBean创建的对象。
而ObjectFactory就是一个普通的工厂对象接口，对于spring在doGetBean处的使用时，在于创建对象的过程由框架通过ObjectFactory定义，而创建的时机交给拓展接口Scope，除此之外ObjectFactory就是一个普通的接口。此外在将给依赖注入列表注册一个ObjectFactory类型的对象，在注入过程中会调用objectFactory.getObject()来创建目标对象注入进去。（如beanFactory.registerResolvableDependency(HttpSession.class, new SessionObjectFactory());）

参考：

【小家Spring】一文读懂Spring中的BeanFactory和FactoryBean（以及它和ObjectFactory的区别）的区别

posted @ 2021-12-09 21:44 残城碎梦阅读(314) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

阅读排行：
· 使用C#创建一个MCP客户端
· 分享一个免费、快速、无限量使用的满血 DeepSeek R1 模型，支持深度思考和联网搜索！
· ollama系列1：轻松3步本地部署deepseek，普通电脑可用
· 基于 Docker 搭建 FRP 内网穿透开源项目（很简单哒）
· 按钮权限的设计及实现

残城碎梦

说说Spring中的BeanFactory和FactoryBean的区别

公告

常用链接

积分与排名

随笔分类 (1448)