1. 整体流程

开始：

AbstractApplicationContext#refresh()
->	finishBeanFactoryInitialization(beanFactory);
->	// 实例化剩下的单例对象
   beanFactory.preInstantiateSingletons();
->  // 实例化剩下的单例对象
	beanFactory.preInstantiateSingletons();  
->

流转

DefaultListableBeanFactory#preInstantiateSingletons()
->for (String beanName : beanNames) {
	..
	//判断是否实现了FactoryBean接口
	if (isFactoryBean(beanName)) {
    ..
    // 根据&+beanName来获取具体的对象
    }else{
    // beanName对应的bean不是FactoryBean，只是普通的bean，通过beanName获取bean实例
	getBean(beanName);
	}
}

继续流转

继续流转：
AbstractBeanFactory 
	public Object getBean(String name) throws BeansException {
		return doGetBean(name, null, null, false);
	}
->
protected <T> T doGetBean(....){
.....
//先从缓存中拿
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
	...
 	//给bean赋值
	｝else{
	//.....
	//如果是单例 ,创建对象
	 sharedInstance = getSingleton(beanName, () -> {
	return AbstractBeanFactory.this.createBean(beanName, 	    mbd, args)
	});
							
	//.... 
}
return  bean ;
}

继续流转

-> 
DefaultSingletonBeanRegistry(是AbstractBeanFactory的父类)

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory){
....
// 从单例工厂中获取对象。即调用lambda 
// 即：createBean
singletonObject = singletonFactory.getObject();
....
}

继续

-> 
AbstractAutowireCapableBeanFactory
.....
// 实际创建bean的调用
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
			throws BeanCreationException {
...........
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
..........
}

最核心的地方

protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
			throws BeanCreationException {
......
instanceWrapper = createBeanInstance(beanName, mbd, args);
.....
// MergedBeanDefinitionPostProcessor后置处理器修改合并bean的定义
// 把@Resouce,@Autowired 等注解标识的属性、方法等扫描到集合中
//AutowiredAnnotationBeanPostProcessor和CommonAnnotationBeanPostProcessor等都会被调用。
// -> findAutowiringMetadata方法完成了@Autowired注解的处理, 将被该注解标注的属性、方法封装为一个个的InjectedElement, 然后放入到InjectionMetadata中的集合injectedElements中
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
....
// 为避免后期循环依赖，可以在bean初始化完成前将创建实例的ObjectFactory加入工厂
// **重点**放进去一个lambda 表达式
// 往三级缓存中放进去一个lambda表达式。该表达式返回的是半成品对象，或者代理对象
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
...
// 对bean的属性进行填充，将各个属性值注入，其中，可能存在依赖于其他bean的属性，则会递归初始化依赖的bean
populateBean(beanName, mbd, instanceWrapper);
// 执行初始化逻辑
exposedObject = initializeBean(beanName, exposedObject, mbd);
....
return exposedObject;
｝
2. 重点分析
2.1 属性注入

populateBean(beanName, mbd, instanceWrapper)

//如果mdb有PropertyValues就获取其PropertyValues
 		PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
		// 获取 mbd 的 自动装配模式
		int resolvedAutowireMode = mbd.getResolvedAutowireMode();
		// 如果 自动装配模式 为 按名称自动装配bean属性 或者 按类型自动装配bean属性
		//解决的问题，再xml配置中，不是所有的对象都需要在xml中显示的写出来
		if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
			MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
			// 根据autotowire的名称(如适用)添加属性值。xml中没写全，能用到
			if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
                //重点 **遍历属性（非简单类型），收集要注入值到newPvs中**
				autowireByName(beanName, mbd, bw, newPvs);
			}
			// Add property values based on autowire by type if applicable.
			// 根据自动装配的类型(如果适用)添加属性值
			if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
				//通过bw的PropertyDescriptor属性类型，查找出对应的Bean对象，将其添加到newPvs中
				autowireByType(beanName, mbd, bw, newPvs);
			}
			//让pvs重新引用newPvs,newPvs此时已经包含了pvs的属性值以及通过AUTOWIRE_BY_NAME，AUTOWIRE_BY_TYPE自动装配所得到的属性值
			pvs = newPvs;
		}
....

		//遍历工厂内的所有后置处理器
for (BeanPostProcessor bp : getBeanPostProcessors()) {
			...
// 让ibp对pvs增加对bw的Bean对象的propertyValue，或编辑pvs的proertyValue。使用注解的时候，通过这个方法完成注入.该方法，查找上面合并的注解信息，然后完成注入
PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
....
｝

//如果pvs不为null
if (pvs != null) {
//应用给定的属性值，解决任何在这个bean工厂运行时其他bean的引用。必须使用深拷贝，所以我们 不会永久地修改这个属性
applyPropertyValues(beanName, mbd, bw, pvs);
}

applyPropertyValues

protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {
....
//获取pvs的PropertyValue对象数组，并将其转换成列表
original = Arrays.asList(pvs.getPropertyValues());
BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);
for (PropertyValue pv : original) {
...
//交由valueResolver根据pv解析出originalValue所封装的对象
Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);
//默认转换后的值是刚解析出来的值
Object convertedValue = resolvedValue;
....
//按原样使用deepCopy构造一个新的MutablePropertyValues对象然后设置到bw中以对bw的属性值更新。完成注入
bw.setPropertyValues(new MutablePropertyValues(deepCopy));
}

}

3.其它

  1. 解析注解。
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);

spring根据配置初始化bean spring怎么初始化一个bean_spring

// 完成对象的注入（没有这个对象就去生成，生成完注入，继续往下走。递归操作）
AutowiredAnnotationBeanPostProcessor # inject（...）
...
//如果instanceCandidate是Class实例
if (instanceCandidate instanceof Class) {
//让instanceCandidate引用 descriptor对autowiredBeanName解析为该工厂的Bean实例
instanceCandidate = descriptor.resolveCandidate(autowiredBeanName, type, this);
}