一直很好奇代码 AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(SimpleBeanConfig.class);运行的时候，spring容器做了什么事情，为了搞清楚，我要看一看Spring源码剖析一下。

一、首先写一个测试方法如下：

AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(StudentConfig.class);
        Student simpleBean = (Student) context.getBean("student");
        System.out.println(simpleBean.toString());

通过debug发现，spring的容器创建以及类的实例化都是在第一行代码中实现的，因此进去AnnotationConfigApplicationContext 看一下，发现构造方法中有三行代码如下：

public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) { 
        this();
        this.register(annotatedClasses);
        this.refresh();
    }

二、Spring容器管理bean

首先调用this()就是本类的构造方法，由于AnnotationConfigApplicationContext继承了GenericApplicationContext因此首先会执行GenericApplicationContext的构造方法。进入发现构造方法中初始化了自己内部的beanFactory为DefaultListableBeanFactory：

public GenericApplicationContext() { 
        this.customClassLoader = false;
        this.refreshed = new AtomicBoolean();
        this.beanFactory = new DefaultListableBeanFactory();
    }

1.this()方法

接下来再看AnnotationConfigApplicationContext中自己的构造方法
this()调用的是本地的无参构造方法，里边有两行代码

public AnnotationConfigApplicationContext() { 
        this.reader = new AnnotatedBeanDefinitionReader(this);
        this.scanner = new ClassPathBeanDefinitionScanner(this);
    }

进入AnnotatedBeanDefinitionReader中
1.1AnnotatedBeanDefinitionReader

public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry) { 
        this(registry, getOrCreateEnvironment(registry));
    }
    public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) { 
        this.beanNameGenerator = new AnnotationBeanNameGenerator();
        this.scopeMetadataResolver = new AnnotationScopeMetadataResolver();
        Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
        Assert.notNull(environment, "Environment must not be null");
        this.registry = registry;
        this.conditionEvaluator = new ConditionEvaluator(registry, environment, (ResourceLoader)null);
        AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
    }

在最后一行中将处理注解的基础设施类放到DefaultListableBeanFactory，内容如下：
1.2AnnotationConfigUtils#registerAnnotationConfigProcessors

public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(BeanDefinitionRegistry registry, Object source) { 
        DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
        if (beanFactory != null) { 
            if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) { 
                beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
            }
            if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) { 
                beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
            }
        }
        Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet(4);
        RootBeanDefinition def;
        if (!registry.containsBeanDefinition("org.springframework.context.annotation.internalConfigurationAnnotationProcessor")) { 
            def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
            def.setSource(source);
            beanDefs.add(registerPostProcessor(registry, def, "org.springframework.context.annotation.internalConfigurationAnnotationProcessor"));
        }
        if (!registry.containsBeanDefinition("org.springframework.context.annotation.internalAutowiredAnnotationProcessor")) { 
            def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
            def.setSource(source);
            beanDefs.add(registerPostProcessor(registry, def, "org.springframework.context.annotation.internalAutowiredAnnotationProcessor"));
        }
        if (!registry.containsBeanDefinition("org.springframework.context.annotation.internalRequiredAnnotationProcessor")) { 
            def = new RootBeanDefinition(RequiredAnnotationBeanPostProcessor.class);
            def.setSource(source);
            beanDefs.add(registerPostProcessor(registry, def, "org.springframework.context.annotation.internalRequiredAnnotationProcessor"));
        }
        if (jsr250Present && !registry.containsBeanDefinition("org.springframework.context.annotation.internalCommonAnnotationProcessor")) { 
            def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
            def.setSource(source);
            beanDefs.add(registerPostProcessor(registry, def, "org.springframework.context.annotation.internalCommonAnnotationProcessor"));
        }
        if (jpaPresent && !registry.containsBeanDefinition("org.springframework.context.annotation.internalPersistenceAnnotationProcessor")) { 
            def = new RootBeanDefinition();
            try { 
                def.setBeanClass(ClassUtils.forName("org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor", AnnotationConfigUtils.class.getClassLoader()));
            } catch (ClassNotFoundException var6) { 
                throw new IllegalStateException("Cannot load optional framework class: org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor", var6);
            }
            def.setSource(source);
            beanDefs.add(registerPostProcessor(registry, def, "org.springframework.context.annotation.internalPersistenceAnnotationProcessor"));
        }
        if (!registry.containsBeanDefinition("org.springframework.context.event.internalEventListenerProcessor")) { 
            def = new RootBeanDefinition(EventListenerMethodProcessor.class);
            def.setSource(source);
            beanDefs.add(registerPostProcessor(registry, def, "org.springframework.context.event.internalEventListenerProcessor"));
        }
        if (!registry.containsBeanDefinition("org.springframework.context.event.internalEventListenerFactory")) { 
            def = new RootBeanDefinition(DefaultEventListenerFactory.class);
            def.setSource(source);
            beanDefs.add(registerPostProcessor(registry, def, "org.springframework.context.event.internalEventListenerFactory"));
        }
        return beanDefs;
    }

1.3AnnotationConfigUtils#registerPostProcessor

private static BeanDefinitionHolder registerPostProcessor(BeanDefinitionRegistry registry, RootBeanDefinition definition, String beanName) { 
        definition.setRole(2);
        registry.registerBeanDefinition(beanName, definition);
        return new BeanDefinitionHolder(definition, beanName);
    }

其中registerPostProcessor（），就是注册动作，继续深入registerBeanDefinition：

public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) throws BeanDefinitionStoreException { 
        this.beanFactory.registerBeanDefinition(beanName, beanDefinition);
    }

只有一行代码，继续入：
1.4DefaultListableBeanFactory#registerBeanDefinition

public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
        throws BeanDefinitionStoreException { 
    Assert.hasText(beanName, "Bean name must not be empty");
    Assert.notNull(beanDefinition, "BeanDefinition must not be null");
    if (beanDefinition instanceof AbstractBeanDefinition) { 
        try { 
            ((AbstractBeanDefinition) beanDefinition).validate();
        } catch (BeanDefinitionValidationException ex) { 
            throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
                    "Validation of bean definition failed", ex);
        }
    }
    //注册BeanDefinition，就是将BeanDefinition放入一个map中，key是beanName
    //注册之前，先查下是否被注册过
    BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
    //如果已经存在，那么就检查是否允许覆盖，不允许直接跑异常，允许的话就记录一些日志，然后覆盖
    if (existingDefinition != null) { 
        //默认允许覆盖
        if (!isAllowBeanDefinitionOverriding()) { 
            //如果bean已经被注册了，并且不允许覆盖，那么抛出异常
            throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
                    "Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName +
                            "': There is already [" + existingDefinition + "] bound.");
        } else if (existingDefinition.getRole() < beanDefinition.getRole()) { 
            // e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
            if (logger.isWarnEnabled()) { 
                logger.warn("Overriding user-defined bean definition for bean '" + beanName +
                        "' with a framework-generated bean definition: replacing [" +
                        existingDefinition + "] with [" + beanDefinition + "]");
            }
        } else if (!beanDefinition.equals(existingDefinition)) { 
            if (logger.isInfoEnabled()) { 
                logger.info("Overriding bean definition for bean '" + beanName +
                        "' with a different definition: replacing [" + existingDefinition +
                        "] with [" + beanDefinition + "]");
            }
        } else { 
            if (logger.isDebugEnabled()) { 
                logger.debug("Overriding bean definition for bean '" + beanName +
                        "' with an equivalent definition: replacing [" + existingDefinition +
                        "] with [" + beanDefinition + "]");
            }
        }
        this.beanDefinitionMap.put(beanName, beanDefinition);
    } else { 
        //检查bean的创建过程是否已经开始了
        //通过判断一个set集合是否为空，因为创建过的bean都会放到那个set中保存下
        if (hasBeanCreationStarted()) { 
            // Cannot modify startup-time collection elements anymore (for stable iteration)
            synchronized (this.beanDefinitionMap) { 
                this.beanDefinitionMap.put(beanName, beanDefinition);
                //下面4行是更新beanDefinitionNames的list
                List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
                updatedDefinitions.addAll(this.beanDefinitionNames);
                updatedDefinitions.add(beanName);
                this.beanDefinitionNames = updatedDefinitions;
                //manualSingletonNames人工注册的单例集合,也要更新
                if (this.manualSingletonNames.contains(beanName)) { 
                    Set<String> updatedSingletons = new LinkedHashSet<>(this.manualSingletonNames);
                    updatedSingletons.remove(beanName);
                    this.manualSingletonNames = updatedSingletons;
                }
            }
        } else { 
            // Still in startup registration phase:仍然在启动注册阶段
            this.beanDefinitionMap.put(beanName, beanDefinition);
            this.beanDefinitionNames.add(beanName);
            this.manualSingletonNames.remove(beanName);
        }
        this.frozenBeanDefinitionNames = null;
    }
    if (existingDefinition != null || containsSingleton(beanName)) { 
        resetBeanDefinition(beanName);
    }
}

beanDefinitionMap：将注册的bean往map中存放，是个ConcurrentHashMap；
放到map之前，先查看map中是否已经存在了，如果已经存在，再判断是否允许覆盖；
如果 map中不存在，那么就put进去。

2.this.register(annotatedClasses);

接下来是AnnotationConfigApplicationContext中的第二个方法this.register，看参数以及方法名就知道是往容器中注册

public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) { 
        this();
        this.register(annotatedClasses);
        this.refresh();
    }

2.1进入到 this.register(annotatedClasses);

public void register(Class<?>... annotatedClasses) { 
        Assert.notEmpty(annotatedClasses, "At least one annotated class must be specified");
        this.reader.register(annotatedClasses);
    }

调用的是AnnotationConfigApplicationContext的注册方法
2.2进入this.reader.register(annotatedClasses);

public void register(Class<?>... annotatedClasses) { 
        Class[] var2 = annotatedClasses;
        int var3 = annotatedClasses.length;
        for(int var4 = 0; var4 < var3; ++var4) { 
            Class<?> annotatedClass = var2[var4];
            this.registerBean(annotatedClass);
        }
    }

其实参数是一个数组，进行遍历调用registerBean
2.3单行直接入，跳到registerBean：

public void registerBean(Class<?> annotatedClass, String name, Class<? extends Annotation>... qualifiers) { 
        //得到bean的描述信息，比如bean的注解，作用范围，是否懒加载，注入方式等
    AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass);
    //被条件注解@Conditional注释的bean跳过注册
    if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) { 
        return;
    }
    abd.setInstanceSupplier(instanceSupplier);
    //解析bean的Scope，比如是否单例singleton还是其他
    ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
    abd.setScope(scopeMetadata.getScopeName());
    //生成bean name，默认就是类名小写
    String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));
    //通过判断注解内容，设置一些公共属性，比如是否懒加载，优先级等
    AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
    if (qualifiers != null) { 
        for (Class<? extends Annotation> qualifier : qualifiers) { 
            if (Primary.class == qualifier) { 
                abd.setPrimary(true);
            } else if (Lazy.class == qualifier) { 
                abd.setLazyInit(true);
            } else { 
                abd.addQualifier(new AutowireCandidateQualifier(qualifier));
            }
        }
    }
    for (BeanDefinitionCustomizer customizer : definitionCustomizers) { 
        customizer.customize(abd);
    }
    BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
    definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
    BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);

就是获取封装以及注册

3.this.refresh();

方法名为刷新，即为刷新容器。

public void refresh() throws BeansException, IllegalStateException { 
        synchronized(this.startupShutdownMonitor) { 
            this.prepareRefresh();
            ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
            this.prepareBeanFactory(beanFactory);
            try { 
                this.postProcessBeanFactory(beanFactory);
                this.invokeBeanFactoryPostProcessors(beanFactory);
                this.registerBeanPostProcessors(beanFactory);
                this.initMessageSource();
                this.initApplicationEventMulticaster();
                this.onRefresh();
                this.registerListeners();
                this.finishBeanFactoryInitialization(beanFactory);
                this.finishRefresh();
            } catch (BeansException var9) { 
                if (this.logger.isWarnEnabled()) { 
                    this.logger.warn("Exception encountered during context initialization - cancelling refresh attempt: " + var9);
                }
                this.destroyBeans();
                this.cancelRefresh(var9);
                throw var9;
            } finally { 
                this.resetCommonCaches();
            }
        }
    }

3.1this.prepareRefresh();做一些刷新前的准备，记录时间什么的

protected void prepareRefresh() { 
        this.startupDate = System.currentTimeMillis();
        this.closed.set(false);
        this.active.set(true);
        if (this.logger.isInfoEnabled()) { 
            this.logger.info("Refreshing " + this);
        }
        this.initPropertySources();
        this.getEnvironment().validateRequiredProperties();
        this.earlyApplicationEvents = new LinkedHashSet();
    }

3.2ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() { 
        this.refreshBeanFactory();
        ConfigurableListableBeanFactory beanFactory = this.getBeanFactory();
        if (this.logger.isDebugEnabled()) { 
            this.logger.debug("Bean factory for " + this.getDisplayName() + ": " + beanFactory);
        }
        return beanFactory;
    }

拿到工厂类
3.3AbstractBeanFactory#addBeanPostProcessor

public void addBeanPostProcessor(BeanPostProcessor beanPostProcessor) { 
        Assert.notNull(beanPostProcessor, "BeanPostProcessor must not be null");
        this.beanPostProcessors.remove(beanPostProcessor);
        this.beanPostProcessors.add(beanPostProcessor);
        if (beanPostProcessor instanceof InstantiationAwareBeanPostProcessor) { 
            this.hasInstantiationAwareBeanPostProcessors = true;
        }
        if (beanPostProcessor instanceof DestructionAwareBeanPostProcessor) { 
            this.hasDestructionAwareBeanPostProcessors = true;
        }
    }

addBeanPostProcessor()方法定义在AbstractBeanFactory抽象类中，Spring添加自己定义的后置处理器
通过this.beanPostProcessors.add(beanPostProcessor);将spring后置处理器全部添加到BeanPostProcessor泛型的一个list当中
private final List beanPostProcessors = new ArrayList();
3.4BeanPostProcessor接口：

public interface BeanPostProcessor { 
    Object postProcessBeforeInitialization(Object var1, String var2) throws BeansException;
    Object postProcessAfterInitialization(Object var1, String var2) throws BeansException;
}

定义了一个前置处理器和一个后置处理器

@Component
public class MyBeanPostProcessor implements BeanPostProcessor, PriorityOrdered { 
    /**
     * 这里拿到bean之后可以根据此bean创建一个代理类对象
     * AOP正是通过BeanPostProcessor和IOC容器建立起了联系
     * @param bean the new bean instance
     * @param beanName the name of the bean
     * @return
     * @throws BeansException
     */
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { 
        if (beanName.equals("student")){ 
            System.out.println("MyBeanPostProcessor的前置处理器执行");
        }
        return bean;
    }
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { 
        if (beanName.equals("student")){ 
            System.out.println("MyBeanPostProcessor的后置处理器执行");
        }
        return bean;
    }
    @Override
    public int getOrder() { 
        return 101;
    }
}

后置处理器的优先级通过继承接口：PriorityOrdered重写getOrder()方法来设置，数字越小优先级越高，所以bean后置处理器在AbstractBeanFactory抽象类中放在一个list的集合中，是一个列表，在创建bean的时候依次执行。
3.4postProcessBeanFactory能够更改工厂bean的一些行为，可自行扩展

3.5invokeBeanFactoryPostProcessors(beanFactory)
BeanFactoryPostProcessor能够在bean实例化之前进行一定的操作，通过”order”控制执行次序(要实现Ordered接口)。
优先处理BeanDefinitionRegistryPostProcessor其次是BeanFactoryPostProcessor

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) { 
        PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, this.getBeanFactoryPostProcessors());
        if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean("loadTimeWeaver")) { 
            beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
            beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
        }
    }

3.6registerBeanPostProcessors(beanFactory)

public static void registerBeanPostProcessors(
    ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) { 
    //从beanFactory查询之前注册的BeanPostProcessor类型的bean名字
    String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
    //实例化一个BeanPostProcessorChecker，用于记录日志信息，比如当一个bean没有被任何后置处理器处理时
    //BeanPostProcessorChecker是一个内部类，实现了BeanPostProcessor接口
    // Register BeanPostProcessorChecker that logs an info message when
    // a bean is created during BeanPostProcessor instantiation, i.e. when
    // a bean is not eligible for getting processed by all BeanPostProcessors.
    int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
    beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
    // Separate between BeanPostProcessors that implement PriorityOrdered,Ordered, and the rest.
    //这里也分为PriorityOrdered,Ordered, and 其他 3中情况分开处理；所以先遍历一遍，把类型分开；
    //遍历时候，顺便把PriorityOrdered实例化了
    List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
    //是否框架内部使用的PostProcessor
    List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
    List<String> orderedPostProcessorNames = new ArrayList<>();
    List<String> nonOrderedPostProcessorNames = new ArrayList<>();
    for (String ppName : postProcessorNames) { 
        if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) { 
            BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
            priorityOrderedPostProcessors.add(pp);
            if (pp instanceof MergedBeanDefinitionPostProcessor) { 
                internalPostProcessors.add(pp);
            }
        } else if (beanFactory.isTypeMatch(ppName, Ordered.class)) { 
            orderedPostProcessorNames.add(ppName);
        } else { 
            nonOrderedPostProcessorNames.add(ppName);
        }
    }
    // First, register the BeanPostProcessors that implement PriorityOrdered.
    //首先注册实现了PriorityOrdered接口的，注册就是把实例化的ostProcessors放到容器的list结合中
    sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
    registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
    // Next, register the BeanPostProcessors that implement Ordered.
    //然后注册Ordered实现了Ordered接口的
    List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>();
    for (String ppName : orderedPostProcessorNames) { 
        BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
        orderedPostProcessors.add(pp);
        if (pp instanceof MergedBeanDefinitionPostProcessor) { 
            internalPostProcessors.add(pp);
        }
    }
    sortPostProcessors(orderedPostProcessors, beanFactory);
    registerBeanPostProcessors(beanFactory, orderedPostProcessors);
    // Now, register all regular BeanPostProcessors.
    //最后注册其他类型的
    List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
    for (String ppName : nonOrderedPostProcessorNames) { 
        BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
        nonOrderedPostProcessors.add(pp);
        if (pp instanceof MergedBeanDefinitionPostProcessor) { 
            internalPostProcessors.add(pp);
        }
    }
    registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
    // Finally, re-register all internal BeanPostProcessors.
    //最后注册内部类型的BeanPostProcessors
    sortPostProcessors(internalPostProcessors, beanFactory);
    registerBeanPostProcessors(beanFactory, internalPostProcessors);
    // Re-register post-processor for detecting inner beans as ApplicationListeners,
    // moving it to the end of the processor chain (for picking up proxies etc).
    //初始化一个类，用于监听器的探测
    beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}

实例化BeanPostProcessor，能够在bean实例化的前后进行操作
3.7finishBeanFactoryInitialization(beanFactory)

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) { 
        if (beanFactory.containsBean("conversionService") && beanFactory.isTypeMatch("conversionService", ConversionService.class)) { 
            beanFactory.setConversionService((ConversionService)beanFactory.getBean("conversionService", ConversionService.class));
        }
        if (!beanFactory.hasEmbeddedValueResolver()) { 
            beanFactory.addEmbeddedValueResolver(new StringValueResolver() { 
                public String resolveStringValue(String strVal) { 
                    return AbstractApplicationContext.this.getEnvironment().resolvePlaceholders(strVal);
                }
            });
        }
        String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
        String[] var3 = weaverAwareNames;
        int var4 = weaverAwareNames.length;
        for(int var5 = 0; var5 < var4; ++var5) { 
            String weaverAwareName = var3[var5];
            this.getBean(weaverAwareName);
        }
        beanFactory.setTempClassLoader((ClassLoader)null);
        beanFactory.freezeConfiguration();
        beanFactory.preInstantiateSingletons();
    }

实例化剩下的bean，完成全部bean的实例化（懒加载除外），在最后的beanFactory.preInstantiateSingletons();实现了所需类的实例化，通过debug发现是调用了AbstractBeanFactory下的getBean()方法进行的实例化，而getBean()方法又有一行调用doGetBean()的代码
3.7.1AbstractBeanFactory#doGetBean()

protected <T> T doGetBean(String name, Class<T> requiredType, final Object[] args, boolean typeCheckOnly) throws BeansException { 
        final String beanName = this.transformedBeanName(name);
        Object sharedInstance = this.getSingleton(beanName);
        Object bean;
        if (sharedInstance != null && args == null) { 
            if (this.logger.isDebugEnabled()) { 
                if (this.isSingletonCurrentlyInCreation(beanName)) { 
                    this.logger.debug("Returning eagerly cached instance of singleton bean '" + beanName + "' that is not fully initialized yet - a consequence of a circular reference");
                } else { 
                    this.logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
                }
            }
            bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, (RootBeanDefinition)null);
        } else { 
            if (this.isPrototypeCurrentlyInCreation(beanName)) { 
                throw new BeanCurrentlyInCreationException(beanName);
            }
            BeanFactory parentBeanFactory = this.getParentBeanFactory();
            if (parentBeanFactory != null && !this.containsBeanDefinition(beanName)) { 
                String nameToLookup = this.originalBeanName(name);
                if (args != null) { 
                    return parentBeanFactory.getBean(nameToLookup, args);
                }
                return parentBeanFactory.getBean(nameToLookup, requiredType);
            }
            if (!typeCheckOnly) { 
                this.markBeanAsCreated(beanName);
            }
            try { 
                final RootBeanDefinition mbd = this.getMergedLocalBeanDefinition(beanName);
                this.checkMergedBeanDefinition(mbd, beanName, args);
                String[] dependsOn = mbd.getDependsOn();
                String[] var11;
                if (dependsOn != null) { 
                    var11 = dependsOn;
                    int var12 = dependsOn.length;
                    for(int var13 = 0; var13 < var12; ++var13) { 
                        String dep = var11[var13];
                        if (this.isDependent(beanName, dep)) { 
                            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
                        }
                        this.registerDependentBean(dep, beanName);
                        try { 
                            this.getBean(dep);
                        } catch (NoSuchBeanDefinitionException var24) { 
                            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "'" + beanName + "' depends on missing bean '" + dep + "'", var24);
                        }
                    }
                }
                if (mbd.isSingleton()) { 
                    sharedInstance = this.getSingleton(beanName, new ObjectFactory<Object>() { 
                        public Object getObject() throws BeansException { 
                            try { 
                                return AbstractBeanFactory.this.createBean(beanName, mbd, args);
                            } catch (BeansException var2) { 
                                AbstractBeanFactory.this.destroySingleton(beanName);
                                throw var2;
                            }
                        }
                    });
                    bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
                } else if (mbd.isPrototype()) { 
                    var11 = null;
                    Object prototypeInstance;
                    try { 
                        this.beforePrototypeCreation(beanName);
                        prototypeInstance = this.createBean(beanName, mbd, args);
                    } finally { 
                        this.afterPrototypeCreation(beanName);
                    }
                    bean = this.getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
                } else { 
                    String scopeName = mbd.getScope();
                    Scope scope = (Scope)this.scopes.get(scopeName);
                    if (scope == null) { 
                        throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
                    }
                    try { 
                        Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() { 
                            public Object getObject() throws BeansException { 
                                AbstractBeanFactory.this.beforePrototypeCreation(beanName);
                                Object var1;
                                try { 
                                    var1 = AbstractBeanFactory.this.createBean(beanName, mbd, args);
                                } finally { 
                                    AbstractBeanFactory.this.afterPrototypeCreation(beanName);
                                }
                                return var1;
                            }
                        });
                        bean = this.getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
                    } catch (IllegalStateException var23) { 
                        throw new BeanCreationException(beanName, "Scope '" + scopeName + "' is not active for the current thread; consider defining a scoped proxy for this bean if you intend to refer to it from a singleton", var23);
                    }
                }
            } catch (BeansException var26) { 
                this.cleanupAfterBeanCreationFailure(beanName);
                throw var26;
            }
        }
        if (requiredType != null && bean != null && !requiredType.isInstance(bean)) { 
            try { 
                return this.getTypeConverter().convertIfNecessary(bean, requiredType);
            } catch (TypeMismatchException var25) { 
                if (this.logger.isDebugEnabled()) { 
                    this.logger.debug("Failed to convert bean '" + name + "' to required type '" + ClassUtils.getQualifiedName(requiredType) + "'", var25);
                }
                throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
            }
        } else { 
            return bean;
        }
    }

通过debug发现是在AbstractAutowireCapableBeanFactory中的createBean完成了bean的实例化
Object sharedInstance = this.getSingleton(beanName);//尝试从缓存中获取单例bean
3.7.2AbstractAutowireCapableBeanFactory#createBean

protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException { 
        if (this.logger.isDebugEnabled()) { 
            this.logger.debug("Creating instance of bean '" + beanName + "'");
        }
        RootBeanDefinition mbdToUse = mbd;
        Class<?> resolvedClass = this.resolveBeanClass(mbd, beanName, new Class[0]);
        if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) { 
            mbdToUse = new RootBeanDefinition(mbd);
            mbdToUse.setBeanClass(resolvedClass);
        }
        try { 
            mbdToUse.prepareMethodOverrides();
        } catch (BeanDefinitionValidationException var7) { 
            throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(), beanName, "Validation of method overrides failed", var7);
        }
        Object beanInstance;
        try { 
            beanInstance = this.resolveBeforeInstantiation(beanName, mbdToUse);
            if (beanInstance != null) { 
                return beanInstance;
            }
        } catch (Throwable var8) { 
            throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "BeanPostProcessor before instantiation of bean failed", var8);
        }
        beanInstance = this.doCreateBean(beanName, mbdToUse, args);
        if (this.logger.isDebugEnabled()) { 
            this.logger.debug("Finished creating instance of bean '" + beanName + "'");
        }
        return beanInstance;
    }

create中又调用doCreateBean来进行实例化操作
3.7.3AbstractAutowireCapableBeanFactory#doCreateBean

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, Object[] args) throws BeanCreationException { 
        BeanWrapper instanceWrapper = null;
        if (mbd.isSingleton()) { 
            instanceWrapper = (BeanWrapper)this.factoryBeanInstanceCache.remove(beanName);
        }
        if (instanceWrapper == null) { 
            instanceWrapper = this.createBeanInstance(beanName, mbd, args);
        }
        final Object bean = instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null;
        Class<?> beanType = instanceWrapper != null ? instanceWrapper.getWrappedClass() : null;
        mbd.resolvedTargetType = beanType;
        synchronized(mbd.postProcessingLock) { 
            if (!mbd.postProcessed) { 
                try { 
                    this.applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
                } catch (Throwable var17) { 
                    throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Post-processing of merged bean definition failed", var17);
                }
                mbd.postProcessed = true;
            }
        }
        boolean earlySingletonExposure = mbd.isSingleton() && this.allowCircularReferences && this.isSingletonCurrentlyInCreation(beanName);
        if (earlySingletonExposure) { 
            if (this.logger.isDebugEnabled()) { 
                this.logger.debug("Eagerly caching bean '" + beanName + "' to allow for resolving potential circular references");
            }
            this.addSingletonFactory(beanName, new ObjectFactory<Object>() { 
                public Object getObject() throws BeansException { 
                    return AbstractAutowireCapableBeanFactory.this.getEarlyBeanReference(beanName, mbd, bean);
                }
            });
        }
        Object exposedObject = bean;
        try { 
            this.populateBean(beanName, mbd, instanceWrapper);
            if (exposedObject != null) { 
                exposedObject = this.initializeBean(beanName, exposedObject, mbd);
            }
        } catch (Throwable var18) { 
            if (var18 instanceof BeanCreationException && beanName.equals(((BeanCreationException)var18).getBeanName())) { 
                throw (BeanCreationException)var18;
            }
            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", var18);
        }
        if (earlySingletonExposure) { 
            Object earlySingletonReference = this.getSingleton(beanName, false);
            if (earlySingletonReference != null) { 
                if (exposedObject == bean) { 
                    exposedObject = earlySingletonReference;
                } else if (!this.allowRawInjectionDespiteWrapping && this.hasDependentBean(beanName)) { 
                    String[] dependentBeans = this.getDependentBeans(beanName);
                    Set<String> actualDependentBeans = new LinkedHashSet(dependentBeans.length);
                    String[] var12 = dependentBeans;
                    int var13 = dependentBeans.length;
                    for(int var14 = 0; var14 < var13; ++var14) { 
                        String dependentBean = var12[var14];
                        if (!this.removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) { 
                            actualDependentBeans.add(dependentBean);
                        }
                    }
                    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.");
                    }
                }
            }
        }
        try { 
            this.registerDisposableBeanIfNecessary(beanName, bean, mbd);
            return exposedObject;
        } catch (BeanDefinitionValidationException var16) { 
            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", var16);
        }
    }

其中有一行代码boolean earlySingletonExposure = mbd.isSingleton() && this.allowCircularReferences && this.isSingletonCurrentlyInCreation(beanName);中的allowCircularReferences判断是否支持循环依赖，默认是true，可以通过以下代码修改循环依赖失效

AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
        context.register(StudentConfig.class);
        AbstractAutowireCapableBeanFactory beanFactory = (AbstractAutowireCapableBeanFactory) context.getBeanFactory();
        beanFactory.setAllowCircularReferences(false);
        context.refresh();
        Student simpleBean = (Student) context.getBean("student");
        System.out.println(simpleBean.toString());

实例化类是通过instanceWrapper = this.createBeanInstance(beanName, mbd, args);

3.7.2getSingleton

protected Object getSingleton(String beanName, boolean allowEarlyReference) { 
        Object singletonObject = this.singletonObjects.get(beanName);
        if (singletonObject == null && this.isSingletonCurrentlyInCreation(beanName)) { 
            synchronized(this.singletonObjects) { 
                singletonObject = this.earlySingletonObjects.get(beanName);
                if (singletonObject == null && allowEarlyReference) { 
                    ObjectFactory<?> singletonFactory = (ObjectFactory)this.singletonFactories.get(beanName);
                    if (singletonFactory != null) { 
                        singletonObject = singletonFactory.getObject();
                        this.earlySingletonObjects.put(beanName, singletonObject);
                        this.singletonFactories.remove(beanName);
                    }
                }
            }
        }
        return singletonObject != NULL_OBJECT ? singletonObject : null;
    }
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) { 
        Assert.notNull(beanName, "'beanName' must not be null");
        synchronized(this.singletonObjects) { 
            Object singletonObject = this.singletonObjects.get(beanName);
            if (singletonObject == null) { 
                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 (this.logger.isDebugEnabled()) { 
                    this.logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
                }
                this.beforeSingletonCreation(beanName);
                boolean newSingleton = false;
                boolean recordSuppressedExceptions = this.suppressedExceptions == null;
                if (recordSuppressedExceptions) { 
                    this.suppressedExceptions = new LinkedHashSet();
                }
                try { 
                    singletonObject = singletonFactory.getObject();
                    newSingleton = true;
                } catch (IllegalStateException var16) { 
                    singletonObject = this.singletonObjects.get(beanName);
                    if (singletonObject == null) { 
                        throw var16;
                    }
                } catch (BeanCreationException var17) { 
                    BeanCreationException ex = var17;
                    if (recordSuppressedExceptions) { 
                        Iterator var8 = this.suppressedExceptions.iterator();
                        while(var8.hasNext()) { 
                            Exception suppressedException = (Exception)var8.next();
                            ex.addRelatedCause(suppressedException);
                        }
                    }
                    throw ex;
                } finally { 
                    if (recordSuppressedExceptions) { 
                        this.suppressedExceptions = null;
                    }
                    this.afterSingletonCreation(beanName);
                }
                if (newSingleton) { 
                    this.addSingleton(beanName, singletonObject);
                }
            }
            return singletonObject != NULL_OBJECT ? singletonObject : null;
        }
    }

beforeSingletonCreation方法是个空实现，里面没有任何逻辑，但其实不是， 这个函数中做了一个很重要的操作：记录加载状态，也就是通过this.singletonsCurrentlylnCreation.add(beanName)将当前正要创建的bean记录在缓存中，这样便可以对循环依赖进行检测。

Spring为了解决单例的循环依赖问题，使用了三级缓存。

这三级缓存分别指：
singletonFactories ： 单例对象工厂的cache
earlySingletonObjects ：提前暴光的单例对象的Cache
singletonObjects：单例对象的cache

以下来源：https://blog.csdn.net/u010853261/article/details/77940767

isSingletonCurrentlyInCreation()判断当前单例bean是否正在创建中，也就是没有初始化完成(比如A的构造器依赖了B对象所以得先去创建B对象， 或则在A的populateBean过程中依赖了B对象，得先去创建B对象，这时的A就是处于创建中的状态。)
allowEarlyReference 是否允许从singletonFactories中通过getObject拿到对象
分析getSingleton()的整个过程，Spring首先从一级缓存singletonObjects中获取。如果获取不到，并且对象正在创建中，就再从二级缓存earlySingletonObjects中获取。如果还是获取不到且允许singletonFactories通过getObject()获取，就从三级缓存singletonFactory.getObject()(三级缓存)获取，如果获取到了则：

this.earlySingletonObjects.put(beanName, singletonObject);
                        this.singletonFactories.remove(beanName);

A的某个field或者setter依赖了B的实例对象，同时B的某个field或者setter依赖了A的实例对象”这种循环依赖的情况。A首先完成了初始化的第一步，并且将自己提前曝光到singletonFactories中，此时进行初始化的第二步，发现自己依赖对象B，此时就尝试去get(B)，发现B还没有被create，所以走create流程，B在初始化第一步的时候发现自己依赖了对象A，于是尝试get(A)，尝试一级缓存singletonObjects(肯定没有，因为A还没初始化完全)，尝试二级缓存earlySingletonObjects（也没有），尝试三级缓存singletonFactories，由于A通过ObjectFactory将自己提前曝光了，所以B能够通过ObjectFactory.getObject拿到A对象(虽然A还没有初始化完全，但是总比没有好呀)，B拿到A对象后顺利完成了初始化阶段1、2、3，完全初始化之后将自己放入到一级缓存singletonObjects中。此时返回A中，A此时能拿到B的对象顺利完成自己的初始化阶段2、3，最终A也完成了初始化，进去了一级缓存singletonObjects中，而且更加幸运的是，由于B拿到了A的对象引用，所以B现在hold住的A对象完成了初始化。

知道了这个原理时候，肯定就知道为啥Spring不能解决“A的构造方法中依赖了B的实例对象，同时B的构造方法中依赖了A的实例对象”这类问题了！因为加入singletonFactories三级缓存的前提是执行了构造器，所以构造器的循环依赖没法解决。

3.8finishRefresh

protected void finishRefresh() { 
        this.initLifecycleProcessor();
        this.getLifecycleProcessor().onRefresh();
        this.publishEvent((ApplicationEvent)(new ContextRefreshedEvent(this)));
        LiveBeansView.registerApplicationContext(this);
    }

完成刷新，发布事件