咱们前面了解了spring容器创建，然后加载了bean的定义信息，执行了BDRPP，执行了BFPP，注册了BPP，前面的这么多步骤，就是为了创建Bean实例并初始化，接下来咱们了解剩下的流程
概括
咱们都知道，前面的步骤创建了很多内部使用的bean，但是真正咱们使用bean大部分没有创建，为什么说大部分呢，因为BDRPP、BFPP、BPP这个时间已经创建完了，并且BFPP已经执行完了。说了这么多没用的，咱们看下剩下的流程吧
- getBean
- doGetBean
- getSingleton
- createBean
- doCreateBean
- --------------到这里才真正开始创建对象了---------------
- craeteBeanInstance 实例化bean
- populateBean 给属性赋值
- invokeAwareMethods 执行aware
- applyBeanPostProcessorsBeforeInitialization 执行BPP的before方法
- invokeInitMethods 执行init方法
- applyBeanPostProcessorsAfterInitialization 执行BPP的after方法
这篇文章的重点是找到实例化方法
源码
public void preInstantiateSingletons() throws BeansException {
if (logger.isTraceEnabled()) {
logger.trace("Pre-instantiating singletons in " + this);
}
// 获取到所有的bean定义信息的名称
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
// 创建bean
for (String beanName : beanNames) {
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
// 要求bean不能是抽象的，要求是单例并且是非懒加载的
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
//如果是FactoryBean
if (isFactoryBean(beanName)) {
// 创建FactoryBean
Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
if (bean instanceof FactoryBean) {
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());
}
// 如果特殊的FactoryBean，并且重写了这些方法，需要走正常流程，那么则按照正常流程进行创建
if (isEagerInit) {
// 创建 bean
getBean(beanName);
}
}
}else {
// 创建 bean
getBean(beanName);
}
}
}
// 最后对SmartInitializingSingleton类型的bean进行回调
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();
}
}
}
}
getBean(beanName) 获取bean
protected <T> T doGetBean(String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)throws BeansException {
String beanName = transformedBeanName(name);
Object bean;
// 从缓存中获取bean对象
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 = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}else {
// 验证多实例的bean不能存在创建中
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
// 获取到父工厂
BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
// 这里调用父工厂获取bean
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 if (requiredType != null) {
return parentBeanFactory.getBean(nameToLookup, requiredType);
}else {
return (T) parentBeanFactory.getBean(nameToLookup);
}
}
// 创建标识
if (!typeCheckOnly) {
markBeanAsCreated(beanName);
}
try {
// 合并bean定义信息
RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
// 检查下
checkMergedBeanDefinition(mbd, beanName, args);
// depends-on="" 获取依赖
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);
}
}
}
// 创建bean通过函数式接口 ObjectFactory
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, () -> {
try {
return createBean(beanName, mbd, args);
}catch (BeansException ex) {
// 创建失败进行销毁
destroySingleton(beanName);
throw ex;
}
});
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}else if (mbd.isPrototype()) {
// 多实例bean
Object prototypeInstance = null;
try {
// 标识多实例bean在创建中
beforePrototypeCreation(beanName);
// 开始创建
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;
}
}
// 检查类型是否和预期的一致
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());
}
}
return (T) bean;
}
DefaultSingletonBeanRegistry.getSingleton 从缓存中获取bean对象
三个层级的缓存存储的是什么样的对象呢？
- 一级缓存：完整的bean对象
- 二级缓存：非完整的对象
- 三级缓存：函数式接口
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
// 从一级缓存中获取
Object singletonObject = this.singletonObjects.get(beanName);
// 如果一级缓存中不存在，并且当前bean还在创建中
// isSingletonCurrentlyInCreation 为了解决普通bean循环依赖的问题（提前暴露）
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
// 继续从二级缓存获取
singletonObject = this.earlySingletonObjects.get(beanName);
// 如果二级缓存还是获取不到
if (singletonObject == null && allowEarlyReference) {
//单例模式，对一级缓存加锁
synchronized (this.singletonObjects) {
// 懒汉模式下需要重新获取
singletonObject = this.singletonObjects.get(beanName);
// 如果一级缓存不存在
if (singletonObject == null) {
// 从二级缓存取
singletonObject = this.earlySingletonObjects.get(beanName);
// 二级缓存还是不存在
if (singletonObject == null) {
// 从三级缓存中取
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
// 如果三级缓存取到了
if (singletonFactory != null) {
// 调用函数式接口的方法创建bean
singletonObject = singletonFactory.getObject();
// 添加到二级缓存
this.earlySingletonObjects.put(beanName, singletonObject);
// 删除三级缓存
this.singletonFactories.remove(beanName);
}
}
}
}
}
}
return singletonObject;
}
AbstractBeanFactory.getObjectForBeanInstance 检查bean实例，合并bean定义，设置标识
protected Object getObjectForBeanInstance(Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {
// 如果是FactoryBean的引用，验证并标识是factoryBean
if (BeanFactoryUtils.isFactoryDereference(name)) {
if (beanInstance instanceof NullBean) {
return beanInstance;
}
if (!(beanInstance instanceof FactoryBean)) {
throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass());
}
if (mbd != null) {
mbd.isFactoryBean = true;
}
return beanInstance;
}
// 作者说这里实际是想得到factoryBean的引用
if (!(beanInstance instanceof FactoryBean)) {
return beanInstance;
}
Object object = null;
if (mbd != null) {
mbd.isFactoryBean = true;
}else {
object = getCachedObjectForFactoryBean(beanName);
}
if (object == null) {
// Return bean instance from factory.
FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
// Caches object obtained from FactoryBean if it is a singleton.
if (mbd == null && containsBeanDefinition(beanName)) {
mbd = getMergedLocalBeanDefinition(beanName);
}
boolean synthetic = (mbd != null && mbd.isSynthetic());
object = getObjectFromFactoryBean(factory, beanName, !synthetic);
}
return object;
}
AbstractAutowireCapableBeanFactory.createBean 创建bean
如果前面步骤没有获取到bean的对象，那么需要接下来创建了
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)throws BeanCreationException {
if (logger.isTraceEnabled()) {
logger.trace("Creating instance of bean '" + beanName + "'");
}
RootBeanDefinition mbdToUse = mbd;
// ？？？？？？？
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
// 准备覆盖的方法
try {
mbdToUse.prepareMethodOverrides();
}catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),beanName, "Validation of method overrides failed", ex);
}
try {
// 给BPP一个机会，返回代理对象<AOP时咱们一起了解>
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);
}
}
AbstractAutowireCapableBeanFactory.doCreateBean 真正创建bean的方法
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)throws BeanCreationException {
// 实例化bean
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
// 包装bean
Object bean = instanceWrapper.getWrappedInstance();
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
// 让后置处理器修改最后的bean定义信息
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
}catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,"Post-processing of merged bean definition failed", ex);
}
// 合并标识
mbd.postProcessed = true;
}
}
// 解决循环依赖，不允许循环依赖会抛出异常（创建bean容器的时候有设置过这个参数allowCircularReferences）
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");
}
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
// Initialize the bean instance.
Object exposedObject = bean;
try {
// 对属性进行赋值
populateBean(beanName, mbd, instanceWrapper);
// 初始化
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 {
// 如果是一次性bean，添加到注销容器中
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
// 返回bean
return exposedObject;
}
599
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
