finishBeanFactoryInitialization()

freezeConfiguration()

preInstantiateSingletons()

getBean()

---

        这一篇博文主要是记录refresh()方法中的finishBeanFactoryInitialization()方法。对于使用注解注入Bean的方式来说，这个方法是很重要的，它会初始化所有剩下的单实例Bean。

public AnnotationConfigApplicationContext(String... basePackages) {
	this();
	scan(basePackages);
	refresh();
}
public void refresh() throws BeansException, IllegalStateException {
	synchronized (this.startupShutdownMonitor) {
		// 刷新上下文
		// 在这里面主要做了三件事：初始化属性值、校验属性的合法性、创建容器保存早期应用事件
		prepareRefresh();

		// 在这个方法中主要是获取DefaultListableBeanFactory这个Bean工厂 后续都是在用
		ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

		// 准备Bean工厂以便在此上下文中使用
		// 设置Bean工厂的类加载器等、注册可以解析的自动装配、添加后置处理器、注册默认的Bean环境
		prepareBeanFactory(beanFactory);

		try {
			// 允许在上下文子类中对Bean工厂进行后处理
			// 根据传来的是哪个子类就到其重写方法中创建和准备环境
			postProcessBeanFactory(beanFactory);

			// 调用在上下文中注册为bean的工厂处理器（重要）
			// 注解开发对包进行扫描得到Bean的定义
			invokeBeanFactoryPostProcessors(beanFactory);

			// 注册拦截bean创建的bean处理器 如果没有BeanProcessors 此步骤什么也不做
			registerBeanPostProcessors(beanFactory);

			// 初始化此上下文的消息源
			// 将messageSource这个Bean对象放到beanFactory中的singletonObjects中
			initMessageSource();

			// 初始化此上下文的事件多播
			// 将applicationEventMulticaster这个Bean对象放到beanFactory中的singletonObjects中
			initApplicationEventMulticaster();

			// 初始化特定上下文子类中的其他特殊bean
			onRefresh();

			// 检查侦听器bean并注册它们
			// 在所有Bean中查找Listener这个Bean对象并注册到消息广播中 没有的话什么也不做
			registerListeners();

			// 实例化所有剩余的（非惰性初始化）单例
            // 这一片博文主要就是记录这个方法
			finishBeanFactoryInitialization(beanFactory);

			// 最后一步：发布相应的事件
			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. 销毁已创建的singleton以避免挂起资源
			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...
			// 重置Spring核心中的常见内省缓存，因为我们可能不再需要单例bean的元数据
			resetCommonCaches();
		}
	}
}

finishBeanFactoryInitialization()

        在看这个方法的源码前可以先看一下大概发生了什么事情。在registerListeners()方法与finishRefresh()方法都加个断点，看一下新增加了什么Bean。经过下面两张图可以发现，在BeanFactory中的sinletonObjects（bean一级缓存）中多了一个user对象。而这个bean就是在配置类中加的@Bean注解注册进来IoC容器的。所以说这一步就是来初始化那些剩余的没有处理的Bean。

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
	//  初始化此上下文的转换服务
	// 如果Bean工程包含conversionService并且符合这个类型 则获取这个转换服务
	if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
			beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
		beanFactory.setConversionService(
				beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
	}

	// 如果之前没有注册任何bean后处理器（如PropertyPlaceholderConfigurer bean），则注册默认的嵌入式值解析器：此时，主要用于注释属性值中的解析。
	if (!beanFactory.hasEmbeddedValueResolver()) {
		beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
	}

	// 尽早初始化LoadTimeWeaverWare bean，以便尽早注册其转换器，这是为了AspectJ的支持
	String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
	for (String weaverAwareName : weaverAwareNames) {
		getBean(weaverAwareName);
	}

	// 停止使用临时ClassLoader进行类型匹配。
	beanFactory.setTempClassLoader(null);

	// 缓存所有的BeanDefinition元信息，不希望未来发生变化
	beanFactory.freezeConfiguration();

	// 实例化所有剩余的（非惰性init）singleton。
	beanFactory.preInstantiateSingletons();
}

freezeConfiguration()

public void freezeConfiguration() {
	this.configurationFrozen = true;
	this.frozenBeanDefinitionNames = StringUtils.toStringArray(this.beanDefinitionNames);
}

preInstantiateSingletons()

        最主要看的就是finishBeanFactoryInitialization()方法的最后一行：也就是实例化剩余未处理的单例bean。这个方法进入到DefaultListableBeanFactory类中。这个类就是refresh()刷新方法的第二步获取到的Bean工厂。

public void preInstantiateSingletons() throws BeansException {
	if (logger.isTraceEnabled()) {
		logger.trace("Pre-instantiating singletons in " + this);
	}

	// 对副本进行迭代，以允许init方法注册新的bean定义
	// 虽然这可能不是常规工厂引导的一部分，但它在其他方面确实很好
	List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
	
	// 循环迭代所有的BeanDefinition
	for (String beanName : beanNames) {
		// 根据beanName 获取 BeanDefinition
		RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
		// 如果此BeanDefinition未非抽象、单例、非懒加载就进入这个If中
		if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
			// 判断这个beanName是否为FactoryBean（这里就多了个概念关于什么是FactoryBean）
			if (isFactoryBean(beanName)) {
				Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
				if (bean instanceof FactoryBean) {
					final FactoryBean<?> factory = (FactoryBean<?>) bean;
					boolean isEagerInit;
					if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
						isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
										((SmartFactoryBean<?>) factory)::isEagerInit,
								getAccessControlContext());
					} else {
						isEagerInit = (factory instanceof SmartFactoryBean &&
								((SmartFactoryBean<?>) factory).isEagerInit());
					}
					if (isEagerInit) {
						getBean(beanName);
					}
				}
			} else {
				// 当不为FactoryBean 就在在这初始化Bean对象，并为其进行赋值操作
				getBean(beanName);
			}
		}
	}

	// 触发所有适用bean的初始化后回调
	for (String beanName : beanNames) {
		Object singletonInstance = getSingleton(beanName);
		if (singletonInstance instanceof SmartInitializingSingleton) {
			final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
			if (System.getSecurityManager() != null) {
				AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
					smartSingleton.afterSingletonsInstantiated();
					return null;
				}, getAccessControlContext());
			} else {
				smartSingleton.afterSingletonsInstantiated();
			}
		}
	}
}

getBean()

        重要的就是非FactoryBean的情况下会将BeanName传入getBean()方法，然后就会进入AbstractBeanFactory类中。在doGetBean()方法中源码太多，就省略展示了，主要记录其主要的方法作用。

// 单例对象缓存：bean名称到bean实例
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
// 单例工厂缓存：bean名称到ObjectFactory
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
// 早期singleton对象的缓存：bean名称到bean实例
private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);
// 一组已注册的singleton，按注册顺序包含bean名称
private final Set<String> registeredSingletons = new LinkedHashSet<>(256);

public Object getBean(String name) throws BeansException {
	return doGetBean(name, null, null, false);
}

protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
			@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {

    // 对Bean的名字进行转换
	final String beanName = transformedBeanName(name);
    Object bean;
    // 急切地检查单例缓存中是否有手动注册的单例 对应下面代码块的前两个方法
    Object sharedInstance = getSingleton(beanName);
    if (sharedInstance != null && args == null) {
        //...省略代码
    } else {
        //...省略代码
        if (!typeCheckOnly) {
		    // 标记该Bean为已经创建状态
			markBeanAsCreated(beanName);
		}
        try {
            final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
            // 检查这个BeanDefinition是否为抽象的 如果为抽象的则报异常
            checkMergedBeanDefinition(mbd, beanName, args);
            // 判断此BeanDefinition是否为单例的
            if (mbd.isSingleton()) {
                sharedInstance = getSingleton(beanName, () -> {
                    try {
	                    // 创建单例Bean
	                    return createBean(beanName, mbd, args);
                    } catch (BeansException ex) {
	                    // 从单例缓存中显式删除实例：它可能是在创建过程中急切地放在那里的，以允许循环引用解析。同时删除任何接收到对bean的临时引用的bean
	                    destroySingleton(beanName);
	                    throw ex;
                    }
                    // 检查Bean实例 如果是Bean则返回本身 如果是FactoryBean则返回FactoryBean
                    bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
                });
            } 
        } catch(BeansException ex) {
            cleanupAfterBeanCreationFailure(beanName);
            throw ex;
        }
    }
}

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) {
			// ...省略
			// 创建之前检查是否创建过（从isCreationCheckExclusions与singletonsCurrentlyInCreation中检查）
			beforeSingletonCreation(beanName);
			boolean newSingleton = false;
			boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
			if (recordSuppressedExceptions) {
				this.suppressedExceptions = new LinkedHashSet<>();
			}
			try {
				// TODO 得到单例的Bean实例对象
				singletonObject = singletonFactory.getObject();
				newSingleton = true;
			} catch (IllegalStateException ex) {
				// ...省略
			} catch (BeanCreationException ex) {
				// ...省略
			} finally {
				if (recordSuppressedExceptions) {
					this.suppressedExceptions = null;
				}
				afterSingletonCreation(beanName);
			}
			// 如果是一个新的Bean对象 把Bean放到Map中 这个方法在下面
			if (newSingleton) {
				addSingleton(beanName, singletonObject);
			}
		}
		return 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);
	}
}

getSingleton()

        来到DefaultSingletonBeanRegistry类中执行。

@Nullable
public Object getSingleton(String beanName) {
	return getSingleton(beanName, true);
}

@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
	// 从singletonObjects 这个Map中获取Bean对象 如果存在则不需要创建
	Object singletonObject = this.singletonObjects.get(beanName);
	// 如果缓存中不存在目标对象 则判断在singletonsCurrentlyInCreation中是否有这个BeanName
	// 可以看到这个判断用了双重检查锁（先判断是否为null再加锁再判断是否为null）
	if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
		synchronized (this.singletonObjects) {
			singletonObject = this.earlySingletonObjects.get(beanName);
			if (singletonObject == null && allowEarlyReference) {
				ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
				if (singletonFactory != null) {
					singletonObject = singletonFactory.getObject();
					this.earlySingletonObjects.put(beanName, singletonObject);
					this.singletonFactories.remove(beanName);
				}
			}
		}
	}
	return singletonObject;
}

createBean()

        这个方法在AbstractAutowireCapableBeanFacory类中。

protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
		throws BeanCreationException {

	// 其它代码我都省略了
    // 创建Bean实例
    Object beanInstance = doCreateBean(beanName, mbdToUse, args);
}

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
	// 首先根据BeanDefinition以及BeanName解析出Bean的Class对象
	Class<?> beanClass = resolveBeanClass(mbd, beanName);

	if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
		throw new BeanCreationException(mbd.getResourceDescription(), beanName,
				"Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
	}

	// 如果存在Supplier回调 则调用obtainFromSupplier()进行初始化
	Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
	if (instanceSupplier != null) {
		return obtainFromSupplier(instanceSupplier, beanName);
	}

	// 如果工厂方法不为空 则使用工厂方法初始化策略
	if (mbd.getFactoryMethodName() != null) {
		return instantiateUsingFactoryMethod(beanName, mbd, args);
	}

	// 重新创建同一个bean时的快捷方式
	boolean resolved = false;
	boolean autowireNecessary = false;
	if (args == null) {
		synchronized (mbd.constructorArgumentLock) {
			if (mbd.resolvedConstructorOrFactoryMethod != null) {
				resolved = true;
				autowireNecessary = mbd.constructorArgumentsResolved;
			}
		}
	}
	if (resolved) {
		if (autowireNecessary) {
			return autowireConstructor(beanName, mbd, null, null);
		} else {
			return instantiateBean(beanName, mbd);
		}
	}

	// 自动装配的条件构造
	Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
	if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
			mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
		return autowireConstructor(beanName, mbd, ctors, args);
	}

	// 默认构造的首选构造函数
	ctors = mbd.getPreferredConstructors();
	if (ctors != null) {
		return autowireConstructor(beanName, mbd, ctors, null);
	}

	// 无需特殊处理：只需使用无参数构造函数。
	return instantiateBean(beanName, mbd);
}