前言
registerBeanPostProcessors 之后，Spring 要开始准备实例化 Bean。不过在这之前，Spring 初始化了非常多的内部组件。
// 国际化消息组件
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);这些组件目前不需要话费太大精力去研究，不过要注意一点是在实例化 Bean 前，Spring 留了个扩展方法onRefresh();给程序员扩展。
finishBeanFactoryInitialization
走到这里，要进入 Spring 的核心。
这个方法技术点过于庞大，Spring 对各个执行步骤都考虑的非常周全，因此这个方法内部看起来非常的复杂，往往看到一个点，需要往后面深入好几层，返回来才明白 Spring 开发者为什么这么做。
所以，对于此方法，需要拆分为好几步去分析。这次只需要知道如何实例化一个普通 bean。
配置一个类
以注解配置的方式配置一个 Bean
Myconfig.java
@Configurable
@ComponentScan("com.Playwi0.bean")
public class MyConfig {
}A.java
javapackage com.Playwi0.bean;
import org.springframework.stereotype.Component;
@Component
public class A {
public A(){
System.out.println("a");
}
}就这么个普通的 Bean，来看看 Spring 如何实例化。为了简洁明了，我会删去与本次主体无关代码
preInstantiateSingletons
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
// 删去代码
......
// Instantiate all remaining (non-lazy-init) singletons.
// 开始实例化 bean
beanFactory.preInstantiateSingletons();
}跟进此方法 preInstantiateSingletons
@Override
public void preInstantiateSingletons() throws BeansException {
// 删去代码
.....
// 先 copy 一份所有添加到 BeanFactory 的 beanDefinition 的名称
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
for (String beanName : beanNames) {
// 通过 getMergedLocalBeanDefinition 方法合并所有需要合并的 BeanDefinition
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
// 要在这一步初始化需要满足三个条件：不是抽象类，BeanDefinition 必须是单例，没有设置延迟加载
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
if (isFactoryBean(beanName)) {
// 删去代码
.....
}
else {
getBean(beanName);
}
}
}
// 删去代码
.....
}遍历所有的 beanDefinition 的名称，调用了getMergedLocalBeanDefinition(beanName);方法进行 BeanDefinition 之间的合并，这个方法后面文章会细讲，这里只需要知道当前 BeanDefinition 会与父类或接口的 BeanDefinition 某些属性进行整合，得到全新的 RootBeanDefinition。
要想实例化 Bean，还要满足三个要求：不是抽象类，BeanDefinition 必须是单例，没有设置延迟加载。也就是在 Spring 开始的时候，原型类型的 Bean，并不会实例化。
最后判断是不是 FactoryBean，前面配置的肯定不是一个 FactoryBean，因此会进入getBean(beanName);.
getBean
getBean 也是一个非常重要的方法，同样的，在这里我们只需截取需要的部分就可以，后面还会具体分析。
@Override
public Object getBean(String name) throws BeansException {
return doGetBean(name, null, null, false);
}这里面调用的是 doGetBean 方法
doGetBean
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
// 删除代码
....
// 从缓存找 Bean，如果已经实例化可以找到
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
// 删除代码
....
}
else {
// 删除代码
....
// 如果没有实例化 BeanDefinition 则递归循环调用父 BeanFactory，也就是最顶层的 BeanFactory 去实例化 BeanDefinition
BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
// Not found -> check parent.
String nameToLookup = originalBeanName(name);
if (parentBeanFactory instanceof AbstractBeanFactory) {
return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
nameToLookup, requiredType, args, typeCheckOnly);
}
else if (args != null) {
// Delegation to parent with explicit args.
return (T) parentBeanFactory.getBean(nameToLookup, args);
}
else if (requiredType != null) {
// No args -> delegate to standard getBean method.
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
else {
return (T) parentBeanFactory.getBean(nameToLookup);
}
}
// 删除代码
....
try {
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
// 不是抽象类
checkMergedBeanDefinition(mbd, beanName, args);
// 如果有 DependsOn，要先实例化 DependsOn 的 Bean
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
// 删除代码
....
}
// Create bean instance.
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, () -> {
try {
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
destroySingleton(beanName);
throw ex;
}
});
// 删除代码
....
}
else if (mbd.isPrototype()) {
// 删除代码
....
}
return (T) bean;
}Spring 在实例化之前，会检查一遍缓存，如果已经实例化，会从缓存里取出来。
Object sharedInstance = getSingleton(beanName);我们是第一次进来，正常情况下是没有实例化的，因此会到else逻辑。
这里的第一步是递归找出父 BeanFactory，有点类似于 Java 的双亲委派机制，采用最顶层的 BeanFactory 去生产 Bean，防止多次加载。正常情况是不会经过这里。
最终走进try 代码块，第一步和前面一样合并 BeanDefinition，再一次检查是不是抽象类，抽象类是不能实例化的。
protected void checkMergedBeanDefinition(RootBeanDefinition mbd, String beanName, @Nullable Object[] args)
throws BeanDefinitionStoreException {
if (mbd.isAbstract()) {
throw new BeanIsAbstractException(beanName);
}
}可能你会问，这里为什么只判断一个条件？注意这里是 getBean 方法进来，这个方法外面也是可以调用的，而前面三个条件，是 Spring 初始化内部的判断。
在这之后，如果该类有依赖的 Bean，要先实例化依赖的 Bean 调用的也是 getBean 方法。很明显前面配置的 Bean 是没有的。
再一次判断是否为单例，单例有单例的实例化方式，原型有原型的。前面并没有配置，默认为单例，进入到 getSingleton 方法，这个方法和上面的并不是同一个方法，同时里面传了个 Lamber 表达式，转换一下，更好阅读一点
public interface ObjectFactory<T> {
T getObject() throws BeansException;
}
ObjectFactory singletonFactory = new ObjectFactory{
public T getObject() throws BeansException{
return createBean(beanName, mbd, args);
}
}
sharedInstance = getSingleton(beanName, singletonFactory);getSingleton
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(beanName, "Bean name must not be null");
synchronized (this.singletonObjects) {
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
// 删除代码
....
// 把 Bean 加入到正在创建集合 this.singletonsCurrentlyInCreation.add(beanName)
beforeSingletonCreation(beanName);
boolean newSingleton = false;
boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
// 删除代码
....
try {
.
singletonObject = singletonFactory.getObject();
newSingleton = true;
}
catch (IllegalStateException ex) {
// 删除代码
....
}
catch (BeanCreationException ex) {
// 删除代码
....
}
finally {
// 删除代码
....
afterSingletonCreation(beanName);
}
if (newSingleton) {
addSingleton(beanName, singletonObject);
}
}
return singletonObject;
}
}这句代码先留着，后边一并解释。
Object singletonObject = this.singletonObjects.get(beanName);beforeSingletonCreation(beanName);这里会把 beanName 放入 singletonsCurrentlyInCreation 集合，表示这个 Bean 在实例化。
protected void beforeSingletonCreation(String beanName) {
// 在这正在实例化 Bean 会被加入到 singletonsCurrentlyInCreation 集合
if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
}在这行代码singletonObject = singletonFactory.getObject();执行完后，singletonObject 变量接收的就是实例化好的 Bean。
实例化好后，newSingleton = true;标记有一个新的 Bean 生成，在最后面使用到了这个变量。
if (newSingleton) {
addSingleton(beanName, singletonObject);
}
protected void addSingleton(String beanName, Object singletonObject) {
synchronized (this.singletonObjects) {
// 放到集合
this.singletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
this.earlySingletonObjects.remove(beanName);
this.registeredSingletons.add(beanName);
}
}也就是说每个实例化好的 Bean， 都会放到这个集合里面，作为 Spring 的缓存。“从 Spring 容器里取出一个 Bean”，狭义上说的容器就是这个 singletonObjects 集合。看到这里你应该明白，这并不能代表 Spring 容器，只是容器里的一个 Map，专门被用来保存实例化好的 Bean，可以被认作为缓存。因此你会看到，Spring 在前面多次从这个 Map 中取 Bean，其实就是检查这个 Bean 有没有被实例化；如果实例化了，就不需要在走这么复杂的步骤，提高效率。
/** Cache of singleton objects: bean name to bean instance. */
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);加入 Map 之前，还有一行代码afterSingletonCreation(beanName);，在finally代码块里。
protected void afterSingletonCreation(String beanName) {
if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.remove(beanName)) {
throw new IllegalStateException("Singleton '" + beanName + "' isn't currently in creation");
}
}这里最重要的一步就是把 beanName 移出了 singletonsCurrentlyInCreation 集合，因为这个 Bean 已经实例化完成。
createBean
singletonObject = singletonFactory.getObject();这里调用的是前面 Lamber 表达式中的 return createBean(beanName, mbd, args);这行代码。
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
// 删除代码
....
RootBeanDefinition mbdToUse = mbd;
// 删除代码
....
try {
// 开始创建 Bean
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isTraceEnabled()) {
logger.trace("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
}
catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
// 删除代码
....
}
catch (Throwable ex) {
// 删除代码
....
}
}跟进 doCreateBean 方法
doCreateBean
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {
// Instantiate the bean.
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
final Object bean = instanceWrapper.getWrappedInstance();
// 删除代码
....
Object exposedObject = bean;
// 删除代码
....
return exposedObject;
}如果是单例，则先把缓存中那一份移除。注意 factoryBeanInstanceCache 保存不是 Bean 实例，是包装了 Bean 实例的 BeanWrapper。其实也不算移除，算是取出来，如果存在，说明已经实例化过了，跳过实例化步骤。没有进入实例化instanceWrapper = createBeanInstance(beanName, mbd, args);
createBeanInstance
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
// 删除代码
....
// No special handling: simply use no-arg constructor.
return instantiateBean(beanName, mbd);
}前面是推断构造方法的过程，这里的推断构造方法不是想象那样，取出构造方法，后面文章会分析，直接到最后 instantiateBean(beanName, mbd);
instantiateBean
protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
try {
Object beanInstance;
final BeanFactory parent = this;
if (System.getSecurityManager() != null) {
beanInstance = AccessController.doPrivileged((PrivilegedAction<Object>) () ->
getInstantiationStrategy().instantiate(mbd, beanName, parent),
getAccessControlContext());
}
else {
beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
}
BeanWrapper bw = new BeanWrapperImpl(beanInstance);
initBeanWrapper(bw);
return bw;
}
catch (Throwable ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
}
}不管走进哪个判断，都是执行getInstantiationStrategy().instantiate(mbd, beanName, parent);
instantiate
@Override
public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
// Don't override the class with CGLIB if no overrides.
if (!bd.hasMethodOverrides()) {
Constructor<?> constructorToUse;
synchronized (bd.constructorArgumentLock) {
// 删除代码
....
try {
if (System.getSecurityManager() != null) {
constructorToUse = AccessController.doPrivileged(
(PrivilegedExceptionAction<Constructor<?>>) clazz::getDeclaredConstructor);
}
else {
constructorToUse = clazz.getDeclaredConstructor();
}
bd.resolvedConstructorOrFactoryMethod = constructorToUse;
}
catch (Throwable ex) {
throw new BeanInstantiationException(clazz, "No default constructor found", ex);
}
}
}
return BeanUtils.instantiateClass(constructorToUse);
}
else {
// 删除代码
....
}
}这一步是拿到默认构造方法，最明显的一行代码constructorToUse = clazz.getDeclaredConstructor();
instantiateClass
public static <T> T instantiateClass(Constructor<T> ctor, Object... args) throws BeanInstantiationException {
Assert.notNull(ctor, "Constructor must not be null");
try {
// 删除代码
....
return ctor.newInstance(argsWithDefaultValues);
}
}
catch (InstantiationException ex) {
// 删除代码
....
}
}最后反射执行ctor.newInstance(argsWithDefaultValues);实例化 Bean。