源码专题——Spring IOC 容器初始化解析（上）[1]

源码专题——Spring IOC 容器初始化解析（中）[1]

源码专题——Spring IOC 容器初始化解析（下）[1]

/**
 * 真正的创建bean实例(这里创建实例包装类)，调用构造方法或者工厂方法
 */
instanceWrapper = createBeanInstance(beanName, mbd, args);

/**
 * 添加到我们的单例工厂中缓存起来
 *
 * 提早暴露早期对象 (还没有进行初始化的对象)  就是还没有进行赋值的对象就是早期对象
 *
 */
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));

/**
 * 给我们的Bean进行赋值
 */
populateBean(beanName, mbd, instanceWrapper);
/**
 * 初始化bean
 */
exposedObject = initializeBean(beanName, exposedObject, mbd);

protected Object getSingleton(String beanName, boolean allowEarlyReference) {

    /**
     * singletonObjects 这个就是我们大名鼎鼎的单例缓存池
     */
    Object singletonObject = this.singletonObjects.get(beanName);

    /**
     * singletonObject == null 并且单例正在创建
     *
     * isSingletonCurrentlyInCreation就是个标识，标识这个bean是否正在被创建。
     */
    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
        synchronized (this.singletonObjects) {
           //去早期对象里面去获取，如果获取到了就直接返回了。
            singletonObject = this.earlySingletonObjects.get(beanName);
            if (singletonObject == null && allowEarlyReference) {
               //如果早期对象没获取到，就去单例工厂里面获取
                ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                if (singletonFactory != null) {
                   //如果单例工厂取到了 ，加到早期对象中，然后从单例工厂中移除
                    singletonObject = singletonFactory.getObject();
                    this.earlySingletonObjects.put(beanName, singletonObject);
                    this.singletonFactories.remove(beanName);
                }
            }
        }
    }
    return singletonObject;
}

/**
 * 如果缓存中没有拿到，就去检查父工厂里面有没有
 */
BeanFactory parentBeanFactory = getParentBeanFactory();

 /**
  * 真正的创建bean实例了，调用构造方法或者工厂方法
  */
instanceWrapper = createBeanInstance(beanName, mbd, args);

protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
    Assert.notNull(singletonFactory, "Singleton factory must not be null");

    /**
     * singletonObjects 单例缓存池
     * singletonFactories  单例工厂
     * earlySingletonObjects 早期单例对象
     */
    synchronized (this.singletonObjects) {
        if (!this.singletonObjects.containsKey(beanName)) {
            this.singletonFactories.put(beanName, singletonFactory);
            this.earlySingletonObjects.remove(beanName);
            this.registeredSingletons.add(beanName);
        }
    }
}

@Component
public class InstanceA {

    private InstanceB instanceB;

    public InstanceB getInstanceB() {
        return instanceB;
    }

    public void setInstanceB(InstanceB instanceB) {
        this.instanceB = instanceB;
    }
}

@Component
public class InstanceB {

    private InstanceA instanceA;

    public InstanceA getInstanceA() {
        return instanceA;
    }

    public void setInstanceA(InstanceA instanceA) {
        this.instanceA = instanceA;
    }
}

AnnotationConfigApplicationContext context = 
       new AnnotationConfigApplicationContext(BeanConfig.class);

   context.getBean("instanceA");

/**
 * 真正的创建bean实例了，调用构造方法或者工厂方法
 */
instanceWrapper = createBeanInstance(beanName, mbd, args);

// Candidate constructors for autowiring?
  Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
        if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
          mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
        //通过构造器进行诸注入
    return autowireConstructor(beanName, mbd, ctors, args);
}