代码:
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
//判断BeanFactory中是否存在名称为“conversionService”且类型为ConversionService的Bean,如果存在则将其注入到beanFactory
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)注册,
则注册一个默认的嵌入式值解析器:此时,主要用于解析注释属性值。*/
// 如果beanFactory之前没有注册嵌入值解析器,则注册默认的嵌入值解析器:主要用于注解属性值的解析。
if (!beanFactory.hasEmbeddedValueResolver()) {
beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
}
// 尽早初始化LoadTimeWeaverAware bean,以允许尽早注册它们的转换器transformers。
String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
for (String weaverAwareName : weaverAwareNames) {
getBean(weaverAwareName);
}
// 停止使用临时ClassLoader进行类型匹配。
beanFactory.setTempClassLoader(null);//为了类型匹配,停止使用临时的类加载器
//缓存容器中所有注册的BeanDefinition元数据,以防被修改。
beanFactory.freezeConfiguration();
//重点:实例化所有剩余的(非lazy-init)单例bean。
beanFactory.preInstantiateSingletons(); //对配置了lazy-init属性的单态模式Bean进行预实例化处理
}
接下来的代码大家可以参照第2章的流程图来阅读。我把图拿过来了。
public void preInstantiateSingletons() throws BeansException {
if (logger.isTraceEnabled()) {
logger.trace("Pre-instantiating singletons in " + this);
}
//遍历一个副本以允许init方法注册新的bean定义。虽然这可能不是常规的工厂引导的一部分,但它可以正常工作。
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);//创建一个beanNames的备份
//遍历所有beanDefinitionNames,开始实例化bean
for (String beanName : beanNames) {
//验证是否需要实例化
//获取当前beanName对应的bean定义信息
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {//bean不是抽象的,不是懒加载,是单例
if (isFactoryBean(beanName)) { //判断是否是FactoryBean接口的的实现类
//获取实现类接口对应的bean。若是,通过getBean(&beanName)拿到的是FactoryBean本身;通过getBean(beanName)拿到的是FactoryBean创建的Bean实例
//这里拿到的是FactoryBean本身
Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
if (bean instanceof FactoryBean) {
FactoryBean<?> factory = (FactoryBean<?>) bean;
//判断这个FactoryBean是否希望急切的初始化
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) {
//TODO 初始化bean(FactoryBean.getObject返回的对象)
getBean(beanName);
}
}
}
else { //不是FactoryBean接口的的实现类
//TODO 获取bean(初始化)
getBean(beanName);
}
}
}
//触发所有SmartInitializingSingleton的后初始化回调
for (String beanName : beanNames) {
Object singletonInstance = getSingleton(beanName);
if (singletonInstance instanceof SmartInitializingSingleton) {
SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
//获取系统安全性接口
if (System.getSecurityManager() != null) {
//如果有,根据所拥有的权限和指定来执行回调方法
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
smartSingleton.afterSingletonsInstantiated();
return null;
}, getAccessControlContext());
}
else {
//没有就直接执行回调方法
smartSingleton.afterSingletonsInstantiated();
}
}
}
}
public Object getBean(String name) throws BeansException {
return doGetBean(name, null, null, false);
}
protected <T> T doGetBean(
String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
throws BeansException {
//去除factoryBean名字前的&符号,解析别名
String beanName = transformedBeanName(name);
Object bean;
//直接尝试分别从三级缓存获取或者singletonFactory.getObject()中获取,解决循环依赖
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {//如果缓存中有且参数为空
if (logger.isTraceEnabled()) {
if (isSingletonCurrentlyInCreation(beanName)) {
logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
"' that is not fully initialized yet - a consequence of a circular reference");
}
else {
logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
}
}
//获取给定bean实例的对象,如果是FactoryBean,则为bean实例本身或其创建的对象。
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
else { //缓存中没有 或者 缓存中有但参数不为空
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
// 获取父工厂,如果当前工厂找不到,就去父工厂查找,一直链式查找,直到找到
BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
String nameToLookup = originalBeanName(name);//将bean名称解析规范
if (parentBeanFactory instanceof AbstractBeanFactory) {
return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
nameToLookup, requiredType, args, typeCheckOnly);
}
else if (args != null) {
return (T) parentBeanFactory.getBean(nameToLookup, args);
}
else if (requiredType != null) {。
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
else {
return (T) parentBeanFactory.getBean(nameToLookup);
}
}
// TODO 如果不需要类型检查,那么标记bean已经创建过了
if (!typeCheckOnly) {
//标记bean为已创建,加入alreadyCreated集合
markBeanAsCreated(beanName);
}
try {
//获取Bean定义信息
RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
//检查,若是抽象类则抛出异常
checkMergedBeanDefinition(mbd, beanName, args);
// 保证初始化当前bean所依赖的bean。
String[] dependsOn = mbd.getDependsOn();//获取当前bean的依赖项
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);
try {
//递归getBean,确保依赖项全部初始化
getBean(dep);
}
catch (NoSuchBeanDefinitionException ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
}
}
}
// Create bean instance. 创建bean实例。
if (mbd.isSingleton()) { //如果是还单例bean(没有被修改成其他类型)
//创建单例bean
sharedInstance = getSingleton(beanName, () -> { //表达式会在getSingleton方法调用singletonFactory参数时执行
//重写factoryBean中的getObject方法
try {
//TODO 创建bean,填充属性,处理循环依赖
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
/* 显式地从单例缓存中删除实例:它可能是在创建过程中急切地放在那里的,以允许循环引用解析。
还要删除接收到对bean的临时引用的任何bean。 */
destroySingleton(beanName);
throw ex;
}
});
//若获取的bean为factoryBean,则获取该工厂创建的单例对象;
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
else if (mbd.isPrototype()) { //创建多实例的bean
Object prototypeInstance = null;
try {
beforePrototypeCreation(beanName);
//创建bean
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
else { //其他的作用域的bean
String scopeName = mbd.getScope();
if (!StringUtils.hasLength(scopeName)) {
throw new IllegalStateException("No scope name defined for bean ´" + beanName + "'");
}
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, () -> {
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;
}
}
// 检查所需的类型是否与实际bean实例的类型匹配。
if (requiredType != null && !requiredType.isInstance(bean)) {
try {
T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
if (convertedBean == null) {
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
return convertedBean;
}
catch (TypeMismatchException ex) {
if (logger.isTraceEnabled()) {
logger.trace("Failed to convert bean '" + name + "' to required type '" +
ClassUtils.getQualifiedName(requiredType) + "'", ex);
}
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
}
//返回创建的bean
return (T) bean;
}
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
if (logger.isTraceEnabled()) {
logger.trace("Creating instance of bean '" + beanName + "'");
}
//bean定义的备份
RootBeanDefinition mbdToUse = mbd;
/* 确保bean类在此时被实际解析,如果动态解析的class不能存储在共享合并bean定义中,则克隆bean定义。*/
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);//TODO 获取beanDefinition对的class
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
//验证及准备覆盖的方法(对override属性进行标记及验证)
try {
mbdToUse.prepareMethodOverrides();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
beanName, "Validation of method overrides failed", ex);
}
try {
//给BeanPostProcessors一个返回代理而不是目标bean实例的机会。
//执行InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation的实现方法
//执行BeanPostProcessor.postProcessAfterInitialization的实现方法
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);
}
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) {
throw ex;
}
catch (Throwable ex) {
throw new BeanCreationException(
mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
}
}
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
//实例化bean
BeanWrapper instanceWrapper = null;
//实例化bean的包装类
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
//TODO 创建beanName对应的对象,放入包装类,此时还不算是spring bean,还未初始化,是个半成品
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
//获取beanName对应的对象
Object bean = instanceWrapper.getWrappedInstance();
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
//允许后处理器修改合并的bean定义。
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try { //合并BeanDefinition
//BeanPostProcessors,执行MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition实现类方法
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Post-processing of merged bean definition failed", ex);
}
mbd.postProcessed = true;
}
}
//即使是由像BeanFactoryAware这样的生命周期接口触发的时候,也可以热切地缓存单例对象来解析循环引用。
//判断当前是否单例&&允许循环引用&&当前bean正在创建
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) { //开始解决循环依赖
if (logger.isTraceEnabled()) {
logger.trace("Eagerly caching bean '" + beanName +
"' to allow for resolving potential circular references");
}
//将当前bean的工厂存入三级缓存singletonFactories
addSingletonFactory(beanName,
//执行SmartInstantiationAwareBeanPostProcessor.getEarlyBeanReference实现方法
() -> getEarlyBeanReference(beanName, mbd, bean) //在singletonFactory.getObject时会执行这个方法
);
}
// Initialize the bean instance.
Object exposedObject = bean;
try {
//属性填充,对循环依赖的属性进行处理
populateBean(beanName, mbd, instanceWrapper);
//初始化,调用工厂回调以及初始化方法和beanPostProcessor后处理程序,执行部分Aware(AOP在这里完成)
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<String> 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 " +
"'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.");
}
}
}
}
try {
//注册DisposableBean,如果配置了destroy-methoy,这里需要注册以便于在销毁的时候调用
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
return exposedObject;
}