上一篇Spring源码分析之IOC (四)主要讲到spring启动完成了所有的准备工作,接下来就该分析Spring是如何初始化对象的,本文接着从finishBeanFactoryInitialization(beanFactory)开始分析。
/**
* 完成beanFactory的初始化
* 初始化所有单例
* Finish the initialization of this context's bean factory,
* initializing all remaining singleton beans.
*/
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
// 初始化容器的转换期,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));
}
//EmbeddedValueResolver是用来处理placeholders占位符的,如果没有EmbeddedValueResolver的话注册一个默认的
if (!beanFactory.hasEmbeddedValueResolver()) {
beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
}
//提前初始化LoadTimeWeaverAware类,LoadTimeWeaverAware属于aop范畴
String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
for (String weaverAwareName : weaverAwareNames) {
getBean(weaverAwareName);
}
beanFactory.setTempClassLoader(null);
//冻结已加载的beanDefinitionNames,不允许被修改
beanFactory.freezeConfiguration();
//初始化所有非延迟加载单例
beanFactory.preInstantiateSingletons();
}
关键代码都加上注释了,可以简单了解下,重点在beanFactory.preInstantiateSingletons(),进入该方法看下具体实现:
public void preInstantiateSingletons() throws BeansException {
//拿到所有的beanDefinitionNames
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
//for循环一个一个初始化
for (String beanName : beanNames) {
//根据beanName获取BeanDefinition,RootBeanDefinition是BeanDefinition的子类,
//getMergedLocalBeanDefinition方法顾名思义就是合并,如果指定了parent,会继承parent的属性
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
// 如果不是抽象类 并且 是单例的 并且 不是延迟加载 就进行初始化bean
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
//判断是否是工厂bean:FactoryBean,通过beanName初始化bean对象实际上返回的是FactoryBean的getObject方法返回的对象
if (isFactoryBean(beanName)) {
// FACTORY_BEAN_PREFIX为&,加上该前缀表示获取工厂bean而不是bean包装的对象
Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
if (bean instanceof FactoryBean) {
FactoryBean<?> factory = (FactoryBean<?>) bean;
//判断是否需要立即初始化工厂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) {
//需要立即初始化工厂bean包装的对象是调用初始化方法getBean,此时没有加FACTORY_BEAN_PREFIX,获取的就是包装的bean
getBean(beanName);
}
}
}else {
//初始化普通bean
getBean(beanName);
}
}
}
// Trigger post-initialization callback for all applicable beans...
//获取所有的bean,并判断是否是SmartInitializingSingleton类型,并触发所有 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();
}
}
}
}
该方法分两个步骤,一是先创建bean,而是等bean创建完后,判断bean是不是SmartInitializingSingleton类型,是的话就执行回调方法。创建bean时会先判断是不是工厂bean,如果是工厂bean的话,先获取工厂bean对象,并判断工厂bean有没有立即初始化的配置,存在且为TRUE的情况下,会立即初始化工厂bean包装的对象,其他普通bean就直接调用getBean方法来初始化,我们先进入getBean中查看:
public Object getBean(String name) throws BeansException {
return doGetBean(name, null, null, false);
}
getBean没有其他的代码逻辑处理,而是直接调用了doGetBean,我们继续看doGetBean。
protected <T> T doGetBean(
String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
throws BeansException {
//name转换beanName,如果是工厂类的beanName,传进来的就是&+类名,此处会删除&,也就是beanName值接为类名,后面获取会根据name和beanName一起创建对象
String beanName = transformedBeanName(name);
Object bean;
// Eagerly check singleton cache for manually registered singletons.
//提前校验是否已经被创建了,如果已经创建了或者创建中,会直接返回缓存中的对象
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 + "'");
}
}
//如果已经创建或创建中了,直接调用getObjectForBeanInstance方法获取bean对象
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
else {
// Fail if we're already creating this bean instance:
// We're assumably within a circular reference.
//如果bean类型是原型,则判断当前bean是不是在创建中,如果在创建中就抛出异常,spring处理不了原型bean的循环依赖
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
// Check if bean definition exists in this factory.
// 如果当前容器没有该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);
}
}
//标记bean已创建,this.alreadyCreated.add(beanName);
if (!typeCheckOnly) {
markBeanAsCreated(beanName);
}
try {
//获取合并后的BeanDefinition,此时mbd已经包含了bean的所有属性,bean的创建依赖mbd
RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
//校验下bean是不是抽象类,如果是就抛异常
checkMergedBeanDefinition(mbd, beanName, args);
// Guarantee initialization of beans that the current bean depends on.
// 如果bean配置了DependsOn注解,或者bean标签有depends-on属性,则先初始化dependsOn对应的类
String[] dependsOn = mbd.getDependsOn();
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(dep);
}
catch (NoSuchBeanDefinitionException ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
}
}
}
// 如果是单例模式走这里
if (mbd.isSingleton()) {
// 获取单例bean
sharedInstance = getSingleton(beanName, () -> {
try {
//ObjectFactory的匿名实现类,创建单例bean
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
// Explicitly remove instance from singleton cache: It might have been put there
// eagerly by the creation process, to allow for circular reference resolution.
// Also remove any beans that received a temporary reference to the bean.
destroySingleton(beanName);
throw ex;
}
});
//对bean进行二次加工,比如bean为FactoryBean类型的话,如果name获取的是FactoryBean内部包装类,就会返回FactoryBean#getObject方法产生的对象
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
//如果是原型模式走这里
else if (mbd.isPrototype()) {
// It's a prototype -> create a new instance.
Object prototypeInstance = null;
try {
beforePrototypeCreation(beanName);
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
//如果是其他作用域走这里
else {
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;
}
}
// 此时requireType为null,不需要处理
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;
}
因为我们主要关注spring的IOC,所以只需要关注bean的作用域为singleton的即可。那么我们只需要看这一块代码即可
我们先看下getSingleton方法:
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(beanName, "Bean name must not be null");
synchronized (this.singletonObjects) {
// 先从一级缓存中拿,存在则直接返回,不存在则创建,singletonObjects为一级缓存,存储的是最终创建完成的bean
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
//singletonsCurrentlyInDestruction是关闭容器或者容器启动失败时的标志,此时不能再继续创建bean
if (this.singletonsCurrentlyInDestruction) {
throw new BeanCreationNotAllowedException(beanName,
"Singleton bean creation not allowed while singletons of this factory are in destruction " +
"(Do not request a bean from a BeanFactory in a destroy method implementation!)");
}
if (logger.isDebugEnabled()) {
logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
}
//底层为singletonsCurrentlyInCreation.add(beanName),标记该bean正在创建,其他地方再创建会直接报错
beforeSingletonCreation(beanName);
boolean newSingleton = false;
boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
if (recordSuppressedExceptions) {
this.suppressedExceptions = new LinkedHashSet<>();
}
try {
// 方法回调,执行外面调用getSingleton(String beanName, ObjectFactory<?> singletonFactory)方法的ObjectFactory内部实现类,即createBean
singletonObject = singletonFactory.getObject();
newSingleton = true;
}
catch (IllegalStateException ex) {
// Has the singleton object implicitly appeared in the meantime ->
// if yes, proceed with it since the exception indicates that state.
singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
throw ex;
}
}
catch (BeanCreationException ex) {
if (recordSuppressedExceptions) {
for (Exception suppressedException : this.suppressedExceptions) {
ex.addRelatedCause(suppressedException);
}
}
throw ex;
}
finally {
if (recordSuppressedExceptions) {
this.suppressedExceptions = null;
}
//从保存创建中的set集合inCreationCheckExclusions中清除,singletonsCurrentlyInCreation.remove(beanName),同上面的beforeSingletonCreation是一对
afterSingletonCreation(beanName);
}
if (newSingleton) {
//清除二三级缓存,并将最终的bean保存在一级缓存中,供后面直接使用
addSingleton(beanName, singletonObject);
}
}
//直接返回
return singletonObject;
}
}
getSingleton方法里先是从一级缓存中拿数据,如果存在就直接返回,不存在则创建,创建过程中前面是校验和加正在创建中的标记,中间singletonFactory.getObject()是真正创建bean的过程,后面是清除正在创建中标记,并将创建完成的bean加入到一级缓存中,同是清理二三级缓存,以及返回当前创建的bean。
中间创建bean的方法:singletonFactory.getObject()调用的就是外面的createBean方法,这个方法我们下期再继续分析。