Sping IOC容器启动流程和扩展点源码分析

本文将详尽的介绍spring容器启动的主流程，并画出流程图和标记出所有的扩展点。

Spring主流程方法refresh

这是刷新上下文ApplicationContext的方法

public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
        //上下文容器刷新前的预处理
        prepareRefresh();
        //获取bean工厂
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
        // 准备bean工厂，这里添加了BeanPostProcessor
        prepareBeanFactory(beanFactory);

        try {
            //允许在上下文子类中对bean工厂进行后处理。
            postProcessBeanFactory(beanFactory);
            // 在上下文中调用注册为bean的工厂后置处理器。
            invokeBeanFactoryPostProcessors(beanFactory);
            //注册拦截bean创建的bean后置处理器。
            registerBeanPostProcessors(beanFactory);
            // 初始化此上下文的消息源。
            initMessageSource();
            //初始化此上下文的消息源。
            initApplicationEventMulticaster();
            //初始化特定上下文子类中的其他特殊bean。
            onRefresh();
            //检查侦听器bean并注册它们。
            registerListeners();
            //实例化所有剩余的（非延迟初始化）单例。
            finishBeanFactoryInitialization(beanFactory);//自定义单例Bean的初始化
            //最后一步：发布相应的事件。
            finishRefresh();
            
        }catch (BeansException ex) {
            //毁已经创建的单实例以避免悬空资源。
            destroyBeans();
            //重置“active”标志。
            cancelRefresh(ex);
            // 将异常传播到调用方。
            throw ex;
        }finally {
            // 重置Spring核心中的公共内部缓存，因为我们可能不再需要单例bean的元数据了
            resetCommonCaches();
        }
    }
}

本次分析重点是单例Bean的初始化生命周期流程，也就是finishBeanFactoryInitialization(beanFactory)方法

finishBeanFactoryInitialization方法

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
	//....这里删除部分不关注的代码....

    //允许缓存所有bean定义元数据，而不需要进一步的更改。
    beanFactory.freezeConfiguration();

    //初始化所有剩余的非懒加载的单例Bean
    beanFactory.preInstantiateSingletons();
}

preInstantiateSingletons方法

public void preInstantiateSingletons() throws BeansException {
    //获取所有定义的Bean名称(包括自定义的和系统的)
    List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

    //循环，初始化所有非懒加载的Bean
    for (String beanName : beanNames) {
        RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
        //判断不是抽象类，并且是单例类，且要非延迟加载的
        if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
            //判断是不是工厂Bean
            if (isFactoryBean(beanName)) {
                //获取工厂Bean,会触发工厂Bean的初始化，拼接上前缀&就是获取工厂Bean本身
                Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
                if (bean instanceof FactoryBean) {
                    //....删除不关注的代码
                    if (isEagerInit) {
                        getBean(beanName);
                    }
                }
            }else {
                //getBean方法触发Bean的初始化，关键的点
                getBean(beanName);
            }
        }
    }

    //为所有适用的bean触发初始化后回调。
    for (String beanName : beanNames) {
        //从三级缓存中获取Bean,三级缓存用于解决循环依赖问题
        Object singletonInstance = getSingleton(beanName);
        //判断实现SmartInitializingSingleton接口，回调afterSingletonsInstantiated方法
        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(beanName) 和 getSingleton(beanName)方法
SmartInitializingSingleton接口是所有非延迟加载的单例Bean初始化完成后会回调的接口

getSingleton(beanName)方法

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

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
	//从一级缓存中获取实例: 一级缓存用于缓存已经完成实例化的单例Bean
	Object singletonObject = this.singletonObjects.get(beanName);
	if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
		synchronized (this.singletonObjects) {
            //从二级缓存中获取: 二级缓存用于缓存已经实例化的Bean，但是还没有设置依赖的类
			singletonObject = this.earlySingletonObjects.get(beanName);
			if (singletonObject == null && allowEarlyReference) {
                //从三级缓存获取：三级缓存用于缓存单例工厂，工厂封装了对应的创建Bean的方法
				ObjectFactory<?> singletonFactory = 
										this.singletonFactories.get(beanName);
				if (singletonFactory != null) {
                    //从工厂中获取单例
					singletonObject = singletonFactory.getObject();
                    //放入二级缓存中
					this.earlySingletonObjects.put(beanName, singletonObject);
                    //从三级缓存移除
					this.singletonFactories.remove(beanName);
				}
			}
		}
	}
	return singletonObject;
}

getBean(beanName)方法

//调用了doGetBean方法
public Object getBean(String name) throws BeansException {
	return doGetBean(name, null, null, false);
}

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

    final String beanName = transformedBeanName(name);
    Object bean;

    //校验从三级缓存获取注册的Bean
    Object sharedInstance = getSingleton(beanName);
    if (sharedInstance != null && args == null) {
        //...删除不关注代码
        bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    }else {
        
        //获取父容器并校验
        BeanFactory parentBeanFactory = getParentBeanFactory();
        //存在父容器，则创建并注册父容器Bean
        if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
            String nameToLookup = originalBeanName(name);
            if (parentBeanFactory instanceof AbstractBeanFactory) {
                return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
                    nameToLookup, requiredType, args, typeCheckOnly);
            }else if (args != null) {
                return (T) parentBeanFactory.getBean(nameToLookup, args);
            }else {
                return parentBeanFactory.getBean(nameToLookup, requiredType);
            }
        }
		
        //将初始化了的BeanName缓存到已创建的HashSet集合中
        if (!typeCheckOnly) {
            markBeanAsCreated(beanName);
        }

        try {
            final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
            checkMergedBeanDefinition(mbd, beanName, args);

            //初始化当前Bean依赖的Bean，例如@DependOn注解标记依赖的Bean
            String[] dependsOn = mbd.getDependsOn();
            if (dependsOn != null) {
                for (String dep : dependsOn) {
                    //....
                    registerDependentBean(dep, beanName);
                    try {
                        getBean(dep);
                    }catch (NoSuchBeanDefinitionException ex) {
                        throw new BeanCreationException("....", ex);
                    }
                }
            }

            //创建单例Bean对象并注册
            if (mbd.isSingleton()) {
                //从缓存中获取单例对象，如果没有，则调用createBean创建实例并缓存
                sharedInstance = getSingleton(beanName, () -> {
                    try {
                        return createBean(beanName, mbd, args);
                    }catch (BeansException ex) {
                       //从缓存中移除Bean,并调用Bean的销毁方法
                        destroySingleton(beanName);
                        throw ex;
                    }
                });
    //判断刚创建的是FactoryBean,且beanName不以&开头，则调用FactoryBean的getObject方法获取Bean
                bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
            
            }else if (mbd.isPrototype()) {
                //多实例Bean创建逻辑删除....
            }else {
                //其它Scope类型bean创建逻辑...
            }
        }catch (BeansException ex) {
            cleanupAfterBeanCreationFailure(beanName);
            throw ex;
        }
    }

    //检查所需类型是否与实际bean实例的类型匹配。不匹配则进行类型转换
    if (requiredType != null && !requiredType.isInstance(bean)) {
        try {
            T convertedBean = getTypeConverter()
                .convertIfNecessary(bean,requiredType);
			return convertedBean;
        }catch (TypeMismatchException ex) {....}
    }
    return (T) bean;
}

**重点关注：sharedInstance = getSingleton(beanName, () -> createBean(beanName, mbd, args))**这是延迟加载的lamda表达式形式

createBean(beanName, mbd, args)方法

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

    RootBeanDefinition mbdToUse = mbd;
	//...删除不关注的逻辑代码
    try {
        //调用InstantiationAwareBeanPostProcessor后置处理器接口进行逻辑处理解析(重点)
        Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
        if (bean != null) {
            return bean;
        }
    }catch (Throwable ex) {
        throw new BeanCreationException("....", ex);
    }

    try {
        //进行上面调用后返回null,则创建Bean；(重点方法)
        Object beanInstance = doCreateBean(beanName, mbdToUse, args);
        return beanInstance;
    }catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
       throw ex;
    }
}

resolveBeforeInstantiation方法（后置处理器接口进行逻辑处理解析）

protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
	Object bean = null;
	if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
		//判断确保类已经被解析了，并且实现了InstantiationAwareBeanPostProcessor接口
		if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
			Class<?> targetType = determineTargetType(beanName, mbd);
			if (targetType != null) {
       //调用InstantiationAwareBeanPostProcessor接口的postProcessBeforeInstantiation方法
				bean = applyBeanPostProcessorsBeforeInstantiation(targetType, 
                                                                  beanName);
				if (bean != null) {
                    //如果上面调用接口方法返回不为null，则跳过Bean构造方法，属性设置，实例化等流程，直调用BeanPostProcessor后置处理器的postProcessBeforeInitialization方法
					bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
				}
			}
		}
		mbd.beforeInstantiationResolved = (bean != null);
	}
	return bean;
}

getSingleton(String beanName, ObjectFactory<?> singletonFactory)方法

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
	
	synchronized (this.singletonObjects) {
		Object singletonObject = this.singletonObjects.get(beanName);
		if (singletonObject == null) {
			//...省略代码...
			beforeSingletonCreation(beanName);//创建前的校验和缓存
			boolean newSingleton = false;
			boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
			if (recordSuppressedExceptions) {
				this.suppressedExceptions = new LinkedHashSet<>();
			}
			try {
                //singletonFactory是lamda表达式，执行createBean(beanName, mbd, args)方法
				singletonObject = singletonFactory.getObject();
				newSingleton = true;
			}catch (IllegalStateException ex) {
				//再次从缓存中获取
				singletonObject = this.singletonObjects.get(beanName);
				if (singletonObject == null) {
					throw ex;
				}
			}catch (BeanCreationException ex) {
				//...省略代码...
				throw ex;
			}
			finally {
				//...省略代码...
				afterSingletonCreation(beanName);//再次校验缓存
			}
			if (newSingleton) {
                //单例创建完成后放入缓存中
				addSingleton(beanName, singletonObject);
			}
		}
		return singletonObject;
	}
}

addSingleton(beanName, singletonObject)

protected void addSingleton(String beanName, Object singletonObject) {
    synchronized (this.singletonObjects) {
        //Map缓存生成的单例名称与实例的映射
        this.singletonObjects.put(beanName, singletonObject);
        //移除缓存单例工厂，工厂是一个lamda表达式，可创建对应的实例对象
        this.singletonFactories.remove(beanName);
        //循环依赖时候暂时缓存未赋值完成的单例类，这里创建完成后移除缓存
        this.earlySingletonObjects.remove(beanName);
        //LinkedHashSet缓存已经注册了的单例Bean名称，用于检测重复注册的名字
        this.registeredSingletons.add(beanName);
    }
}

doCreateBean核心方法

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)throws BeanCreationException {
	
	BeanWrapper instanceWrapper = null;
	if (mbd.isSingleton()) {
		instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
	}
    //从缓存中没有获取到Bean,则创建Bean,然后封装在 BeanWrapperImpl中
	if (instanceWrapper == null) {
		instanceWrapper = createBeanInstance(beanName, mbd, args);
	}
    //获取创建的Bean和所属的类
	final Object bean = instanceWrapper.getWrappedInstance();
	Class<?> beanType = instanceWrapper.getWrappedClass();
	if (beanType != NullBean.class) {
		mbd.resolvedTargetType = beanType;
	}
	//允许后处理程序修改合并的bean定义。
	synchronized (mbd.postProcessingLock) {
		if (!mbd.postProcessed) {
			try {
       //调用MergedBeanDefinitionPostProcessor接口(继承并扩展了后置处理器)收集Bean的注入信息，
	  //例如实现类AutowiredAnnotationBeanPostProcessor专门处理@Autowired  @Value注解
				applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
			}catch (Throwable ex) { ...}
			mbd.postProcessed = true;
		}
	}
	//判断对象如果是正在创建的单例Bean且运行循环引用，则将Bean封装到ObjectFactory对象引用中，为解决循环引用做铺垫，实际调用ObjectFactory的getObject方法时候才返回对象
	boolean earlySingletonExposure = (mbd.isSingleton() && 
    		this.allowCircularReferences && isSingletonCurrentlyInCreation(beanName));
	if (earlySingletonExposure) {
		//将Bean封装成ObjectFactory对象缓存到三级缓存中
		addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
	}
	
	Object exposedObject = bean;
	try {
        //调用后置处理器注入字段属性等信息，同时会触发InstantiationAwareBeanPostProcessor后置处理器接口postProcessAfterInstantiation和postProcessPropertyValues方法的逻辑
		populateBean(beanName, mbd, instanceWrapper); //依赖注入问题在这里解决
        
        //调用Bean初始化方法和触发后置处理器逻辑
		exposedObject = initializeBean(beanName, exposedObject, mbd);
	}catch (Throwable ex) {
		//.....异常处理省略
	}
	if (earlySingletonExposure) {
		Object earlySingletonReference = getSingleton(beanName, false);
		if (earlySingletonReference != null) {
			//.....省略代码
		}
	}
	//注册Bean的销毁方法，关闭容器的时候调用
	try {
		registerDisposableBeanIfNecessary(beanName, bean, mbd);
	}catch (BeanDefinitionValidationException ex) { ... }
    
	return exposedObject;
}

addSingletonFactory方法

protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
    Assert.notNull(singletonFactory, "Singleton factory must not be null");
    synchronized (this.singletonObjects) {
        if (!this.singletonObjects.containsKey(beanName)) {
            //将刚刚创建的Bean封装到ObjectFactory中，保存到三级缓存
            this.singletonFactories.put(beanName, singletonFactory);
            this.earlySingletonObjects.remove(beanName);
            this.registeredSingletons.add(beanName);
        }
    }
}

populateBean 方法注入Bean的属性等信息

protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
	//...省略无关代码...
    
	// 执行InstantiationAwareBeanPostProcessors接口，决定是否需要属性填充
	boolean continueWithPropertyPopulation = true;
	if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
		for (BeanPostProcessor bp : getBeanPostProcessors()) {
			if (bp instanceof InstantiationAwareBeanPostProcessor) {
				InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                //接口实现返回false,则后面会跳过属性填充
				if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
					continueWithPropertyPopulation = false;
					break;
				}
			}
		}
	}
    //跳过属性填充
	if (!continueWithPropertyPopulation) {
		return;
	}
 
	PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
	if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME || mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) {
		MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
		//通过name注入属性
		if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME) {
			autowireByName(beanName, mbd, bw, newPvs);
		}
		//通过类型注入属性
		if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) {
			autowireByType(beanName, mbd, bw, newPvs);
		}
		pvs = newPvs;
	}
    
	boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
	boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);
	if (hasInstAwareBpps || needsDepCheck) {
		if (pvs == null) {
			pvs = mbd.getPropertyValues();
		}
		PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
		if (hasInstAwareBpps) {
			for (BeanPostProcessor bp : getBeanPostProcessors()) {
 				//执行InstantiationAwareBeanPostProcessors接口修改属性的方法
                //比如@Autowired注入操作就是这个进行的
				if (bp instanceof InstantiationAwareBeanPostProcessor) {
					InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
					pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
					if (pvs == null) {
						return;
					}
				}
			}
		}
        
		if (needsDepCheck) {
			checkDependencies(beanName, mbd, filteredPds, pvs);
		}
	}
    //将修改后的属性值注入到Bean中
	if (pvs != null) {
		applyPropertyValues(beanName, mbd, bw, pvs);
	}
}

initializeBean方法

protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
	if (System.getSecurityManager() != null) {
		AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
			invokeAwareMethods(beanName, bean);
			return null;
		}, getAccessControlContext());
	}else {
        //调用Aware接口的一些实现类
		invokeAwareMethods(beanName, bean);
	}
    
	Object wrappedBean = bean;
	if (mbd == null || !mbd.isSynthetic()) {
        //调用后置处理器的 postProcessBeforeInitialization方法
		wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
	}
	try {
        //调用Bean的初始化方法
		invokeInitMethods(beanName, wrappedBean, mbd);
	}catch (Throwable ex) {....}
    
	if (mbd == null || !mbd.isSynthetic()) {
        //调用后置处理器的 postProcessorsAfterInitialization方法
		wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
	}
	return wrappedBean;
}

启动流程图及其拓展点