Spring源码深入阅读AnnotationConfigApplicationContext

系统管理员 2022-12-08 14:06 127阅读 0赞

一直很好奇代码 `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);
        }

完成刷新，发布事件