1. Spring IOC流程
首先IOC是用于管理Bean的一个容器，把所有的Bean创建好，使用的时候再调用
1） IOC要管理哪些Bean呢？全部？
非也：在原生的spring中，我们有一个xml文件，文件中有这么一段代码，如下
在这个配置文件中的Bean标签中配置的Bean才会被IOC容器管理
2）怎么读取XML文件？什么时候读取？
new ClassPathXmlApplication("applicationcontent.xml"); 加载配置文件
BeanDefinitionReader类去读取XML文件信息，保存起来
3）读取完成XML之后，Bean就创建好了么？
读取XML之后，Bean其实并没有创建，只是相当于定义好了这个Bean是怎么样的，但是并没有动作，相当于将XML读取成为了JAVA认识的东西，之后通过BeanFactory这个工厂类去逐一实例化
4）此时的定义信息可以更改么？
可以更改，例如我们在原始的注入数据库连接时，有配置过这么一个Bean，代码如下：
此时这段代码中存在一个变量 “${jdbc.username}”, 那在BeanFactory读取定义信息时，利用BeanFactoryPostProcessor这个类，就会将变量替换成实际的信息
5）Bean怎么创建？通过什么机制创建？
Bean的创建是使用BeanFactory创建的，在BeanFactory拿到Bean的定义信息之后，利用反射机制，一步步去将一个Bean实例化好
6）创建完成之后就结束了么？
此时还没有结束，在实例化完成一个Bean时，此时只是在堆中开辟了一块空间，实例化之后，还需要将Bean的属性填充进去
7）AOP是在什么时候处理的？
AOP的作用其实就是增强，在Bean的生命周期的中间插入一部分东西，而最合适的时候其实就是初始化的时候，在初始化之前，会执行BeanPostProcessor的Before方法，在初始化之后会执行BeanPostProcessor的After方法，这其实就是AOP
8）为什么要初始化？初始化和实例化有什么区别？
实例化是在堆中开辟一块空间，实例化之后，其实只是一个空对象，而初始化代表要将这个空对象中的属性赋值
9）什么时候被销毁？
IOC容器关闭的时候
2. Bean的完整生命周期梳理
实例化Bean → 填充属性 → BeanPostProcessor.before → 初始化Bean 调用init方法 → BeanPostProcessor.after → 完整对象 → 容器关闭时，销毁对象
3. 源码学习
开始：从AbstractApplicationContext的refresh()方法开始看起
1）prepareRefresh 准备工作
this.startupDate = System.currentTimeMillis(); // 设置启动时间
this.closed.set(false); // 设置容器关闭为false，即设置容器为开启状态
this.active.set(true); // 设置容器为活跃状态
if (this.logger.isDebugEnabled()) {
if (this.logger.isTraceEnabled()) {
this.logger.trace("Refreshing " + this);
} else {
this.logger.debug("Refreshing " + this.getDisplayName());
}
}
this.initPropertySources(); // 初始化属性资源
this.getEnvironment().validateRequiredProperties(); // 获取环境对象，验证属性值 （准备环境对象）
// 创建一些集合
if (this.earlyApplicationListeners == null) {
this.earlyApplicationListeners = new LinkedHashSet(this.applicationListeners);
} else {
this.applicationListeners.clear();
this.applicationListeners.addAll(this.earlyApplicationListeners);
}
this.earlyApplicationEvents = new LinkedHashSet();
从源码来看，此方法只是准备了一些对象，创建了一些集合，啥活儿都没干
2）创建工厂
ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory(); // 获得新鲜的Bean工厂
if (this.hasBeanFactory()) { // 判断是否存在工厂
this.destroyBeans(); // 销毁
this.closeBeanFactory(); // 关闭
}
try {
DefaultListableBeanFactory beanFactory = this.createBeanFactory(); 创建一个Bean工厂
beanFactory.setSerializationId(this.getId()); // 序列化
this.customizeBeanFactory(beanFactory); // ？设置属性
this.loadBeanDefinitions(beanFactory); // 加载XML，读取Bean定义信息到Definitions中
synchronized(this.beanFactoryMonitor) {
this.beanFactory = beanFactory; // 将创建好的Bean工厂赋值给自己的属性
}
} catch (IOException var5) {
throw new ApplicationContextException("I/O error parsing bean definition source for " + this.getDisplayName(), var5);
}
3）prepareBeanFactory 给BeanFactory的属性赋值
4）postProcessBeanFactory 扩展方法，没有具体实现
5）invokeBeanFactoryPostProcessors
调用所有的实现的BeanFactoryPostProcessors
6）registerBeanPostProcessors 注册AOP
7）initMessageSource 国际化
8）initApplicationEventMulticaster 多播器？
9）onRefresh 没有具体实现
10）registerListeners 注册监听器
11）finishBeanFactoryInitialization 实例化Bean
beanFactory.preInstantiateSingletons(); // 核心
List
Iterator var2 = beanNames.iterator(); // 迭代这个LIST
while(true) {
String beanName;
Object bean;
do {
while(true) {
RootBeanDefinition bd;
do { //是懒加载的Bean
do { // 不是单例的Bean
do { // 抽象的Bean
if (!var2.hasNext()) {
var2 = beanNames.iterator();
while(var2.hasNext()) {
beanName = (String)var2.next();
Object singletonInstance = this.getSingleton(beanName);
if (singletonInstance instanceof SmartInitializingSingleton) {
SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton)singletonInstance;
if (System.getSecurityManager() != null) {
AccessController.doPrivileged(() -> {
smartSingleton.afterSingletonsInstantiated();
return null;
}, this.getAccessControlContext());
} else {
smartSingleton.afterSingletonsInstantiated();
}
}
}
return;
}
beanName = (String)var2.next();
bd = this.getMergedLocalBeanDefinition(beanName); // 获取Bean的定义信息
} while(bd.isAbstract()); // 抽象的
} while(!bd.isSingleton()); // 不是单例的
} while(bd.isLazyInit()); // 是懒加载的
// 是不是FactoryBean，是不是工厂Bean
if (this.isFactoryBean(beanName)) {
bean = this.getBean("&" + beanName);
break;
}
// 很明显，我们的普通类不是懒加载的Bean，是单例的Bean，不是抽象的Bean，所以，上边的所有while都进不去，直接到这
// 获取Bean，点进去看getBean
this.getBean(beanName);
}
} while(!(bean instanceof FactoryBean));
FactoryBean factory = (FactoryBean)bean;
boolean isEagerInit;
if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
SmartFactoryBean var10000 = (SmartFactoryBean)factory;
((SmartFactoryBean)factory).getClass();
isEagerInit = (Boolean)AccessController.doPrivileged(var10000::isEagerInit, this.getAccessControlContext());
} else {
isEagerInit = factory instanceof SmartFactoryBean && ((SmartFactoryBean)factory).isEagerInit();
}
if (isEagerInit) {
this.getBean(beanName);
}
}
return this.doGetBean(name, (Class)null, (Object[])null, false);
注意，当我们看到源码中带有do前缀的方法时，就应该知道，这个方法才是实际干活的方法，然后我们进入到doGetBean这个方法中
String beanName = this.transformedBeanName(name); // 获取BeanName
Object sharedInstance = this.getSingleton(beanName); // 查询项目中是否存在该对象
String[] dependsOn = mbd.getDependsOn(); // 判断是否有依赖Bean， 如果有肯定会将这个被依赖的Bean先创建好
return this.createBean(beanName, mbd, args); // 创建Bean
上述只说明了一些关键代码的作用，走到createBean时，我们继续点进去看
beanInstance = this.doCreateBean(beanName, mbdToUse, args); // 找到do开头的方法，点进去继续看
进去之后，我们可以看到有如下代码：
instanceWrapper = this.createBeanInstance(beanName, mbd, args); // 创建Bean实例，说明要开始实例化了，继续点进去
看关键的几行代码，如下：
Class beanClass = this.resolveBeanClass(mbd, beanName, new Class[0]); // 获取Bean的Class类
Constructor[] ctors = this.determineConstructorsFromBeanPostProcessors(beanClass, beanName); // 获取构造器
// 如果构造器为空，则调用instantiateBean去实例化Bean
return ctors != null ? this.autowireConstructor(beanName, mbd, ctors, (Object[])null) : this.instantiateBean(beanName, mbd);
进入到instantiateBean方法中找到如下代码：
beanInstance = this.getInstantiationStrategy().instantiate(mbd, beanName, this); // 实例化 instantiate
点进去看一下，代码如下：
return BeanUtils.instantiateClass(constructorToUse, new Object[0]); // 实例化类，进入
会看到如下代码：
return ctor.newInstance(argsWithDefaultValues); // 构造器.newInstance 创建对象
到此，我们的Bean的创建就完成了，由于使用的是springboot工程，所有有些源码和spring工程不同