《Spring Framework 系列》- IOC

org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean
① 检查容器中有无实例，有的话直接返回Object sharedInstance = getSingleton(beanName);
@ check if the bean exists in this facotryBeanFactory parentBeanFactory = getParentBeanFactory();
③ 加载beanDefinition（checkMerged）final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);checkMergedBeanDefinition(mbd, beanName, args);
④ 判断bean的类型isSingleton()isPrototype()other
⑤ 获取单例对象sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {    @Override    public Object getObject() throws BeansException {        try {            return createBean(beanName, mbd, args);        }        catch (BeansException ex) {            // Explicitly remove instance from singleton cache: It might have been put there            // eagerly by the creation process, to allow for circular reference resolution.            // Also remove any beans that received a temporary reference to the bean.            destroySingleton(beanName);            throw ex;        }    }});

⑥ create beancreateBean(beanName, mbd, args);

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean    /*** Central method of this class: creates a bean instance,* populates the bean instance, applies post-processors, etc.* @see #doCreateBean*/    1. 执行 实例化后置处理器 - InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation    且在此处提供了一个代理特性，允许调用后置处理器 BeanPostProcessor#postProcessAfterInitialization，    此时我们对该特性先不做扩展和探讨，继续深入createBean方法// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
/**   * Apply before-instantiation post-processors, resolving whether there is a   * before-instantiation shortcut for the specified bean.   * @param beanName the name of the bean   * @param mbd the bean definition for the bean   * @return the shortcut-determined bean instance, or {@code null} if none   */protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {    Object bean = null;    if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {        // Make sure bean class is actually resolved at this point.        if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {            Class<?> targetType = determineTargetType(beanName, mbd);            if (targetType != null) {                bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);                if (bean != null) {                    bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);                }            }        }        mbd.beforeInstantiationResolved = (bean != null);    }    return bean;}
2. 调用 AbstractAutowireCapableBeanFactory#doCreateBeanObject beanInstance = doCreateBean(beanName, mbdToUse, args);
3. 进入 创建 bean wrapper 实例方法 createBeanInstance()    instanceWrapper = createBeanInstance(beanName, mbd, args);
4. 进入 实例化bean方法  instantiateBean()     instantiateBean(beanName, mbd);
5. 执行构造器后置处理器 - SmartInstantiationAwareBeanPostProcessor#determineCandidateConstructors    tips: 用于构造器注册（涉及 spring 3种依赖注入的方式中的构造器注入方式）Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);if (ctors != null ||    mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||    mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args))  {    return autowireConstructor(beanName, mbd, ctors, args);}
  /**   * "autowire constructor" (with constructor arguments by type) behavior.   * Also applied if explicit constructor argument values are specified,   * matching all remaining arguments with beans from the bean factory.   * <p>This corresponds to constructor injection: In this mode, a Spring   * bean factory is able to host components that expect constructor-based   * dependency resolution.   * @param beanName the name of the bean   * @param mbd the bean definition for the bean   * @param ctors the chosen candidate constructors   * @param explicitArgs argument values passed in programmatically via the getBean method,   * or {@code null} if none (-> use constructor argument values from bean definition)   * @return BeanWrapper for the new instance   */  protected BeanWrapper autowireConstructor(      String beanName, RootBeanDefinition mbd, Constructor<?>[] ctors, Object[] explicitArgs) {
6. 执行 合并bean信息后置处理器 -（MergedBeanDefinitionPostProcessor#postProcessMergedBeanDefinition）    applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);                7. 实例化完成，进入填充属性方法 populateBean()    populateBean(beanName, mbd, instanceWrapper);          8. 执行 实例化后置处理器 - InstantiationAwareBeanPostProcessor#postProcessAfterInstantiation    if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {        9. 依赖注入处理     -- 但未真正注入bean中，放入 MutablePropertyValues（newPvs） 变量中    autowireByName(beanName, mbd, bw, newPvs);    autowireByType(beanName, mbd, bw, newPvs);
10. 执行 实例化后置处理器 - InstantiationAwareBeanPostProcessor#postProcessPropertyValues    tips：此阶段可以对bean属性进行二次加工，因为此时 属性还未真正注入进 成品bean 中    pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);        11. bean 的属性赋值    重点方法（暂不做讨论）    applyPropertyValues(beanName, mbd, bw, pvs);                12.执行 初始化后置处理器 - BeanPostProcessor#postProcessBeforeInstantiation    wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);                12.bean 级别（bean视角）的生命周期函数执行    exposedObject = initializeBean(beanName, exposedObject, mbd);            invokeAwareMethods(beanName, bean);    -->   调用 Aware类型的Method    private void invokeAwareMethods(final String beanName, final Object bean) {    if (bean instanceof Aware) {      if (bean instanceof BeanNameAware) {        ((BeanNameAware) bean).setBeanName(beanName);      }      if (bean instanceof BeanClassLoaderAware) {        ((BeanClassLoaderAware) bean).setBeanClassLoader(getBeanClassLoader());      }      if (bean instanceof BeanFactoryAware) {        ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);      }    }  }            invokeInitMethods(beanName, wrappedBean, mbd);    --> 调用 InitializingBean#afterPropertiesSet     --> 调用 bean xml 的 Init-Method
13.执行 初始化后置处理器 - BeanPostProcessor#postProcessAfterInstantiation     wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);