一直很好奇代碼 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_INFRASTRUCTUREif (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的listList<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*/@Overridepublic Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {if (beanName.equals("student")){System.out.println("MyBeanPostProcessor的前置處理器執行");}return bean;}@Overridepublic Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {if (beanName.equals("student")){System.out.println("MyBeanPostProcessor的后置處理器執行");}return bean;}@Overridepublic 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<>();//是否框架內部使用的PostProcessorList<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.//最后注冊內部類型的BeanPostProcessorssortPostProcessors(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);}

完成刷新，發布事件

總結

以上是生活随笔為你收集整理的Spring源码深入阅读AnnotationConfigApplicationContext的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。