Spring IOC加载流程

已于 2022-06-23 00:07:41 修改
阅读量1.8w 收藏 12
点赞数 2
分类专栏： Spring 文章标签： java spring boot spring
于 2022-03-26 21:58:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JokerLJG/article/details/123475366
版权

文章目录

Bean配置方式

1. 注解

相应注解包括：@Component、@Controller、@RestController、@Service、@Repository等。

2. XML

3. JavaConfig

IOC加载流程

IOC加载流程图
请添加图片描述

Bean具体加载流程图
请添加图片描述

三级缓存原理

Sping使用三级缓存模式主要是为了出于对IOC和AOP的考虑，三级缓存既能解决循环依赖，也能解决AOP（生成代理bean）。

注意：三级缓存只在单例bean中涉及，非单例bean不涉及三级缓存。

解决循环依赖和代理，其实使用二级缓存和三级缓存的方式都能做到。

  • 二级缓存方式：不管有没有循环依赖，都提前创建好代理对象，并将代理对象放入二级缓存，出现循环依赖时，其他对象直接就可以取到代理对象并注入。

  • 三级缓存方式：先只生成对象工厂，并放入到三级缓存，不提前创建好代理对象，在出现循环依赖被其他对象注入时，才通过三级缓存中的对象工厂生成代理对象，并将代理对象放入二级缓存。

    这样在没有循环依赖的情况下，bean就可以按着Spring设计原则的步骤来创建。（Sping使用的就是这种方式）。这种情况下，早期的bean也不会真正暴露，不用提前执行代理过程，也不用重复执行代理过程。

为何使用三级缓存，而不是二级缓存

下面从两点原因来分析：

  1. 如果要使用二级缓存解决循环依赖，意味着Bean在构造（实例化）完后就创建代理对象，这样违背了Spring设计原则。

    Spring正常的代理应该是发生在bean初始化后，由AbstractAutoProxyCreator.postProcessAfterInitialization处理。而循环依赖要求bean在填充属性前就提前生成代理。

    如果所有bean都提前生成代理，那AbstractAutoProxyCreator.postProcessAfterInitialization就直接没用了，相当于把原来生成代理的设计完全舍弃，但这么做只是为了解决循环依赖。这是得不尝试的，在非必要的情况下对核心代码大改甚至推翻重写是一种大忌。

    所以Spring在原有设计的基础上做了扩展：

    1. 当循环依赖发生时，提前代理；

      对象实例化后用ObjectFactory封装对象，并放到三级缓存（提前曝光的是ObjectFactory对象）。在遇到循环依赖，对象被注入时，才通过ObjectFactory.getObject方法生成代理对象，并把代理对象放入到第二级缓存。

    2. 为了防止对象在后面的初始化时重复代理，在生成代理对象时，earlyProxyReferences缓存会记录已代理的对象。

    3. 当没有循环依赖时，代理方式不变，依然是初始化后完成代理。

三级缓存中的第二级缓存（提前保留的半成品bean）只有在出现循环依赖的情况是才会用到，未出现循环依赖时并不会用到。

  1. 二级缓存在以下特殊情况下，无法解决循环依赖问题

    1. 通过构造器注入Bean的情况，无法解决循环依赖问题
    2. 通过Setter注入代理Bean的情况，无法解决循环依赖问题
    3. 设置了@DependsOn的的情况，无法解决循环依赖问题

三级缓存作用

缓存级别缓存名称描述
一级缓存singletonObjects存放完成品bean对象（可能是原对象或代理对象）
从该缓存中取出的bean可以直接使用
二级缓存earlySingletonObjects存放半成品bean对象（可能是原对象或代理对象）早期曝光的bean对象
半成品bean对象是已实例化（但未注入属性和初始化），提早暴露的。
三级缓存singletonFactories存放bean的工厂对象
用来生成半成品的bean并放入到二级缓存中。
工厂对象封装了实例化（但未注入属性和初始化）的原对象。

三级缓存源码

三级缓存源码类：DefaultSingletonBeanRegistry

一级缓存：存放实例化+属性注入+初始化+代理（如果有代理）后的单例bean

private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);

二级缓存：存放实例化+代理（如果有代理）后的单例bean

private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);

三级缓存：存放封装了单例bean（实例化的）的对象工厂

private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);

其它属性

// 已经完成注册的单例beanName
private final Set<String> registeredSingletons = new LinkedHashSet<>(256);
// 正在创建中的beanName
private final Set<String> singletonsCurrentlyInCreation =  Collections.newSetFromMap(new ConcurrentHashMap<>(16));
// 当前不检查的bean的集合
private final Set<String> inCreationCheckExclusions = Collections.newSetFromMap(new ConcurrentHashMap<>(16));
// 存放异常出现的相关的原因的集合
private Set<Exception> suppressedExceptions;
// 标志，目前是否在销毁单例中
private boolean singletonsCurrentlyInDestruction = false;
// 存放一次性bean的缓存
private final Map<String, Object> disposableBeans = new LinkedHashMap<>();
// 外部bean与被包含在外部bean的所有内部bean集合包含关系的缓存
private final Map<String, Set<String>> containedBeanMap = new ConcurrentHashMap<>(16);
// 指定bean与依赖指定bean的所有bean的依赖关系的缓存
private final Map<String, Set<String>> dependentBeanMap = new ConcurrentHashMap<>(64);
// 指定bean与创建这个bean所需要依赖的所有bean的依赖关系的缓存
private final Map<String, Set<String>> dependenciesForBeanMap = new ConcurrentHashMap<>(64);

三级缓存源码详细描述可参考文章：Spring三级缓存源码

Bean加载核心方法

1. getSingleton(beanName)

DefaultSingletonBeanRegistry.getSingleton(String beanName)

从缓存中获取单例bean。

  • 如果一级缓存有直接返回；
  • 如果二级缓存有直接返回；
  • 如果三级缓存有，通过singletonFactory.getObject()得到未完成的单例对象（实例化，但未属性注入和初始化），放入到二级缓存，并删除三级缓存。
    /**
     * 获取单例（从缓存中获取）
     */
    @Override
    @Nullable
    public Object getSingleton(String beanName) {
        // 允许早期依赖
        return getSingleton(beanName, true);
    }

    /**
     * 获取单例
     * 1.如果一级缓存有直接返回
     * 2.如果二级缓存有直接返回
     * 3.如果三级缓存有，通过singletonFactory.getObject()的到未完成的单例对象，并移除三级缓存，返回未完成的单例对象
     * @param allowEarlyReference  true：允许早期依赖
     * @return
     */
    @Nullable
    protected Object getSingleton(String beanName, boolean allowEarlyReference) {
        // 如果一级缓存有，直接返回
        Object singletonObject = this.singletonObjects.get(beanName);
        // 如果一级缓存没有，但正在创建
        if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
            synchronized (this.singletonObjects) {
                // 如果二级缓存中有，说明正在加载，则直接返回
                singletonObject = this.earlySingletonObjects.get(beanName);
                // 二级缓存也没有，且允许早期依赖
                if (singletonObject == null && allowEarlyReference) {
                    ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                    // 三级缓存有，调用getObject方法创建bean并放入到二级缓存，并删除三级缓存
                    if (singletonFactory != null) {
                        singletonObject = singletonFactory.getObject();
                        this.earlySingletonObjects.put(beanName, singletonObject);
                        this.singletonFactories.remove(beanName);
                    }
                }
            }
        }
        return singletonObject;
    }

2. getSingleton(beanName，singletonFactory)

DefaultSingletonBeanRegistry.getSingleton(String beanName, ObjectFactory<?> singletonFactory)

获取单例bean。

  • 若一级缓存中有，返回一级缓存的bean；
  • 否则通过对象工厂的singletonFactory.getObject()方法得到bean，并放入一级缓存中，移除其他级的缓存。
    /**
     * 获取单例（没有则创建）
     */
    public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
        Assert.notNull(beanName, "Bean name must not be null");
        synchronized (this.singletonObjects) {
            // 一级缓存有，直接返回
            Object singletonObject = this.singletonObjects.get(beanName);
            if (singletonObject == null) {
                // 当前正在销毁bean，不能创建
                if (this.singletonsCurrentlyInDestruction) {
                    throw new BeanCreationNotAllowedException(beanName,
                            "Singleton bean creation not allowed while singletons of this factory are in destruction " +
                                    "(Do not request a bean from a BeanFactory in a destroy method implementation!)");
                }
                if (logger.isDebugEnabled()) {
                    logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
                }
                // 创建前检查，记录正在加载状态
                beforeSingletonCreation(beanName);
                boolean newSingleton = false;
                // 如果当前没有异常，初始化异常集合
                boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
                if (recordSuppressedExceptions) {
                    this.suppressedExceptions = new LinkedHashSet<>();
                }
                try {
                    // 调用getObject方法创建bean
                    singletonObject = singletonFactory.getObject();
                    newSingleton = true;
                }
                catch (IllegalStateException ex) {
                    // 有可能是其他方式创建的bean
                    singletonObject = this.singletonObjects.get(beanName);
                    if (singletonObject == null) {
                        throw ex;
                    }
                }
                catch (BeanCreationException ex) {
                    if (recordSuppressedExceptions) {
                        for (Exception suppressedException : this.suppressedExceptions) {
                            ex.addRelatedCause(suppressedException);
                        }
                    }
                    throw ex;
                }
                finally {
                    if (recordSuppressedExceptions) {
                        this.suppressedExceptions = null;
                    }
                    // 创建后检查，移除加载状态
                    afterSingletonCreation(beanName);
                }
                // 如果是新创建的bean，添加到一级缓存（并移除二级、三级缓存）
                if (newSingleton) {
                    addSingleton(beanName, singletonObject);
                }
            }
            return singletonObject;
        }
    }

3. createBeanInstance(beanName, mbd, args)

AbstractAutowireCapableBeanFactory.createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args)

实例化。

    protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
        // 解析class
        Class<?> beanClass = resolveBeanClass(mbd, beanName);
        //确保class不为空，并且访问权限为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());
        }
        //配置的一种特殊的callback回调方法，通过这个callback创建bean
        Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
        if (instanceSupplier != null) {
            return obtainFromSupplier(instanceSupplier, beanName);
        }
        //通过工厂方法创建
        if (mbd.getFactoryMethodName() != null)  {
            return instantiateUsingFactoryMethod(beanName, mbd, args);
        }
        // 一个类可能有多个构造器，所以Spring得根据参数个数、类型确定需要调用的构造器
        // 在使用构造器创建实例后，Spring会将解析过后确定下来的构造器或工厂方法保存在缓存中，避免再次创建相同bean时再次解析
        boolean resolved = false;
        boolean autowireNecessary = false;
        if (args == null) {
            synchronized (mbd.constructorArgumentLock) {
                if (mbd.resolvedConstructorOrFactoryMethod != null) {
                    //已经解析过class的构造器
                    resolved = true;
                    autowireNecessary = mbd.constructorArgumentsResolved;
                }
            }
        }
        if (resolved) {
            //已经解析过class的构造器，使用已经解析好的构造器
            if (autowireNecessary) {
                //构造函数自动注入
                return autowireConstructor(beanName, mbd, null, null);
            }
            else {
                //使用默认构造器
                return instantiateBean(beanName, mbd);
            }
        }
        // 需要根据参数解析、确定构造函数
        Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
        // 解析的构造器不为空 || 注入类型为构造函数自动注入 || bean定义中有构造器参数 || 传入参数不为空
        if (ctors != null ||
                mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
                mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args))  {
            //构造函数自动注入
            return autowireConstructor(beanName, mbd, ctors, args);
        }
        // 使用默认构造器
        return instantiateBean(beanName, mbd);
    }

4. addSingletonFactory(beanName，singletonFacotry)

DefaultSingletonBeanRegistry.addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory)

添加bean的对象工厂到三级缓存。

  • 三级缓存中放的是bean的对象工厂，里面封装了刚实例化的bean原始对象。
    /**
     * 添加到三级级缓存
     */
    protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
        Assert.notNull(singletonFactory, "Singleton factory must not be null");
        synchronized (this.singletonObjects) {
            // 如果一级缓存没有，添加对象工厂到三级缓存
            if (!this.singletonObjects.containsKey(beanName)) {
                this.singletonFactories.put(beanName, singletonFactory);
                this.earlySingletonObjects.remove(beanName);
                this.registeredSingletons.add(beanName);
            }
        }
    }

5. populateBean(beanName, mbd, instanceWrapper)

AbstractAutowireCapableBeanFactory.populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw)

属性注入。

protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
    /*
     * 1 校验bw为null的情况
     * 如果此bean定义中定义了<property>标签，那么抛出异常，其他情况则直接返回
     */
    //如果bw为null
    if (bw == null) {
        //如果mbd存在propertyValues属性，即定义了<property>标签
        //因为BeanWrapper都为null了，不能进行依赖注入，那么抛出异常
        if (mbd.hasPropertyValues()) {
            throw new BeanCreationException(
                    mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
        } else {
            //跳过null实例的属性装配阶段
            return;
        }
    }

    /*
     * 2 在bean实例化之后，属性填充（初始化）之前，回调InstantiationAwareBeanPostProcessor后处理器的
     * postProcessAfterInstantiation方法，可用于修改bean实例的状态
     *
     * Spring在这个扩展点方法中没有任何额外操作，但是我们可以自定义后处理器，重写该方法定义自己的逻辑。
     */
    // 确保mbd不是合成的，并且具有InstantiationAwareBeanPostProcessor这个后处理器
    if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
        //遍历所有注册的BeanPostProcessor后处理器
        for (BeanPostProcessor bp : getBeanPostProcessors()) {
            //如果属于InstantiationAwareBeanPostProcessor类型
            if (bp instanceof InstantiationAwareBeanPostProcessor) {
                //强制转型
                InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                //回调postProcessAfterInstantiation方法，传递的参数就是此前获取的bean实例以及beanName
                //该方法可用于在bean实例化之后，初始化之前，修改bean实例的状态
                //如果返回false，则不会继续应用后续的处理同时也会结束后续的属性填充流程，该方法结束，否则继续向后调用
                if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
                    return;
                }
            }
        }
    }

    //获取bean定义的PropertyValues集合，在此前的parsePropertyElement方法中，我们说过
    //所有的<property>标签标签都被解析为PropertyValue对象并存入PropertyValues集合中了
    PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);

    /*
     * 3 根据名称或者类型进行setter自动注入，适用于基于XML的配置autowire自动注入，现在很少基于XML配置了
     * 并没有真正的注入，而是将可以自动注入的属性名和bean实例存入新建的newPvs中，后面会统一注入
     */
    //获取已解析的自动注入模式，默认就是0，即不自动注入，可以设置，对应XML的autowire属性
    int resolvedAutowireMode = mbd.getResolvedAutowireMode();
    //如果是1（就是byName），或者如果是2（就是byType），单纯使用注解注入就是0
    if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
        //根据原来的属性新建一个属性集合
        MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
        // 基于byName的setter自动注入
        //并没有真正的注入，而是将可以自动注入的属性名和bean实例存入新建的newPvs中，后面会统一注入
        if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
            autowireByName(beanName, mbd, bw, newPvs);
        }
        // 基于byType的setter自动注入
        //并没有真正的注入，而是将可以自动注入的属性名和bean实例存入新建的newPvs中，后面会统一注入
        if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
            autowireByType(beanName, mbd, bw, newPvs);
        }
        //pvs赋值为newPvs
        //现在pvs中包括了我们定义的<property>标签属性，以及找到的byName和byType的setter自动注入属性
        pvs = newPvs;
    }
    //是否具有InstantiationAwareBeanPostProcessor这个后处理器
    boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
    //是否需要进行依赖检查，即是否设置dependencyCheck属性，表示属性强制检查，就是XML的dependency-check属性
    //然而这个属性早在spring3.0的时候就被废弃了，代替它的就是构造器注入或者@Required，默认就是0，不进行强制检查，因此为false
    boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);

    PropertyDescriptor[] filteredPds = null;
    /*
     * 4 查找全部InstantiationAwareBeanPostProcessor后处理器，回调postProcessProperties方法
     * 解析此前通过applyMergedBeanDefinitionPostProcessors方法找到的自动注入注解，这里进行了注解的真正的注入
     */
    if (hasInstAwareBpps) {
        //如果为null，初始化一个空的MutablePropertyValues对象
        if (pvs == null) {
            pvs = mbd.getPropertyValues();
        }
        //获取、遍历全部注册的后处理器
        for (BeanPostProcessor bp : getBeanPostProcessors()) {
            //如果属于SmartInstantiationAwareBeanPostProcessor类型
            if (bp instanceof InstantiationAwareBeanPostProcessor) {
                //强转
                InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                /*
                 * 回调postProcessProperties方法，传递的参数就是目前的pvs、bean实例、beanName，解析、注入此前通过
                 * applyMergedBeanDefinitionPostProcessors方法找到的自动注入注解，返回PropertyValues
                 *
                 * CommonAnnotationBeanPostProcessor -> 解析注入@WebServiceRef、@EJB、@Resource注解，默认直接返回参数pvs
                 * AutowiredAnnotationBeanPostProcessor -> 解析注入@Autowired、@Value、@Inject注解，默认直接返回参数pvs
                 *
                 * 在Spring 5.1 之前使用的是postProcessPropertyValues回调方法，Spring 5.1开始该方法被不推荐使用，推荐使用postProcessProperties来替代
                 */
                PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
                //如果pvsToUse为null，那么调用此前的已被放弃的postProcessPropertyValues方法继续尝试
                if (pvsToUse == null) {
                    //获取属性描述符
                    if (filteredPds == null) {
                        filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
                    }
                    //调用postProcessPropertyValues方法，该方法已被丢弃
                    //实际上CommonAnnotationBeanPostProcessor和AutowiredAnnotationBeanPostProcessor的方法内部就是直接调用的postProcessProperties方法
                    //只有RequiredAnnotationBeanPostProcessor有自己的逻辑，但是我们知道RequiredAnnotationBeanPostProcessor已经整体丢弃了
                    pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
                    //还是返回null，那什么直接结束这个方法
                    if (pvsToUse == null) {
                        return;
                    }
                }
                //从新设置pvs，对于CommonAnnotationBeanPostProcessor和AutowiredAnnotationBeanPostProcessor来说具有同一批数据
                pvs = pvsToUse;
            }
        }
    }
    //如果需要进行依赖检查，默认不需要，Spring3.0之后没法设置设置
    if (needsDepCheck) {
        if (filteredPds == null) {
            filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
        }
        checkDependencies(beanName, mbd, filteredPds, pvs);
    }
    /*
     * 5 如果pvs不为null，这里默认的pvs就是<property>标签和byName或者byType找到的属性值的汇总
     * 这里将所有PropertyValues中的属性继续填充到bean实例中
     */
    if (pvs != null) {
        applyPropertyValues(beanName, mbd, bw, pvs);
    }
}

6. initializeBean(beanName, exposedObject, mbd)

AbstractAutowireCapableBeanFactory.initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd)

初始化、生成代理对象（如果有代理且对象还未被代理）。

  • 对象有代理，但可能因为循环依赖，已经提前通过对象工厂生成代理对象放入了二级缓存。

    生成代理对象的具体逻辑在applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName)方法中。

protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
    if (System.getSecurityManager() != null) { // 安全模式
        AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
            // <1> 激活 Aware 方法，对特殊的 bean 处理：Aware、BeanClassLoaderAware、BeanFactoryAware
            invokeAwareMethods(beanName, bean);
            return null;
        }, getAccessControlContext());
    }
    else {
        invokeAwareMethods(beanName, bean);
    }

    // 后处理器，before
    Object wrappedBean = bean;
    if (mbd == null || !mbd.isSynthetic()) {
        wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
    }

    // 激活用户自定义的 init 方法
    try {
        invokeInitMethods(beanName, wrappedBean, mbd);
    }
    catch (Throwable ex) {
        throw new BeanCreationException(
                (mbd != null ? mbd.getResourceDescription() : null),
                beanName, "Invocation of init method failed", ex);
    }
    // 后处理器，after
    if (mbd == null || !mbd.isSynthetic()) {
        wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
    }

    return wrappedBean;
}

7. addSingleton(beanName, singletonObject)

DefaultSingletonBeanRegistry.addSingleton(String beanName, Object singletonObject)

放入一级缓存，清除其他级的缓存。

    /**
     * 添加到一级缓存（并移除二级、三级缓存）
     */
    protected void addSingleton(String beanName, Object singletonObject) {
        synchronized (this.singletonObjects) {
            // 加入单例对象到一级缓存
            this.singletonObjects.put(beanName, singletonObject);
            // 删除三级缓存
            this.singletonFactories.remove(beanName);
            // 删除二级缓存
            this.earlySingletonObjects.remove(beanName);
            // 加入已注册的bean
            this.registeredSingletons.add(beanName);
        }
    }

8. getObjectForBeanInstance(sharedInstance, name, beanName, mbd)

AbstractBeanFactory.getObjectForBeanInstance(
Object beanInstance, String name, String beanName, RootBeanDefinition mbd)

得到最终完整的可以使用的单例bean对象（原对象或代理对象）。

    protected Object getObjectForBeanInstance(Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {

        // 如果Bean不是工厂，不要让调用代码尝试取消对工厂的引用
        // 如果 name为FactoryBean的解引用.name是以'&'开头，就是FactoryBean的解引用
        if (BeanFactoryUtils.isFactoryDereference(name)) {
            //如果beanInstance是NullBean实例
            if (beanInstance instanceof NullBean) {
                //返回beanInstance
                return beanInstance;
            }
            //如果beanInstance不是FactoryBean实例
            if (!(beanInstance instanceof FactoryBean)) {
                //抛出Bean不是一个Factory异常
                throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass());
            }
            //如果mbd不为null
            if (mbd != null) {
                //设置mbd是否是FactoryBean标记为true
                mbd.isFactoryBean = true;
            }
            //返回beanInstance
            return beanInstance;
        }

        // 现在我们有了Bean实例，他可能是一个普通的Bean或FactoryBean。
        // 如果它是FactoryBean,我们使用它来创建一个Bean实例，除非调用者确实需要对工厂的引用。
        //如果beanInstance不是FactoryBean实例
        if (!(beanInstance instanceof FactoryBean)) {
            return beanInstance;
        }
        //定义为bean公开的对象，初始化为null
        Object object = null;
        //如果mbd不为null
        if (mbd != null) {
            //更新mbd的是否是FactoryBean标记为true
            mbd.isFactoryBean = true;
        }
        else {
            //从FactoryBean获得的对象缓存集中获取beanName对应的Bean对象
            object = getCachedObjectForFactoryBean(beanName);
        }
        //如果object为null
        if (object == null) {
            // 从工厂返回Bean实例
            //将beanInstance强转为FactoryBean对象
            FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
            // 如果是单例对象，则缓存从FactoryBean获得的对象、
            //如果mbd为null && 该BeanFactory包含beanName的BeanDefinition对象。
            if (mbd == null && containsBeanDefinition(beanName)) {
                //获取beanName合并后的本地RootBeanDefintiond对象
                mbd = getMergedLocalBeanDefinition(beanName);
            }
            //是否是'synthetic'标记：mbd不为null && 返回此bean定义是否是"synthetic"【一般是指只有AOP相关的prointCut配置或者
            // 		Advice配置才会将 synthetic设置为true】
            boolean synthetic = (mbd != null && mbd.isSynthetic());
            //从BeanFactory对象中获取管理的对象.如果不是synthetic会对其对象进行该工厂的后置处理
            object = getObjectFromFactoryBean(factory, beanName, !synthetic);
        }
        //返回为bean公开的对象
        return object;
    }

Bean加载示例说明

涉及循环依赖和代理的Bean加载

例子：对象A和对象B相互循环依赖，且都有代理。

  • A实例化;
  • 用对象工厂封装A的实例化对象，将A的工厂对象加入第三级缓存；
  • A属性注入（需注入属性B），
  • 发现需要先加载B；
  • B实例化；
  • 用对象工厂封装B的实例化对象，将B的工厂对象加入第三级缓存；
  • B属性注入（需注入属性A）；
  • 通过A的工厂对象得到A代理对象，将A代理对象加入第二级缓存（此时A还是半成品），并从第三级缓存移除A工厂对象，。
  • B完成属性注入（注入的是A代理对象）；
  • B初始化，生成B的代理对象；
  • B代理对象加入第一级缓存，并从第三级缓存移除B工厂对象；
  • 得到B完成品对象（代理对象）；
  • A完成属性注入；
  • A初始化；
  • A代理对象加入第一级缓存，并从第二级缓存移除A代理对象；
  • 得到A完成品对象（代理对象）。
骑个小蜗牛
关注
  • 2
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring学习笔记：（一）IOC容器加载过程
xueguchen的博客
10-19 821
1. Spring框架功能整体介绍 1.1 Spring Core Container 作用： Core 和 Beans 模块是框架的基础部分，提供 IoC （转控制）和依赖注入特性。 这里 的基础 概念是 BeanFactory，它提供对 Factory 模式的经典实 现来消除对程序’性单 例模式的需要，并真 正地允许你从程序逻辑中分离出依赖关系和配置 Beans (BeanFacotry的作用)：包含访问配直文件、创建和管理 bean 以及进行 Inversion of Control I Dep
02.IOC容器加载过程及Bean的生命周期和后置处理器
weixin_49352973的博客
05-29 538
Spring思维导图 SpringBean加载流 SpringIOC加载过程-invokeBeanFactoryPostProcessors SpringIOC 容器加载过程 第一步：实例化化容器：AnnotationConfigApplicationContext @Configuration @ComponentScan("cn.zhe") public class MainStartTest { public static void main(String[] args) { // Sprin
Spring框架Ioc容器加载流程及Bean的生命周期源码分析
最新发布
04-03 543
这份《“java高分面试指南”-25分类227页1000+题50w+字解析》同样可分享给有需要的朋友，感兴趣的伙伴们可挑战一下自我，在不看答案解析的情况，测试测试自己的解题水平，这样也能达到事半功倍的效果！（好东西要大家一起看才香）厂，18年进入阿里一直到现在。**深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
spring~1、spring的IOC底层阅览流程图
小浪与艳花
07-19 451
spring工作原理和机制一级目录二级目录三级目录 一级目录 二级目录 三级目录
Ioc容器加载过程-bean生命周期源码解析
PnJgHT的博客
09-28 637
的类例的bean定义如ConfigurationClassPostProcessor.class（在这个类中负责解析配置类，会解析加了@Configuration\@Component\@Import等注解）、AutowiredAnnotationBeanPostProcessor.class（这个类会去解析@Autowired）等处理器，这个只是注册这些类，真正去把类解析bean定义的是由他注册的后置处理器去完成的。调用我们的bean工厂的后置处理器。创建扫面读取到的配置类的工具。
Spring IOC实现原理详解之IOC初始化流程
weixin_64752717的博客
06-29 263
Spring IoC实现原理详解之IoC初始化流程
Spring -Spring之依赖注入源码解析(上)实践（流程图）
weixin_43874650的博客
11-08 75
IOC依赖注入
Spring IoC加载流程讲解
01-12
Spring IoC 加载流程讲解 在本节中，我们将对 Spring IoC 加载流程进行详细的讲解，并探讨 IoC 思想和依赖倒置原则的应用。 IoC 控制反转 IoC（Inversion of Control）是指在软件设计中，将对象实例的控制权从...
springioc加载流程图.pdf
01-12
springioc加载流程图.pdf
详解Spring IOC 容器启动流程分析
08-25
Spring IOC 容器启动流程分析 Spring IOC 容器是 Java 企业级应用程序的核心组件之一，它提供了一个统一的依赖注入机制，使得应用程序的组件之间能够松耦合。Spring IOC 容器的启动流程是整个 Spring 框架的核心...
Spring.Net IOC依赖注入原理流程解析
08-18
Spring.Net IOC依赖注入原理流程解析 本文将详细介绍Spring.Net IOC依赖注入原理流程解析，通过示例代码介绍了非常详细，对大家的学习或者工作具有一定的参考学习价值。 一、什么是IOC？ IOC（Inversion of ...
详解Spring简单容器中的Bean基本加载过程
08-30
Spring IOC 容器的核心是 BeanFactory，它负责管理和加载应用程序中的对象。在本篇中，我们将详细介绍 Spring 简单容器中的 Bean 基本加载过程。 Bean 的加载过程是指从静态的 XML 文件定义到变成可以使用的对象的...
SpringIOC过程
weixin_56289362的博客
04-07 633
一、什么是IOC 1、控制反转，把对象创建和对象之间的调用过程，交给Spring进行管理 2、使用IOC目的：为了耦合度降低 二、IOC底层原理 （主要是依靠xml解析、工厂模式还有反射 三、
Spring源码深度解析：四、Spring配置文件加载流程
代码的知行者
10-30 2458
接下来我们学习Spring配置文件加载流程，主要加载xml配置文件的属性值到当前工厂中，最重要的就是BeanDefinitionAbstractApplicationContext#obtainFreshBeanFactory() 首先我们debug进入spring的刷新方法，接着进入子方法该方法先创建容器对象：，然后加载xml配置文件的属性值到当前工厂中，最重要的就是BeanDefinition。具体代码如下： AbstractApplicationContext#refreshBeanFactory()
Spring IOC 加载过程
swadian2008的博客
04-21 1357
目录 1.什么是BeanFactory? 2.BeanFactory和ApplicationContext的区别？ 3.简述SpringIOC的加载过程 4.Spring中有哪些扩展接口及调用时机？ 5.简述Bean的生命周期 1.什么是BeanFactory? BeanFactory是用于访问Spring Bean容器(IOC容器)的顶层核心接口，典型的工厂模式，用于生产Bean的一个Bean工厂，其提供了生产Bean所需的最基本规则。 2.BeanFactory和Applicatio
.spring5源码 -- ioc加载的整体流程
java_xiaoo的博客
09-24 523
之前我们知道了spring ioc的加载过程, 具体如下图. 下面我们就来对照下图, 看看ioc加载的源代码. 下面在用装修类比, 看看个个组件都是怎么工作的. 接下来是源码分析的整体结构图. 对照上面的思路梳理出来的 一、源码分析的入口 通常,我们的入口都是从main方法进入. 这里我们也来定义一个main方法 public class MainStarter { public static void main(String[] args) { ...
Spring源码：Spring IoC容器加载过程（2）
weixin_30636089的博客
05-10 100
Spring源码版本：4.3.23.RELEASE 一、加载XML配置 通过XML配置创建Spring，创建入口是使用org.springframework.context.support.ClassPathXmlApplicationContext类，创建容器的代码如下： 1 package hello; 2 3 import org.springframework.co...
springIOC容器加载全过程
qq_34391845的博客
06-15 574
spring加载配置文件后会调用refresh()方法： springIoc的创建全过程refresh()方法 1.prepareRefresh()刷新前的预处理 1)、initPropertySources()初始化一些属性配置，子类继承实现个性化 2)、getEnvironment().validateRequiredProperties()；检验属性的合法性 2.obtainFreshBeanFactory() 获取BeanFactory； 1)、...
spring ioc的流程
10-28
Spring IoC容器的启动流程可以分为以下几个步骤： 1. 创建并初始化一个空的IoC容器。 2. 加载Bean定义资源，包括XML文件、Java注解等。 3. 解析Bean定义，将Bean定义转换为IoC容器内部的数据结构。 4. 注册Bean定义，将Bean定义注册到IoC容器中。 5. 预实例化单例Bean，将所有的单例Bean提前实例化并放入缓存中。 6. 完成IoC容器的初始化工作，包括依赖注入、AOP代理等。 7. 容器启动完成，可以使用IoC容器提供的Bean实例。 其中，IoC容器的启动入口是AbstractApplicationContext#refresh方法，该方法定义了Spring启动的“提纲”，包含了IoC容器初始化的入口obtainFreshBeanFactory方法。在IoC容器的启动过程中，BeanDefinition的载入和注册是其中的重要步骤，而Javabean之间的依赖关系并不会在初始化的时候完成。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值