之前一直想要找到一个学习spring源码的主线。看了《spring源码深度解析》这本书，效果不是很好，没有得到我想得到的。最终还是借助《spring技术内幕》这本书，抽丝剥茧，打开了思路。
我换一种方式来学习spring源码，走一个不一样的spring源码学习方式——从“农村包围城市”。
先理解里边的关键点，然后逐一击破，走一个星星之火可以燎原的学习道路。
不一样的spring源码学习方式——从“农村包围城市”。我把IOC作为学习spring源码的切入点。
采用归一的方法，不妨问题化繁为简，先不要想那么多，然后自顶而下的去梳理脉络，真的有轻松很多。
spring源码这一块，近期我会持续更新的~！这篇文章先梳理出来一个spring的脉络，后续在逐一展开分享。
第一个概念，就是IOC容器—— BeanFactory
首先说一下我对spring容器的理解，本身spring的设计之初，也是为了来管理复杂的类和对象关系，所以spring 的一个核心就是 IOC 容器。那么容器本身就是用来包裹 POJO对象的集装箱。
BeanFactory 是一个接口，它声明了一个容器应该具备的最起码的功能。
其中包括了获取 容器的方法 getBean() 这是最最最重要的方法，通过它可以拿到我们想要的容器。还包括了判断容器是否存在的方法 constainsBean（）， 是否是单例的方法，是否是多例的方法，以及获取类的类型，获取到别名的方法。
第二个概念，FactoryBean ，看起来和 BeanFactory很像的东西
FactoryBean也是一个接口，只有三个方法，一个是获取对象，第二个是获取对象的类型，第三个是判断对象是否是单例的。
至于两者的对应关系如下图所示，BeanFactory 是容器工厂， 而FactoryBean 是对象工厂。前者是用来管理容器的，后者是用来获取对象的。
BeanFactory 的一个非常重要的实现类 DefaultListableBeanFactory
可以说 DefaultListableBeanFactory 已经是一个默认完整的容器了，该有的功能基本上都有了（入股以人的进化史来比喻，此时容器经从猴子进化成人了，具备的容器的最初比较完整的形态）。根据这个图，其实已经可以作为阅读spring源码的切入点了。想要看懂spring源码就必须懂 IOC容器，想要懂IOC容器，不妨以这个图上的每个接口，和每个实现类，都做了什么来展开。我相信如果有耐心看完全部，IOC容器是什么，都包括什么功能，应该也能学到百分只八十了！（这里就不普及如何查看具体的某个接口和类的源码了）
这里分享一下学习方法，阅读spring源码，要化繁为简，自顶向下的去学习，这就是打开spring的切入点。为什么要自顶向下去阅读，spring是践行面向接口编程最好的一个框架技术了。顶层的接口，只定义了最简单的一些内容，读起来不是很吃力。
先把最基础的给拿下，然后再向下走，通过不断的增加接口（每个接口都是有单一的职责的），越是向下的类，继承的类和实现的接口越多（通过扩展接口的方式来增加功能）。在一个庞大的可扩展的框架里边，这是非常重要的。
第三个概念，ApplicationContext
ApplicationContext 是进化后的容器的又一个新的时代的容器，就好猴子进化成人，人又学会了打造工具，最北最初的文明形态。同样下边的图中的接口，也是我们展开spring容器相关学习重要的点。
实现 ApplicationEventPublisher 接口，引入了事件的机制。
实现 ResourcePatternResolver 接口， 用来加载资源相关内容。
实现 HierarchicalBeanFactory 接口，提供父容器的访问功能.
DefaultListableBeanFactory 和 ApplicationContext 的区别就是，前者是一个纯粹的容器，而后者带有资源加载等模块。
再来看下applicationContext 都有什么
第四个概念，AbstractApplicationContext
IOC容器的又一大进步，一个能拿的出手的IOC容器雏形。
看到文章这里的朋友可能会发现，如果按照我上边的流程走下来，用到的其实就几个接口了。这就是自顶向下学习建立知识体系的好处，思路清晰。
AbstractApplicationContext 在这里主要是继承了 DefaultResourceLoader，使之具备了 ResourceLoader读入以Resource定义的BeanDefinition的能力。
AbstractApplicationContext 实现了ConfigurableApplicationContext接口。在这个接口中中定义了一些基本操作，比如设置上下文ID，设置父应用上下文，添加监听器和刷新容器相关的操作等。
先看一个成熟的ApplicationContext 的案例
ApplicationContext 是一个高级的容器，应为它带有资源的读取，对于不同类型的资源，有不同的实现。例如ClassPathXmlApplicationContext，从class path下读取配置文件的方式。 XmlWebApplicationContext 从web容器中加载资源。而这的FileSystemXmlApplicationContext 则是通过文件系统载入资源。
2021.3.23 1:00
又到凌晨一点了，该睡了，整理一下明天晚上要写的内容
容器的初始化过程
在上边的环节中，大概能够明白IOC容器是什么，都有哪些功能。
接下来一起看看容器是怎样一个初始化过程。
容器的初始化，其实就忙活了一件事，就是把Bean装到容器里边。但是这件事又是分为三个步骤来完成的：一是资源定位（ResourceLoader）；二是BeanDefinitiond载入的过程，就是把第一步加载到资源，转义成IOC容器内部的数据结构；三是通过BeanDefinitionRegister将BeanDefinition注册到IOC容器里边。在IOC容器里边，通过一个HashMap来存放BeanDefinition。
BeanDefinition 究竟是什么BeanDefinition 是对POJO对象的一个描述。
refresh（） 方法是容器启动的入口
该方法是在 ConfigurableApplicationContext 这个接口中被声明的，下图右下角可以看到。
该方法是在 AbstractApplicationContext 抽象类中被实现的，它作为一个模板方法，用到了模板方法模式，定义了初始化一个容器的算法骨架。
@Override
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// Prepare this context for refreshing.
prepareRefresh();
// Tell the subclass to refresh the internal bean factory.
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// Prepare the bean factory for use in this context.
prepareBeanFactory(beanFactory);
try {
// Allows post-processing of the bean factory in context subclasses.
postProcessBeanFactory(beanFactory);
// Invoke factory processors registered as beans in the context.
invokeBeanFactoryPostProcessors(beanFactory);
// Register bean processors that intercept bean creation.
registerBeanPostProcessors(beanFactory);
// Initialize message source for this context.
initMessageSource();
// Initialize event multicaster for this context.
initApplicationEventMulticaster();
// Initialize other special beans in specific context subclasses.
onRefresh();
// Check for listener beans and register them.
registerListeners();
// Instantiate all remaining (non-lazy-init) singletons.
finishBeanFactoryInitialization(beanFactory);
// Last step: publish corresponding event.
finishRefresh();
}
catch (BeansException ex) {
if (logger.isWarnEnabled()) {
logger.warn("Exception encountered during context initialization - " +
"cancelling refresh attempt: " + ex);
}
// Destroy already created singletons to avoid dangling resources.
destroyBeans();
// Reset 'active' flag.
cancelRefresh(ex);
// Propagate exception to caller.
throw ex;
}
finally {
// Reset common introspection caches in Spring's core, since we
// might not ever need metadata for singleton beans anymore...
resetCommonCaches();
}
} 答案是 AbstractRefreshableApplicationContext 类的 refreshBeanFactory() 方法， 从下边的图上可以看到，AbstractRefreshableApplicationContext 是继承了 AbstractApplicationContext
注意一种自顶向下的思路。一定要顺着脉络去学。
refreshBeanFactory() 这个方法正是负责创建 BeanFactory的。
@Override
protected final void refreshBeanFactory() throws BeansException {
if (hasBeanFactory()) {
destroyBeans();
closeBeanFactory();
}
try {
DefaultListableBeanFactory beanFactory = createBeanFactory();
beanFactory.setSerializationId(getId());
customizeBeanFactory(beanFactory);
loadBeanDefinitions(beanFactory);
synchronized (this.beanFactoryMonitor) {
this.beanFactory = beanFactory;
}
}
catch (IOException ex) {
throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
}
}这段代码的主要逻辑就是，先看看有没有容器，如果有就销毁。如果没有就创建一个 DefaultListableBeanFactory 实例容器。
到这里我们能够创建了 BeanFactory容器。同事有引入了另外应该问题，这个也是比较关键的，正是在这里使用了模板方法，引入了加载BeanDefinitions 的方法 loadBeanDefinitions(beanFactory); 继续点这个方法，我们在AbstractRefreshableApplicationContext 类里看到的是一个抽象方法，
protected abstract void loadBeanDefinitions(DefaultListableBeanFactory beanFactory)
throws BeansException, IOException;一直提到，spring是把单一职责运用到极致的一个优秀的框架。 此类的目的从名字上就能看出来，这是用来刷新 BeanFactory的，说是创建了BeanFactory 有些牵强，毕竟是如果有容器就先销毁。 创建好了BeanFactory以后，接下来就要load BeanDefinitions，根据单一职责，这个工作不应该在此类完成，所以定义成了抽象类，交给了子类去实现。 这里也是模板方法模式。这里这样做还有一个好处是方便扩展，因为你加载 BeanDefinition,还有一个好处，就是你可能有不用的方式来加载，这也预留了扩展和定制的空间。
BeanDefinition 是在哪里被加载的，源码在哪里
其实想都不用想，我们想要看 BeanDefinition 也只能到 AbstractRefreshableApplicationContext的子类去看了。
而AbstractRefreshableApplicationContext的子类只有这么几个，如下图：从名字不难看到，其中包含了 注解的方式，包括的文件系统的方式，包括了xml的方式。
而其中 真的实现了 loadBeanDefinitions 方法的只有画红线的子类。
感兴趣的朋友可以点进去，看看每个的内容。我不准备在这篇文章中展开太多。
这里只看一个 AbstractXmlApplicationContext 这个子类里边的 loadBeanDefinitions 方法
如下代码，又引入了 资源加载者 reader。我们要清楚的知道，资源加载的工作是交给 Reader来完成的，并且这写资源有不同的形式：xml，注解，文件系统。不同形式的资源，只不过是对同一件事的不同描述方式。
@Override
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
// 创建一个读xml类型的 DefinitionReader， 其实其他几个子类，这里是不一样的，通过xml和注解有不用的reader来处理。
XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
// Configure the bean definition reader with this context's
// resource loading environment.
beanDefinitionReader.setEnvironment(this.getEnvironment());
beanDefinitionReader.setResourceLoader(this);
beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
// Allow a subclass to provide custom initialization of the reader,
// 初始化 DefinitionReader
initBeanDefinitionReader(beanDefinitionReader);
// 将 beanDefinition 通过初始化好的 beanDefinitionReader 加载进来
loadBeanDefinitions(beanDefinitionReader);
}
这里目前不准备展开太多关于 资源加载者 reader。后续可能要单独的出文章来分析。资源加载者 reader，主要做的工作，就是把我们写的配置文件也好，注解也好，这些对类的描述信息，给转化到 beanDefinition中。
不过作为主线里边的内容，还是要列一下的，关于资源加载者 reader，具体的实现，如何把类的描述信息转化到 beanDefinition中的 ， 应该看AbstractBeanDefinitionReader 这个抽象类 子类。
到这里结束，我们只知道资源被转换成了 beanDefinition，后续是要把这些入住到容器里边！
~ 这里留一个作业吧： 以后展开 ResourceLoader beanDefinitionReader
BeanDefinition 加载到了哪里，如何存储的
顺着上边的思路看到这里的话，应该比较清晰，BeanDefinition 是BeanFactory的内容，自然存在了BeanFactory里边， 这在 DefaultListableBeanFactory 类中有了定义，定义如下：
private final Map beanDefinitionMap = new ConcurrentHashMap(256);BeanDefinition 注册到 BeanFactory
DefaultListableBeanFactory 实现了 BeanDefinitionRegistry接口， 然后在DefaultListableBeanFactory 类中进行了实现，代码比较简单，就是把 beanDefinition 放到 map里边。不过逻辑里边有一些判断，是否是重名的beanDefinition，如果是的话，需要判断该BeanDefinition是否允许被覆盖，如果允许则覆盖，如果不允许则报错。
容器的依赖注入问题
依赖注入的入口是 AbstractBeanFactory 的 getBean() 方法
@Override
public Object getBean(String name) throws BeansException {
return doGetBean(name, null, null, false);
}
@Override
public T getBean(String name, Class requiredType) throws BeansException {
return doGetBean(name, requiredType, null, false);
}
@Override
public Object getBean(String name, Object... args) throws BeansException {
return doGetBean(name, null, args, false);
} 调用了 doGetBean 方法
protected T doGetBean(
final String name, final Class requiredType, final Object[] args, boolean typeCheckOnly)
throws BeansException {
final String beanName = transformedBeanName(name);
Object bean;
// 如果该 Bean是单例的，则先从单例池中取
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
if (logger.isDebugEnabled()) {
if (isSingletonCurrentlyInCreation(beanName)) {
logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
"' that is not fully initialized yet - a consequence of a circular reference");
}
else {
logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
}
}
// 获取 Bean 实例，也就是bean对象
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
else {
// Fail if we're already creating this bean instance:
// We're assumably within a circular reference.
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
// 检查 bean definition 是否在 BeanFactory 中存在. 这里就比较重要了，如果当前BeanFactory不存在BeanDefinition，则继续从 parent BeanFactory中取尝试获取。直到获取到了BeanDefinition 如果最终一直没获取到，则报错，
BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
// Not found -> check parent.
String nameToLookup = originalBeanName(name);
if (args != null) {
// Delegation to parent with explicit args.
return (T) parentBeanFactory.getBean(nameToLookup, args);
}
else {
// No args -> delegate to standard getBean method.
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
}
if (!typeCheckOnly) {
markBeanAsCreated(beanName);
}
try {
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
checkMergedBeanDefinition(mbd, beanName, args);
// 当前bean 依赖的 bean 都进行一个初始化.
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
for (String dep : dependsOn) {
if (isDependent(beanName, dep)) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
}
registerDependentBean(dep, beanName);
getBean(dep);
}
}
// 如果是单例的，则执行下边的逻辑，创建单例的实例
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, new ObjectFactory() {
@Override
public Object getObject() throws BeansException {
try {
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
// Explicitly remove instance from singleton cache: It might have been put there
// eagerly by the creation process, to allow for circular reference resolution.
// Also remove any beans that received a temporary reference to the bean.
destroySingleton(beanName);
throw ex;
}
}
});
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
// 如果是多例的，则执行下边的逻辑，创建多例的实例
else if (mbd.isPrototype()) {
// It's a prototype -> create a new instance.
Object prototypeInstance = null;
try {
beforePrototypeCreation(beanName);
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
else {
String scopeName = mbd.getScope();
final Scope scope = this.scopes.get(scopeName);
if (scope == null) {
throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
}
try {
Object scopedInstance = scope.get(beanName, new ObjectFactory() {
@Override
public Object getObject() throws BeansException {
beforePrototypeCreation(beanName);
try {
return createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
}
});
bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
}
catch (IllegalStateException ex) {
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",
ex);
}
}
}
catch (BeansException ex) {
cleanupAfterBeanCreationFailure(beanName);
throw ex;
}
}
// Check if required type matches the type of the actual bean instance.
if (requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) {
try {
return getTypeConverter().convertIfNecessary(bean, requiredType);
}
catch (TypeMismatchException ex) {
if (logger.isDebugEnabled()) {
logger.debug("Failed to convert bean '" + name + "' to required type '" +
ClassUtils.getQualifiedName(requiredType) + "'", ex);
}
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
}
return (T) bean;
}
关注 createBean 方法，这个方法是在子类AbstractAutowireCapableBeanFactory中实现的
@Override
@SuppressWarnings("unchecked")
public T createBean(Class beanClass) throws BeansException {
// Use prototype bean definition, to avoid registering bean as dependent bean.
RootBeanDefinition bd = new RootBeanDefinition(beanClass);
bd.setScope(SCOPE_PROTOTYPE);
bd.allowCaching = ClassUtils.isCacheSafe(beanClass, getBeanClassLoader());
return (T) createBean(beanClass.getName(), bd, null);
}createBean
/**
* Central method of this class: creates a bean instance,
* populates the bean instance, applies post-processors, etc.
* @see #doCreateBean
*/
@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
if (logger.isDebugEnabled()) {
logger.debug("Creating instance of bean '" + beanName + "'");
}
RootBeanDefinition mbdToUse = mbd;
// Make sure bean class is actually resolved at this point, and
// clone the bean definition in case of a dynamically resolved Class
// which cannot be stored in the shared merged bean definition.
Class resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
// Prepare method overrides.
try {
mbdToUse.prepareMethodOverrides();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
beanName, "Validation of method overrides failed", ex);
}
try {
// 让 BeanPostProcessors 执行，返回一个代理对象
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
return bean;
}
}
catch (Throwable ex) {
throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
"BeanPostProcessor before instantiation of bean failed", ex);
}
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isDebugEnabled()) {
logger.debug("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
}doCreateBean（），最终的创建 bean的代码
/**
* Actually create the specified bean. Pre-creation processing has already happened
* at this point, e.g. checking {@code postProcessBeforeInstantiation} callbacks.
* Differentiates between default bean instantiation, use of a
* factory method, and autowiring a constructor.
* @param beanName the name of the bean
* @param mbd the merged bean definition for the bean
* @param args explicit arguments to use for constructor or factory method invocation
* @return a new instance of the bean
* @throws BeanCreationException if the bean could not be created
* @see #instantiateBean
* @see #instantiateUsingFactoryMethod
* @see #autowireConstructor
*/
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
throws BeanCreationException {
// bean对象.
BeanWrapper instanceWrapper = null;
// 如果是单例的，则尝试从单例池中去去单例对象
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
// 单例池中没有拿到对象，则去创建对象
if (instanceWrapper == null) {
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
Class beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
mbd.resolvedTargetType = beanType;
// Allow post-processors to modify the merged bean definition.
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Post-processing of merged bean definition failed", ex);
}
mbd.postProcessed = true;
}
}
// Eagerly cache singletons to be able to resolve circular references
// even when triggered by lifecycle interfaces like BeanFactoryAware.
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
if (logger.isDebugEnabled()) {
logger.debug("Eagerly caching bean '" + beanName +
"' to allow for resolving potential circular references");
}
addSingletonFactory(beanName, new ObjectFactory() {
@Override
public Object getObject() throws BeansException {
return getEarlyBeanReference(beanName, mbd, bean);
}
});
}
// 依赖注入就是在这里完成的.
Object exposedObject = bean;
try {
populateBean(beanName, mbd, instanceWrapper);
if (exposedObject != null) {
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
}
catch (Throwable ex) {
if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
throw (BeanCreationException) ex;
}
else {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
}
}
if (earlySingletonExposure) {
Object earlySingletonReference = getSingleton(beanName, false);
if (earlySingletonReference != null) {
if (exposedObject == bean) {
exposedObject = earlySingletonReference;
}
else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
String[] dependentBeans = getDependentBeans(beanName);
Set actualDependentBeans = new LinkedHashSet(dependentBeans.length);
for (String dependentBean : dependentBeans) {
if (!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.");
}
}
}
}
// Register bean as disposable.
try {
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
return exposedObject;
}
这里边有两个关键的方法，createBeanInstance（）,和 populateBean(beanName, mbd, instanceWrapper)方法。
看我的这篇文章 https://blog.csdn.net/star1210644725/article/details/115339866
