专注于 JetBrains IDEA 全家桶,永久激活,教程
持续更新 PyCharm,IDEA,WebStorm,PhpStorm,DataGrip,RubyMine,CLion,AppCode 永久激活教程

Spring 


doCreateBean方法与
BeanWrapper对象

悄悄拔尖,然后惊艳所有人.期待与你一起进步.

1.万众期待的 doCreateBean

  今天这篇文章,开始分析在Spring中doCreateBean()方法。上一篇文章中提到的createBean()方法的一个子方法:

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
            throws BeanCreationException {

    // BeanWrapper 是用来持有创建出来的Bean对象
    BeanWrapper instanceWrapper = null;
    if (mbd.isSingleton()) {
        // 如果是singleton,先清除缓存中同名的Bean
        instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
    }
    if (instanceWrapper == null) {
        /*
         * 通过createBeanInstance 来完成Bean所包含的java对象的创建。
         * 对象的生成有很多种不同的方式,可以通过工厂方法生成,
         * 也可以通过容器的autowire特性生成,这些生成方式都是由BeanDefinition来指定的
         */
        instanceWrapper = createBeanInstance(beanName, mbd, args);
    }
    /* getWrappedInstance() 获得原生对象*/
    final Object bean = instanceWrapper.getWrappedInstance();
    Class<?> beanType = instanceWrapper.getWrappedClass();
    if (beanType != NullBean.class) {
        mbd.resolvedTargetType = beanType;
    }

    // Allow post-processors to modify the merged bean definition.
    synchronized (mbd.postProcessingLock) {
        if (!mbd.postProcessed) {
            try {
                applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
            }
            catch (Throwable ex) {
                throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                        "Post-processing of merged bean definition failed", ex);
            }
            mbd.postProcessed = true;
        }
    }

    /*
     * 是否需要提前曝光:单例 & 允许循环依赖& 当前的bean正在创建中,检测循环依赖
     */
    boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
            isSingletonCurrentlyInCreation(beanName));
    if (earlySingletonExposure) {
        if (logger.isTraceEnabled()) {
            logger.trace("Eagerly caching bean '" + beanName +
                    "' to allow for resolving potential circular references");
        }
        /*
         * setter 方法注入的Bean,通过提前暴露一个单例工厂方法
         * 从而能够使其他Bean引用到该Bean,注意通过setter方法注入的
         * Bean 必须是单例的才会到这里来。
         * 对 Bean 再一次依赖引用,主要应用 SmartInstantiationAwareBeanPostProcessor
         * 其中 AOP 就是在这里将advice动态织入bean中,若没有则直接返回,不做任何处理
         *
         * 在Spring中解决循环依赖的方法:
         *   在 B 中创建依赖 A 时通过 ObjectFactory 提供的实例化方法来中断 A 中的属性填充,
         *   使 B 中持有的 A 仅仅是刚初始化并没有填充任何属性的 A,初始化 A 的步骤是在最开始创建A的时候进行的,
         *   但是 因为 A 与 B 中的 A 所表示的属性地址是一样的,所以在A中创建好的属性填充自然可以通过B中的A获取,
         *   这样就解决了循环依赖。
         */
        addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
    }

    // Initialize the bean instance.
    /*
     * 将原生对象复制一份 到 exposedObject,这个exposedObject在初始化完成处理之后
     * 会作为依赖注入完成后的Bean
     */
    Object exposedObject = bean;
    try {
        /* Bean的依赖关系处理过程*/
        populateBean(beanName, mbd, instanceWrapper);
        /* 将原生对象变成代理对象*/
        exposedObject = initializeBean(beanName, exposedObject, mbd);
    }
    catch (Throwable ex) {
        if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
            throw (BeanCreationException) ex;
        }
        else {
            throw new BeanCreationException(
                    mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
        }
    }

    if (earlySingletonExposure) {
        Object earlySingletonReference = getSingleton(beanName, false);
        if (earlySingletonReference != null) {
            if (exposedObject == bean) {
                exposedObject = earlySingletonReference;
            }
            else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
                String[] dependentBeans = getDependentBeans(beanName);
                Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
                for (String dependentBean : dependentBeans) {
                    // 检测循环依赖
                    if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
                        actualDependentBeans.add(dependentBean);
                    }
                }
                /*
                 * 因为Bean创建后其所依赖的Bean一定是已经创建的,
                 * actualDependentBeans 不为空则表示当前bean创建后其依赖的Bean却没有全部创建完,
                 * 也就是说存在循环依赖
                 */
                if (!actualDependentBeans.isEmpty()) {
                    throw new BeanCurrentlyInCreationException(beanName,
                            "Bean with name '" + beanName + "' has been injected into other beans [" +
                            StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
                            "] in its raw version as part of a circular reference, but has eventually been " +
                            "wrapped. This means that said other beans do not use the final version of the " +
                            "bean. This is often the result of over-eager type matching - consider using " +
                            "'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
                }
            }
        }
    }

    // Register bean as disposable.
    try {
        registerDisposableBeanIfNecessary(beanName, bean, mbd);
    }
    catch (BeanDefinitionValidationException ex) {
        throw new BeanCreationException(
                mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
    }

    return exposedObject;
}

  简单归纳上述方法都完成了什么事:

  • ①:如果是单例首先需要清除缓存
  • ②:实例化 bean,将 BeanDefinition 转化为 BeanWrapper
  • ③:MergedBeanDefinitionPostProcessor 的应用
  • ④:依赖处理
  • ⑤:属性填充
  • ⑥:循环依赖处理
  • ⑦:注册 DisposableBean
  • ⑧:完成创建并返回

  isSingletonCurrentlyInCreation(beanName)在这里返回的时候为true。还记得在什么地方,将当前正在创建的beanName放入到 singletonsCurrentlyInCreation这个Set 集合中吗?

答案就是: getSingleton(String beanName, ObjectFactory<?> singletonFactory)方法中的 beforeSingletonCreation(beanName)方法中

121_1.png  在这里需要指出 addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean)); 这一行代码在Spring中解决循环依赖起着非常重要的作用。其原理就是,提前暴露 ObjectFactory 将其添加到 singletonFactories中去,然后通过 getObject()返回对象。

2.创建bean

  在今天这篇文章中,还将介绍创建 createBeanInstance() 返回 BeanWrapper 对象的入口,因为在Spring中创建对象的方式做了区分, 分为通过: 使用工厂方法对Bean进行实例化、通过构造方法自动装配的方式构造Bean对象、通过默认的无参构造方法进行实例化。每一种方式都有对应的方法进行处理。这里是完成 BeanWrapper创建的地方:

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
    // Make sure bean class is actually resolved at this point.
    /** 确认需要实例化的bean */
    Class<?> beanClass = resolveBeanClass(mbd, beanName);

    /**
     * 检查一个类的访问权限,spring默认情况下,对于非public的类是允许访问的
     */
    if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
        throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                "Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
    }

    Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
    if (instanceSupplier != null) {
        return obtainFromSupplier(instanceSupplier, beanName);
    }

    /** 使用工厂方法对Bean进行实例化*/
    if (mbd.getFactoryMethodName() != null) {
        return instantiateUsingFactoryMethod(beanName, mbd, args);
    }

    /**
     * 多次构建同一个Bean时,可以使用shortcut
     */
    boolean resolved = false;
    boolean autowireNecessary = false;
    if (args == null) {
        synchronized (mbd.constructorArgumentLock) {
            if (mbd.resolvedConstructorOrFactoryMethod != null) {
                resolved = true;
                // 如果已经解析了构造方法的参数,就必须通过一个带参数的构造方法来实例
                autowireNecessary = mbd.constructorArgumentsResolved;
            }
        }
    }
    if (resolved) {
        if (autowireNecessary) {
            // 通过构造方法自动装配的方式构造Bean对象
            return autowireConstructor(beanName, mbd, null, null);
        }
        else {
            // 通过默认的无参构造方法进行实例化
            return instantiateBean(beanName, mbd);
        }
    }

    // Candidate constructors for autowiring?
    /**
     * 使用构造函数进行实例化
     * 由后置处理器决定返回使用的构造方法
     * 当有多个构造器的时候,Spring 认为是没有通过构造器实例化的
     */
    Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
    if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
            mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
        return autowireConstructor(beanName, mbd, ctors, args);
    }

    // Preferred constructors for default construction?

    ctors = mbd.getPreferredConstructors();
    if (ctors != null) {
        return autowireConstructor(beanName, mbd, ctors, null);
    }

    // No special handling: simply use no-arg constructor.
    /** 使用默认的构造函数*/
    return instantiateBean(beanName, mbd);
}

  在上述方法中通过 determineConstructorsFromBeanPostProcessors()方法来确定使用哪个构造器来完成初始化。这里要注意的就是,当我们的类里面有多个构造器的时候,Spring认为是没有构造器使用的。这一部分的详细解释会在后面的文章,里面在做讨论。

3.BeanWrapper 对象

  这个方法返回主要是用来返回 BeanWrapper 对象。我自己对 BeanWrapper 的理解就是 Bean包装。Spring提供的一个用来操 做javaBean属性的工具,使用它可以直接修改一个对象的属性。BeanWrapper本身是一个接口,它提供了一整套处理Bean的方法,代码如下:

public interface BeanWrapper extends ConfigurablePropertyAccessor {

    /**
     * 为数组和集合自动增长指定一个限制。在普通的BeanWrapper上默认是无限的。
     */
    void setAutoGrowCollectionLimit(int autoGrowCollectionLimit);

    /**
     * 返回数组和集合自动增长的限制。
     */
    int getAutoGrowCollectionLimit();

    /**
     * 返回对象包装的bean实例
     */
    Object getWrappedInstance();

    /**
     * 返回被包装的Bean对象的类型。
     */
    Class<?> getWrappedClass();

    /**
     * 获取包装对象的PropertyDescriptors
     */
    PropertyDescriptor[] getPropertyDescriptors();

    /**
     * 获取包装对象的特定属性的属性描述符。
     */
    PropertyDescriptor getPropertyDescriptor(String propertyName) throws InvalidPropertyException;

}

  这个 BeanWrapper 在Spring中是对Bean实力化来说一个非常重要的对象,在进行依赖关系处理的时候会使用到该对象,关于依赖对象的注入,后面会有专门的文章分析。

文章永久链接:https://tech.souyunku.com/28063

未经允许不得转载:搜云库技术团队 » Spring 


doCreateBean方法与
BeanWrapper对象

JetBrains 全家桶,激活、破解、教程

提供 JetBrains 全家桶激活码、注册码、破解补丁下载及详细激活教程,支持 IntelliJ IDEA、PyCharm、WebStorm 等工具的永久激活。无论是破解教程,还是最新激活码,均可免费获得,帮助开发者解决常见激活问题,确保轻松破解并快速使用 JetBrains 软件。获取免费的破解补丁和激活码,快速解决激活难题,全面覆盖 2024/2025 版本!

联系我们联系我们