spering getBean()，IOC

IOC：前面都是對bean定義的處理，postProcess已經實例化了。
解析bean的時候，把須要依賴注入的字段和方法，在postProcessMergedBeanDefinition方法中加到AutowiredAnnotationBeanPostProcessor的變量中，而後在AutowiredAnnotationBeanPostProcessor的做爲入口，去依賴注入字段和方法。

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
        if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) && beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
            beanFactory.setConversionService(beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));  // 實例化一個轉換器ConversionService
        }
        String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
        for (String weaverAwareName : weaverAwareNames) {
            getBean(weaverAwareName);   //  沒用，
        }
        beanFactory.preInstantiateSingletons();  //IOC
    }
    
public void preInstantiateSingletons() throws BeansException {
        List<String> beanNames;
        synchronized (this.beanDefinitionMap) {   //全部的beanDefinition，也就是bean的定義信息
            beanNames = new ArrayList<String>(this.beanDefinitionNames);  //全部的bean的名字
        }
        for (String beanName : beanNames) {//實例化全部的bean
            RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);  // 合併功能，父子合併了的。
            if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {  //不是抽象的，不是懶加載的，是單利，纔會去實例化。
                if (isFactoryBean(beanName)) {//實現了FactoryBean接口
                    final FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);
                    boolean isEagerInit;
                    if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {//實現了SmartFactoryBean接口
                        isEagerInit = AccessController.doPrivileged(new PrivilegedAction<Boolean>() {
                            @Override
                            public Boolean run() {
                                return ((SmartFactoryBean<?>) factory).isEagerInit();  //調用這個bean的isEagerInit方法，返回true就實例化，
                            }
                        }, getAccessControlContext());
                    }
                    else {
                        isEagerInit = (factory instanceof SmartFactoryBean &&
                                ((SmartFactoryBean<?>) factory).isEagerInit()); //調用這個bean的isEagerInit方法，返回true就實例化，
                    }
                    if (isEagerInit) {//返回true就實例化，
                        getBean(beanName); //實例化
                    }
                }
                else {//沒有實現了FactoryBean接口，
                    getBean(beanName);
                }
            }
        }
    }
    
解析有父類的bean，就是合併子類和父類的信息，涉及到子類覆蓋父類。 protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws BeansException {
        RootBeanDefinition mbd = this.mergedBeanDefinitions.get(beanName);  // 先從緩存中拿
        if (mbd != null) {
            return mbd;
        }
        return getMergedBeanDefinition(beanName, getBeanDefinition(beanName));
    }

    <bean id="parent" class="com.zhuguang.jack.testbean.Parent" abstract="true">
    </bean>
    <bean id="son" class="com.zhuguang.jack.testbean.Son" parent="parent">
    </bean>    父類是用來繼承的公共部分，不會被實例化。

protected RootBeanDefinition getMergedBeanDefinition(String beanName, BeanDefinition bd, BeanDefinition containingBd)throws BeanDefinitionStoreException {//beanName是bean的名字，bd是bean的定義

        synchronized (this.mergedBeanDefinitions) {  //mergedBeanDefinitions 是緩存，
            RootBeanDefinition mbd = null;
            if (containingBd == null) {
                mbd = this.mergedBeanDefinitions.get(beanName);
            }
            if (mbd == null) {
                if (bd.getParentName() == null) { //  bean沒有父類，直接初始化一個RootBeanDefinition
                    if (bd instanceof RootBeanDefinition) {
                        mbd = ((RootBeanDefinition) bd).cloneBeanDefinition();  //也是調用 new RootBeanDefinition(bd);
                    }
                    else {
                        mbd = new RootBeanDefinition(bd);//bd是bean的定義信息，mbd是子類，bd是父類，這裏作一個拷貝，是爲了避免污染db，而是使用從新初始化的mbd。
                    }
                }
                else {
                     //  bean有父類，要加載父類的信息
                    BeanDefinition pbd;
                    try {
                        String parentBeanName = transformedBeanName(bd.getParentName());  //獲取父親的名字，
                        if (!beanName.equals(parentBeanName)) {  //跟父的名字不同，
                            pbd = getMergedBeanDefinition(parentBeanName);  //父類的bean定義，父類在有父類繼續調用。
                        }
                    }
                    mbd = new RootBeanDefinition(pbd);   //pbd是父類，構造父類
                    mbd.overrideFrom(bd);//bd是bean的定義信息，mbd是父類，bd是子類，子類覆蓋父類的信息，
                }

                if (containingBd == null && isCacheBeanMetadata() && isBeanEligibleForMetadataCaching(beanName)) {
                    this.mergedBeanDefinitions.put(beanName, mbd);  //加到緩存
                }
            }
            return mbd;
        }
    }
    
getBean(beanName);

protected <T> T doGetBean(final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)throws BeansException {

        final String beanName = transformedBeanName(name);
        Object bean;

        //單利緩存中獲取
        Object sharedInstance = getSingleton(beanName);
        if (sharedInstance != null && args == null) {
            bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
        }

        else {
            if (isPrototypeCurrentlyInCreation(beanName)) {//已經建立了
                throw new BeanCurrentlyInCreationException(beanName);
            }

            BeanFactory parentBeanFactory = getParentBeanFactory();//父類容器，從父類容器獲取bean。
            if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
                String nameToLookup = originalBeanName(name);
                if (args != null) {
                    return (T) parentBeanFactory.getBean(nameToLookup, args);;//父類容器，從父類容器獲取bean。
                }
                else {
                    return parentBeanFactory.getBean(nameToLookup, requiredType);;//父類容器，從父類容器獲取bean。
                }
            }
            try {
                final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);//父子合併

                String[] dependsOn = mbd.getDependsOn();//依賴的bean，建立這個bean的時候先要建立哪些bean，
                if (dependsOn != null) {
                    for (String dependsOnBean : dependsOn) {
                        if (isDependent(beanName, dependsOnBean)) {//沒有依賴關係
                            throw new BeanCreationException("Circular depends-on relationship between '" +
                                    beanName + "' and '" + dependsOnBean + "'");
                        }
                        registerDependentBean(dependsOnBean, beanName);//增長依賴關係，
                        getBean(dependsOnBean);//先實例化依賴的bean
                    }
                }

                if (mbd.isSingleton()) {//單利
                    sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
                        @Override
                        public Object getObject() throws BeansException {
                            try {
                                return createBean(beanName, mbd, args);
                            }
                        }
                    });
                    bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
                }

                else if (mbd.isPrototype()) {//多利
                    // It's a prototype -> create a new instance.
                    Object prototypeInstance = null;
                    try {
                        beforePrototypeCreation(beanName);
                        prototypeInstance = createBean(beanName, mbd, args);
                    }
                    finally {
                        afterPrototypeCreation(beanName);
                    }
                    bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
                }

                else {
                    String scopeName = mbd.getScope();
                    final Scope scope = this.scopes.get(scopeName);
                    if (scope == null) {
                        throw new IllegalStateException("No Scope registered for scope '" + scopeName + "'");
                    }
                    try {
                        Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() {
                            @Override
                            public Object getObject() throws BeansException {
                                beforePrototypeCreation(beanName);
                                try {
                                    return createBean(beanName, mbd, args);
                                }
                                finally {
                                    afterPrototypeCreation(beanName);
                                }
                            }
                        });
                        bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
                    }
                }
            }
        }

        if (requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) {
            try {
                return getTypeConverter().convertIfNecessary(bean, requiredType);
            }
        }
        return (T) bean;
    }
    
單利：
sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
    @Override
    public Object getObject() throws BeansException {
        try {
            return createBean(beanName, mbd, args);
        }
    }
});

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
        synchronized (this.singletonObjects) {//緩存
            Object singletonObject = this.singletonObjects.get(beanName);
            if (singletonObject == null) {
                try {
                    singletonObject = singletonFactory.getObject();  //createBean
                }
                addSingleton(beanName, singletonObject);//緩存
            }
            return (singletonObject != NULL_OBJECT ? singletonObject : null);
        }
    }

protected Object createBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)throws BeanCreationException {
        resolveBeanClass(mbd, beanName);   //bean的定義，bean的名字，拿出beanClass，
        try {
            mbd.prepareMethodOverrides();
        }
        try {
            Object bean = resolveBeforeInstantiation(beanName, mbd);//BeanPostProcessors已經實例化了，實例化以前插一腳，直接返回這個實例化的bean。後面不用走了。能夠本身去實例化這個bean，spring就不會管這個bean的實例化了。下面有梨子InstantiationAwareBeanPostProcessorTest，
            if (bean != null) {
                return bean;
            }
        }
  //前面resolveBeforeInstantiation沒有成功實例化出這個bean。spring來實例化這個bean。
        Object beanInstance = doCreateBean(beanName, mbd, args);
        return beanInstance;
    }

protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
        Object bean = null;
        if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
            if (mbd.hasBeanClass() && !mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
                bean = applyBeanPostProcessorsBeforeInstantiation(mbd.getBeanClass(), beanName);
                if (bean != null) {
                    bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);  //先執行before在執行after方法，
                }
            }
            mbd.beforeInstantiationResolved = (bean != null);
        }
        return bean;
    }

protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName)throws BeansException {
        for (BeanPostProcessor bp : getBeanPostProcessors()) {  //取出全部的BeanPostProcessors，
            if (bp instanceof InstantiationAwareBeanPostProcessor) {  // 實現InstantiationAwareBeanPostProcessor接口的本身寫的類，能夠本身去實例化這個bean，spring就不會管這個bean的實例化了。下面有梨子InstantiationAwareBeanPostProcessorTest，
                InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);  //經過全部的BeanPostProcessors來返回這個實例化的bean。spring就不會管這個bean的實例化了。
                if (result != null) {
                    return result;
                }
            }
        }
        return null;
    }
    
public class InstantiationAwareBeanPostProcessorTest implements InstantiationAwareBeanPostProcessor {
    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        try {
            return beanClass.newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return null;
    }
    
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {
        BeanWrapper instanceWrapper = null;
        if (mbd.isSingleton()) {
            instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);//緩存，
        }
        if (instanceWrapper == null) {
            instanceWrapper = createBeanInstance(beanName, mbd, args);  // 包裝類，經過反射實例建立完成。可是實例的屬性尚未操做。不包括IOC的依賴注入。屬性是沒有值的。
        }
        final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
        Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);

        synchronized (mbd.postProcessingLock) {
            if (!mbd.postProcessed) {
                applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);   //下面解析， 
 //解析完這個類須要依賴注入的字段和方法以後，在AutowiredAnnotationBeanPostProcessor增長一行記錄factoryBeanTest=[FactoryBeanTest.woman（依賴注入字段）, FactoryBeanTest.setWoman(com.zhuguang.jack.testbean.Woman)（依賴注入方法）]。
                }
                mbd.postProcessed = true;
            }
        }

        boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && isSingletonCurrentlyInCreation(beanName)); // 是單利而且容許循環依賴，
        if (earlySingletonExposure) {
            addSingletonFactory(beanName, new ObjectFactory<Object>() {//把ObjectFactory這個匿名對象加入到spring的三級緩存，在getSingleton從緩存取的時候，會調用三級緩存中的匿名對象ObjectFactory的getObject() 。
                @Override
                public Object getObject() throws BeansException {
                    return getEarlyBeanReference(beanName, mbd, bean);
                }
            });
        }

        Object exposedObject = bean;
        try {
            populateBean(beanName, mbd, instanceWrapper);  //IOC，依賴注入8中類型，
            if (exposedObject != null) {
                exposedObject = initializeBean(beanName, exposedObject, mbd);
            }
        }

        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<String>(dependentBeans.length);
                    for (String dependentBean : dependentBeans) {
                        if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
                            actualDependentBeans.add(dependentBean);
                        }
                    }
                    if (!actualDependentBeans.isEmpty()) {
                        throw new BeanCurrentlyInCreationException(beanName,");
                    }
                }
            }
        }

        try {
            registerDisposableBeanIfNecessary(beanName, bean, mbd);  //註冊，
        }

        return exposedObject;
    }
    
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
        Class<?> beanClass = resolveBeanClass(mbd, beanName);//拿到bean的class，class com.zhuguang.jack.testbean.A，
  if (mbd.getFactoryMethodName() != null)  {
            return instantiateUsingFactoryMethod(beanName, mbd, args);  //本身寫的類去初始化，不要spring實例化，
         }
        return instantiateBean(beanName, mbd);
    }
protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
        try {
            Object beanInstance;
            final BeanFactory parent = this;
            if (System.getSecurityManager() != null) {  //代碼執行權限，
                beanInstance = AccessController.doPrivileged(new PrivilegedAction<Object>() {
                    @Override
                    public Object run() {
                        return getInstantiationStrategy().instantiate(mbd, beanName, parent);
                    }
                }, getAccessControlContext());
            }
            else {
                beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);  //經過反射，com.zhuguang.jack.testbean.A@5226e402實例建立完成。
            }
            BeanWrapper bw = new BeanWrapperImpl(beanInstance);  //包裝，
            initBeanWrapper(bw);
            return bw;
        }
    }

public Object instantiate(RootBeanDefinition beanDefinition, String beanName, BeanFactory owner) {
        if (beanDefinition.getMethodOverrides().isEmpty()) {
            synchronized (beanDefinition.constructorArgumentLock) {
                constructorToUse = (Constructor<?>) beanDefinition.resolvedConstructorOrFactoryMethod;
                if (constructorToUse == null) {
                    final Class<?> clazz = beanDefinition.getBeanClass();  //拿到須要實例化的類，
                    try {
                        if (System.getSecurityManager() != null) {
                            constructorToUse = AccessController.doPrivileged(new PrivilegedExceptionAction<Constructor<?>>() {
                                @Override
                                public Constructor<?> run() throws Exception {
                                    return clazz.getDeclaredConstructor((Class[]) null);  //拿到構造器，無參構造器，爲了防止循環依賴問題。
                                }
                            });
                        }
                    }
                }
            }
            return BeanUtils.instantiateClass(constructorToUse);//反射，實例化bean，
        }
else {
            return instantiateWithMethodInjection(beanDefinition, beanName, owner);//Cglib
        }
    }
    
protected void applyMergedBeanDefinitionPostProcessors(RootBeanDefinition mbd, Class<?> beanType, String beanName)throws BeansException {
        try {
            for (BeanPostProcessor bp : getBeanPostProcessors()) {
                if (bp instanceof MergedBeanDefinitionPostProcessor) {//實現這個接口的bean，才能作處理，
                    MergedBeanDefinitionPostProcessor bdp = (MergedBeanDefinitionPostProcessor) bp;  //  有一個AutowiredAnnotationBeanPostProcessor，
                    bdp.postProcessMergedBeanDefinition(mbd, beanType, beanName);
                }
            }
        }
    }

AutowiredAnnotationBeanPostProcessor類的：依賴注入能夠經過配置文件，也能夠經過註解@Autowired，@Autowired，能夠加載屬性上面，也能夠加載set方法上面。 public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
        if (beanType != null) {
            InjectionMetadata metadata = findAutowiringMetadata(beanName, beanType); //返回這個類，須要註解依賴注入的屬性和方法，
            metadata.checkConfigMembers(beanDefinition);
        }
    }

private InjectionMetadata findAutowiringMetadata(String beanName, Class<?> clazz) {
        String cacheKey = (StringUtils.hasLength(beanName) ? beanName : clazz.getName());
        InjectionMetadata metadata = this.injectionMetadataCache.get(cacheKey);  //AutowiredAnnotationBeanPostProcessor的緩存，
        if (InjectionMetadata.needsRefresh(metadata, clazz)) {
            synchronized (this.injectionMetadataCache) {
                metadata = this.injectionMetadataCache.get(cacheKey);
                if (InjectionMetadata.needsRefresh(metadata, clazz)) {
                    metadata = buildAutowiringMetadata(clazz);  //返回這個類，須要註解依賴注入的屬性和方法，
                    this.injectionMetadataCache.put(cacheKey, metadata);  //解析完這個類須要依賴注入的字段和方法以後，在AutowiredAnnotationBeanPostProcessor增長一行記錄factoryBeanTest = [ FactoryBeanTest.woman, FactoryBeanTest.setWoman(com.zhuguang.jack.testbean.Woman)]，this=AutowiredAnnotationBeanPostProcessor。
                }
            }
        }
        return metadata;
    }
private InjectionMetadata buildAutowiringMetadata(Class<?> clazz) {
        LinkedList<InjectionMetadata.InjectedElement> elements = new LinkedList<InjectionMetadata.InjectedElement>();
        Class<?> targetClass = clazz;

        do {
            LinkedList<InjectionMetadata.InjectedElement> currElements = new LinkedList<InjectionMetadata.InjectedElement>();  //InjectedElement是反射的屬性或者方法對象，
   //@Autowired加載屬性上面，
            for (Field field : targetClass.getDeclaredFields()) { //  拿到類的全部屬性，
                AnnotationAttributes annotation = findAutowiredAnnotation(field);  //獲取字段的Autowired，Value，Inject 3種註解，其他註解無論，返回映射關係，
                if (annotation != null) {
                    if (Modifier.isStatic(field.getModifiers())) {
                        continue;
                    }
                    boolean required = determineRequiredStatus(annotation);//拿到註解的值，
                    currElements.add(new AutowiredFieldElement(field, required));  //一個字段field對應一個AutowiredFieldElement，裝到容器中。尚未涉及到IOC過程。
                }
            }
   //@Autowired加載set方法上面，
            for (Method method : targetClass.getDeclaredMethods()) { // 拿到類的全部方法，有註解的方法是 FactoryBeanTest.setWoman(com.zhuguang.jack.testbean.Woman)。
@Autowired public void setWoman(Woman woman) { this.woman = woman; }，
                Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);  //方法的重載
                AnnotationAttributes annotation = BridgeMethodResolver.isVisibilityBridgeMethodPair(method, bridgedMethod) ?
                        findAutowiredAnnotation(bridgedMethod) : findAutowiredAnnotation(method);  //找到這個方法上面有沒有Autowired，Value，Inject 3種註解，其他註解無論，
                if (annotation != null && method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) {
                    if (Modifier.isStatic(method.getModifiers())) {
                        continue;
                    }
                    boolean required = determineRequiredStatus(annotation);//拿到註解的值，
                    PropertyDescriptor pd = BeanUtils.findPropertyForMethod(method);//拿到方法的類型對象PropertyDescriptor 
                    currElements.add(new AutowiredMethodElement(method, required, pd));//把method, required, pd包裝成AutowiredMethodElement放到容器currElements中去，
                }
            }
            elements.addAll(0, currElements);
            targetClass = targetClass.getSuperclass();
        }
        while (targetClass != null && targetClass != Object.class);  //父類，也去解析父類，
        return new InjectionMetadata(clazz, elements);  //返回這個類，須要註解依賴注入的屬性和方法，
    }

public AutowiredAnnotationBeanPostProcessor() {   //AutowiredAnnotationBeanPostProcessor裏面加了Autowired，Value，Inject 3種註解，
        this.autowiredAnnotationTypes.add(Autowired.class);
        this.autowiredAnnotationTypes.add(Value.class);
        ClassLoader cl = AutowiredAnnotationBeanPostProcessor.class.getClassLoader();
        this.autowiredAnnotationTypes.add((Class<? extends Annotation>) cl.loadClass("javax.inject.Inject"));
    }
    
singletonObjects是一級緩存，一個bean依賴注入完成以後，屬性都完成了，纔會存在在singletonObjects這個Map裏面。 earlySingletonObjects是二級緩存，一個bean尚未徹底實例化，有可能裏面還有一些屬性，尚未徹底依賴注入完。 singletonFactories是三級緩存，裏面存的是ObjectFactory對象。

二級三級緩存，就是爲了解決循環依賴問題，A裏面有B，B裏面有A。A實例化的時候B沒有實例化，此時A仍是一個空殼子，會加到三級緩存，而後getBean(B)，B實例化的時候發現有屬性A，會去實例化getBean(A)，此時A在三級緩存中，會調用這個三級緩存的getObject()方法。

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);//從第三級取
                    if (singletonFactory != null) {
                        singletonObject = singletonFactory.getObject();  //三級緩存調用getObject()，
                        this.earlySingletonObjects.put(beanName, singletonObject);//移到二級緩存，
                        this.singletonFactories.remove(beanName);//從三級緩存刪除，
                    }
                }
            }
        }
return (singletonObject != NULL_OBJECT ? singletonObject : null);
    }
    
protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
        synchronized (this.singletonObjects) {
            if (!this.singletonObjects.containsKey(beanName)) {//一級緩存沒有
                this.singletonFactories.put(beanName, singletonFactory);//放入三級緩存，準備上面的，調用三級緩存的getObject()，
                this.earlySingletonObjects.remove(beanName);//二級緩存移除
                this.registeredSingletons.add(beanName);
            }
        }
    }

protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
        Object exposedObject = bean;
        if (bean != null && !mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
            for (BeanPostProcessor bp : getBeanPostProcessors()) {
                if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {  //這個接口，
                    SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
                    exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
                    if (exposedObject == null) {
                        return exposedObject;
                    }
                }
            }
        }
        return exposedObject;
    }
    
protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {
        PropertyValues pvs = mbd.getPropertyValues();  //拿到factoryBeanTest的須要依賴注入的屬性，PropertyValues: length=1; bean property 'woman'
        boolean continueWithPropertyPopulation = true;  //當前bean的依賴注入到底要不要作，
        if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
            for (BeanPostProcessor bp : getBeanPostProcessors()) {
                if (bp instanceof InstantiationAwareBeanPostProcessor) {  //
                    InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                    if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {   //返回布爾值，當前bean的依賴注入要不要作，
                        continueWithPropertyPopulation = false;
                        break;
                    }
                }
            }
        }
        if (!continueWithPropertyPopulation) {   //爲false，當前bean的依賴注入就不用作了，
            return;
        }
        boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();  //有沒有實現InstantiationAwareBeanPostProcessor接口，
        boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);
        if (hasInstAwareBpps || needsDepCheck) {
            PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
            if (hasInstAwareBpps) {
                for (BeanPostProcessor bp : getBeanPostProcessors()) {
                    if (bp instanceof InstantiationAwareBeanPostProcessor) {  //找到這個接口的類，包括spring的和本身的，
                        InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                        pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);//@Autoware,@Value的依賴注入。 AutowiredAnnotationBeanPostProcessor類的postProcessPropertyValues方法，依賴注入在這裏。
                        if (pvs == null) {
                            return;
                        }
                    }
                }
            }
        }
        applyPropertyValues(beanName, mbd, bw, pvs);   //經過xml依賴注入，
    }

AutowiredAnnotationBeanPostProcessor類：
public PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {
        InjectionMetadata metadata = findResourceMetadata(beanName, bean.getClass());  //從緩存取，須要依賴注入的字段和方法，[FactoryBeanTest.woman, .FactoryBeanTest.setWoman(com.zhuguang.jack.testbean.Woman)]，
        try {
            metadata.inject(bean, beanName, pvs);//依賴注入在這裏。
        }
        return pvs;
    }

public void inject(Object target, String beanName, PropertyValues pvs) throws Throwable {
        Collection<InjectedElement> elementsToIterate = (this.checkedElements != null ? this.checkedElements : this.injectedElements); //[FactoryBeanTest.woman, FactoryBeanTest.setWoman(com.zhuguang.jack.testbean.Woman)]，
        if (!elementsToIterate.isEmpty()) {
            for (InjectedElement element : elementsToIterate) {
                element.inject(target, beanName, pvs);  //目標對象FactoryBeanTest@5d39f2d8，bean名字factoryBeanTest，須要依賴注入的字段或者方法[bean property 'woman'] 。依賴注入在這裏。
            }
        }
    }

//依賴注入字段。依賴注入在這裏。
protected void inject(Object bean, String beanName, PropertyValues pvs) throws Throwable {
            Field field = (Field) this.member;  //FactoryBeanTest.woman
            try {
                Object value;
                if (this.cached) {
                    value = resolvedCachedArgument(beanName, this.cachedFieldValue);
                }
                else {
                    DependencyDescriptor desc = new DependencyDescriptor(field, this.required);
                    desc.setContainingClass(bean.getClass());
                    Set<String> autowiredBeanNames = new LinkedHashSet<String>(1);
                    TypeConverter typeConverter = beanFactory.getTypeConverter();
                    value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);//拿到依賴注入的屬性的值，com.zhuguang.jack.testbean.Woman@abbc908。
                    synchronized (this) {
                        if (!this.cached) {
                            if (value != null || this.required) {
                                this.cachedFieldValue = desc;
                                registerDependentBeans(beanName, autowiredBeanNames);
                            }
                            this.cached = true;
                        }
                    }
                }
                if (value != null) {//com.zhuguang.jack.testbean.Woman@abbc908，
                    ReflectionUtils.makeAccessible(field);
                    field.set(bean, value);   //字段設置值
                }
            }
        }
    }

public Object resolveDependency(DependencyDescriptor descriptor, String beanName,
            Set<String> autowiredBeanNames, TypeConverter typeConverter) throws BeansException {
        else {
            if (result == null) {
                result = doResolveDependency(descriptor, beanName, autowiredBeanNames, typeConverter);
            }
            return result;//com.zhuguang.jack.testbean.Woman@abbc908。
        }
    }

public Object doResolveDependency(DependencyDescriptor descriptor, String beanName,
            Set<String> autowiredBeanNames, TypeConverter typeConverter) throws BeansException {

        Class<?> type = descriptor.getDependencyType();  //class com.zhuguang.jack.testbean.Woman
        Object value = getAutowireCandidateResolver().getSuggestedValue(descriptor);
        if (value != null) {
            if (value instanceof String) {
                String strVal = resolveEmbeddedValue((String) value);
                BeanDefinition bd = (beanName != null && containsBean(beanName) ? getMergedBeanDefinition(beanName) : null);
                value = evaluateBeanDefinitionString(strVal, bd);
            }
            TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
            return (descriptor.getField() != null ?
                    converter.convertIfNecessary(value, type, descriptor.getField()) :
                    converter.convertIfNecessary(value, type, descriptor.getMethodParameter()));
        }

        if (type.isArray()) {  //依賴注入的是數組
            Class<?> componentType = type.getComponentType();
            DependencyDescriptor targetDesc = new DependencyDescriptor(descriptor);
            targetDesc.increaseNestingLevel();
            Map<String, Object> matchingBeans = findAutowireCandidates(beanName, componentType, targetDesc);
            if (matchingBeans.isEmpty()) {
                if (descriptor.isRequired()) {
                    raiseNoSuchBeanDefinitionException(componentType, "array of " + componentType.getName(), descriptor);
                }
                return null;
            }
            if (autowiredBeanNames != null) {
                autowiredBeanNames.addAll(matchingBeans.keySet());
            }
            TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
            Object result = converter.convertIfNecessary(matchingBeans.values(), type);
            if (this.dependencyComparator != null && result instanceof Object[]) {
                Arrays.sort((Object[]) result, this.dependencyComparator);
            }
            return result;
        }
        else if (Collection.class.isAssignableFrom(type) && type.isInterface()) { //依賴注入的是集合
            Class<?> elementType = descriptor.getCollectionType();
            if (elementType == null) {
                if (descriptor.isRequired()) {
                    throw new FatalBeanException("No element type declared for collection [" + type.getName() + "]");
                }
                return null;
            }
            DependencyDescriptor targetDesc = new DependencyDescriptor(descriptor);
            targetDesc.increaseNestingLevel();
            Map<String, Object> matchingBeans = findAutowireCandidates(beanName, elementType, targetDesc);
            if (matchingBeans.isEmpty()) {
                if (descriptor.isRequired()) {
                    raiseNoSuchBeanDefinitionException(elementType, "collection of " + elementType.getName(), descriptor);
                }
                return null;
            }
            if (autowiredBeanNames != null) {
                autowiredBeanNames.addAll(matchingBeans.keySet());
            }
            TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
            Object result = converter.convertIfNecessary(matchingBeans.values(), type);
            if (this.dependencyComparator != null && result instanceof List) {
                Collections.sort((List<?>) result, this.dependencyComparator);
            }
            return result;
        }
        else if (Map.class.isAssignableFrom(type) && type.isInterface()) { //依賴注入的是MAp
            Class<?> keyType = descriptor.getMapKeyType();
            if (keyType == null || !String.class.isAssignableFrom(keyType)) {
                if (descriptor.isRequired()) {
                    throw new FatalBeanException("Key type [" + keyType + "] of map [" + type.getName() +
                            "] must be assignable to [java.lang.String]");
                }
                return null;
            }
            Class<?> valueType = descriptor.getMapValueType();
            if (valueType == null) {
                if (descriptor.isRequired()) {
                    throw new FatalBeanException("No value type declared for map [" + type.getName() + "]");
                }
                return null;
            }
            DependencyDescriptor targetDesc = new DependencyDescriptor(descriptor);
            targetDesc.increaseNestingLevel();
            Map<String, Object> matchingBeans = findAutowireCandidates(beanName, valueType, targetDesc);
            if (matchingBeans.isEmpty()) {
                if (descriptor.isRequired()) {
                    raiseNoSuchBeanDefinitionException(valueType, "map with value type " + valueType.getName(), descriptor);
                }
                return null;
            }
            if (autowiredBeanNames != null) {
                autowiredBeanNames.addAll(matchingBeans.keySet());
            }
            return matchingBeans;
        }
        else {  //依賴注入不是數組，不是Map，不是集合，是基本類型或者對象，
            Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);  //{woman=com.zhuguang.jack.testbean.Woman@9a7a808}，從bean工廠獲取，最終仍是經過getBean()方法獲取。
if (matchingBeans.size() > 1) {//依賴注入的類有多個，報錯。
                String primaryBeanName = determinePrimaryCandidate(matchingBeans, descriptor);
                if (primaryBeanName == null) {
                    throw new NoUniqueBeanDefinitionException(type, matchingBeans.keySet());
                }
                if (autowiredBeanNames != null) {
                    autowiredBeanNames.add(primaryBeanName);
                }
                return matchingBeans.get(primaryBeanName);
            }
            Map.Entry<String, Object> entry = matchingBeans.entrySet().iterator().next();
            if (autowiredBeanNames != null) {
                autowiredBeanNames.add(entry.getKey());
            }
            return entry.getValue();//woman=com.zhuguang.jack.testbean.Woman@abbc908
        }
    }

protected Map<String, Object> findAutowireCandidates(
            String beanName, Class<?> requiredType, DependencyDescriptor descriptor) {

        for (String candidateName : candidateNames) {
            if (!candidateName.equals(beanName) && isAutowireCandidate(candidateName, descriptor)) {
                result.put(candidateName, getBean(candidateName));  //仍是經過getBean()方法獲取須要依賴注入的屬性的值，
            }
        }
        return result;
    }

//方法的依賴注入，依賴注入在這裏。經過反射給方法設置值，形參經過getBean（）方法獲取。
protected void inject(Object bean, String beanName, PropertyValues pvs) throws Throwable {
                else {
                        Object arg = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);
                        if (arg == null && !this.required) {
                            arguments = null;
                            break;
                        }
                        arguments[i] = arg;
                    }
                }
                if (arguments != null) {
                    ReflectionUtils.makeAccessible(method);
                    method.invoke(bean, arguments);   //經過反射給方法設置值，形參經過getBean（）方法獲取。
                }
            }
        }
        
上main是經過註解的依賴注入，還有經過XML的依賴注入。 protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {   //經過xml依賴注入，

        MutablePropertyValues mpvs = null;
        List<PropertyValue> original;

        if (System.getSecurityManager() != null) {
            if (bw instanceof BeanWrapperImpl) {
                ((BeanWrapperImpl) bw).setSecurityContext(getAccessControlContext());
            }
        }

        if (pvs instanceof MutablePropertyValues) {
            mpvs = (MutablePropertyValues) pvs;
            if (mpvs.isConverted()) {
                try {
                    bw.setPropertyValues(mpvs);
                    return;
                }
            }
            original = mpvs.getPropertyValueList();  //[bean property 'woman']，須要xml依賴注入的屬性，
        }
        else {
            original = Arrays.asList(pvs.getPropertyValues());   //[bean property 'woman']，須要xml依賴注入的屬性，
        }

        TypeConverter converter = getCustomTypeConverter();
        if (converter == null) {
            converter = bw;
        }
        BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);

        List<PropertyValue> deepCopy = new ArrayList<PropertyValue>(original.size());
        boolean resolveNecessary = false;
        for (PropertyValue pv : original) {
            else {
                String propertyName = pv.getName();//woman，
                Object originalValue = pv.getValue();//<woman>，RuntimeBeanReference類型，
                Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);  //beanFactory.getBean(refName);從bean工廠拿。由於依賴注入的屬性有多是一個引用，有多是一個字符串須要轉換成時間，
                Object convertedValue = resolvedValue;  //com.zhuguang.jack.testbean.Woman@9a7a808，
                boolean convertible = bw.isWritableProperty(propertyName) &&!PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName);
                if (convertible) {
                    convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter);//com.zhuguang.jack.testbean.Woman@9a7a808，類型轉換以後的值。上面的valueResolver.resolveValueIfNecessary(pv, originalValue)有可能轉換還不夠，還須要轉換，
                }
                if (resolvedValue == originalValue) {
                    if (convertible) {
                        pv.setConvertedValue(convertedValue);
                    }
                    deepCopy.add(pv);
                }
                else if (convertible && originalValue instanceof TypedStringValue &&
                        !((TypedStringValue) originalValue).isDynamic() &&
                        !(convertedValue instanceof Collection || ObjectUtils.isArray(convertedValue))) {
                    pv.setConvertedValue(convertedValue);
                    deepCopy.add(pv);
                }
                else {
                    resolveNecessary = true;
                    deepCopy.add(new PropertyValue(pv, convertedValue));  //pv, convertedValue一個是原始屬性值，一個是轉換以後的值。封裝成PropertyValue，
                }
            }
        }

        try {
            bw.setPropertyValues(new MutablePropertyValues(deepCopy));  //設置值，MutablePropertyValues纔是須要真正設置的值。
        }
    }

public void setPropertyValue(PropertyValue pv) throws BeansException {
        PropertyTokenHolder tokens = (PropertyTokenHolder) pv.resolvedTokens;
        if (tokens == null) {
            String propertyName = pv.getName();
            BeanWrapperImpl nestedBw;
            try {
                nestedBw = getBeanWrapperForPropertyPath(propertyName);
            }
            tokens = getPropertyNameTokens(getFinalPath(nestedBw, propertyName));
            if (nestedBw == this) {
                pv.getOriginalPropertyValue().resolvedTokens = tokens;
            }
            nestedBw.setPropertyValue(tokens, pv);
        }
        else {
            setPropertyValue(tokens, pv);
        }
    }
    
protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
        else {
            invokeAwareMethods(beanName, bean);
        }

        Object wrappedBean = bean;
        if (mbd == null || !mbd.isSynthetic()) {
            wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
        }

        try {
            invokeInitMethods(beanName, wrappedBean, mbd);
        }

        if (mbd == null || !mbd.isSynthetic()) {
            wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
        }
        return wrappedBean;
    }

public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
            throws BeansException {

        Object result = existingBean;
        for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
            result = beanProcessor.postProcessBeforeInitialization(result, beanName);
            if (result == null) {
                return result;
            }
        }
        return result;
    }

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);
            }
        }
    }

protected void invokeInitMethods(String beanName, final Object bean, RootBeanDefinition mbd)throws Throwable {
        boolean isInitializingBean = (bean instanceof InitializingBean);
        if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
            else {
                ((InitializingBean) bean).afterPropertiesSet();   //實例化bean的時候，調用afterPropertiesSet()方法，沒有參數，作資源的加載（redis，mongodb的加載，），一個bean只會調用一次。在bean實例化以後，IOC以後調用。
            }
        }

        if (mbd != null) {
            String initMethodName = mbd.getInitMethodName();
            if (initMethodName != null && !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
                    !mbd.isExternallyManagedInitMethod(initMethodName)) {
                invokeCustomInitMethod(beanName, bean, mbd);
            }
        }
    }

protected void invokeCustomInitMethod(String beanName, final Object bean, RootBeanDefinition mbd) throws Throwable {
        String initMethodName = mbd.getInitMethodName();  //拿到init方法的名稱，init-method，
        final Method initMethod = (mbd.isNonPublicAccessAllowed() ?
                BeanUtils.findMethod(bean.getClass(), initMethodName) :
                ClassUtils.getMethodIfAvailable(bean.getClass(), initMethodName));   //反射獲得這個方法，
        else {
            try {
                ReflectionUtils.makeAccessible(initMethod);
                initMethod.invoke(bean);   //調用，
            }
        }
    }
    
protected void registerDisposableBeanIfNecessary(String beanName, Object bean, RootBeanDefinition mbd) {
        AccessControlContext acc = (System.getSecurityManager() != null ? getAccessControlContext() : null);
        if (!mbd.isPrototype() && requiresDestruction(bean, mbd)) {
            if (mbd.isSingleton()) {  //單利，就緩存，
                registerDisposableBean(beanName,
                        new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));
            }
            else {
                Scope scope = this.scopes.get(mbd.getScope());
                if (scope == null) {
                    throw new IllegalStateException("No Scope registered for scope '" + mbd.getScope() + "'");
                }
                scope.registerDestructionCallback(beanName,
                        new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));
            }
        }
    }

public void registerDisposableBean(String beanName, DisposableBean bean) {
        synchronized (this.disposableBeans) {
            this.disposableBeans.put(beanName, bean);
        }
    }