Spring实战(2)-FactoryBean接口

最新推荐文章于 2024-06-27 15:45:00 发布
最新推荐文章于 2024-06-27 15:45:00 发布
阅读量297 收藏
点赞数 1
分类专栏： Java 文章标签： spring IOC
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/heyrian/article/details/81040794
版权

今天来学习spring中重要的接口FactoryBean

FactoryBean接口

首先来看看FactoryBean接口的内容和作用

package org.springframework.beans.factory;

import org.springframework.lang.Nullable;

public interface FactoryBean<T> {
    @Nullable
    T getObject() throws Exception;

    @Nullable
    Class<?> getObjectType();

    default boolean isSingleton() {
        return true;
    }
}

  • T getObject()：返回由FactoryBean创建的bean实例，如果isSingleton()返回true，则该实例会放到Spring容器中单实例缓存池中。

  • Class<T> getObjectType()：返回FactoryBean创建的bean类型

  • boolean isSingleton()：返回由FactoryBean创建的bean实例的作用域是singleton还是prototype。

当我们通过spring创建bean时，如果该类是FactoryBean的实现类，那么当通过getBean()方法获取bean时，实际调用的是FactoryBean#getObject方法返回的对象，相当于FactoryBean#getObject代理了getBean()方法

如果不想被getObject方法代理，那么在获取Bean时，要在beanName的前面加上&

源码分析

不管通过getBean的那个重载方法获取Bean,最后getBean方法内部都是通过doGetBean来获取bean，先来看看doGetBean

protected <T> T doGetBean(String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly) throws BeansException {
        String beanName = this.transformedBeanName(name);
        Object sharedInstance = this.getSingleton(beanName);
        Object bean;
        if (sharedInstance != null && args == null) {
            if (this.logger.isDebugEnabled()) {
                if (this.isSingletonCurrentlyInCreation(beanName)) {
                    this.logger.debug("Returning eagerly cached instance of singleton bean '" + beanName + "' that is not fully initialized yet - a consequence of a circular reference");
                } else {
                    this.logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
                }
            }

            bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, (RootBeanDefinition)null);
        } else {
            if (this.isPrototypeCurrentlyInCreation(beanName)) {
                throw new BeanCurrentlyInCreationException(beanName);
            }

            BeanFactory parentBeanFactory = this.getParentBeanFactory();
            if (parentBeanFactory != null && !this.containsBeanDefinition(beanName)) {
                String nameToLookup = this.originalBeanName(name);
                if (parentBeanFactory instanceof AbstractBeanFactory) {
                    return ((AbstractBeanFactory)parentBeanFactory).doGetBean(nameToLookup, requiredType, args, typeCheckOnly);
                }

                if (args != null) {
                    return parentBeanFactory.getBean(nameToLookup, args);
                }

                return parentBeanFactory.getBean(nameToLookup, requiredType);
            }

            if (!typeCheckOnly) {
                this.markBeanAsCreated(beanName);
            }

            try {
                RootBeanDefinition mbd = this.getMergedLocalBeanDefinition(beanName);
                this.checkMergedBeanDefinition(mbd, beanName, args);
                String[] dependsOn = mbd.getDependsOn();
                String[] var11;
                if (dependsOn != null) {
                    var11 = dependsOn;
                    int var12 = dependsOn.length;

                    for(int var13 = 0; var13 < var12; ++var13) {
                        String dep = var11[var13];
                        if (this.isDependent(beanName, dep)) {
                            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
                        }

                        this.registerDependentBean(dep, beanName);

                        try {
                            this.getBean(dep);
                        } catch (NoSuchBeanDefinitionException var24) {
                            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "'" + beanName + "' depends on missing bean '" + dep + "'", var24);
                        }
                    }
                }

                if (mbd.isSingleton()) {
                    sharedInstance = this.getSingleton(beanName, () -> {
                        try {
                            return this.createBean(beanName, mbd, args);
                        } catch (BeansException var5) {
                            this.destroySingleton(beanName);
                            throw var5;
                        }
                    });
                    bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
                } else if (mbd.isPrototype()) {
                    var11 = null;

                    Object prototypeInstance;
                    try {
                        this.beforePrototypeCreation(beanName);
                        prototypeInstance = this.createBean(beanName, mbd, args);
                    } finally {
                        this.afterPrototypeCreation(beanName);
                    }

                    bean = this.getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
                } else {
                    String scopeName = mbd.getScope();
                    Scope scope = (Scope)this.scopes.get(scopeName);
                    if (scope == null) {
                        throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
                    }

                    try {
                        Object scopedInstance = scope.get(beanName, () -> {
                            this.beforePrototypeCreation(beanName);

                            Object var4;
                            try {
                                var4 = this.createBean(beanName, mbd, args);
                            } finally {
                                this.afterPrototypeCreation(beanName);
                            }

                            return var4;
                        });
                        bean = this.getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
                    } catch (IllegalStateException var23) {
                        throw new BeanCreationException(beanName, "Scope '" + scopeName + "' is not active for the current thread; consider defining a scoped proxy for this bean if you intend to refer to it from a singleton", var23);
                    }
                }
            } catch (BeansException var26) {
                this.cleanupAfterBeanCreationFailure(beanName);
                throw var26;
            }
        }

        if (requiredType != null && !requiredType.isInstance(bean)) {
            try {
                T convertedBean = this.getTypeConverter().convertIfNecessary(bean, requiredType);
                if (convertedBean == null) {
                    throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
                } else {
                    return convertedBean;
                }
            } catch (TypeMismatchException var25) {
                if (this.logger.isDebugEnabled()) {
                    this.logger.debug("Failed to convert bean '" + name + "' to required type '" + ClassUtils.getQualifiedName(requiredType) + "'", var25);
                }

                throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
            }
        } else {
            return bean;
        }
    }

通过源码观察发现，getObjectForBeanInstance方法是创建bean的关键方法，

protected Object getObjectForBeanInstance(Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {
        if (BeanFactoryUtils.isFactoryDereference(name)) {//判断是否是对FactoryBean的解引用,即Bean的name前面是否加&
            if (beanInstance instanceof NullBean) {
                return beanInstance;
            }

            if (!(beanInstance instanceof FactoryBean)) {//如果是解应用，但bean对象不是FactoryBean，抛出异常，即获取普通的Bean时beanName前面不用加&
                throw new BeanIsNotAFactoryException(this.transformedBeanName(name), beanInstance.getClass());
            }
        }
        //如果是FactoyBean的实现类，且不是解应用
        if (beanInstance instanceof FactoryBean && !BeanFactoryUtils.isFactoryDereference(name)) {
            Object object = null;
            if (mbd == null) {
                object = this.getCachedObjectForFactoryBean(beanName); //从Bean工厂缓存中获取给定名称的实例对象
            }

            if (object == null) {
                FactoryBean<?> factory = (FactoryBean)beanInstance;
                if (mbd == null && this.containsBeanDefinition(beanName)) {
                    mbd = this.getMergedLocalBeanDefinition(beanName);
                }

                boolean synthetic = mbd != null && mbd.isSynthetic();
                object = this.getObjectFromFactoryBean(factory, beanName, !synthetic);
            }

            return object;
        } else {//这一步是获取普通Bean的途径
            return beanInstance;
        }
    }

上面这个方法就是判断FactoryBean和是否要获取普通Bean。getObjectFromFactoryBean是获取非解应用的关键方法：

private Object doGetObjectFromFactoryBean(FactoryBean<?> factory, String beanName) throws BeanCreationException {
        Object object;
        try {
            if (System.getSecurityManager() != null) {
                AccessControlContext acc = this.getAccessControlContext();

                try {
                    object = AccessController.doPrivileged(factory::getObject, acc);
                } catch (PrivilegedActionException var6) {
                    throw var6.getException();
                }
            } else {
                object = factory.getObject();
            }
        } catch (FactoryBeanNotInitializedException var7) {
            throw new BeanCurrentlyInCreationException(beanName, var7.toString());
        } catch (Throwable var8) {
            throw new BeanCreationException(beanName, "FactoryBean threw exception on object creation", var8);
        }

        if (object == null) {
            if (this.isSingletonCurrentlyInCreation(beanName)) {
                throw new BeanCurrentlyInCreationException(beanName, "FactoryBean which is currently in creation returned null from getObject");
            }

            object = new NullBean();
        }

        return object;
    }

发现最后关键是factory#getObject，到此我们算了解了FactoryBean的原理

heyrian
关注
专栏目录
SpringBoot/Spring扩展点系列之FactoryBean让你不在懵逼 - 第435篇
悟纤学院
07-18 460
当Bean的创建过程比较复杂的话，通过FactoryBean来实现实现Bean的复杂创建过程，这个时候FactoryBean的话，可以让使用者使用起来很简单无需关心Bean的创建过程，听起来是不是很像工厂设计模型。
FactoryBean接口
姜希成的博客
11-15 368
Bean可以继承此接口。 getBean的时候，BeanName如果以 & 开头，就直接返回此Bean 如果不是，就返回 getObject() public interface FactoryBean<T> { String OBJECT_TYPE_ATTRIBUTE = "factoryBeanObjectType"; @Nullable T getObject() throws Exception; @Nullable Class<
Spring FactoryBean实战教程
neweastsun的专栏
03-31 360
Spring Bean容器中有两者类型bean：普通bean和工厂bean。前者Spring直接使用，而后者能产生被框架管理的对象。我们可以实现org.springframework.beans.factory.FactoryBean 接口构建工厂bean。 1. 基本工厂bean 2.1 实现FactoryBean 首先看FactoryBean接口定义： public interface FactoryBean { T getObject() throws Exception; Class
Spring框架FactoryBean接口的作用和应用
最新发布
八戒的博客
06-27 651
如果还带有泛型XxxxFactoryBean，就说明这是一个抽象类，具体的创建实例的过程在其子类中。FactoryBean是一个特殊的bean，用于创建和管理自定义 Bean 实例的工厂bean，其中类名中的泛型就是要创建Bean的类名，如果子类是一个抽象类，那么具体的创建实例过程会延伸到其子类。当我们使用 FactoryBean 的时候，Spring 在实例化 Bean 的时候，实例化的是MyBean2FactoryBean 工厂 Bean，MyBean2则是在工厂 Bean中实例化的。
FactoryBean 接口
默翁的博客
04-21 166
Spring 中有两种类型的Bean，一种是普通Bean，另一种是工厂Bean，即FactoryBean，这两种Bean都被容器管理，但工厂Bean跟普通 Bean不同，其返回的对象不是指定类的一个实例，其返回的是该FactoryBean的getObject方法所返回的对象。 接口FactoryBean是由Spring提供的工厂Bean的标准接口,提供了如下3个方法 (1)Object ge...
spring----通过实现FactoryBean接口来配置Bean----笔记
thread
09-21 218
Bean配置文件 &lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springf
spring-boot-starter-mybatis-spring-boot-2.1.3.tar.gz
04-19
1. `@Mapper`注解：标记在Mapper接口上，表明该接口是MyBatis的Mapper，Spring会自动将其与XML配置关联。 2. `@Autowired`注解：用于注入Mapper接口实例，便于业务层调用。 3. `@Select`, `@Insert`, `@Update`, `@...
SpringPlugin-Core在业务中的应用
乌托拉赛文的博客
10-14 1752
前言 一直负责部门的订单模块，从php转到Java也是如此，换了一种语言来实现订单相关功能。那么Spring里有很多已经搭建好基础模块的设计模式来帮助我们解耦实际业务中的逻辑，用起来非常的方便！就比如我们的订单操作模块。生成订单后，有很多操作。比如：取消、支付、关闭…等等。那么用设计模式的思想去处理这些不同的操作，最好用的就是策略模式来解决它们！把不同的操作分配到不同的实现类里去。这不，我发现了一个不错的东西Spring plugin! Spring Plugin Spring plugin这个小东西我也是
Spring组件注册 - springboot实战电商项目mall4j
mall4j的博客
12-13 706
springboot实战电商项目mall4j （https://gitee.com/gz-yami/mall4j) java开源商城系统 1. bean注册 我们有个Person类 public class Person { private Integer age; private String name; public Integer getAge() { return age; } public void setAge(Integer age) { this.age = ag
利用Spring扩展点模拟Feign实现远程调用（干货满满）「扩展点实战系列」- 第445篇
悟纤学院
09-26 502
用过MyBatis的注解编程和@FeignClient，是不是有一点好奇，我们写的代码都是接口，也没有具体的实现类，接口怎么能执行呢？底层到底发生了事情？通过本节模拟FeignClient将会揭开MyBatis和FeignCleint的面纱
Spring实战之调用实例工厂方法创建Bean操作示例
08-25
主要介绍了Spring实战之调用实例工厂方法创建Bean操作,结合实例形式分析了实例工厂方法创建Bean相关配置、实现方法及操作注意事项,需要的朋友可以参考下
Spring实战——容器中的工程Bean
实践求真知
09-24 232
一配置 <?xml version="1.0" encoding="GBK"?> <beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.springframework.org/schema/beans" xsi:schemaLocation="http...
《读spring源码》14实现FactoryBean接口
ppwwp的专栏
11-30 160
package com.enjoy.cap6; import com.enjoy.cap1.Person; import com.enjoy.cap5.LinCodition; import com.enjoy.cap5.WinCodition; import org.springframework.context.annotation.Bean; import org.springframe...
Spring学习:通过实现FactoryBean接口来创建配置比较复杂的IOC容器对象（Bean）
给时光以文明
06-25 221
一、简介： 在Spring IOC容器中有两种类型的Bean，一种是普通的Bean，即自定义创建的Bean类；另一种是工厂Bean，即通过工厂产生返回给IOC容器的Bean。在这里重点学习通过工厂创建返回给IOC容器的Bean，即工厂Bean。 二、工厂Bean应用的主要场合 如果普通bean的配置比较复杂，在配置文件中定义时步骤比较多，此时可以使用 FactoryBean，即实现于接口FactoryBean的类，加载到xml配置文件中所产生的Bean。 三、定义FactoryBean的步骤 定义一个类，
007---实现FactoryBean接口注册组件（方式四）
热门推荐
诗水人间
02-02 14万+
第一步、实现FactoryBean接口 示例代码：传入泛型<>包裹的，即HelloWorld的工厂bean package config; import bean.HelloWorld; import org.springframework.beans.factory.FactoryBean; public class DemoFactoryBean implements F...
【Spring：FactoryBean接口】实现FactoryBean接口，Spring在初始化bean时有何不同
吃货小跟班的博客
03-23 1564
问题描述：最近想要再次熟悉一下阿里中间件HSF的用法，在消费HSF时需要在Spring的配置文件中进行如下配置：<bean id="myClassB" class="com.taobao.hsf.app.spring.util.HSFSpringConsumerBean"> <property name="interfaceName"> <value>com.lican.Mycla
Spring FactoryBean接口
ai_xiangjuan的博客
10-20 427
如果一个bean实现FactoryBean，那么它就不是一个简单的bean，类似于java模式中的工厂模式，用于生产不同的Object。 举例 public class OkHttpClientFactoryBean implements FactoryBean, DisposableBean { private int connectTimeout; private int readTim...
FactoryBean使用及真实应用场景
weixin_45996580的博客
05-28 1184
FactoryBean主要是用来在spring初始化的过程中创建bean的工厂，个人理解它更像一个插件的接口。可以将第三方的类优雅的加载到spring容器中。可能还有其他功能有待开发。
Spring 中beanfactory和 factorybean
03-29
FactoryBean 也是 Spring 框架中的一个接口，它是用来创建 bean 的工厂类。FactoryBean 的作用是将复杂的 bean 创建过程封装起来，让我们可以通过配置文件来定义 bean 的创建方式，而不需要在代码中直接编写复杂的 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值