源码分析
通过上述的各个配置和准备工作，终于来到了重点，将剩余的bean示例化，那么它是如何实现的呢，先看下代码：
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
// Initialize conversion service for this context.
//判断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));
}
// Register a default embedded value resolver if no bean post-processor
// (such as a PropertyPlaceholderConfigurer bean) registered any before:
// at this point, primarily for resolution in annotation attribute values.
// 如果beanFactory之前没有注册嵌入值解析器，则注册默认的嵌入值解析器：主要用于注解属性值的解析。
if (!beanFactory.hasEmbeddedValueResolver()) {
beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
}
// Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
//初始化LoadTimeWeaverAware bean
String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
for (String weaverAwareName : weaverAwareNames) {
getBean(weaverAwareName);
}
// Stop using the temporary ClassLoader for type matching.
//停止使用临时的类加载器来进行类型匹配
beanFactory.setTempClassLoader(null);
// Allow for caching all bean definition metadata, not expecting further changes.
//冻结配置，此时所有的beanDefinition都不再更新修改，即将开始实例化bean
beanFactory.freezeConfiguration();
//实例化所有剩下的bean单例
// Instantiate all remaining (non-lazy-init) singletons.
beanFactory.preInstantiateSingletons();
}
分析上述代码，除去一系列设置，主要方法为最后一个preInstantiateSingletons方法，实例化单例，具体实现如下：
@Override
public void preInstantiateSingletons() throws BeansException {
if (logger.isTraceEnabled()) {
logger.trace("Pre-instantiating singletons in " + this);
}
// Iterate over a copy to allow for init methods which in turn register new bean definitions.
// While this may not be part of the regular factory bootstrap, it does otherwise work fine.
//创建一个beanNames的备份
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
// Trigger initialization of all non-lazy singleton beans...
//遍历beanNames，分别对其进行实例化
for (String beanName : beanNames) {
//获取当前beanName对应的bean定义信息
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
//当前bean是否是非抽象且单例且非懒加载
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
//当前bean是和是FactoryBean
if (isFactoryBean(beanName)) {
//若是，通过getBean(&beanName)拿到的是FactoryBean本身；
//通过getBean(beanName)拿到的是FactoryBean创建的Bean实例
Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
//当前bean是否是FactoryBean
if (bean instanceof FactoryBean) {
//转为FactoryBean父类
final 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) {
//初始化bean
getBean(beanName);
}
}
}
else {
//若不是FactoryBean，则获取bean（初始化）
getBean(beanName);
}
}
}
// Trigger post-initialization callback for all applicable beans...
//触发所有SmartInitializingSingleton的后初始化回调
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();
}
}
}
}
分析代码，执行逻辑如下：
- 创建一个beanNames集合的备份，以便对其进行操作；
- 遍历集合，获取其bean的定义信息；
- 根据定义信息作出判断（
!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()），是否要实例化； - 若是，判断当前bean是否是FactoryBean的实现子类，若不是，则调用
getBean方法进行实例化； - 对所有SmartInitializingSingleton的后初始化回调；
通过分析，去除各个条件判断，我们能看到，最主要的方法任然是getBean方法，具体实现如下：
@Override
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;
// Eagerly check singleton cache for manually registered singletons.
//从缓存中获取该bean，处理那些已经被创建过的单件模式的Bean，对这种Bean的请求不需要重复创建
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
...
//获取给定bean实例的对象，如果是FactoryBean，则为bean实例本身或其创建的对象。
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
else {
// Check if bean definition exists in this factory.
// 获取父工厂,如果当前工厂找不到，就去父工厂查找，一直链式查找，直到找到
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已经创建过了
if (!typeCheckOnly) {
//标记bean为已创建，加入alreadyCreated集合
markBeanAsCreated(beanName);
}
try {
//获取Bean定义信息
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
//检查，若是抽象类则抛出异常
checkMergedBeanDefinition(mbd, beanName, args);
// Guarantee initialization of beans that the current bean depends on.
//获取当前bean的依赖项，
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
for (String dep : dependsOn) {
if (isDependent(beanName, dep)) {
...
}
registerDependentBean(dep, beanName);
try {
//递归getBean，确保依赖项全部初始化
getBean(dep);
}
catch (NoSuchBeanDefinitionException ex) {
...
}
}
}
// Create bean instance.
//创建单例
if (mbd.isSingleton()) {
//创建bean单例
sharedInstance = getSingleton(beanName, () -> {
try {
//重写factoryBean中的getObject方法
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
destroySingleton(beanName);
throw ex;
}
});
//若获取的bean为factoryBean，则获取该工厂创建的单例对象；
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
//创建多实例的bean
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);
}
//其他的作用域的bean
else {
String scopeName = mbd.getScope();
final 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) {
...
}
}
}
catch (BeansException ex) {
...
}
}
// Check if required type matches the type of the actual bean instance.
//检查类型匹配
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) {
...
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
}
//返回创建的bean
return (T) bean;
}
分析代码，此方法执行逻辑如下：
- 根据beanName,调用
getSingleton方法，从缓存中获取当前已创建的bean（可能是个半成品）； - 若该bean存在,则返回该bean或者由该bean创建的单例对象；
- 若该bean不存在，则表示此时bean还未被创建，首先查找是否有父工厂；
- 若有父工厂，且在当前工厂未找到当前bean的定义信息，则从父工厂中逐级往上调用父工厂的
getBean方法，直至获取； - 若没有父工厂，首先判断是否需要类型检查（
!typeCheckOnly），那么标记bean已经创建过了，将该beanName加入到已创建集合中； - 根据beanName，获取当前bean的定义信息；
- 若当前bean存在依赖项，则递归调用
getBean方法，先将其依赖项全部实例化； - 根据bean的作用域性质，分为Singleton，Prototype，和其他，分别具体示例化bean；
通过分析上述过程可以看到，上述的1-7步骤一大堆代码，都还没有对当前bean进行具体的实例化操作做，那么以Singleton为例，它是怎么具体实现实例化的呢？
观察Singleton部分获取单例bean的代码如下：
sharedInstance = getSingleton(beanName, () -> {
try {
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
destroySingleton(beanName);
throw ex;
}
});
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
观察代码，可知是调用getSingleton(String beanName, ObjectFactory<?> singletonFactory)方法，且此处使用createBean方法对ObjectFactory的getObject方法进行重写，进入方法体内部：
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) {
...
//创建单例之前的回调，将beanName加入到正在创建的缓存中
beforeSingletonCreation(beanName);
boolean newSingleton = false;
boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
if (recordSuppressedExceptions) {
this.suppressedExceptions = new LinkedHashSet<>();
}
try {
//执行工厂的getObject()方法获取bean示例，此时方法为上述方法中的createBean的方法
singletonObject = singletonFactory.getObject();
newSingleton = true;
}
catch (Exception ex) {
...
}
finally {
if (recordSuppressedExceptions) {
this.suppressedExceptions = null;
}
//创建单例后的回调，将beanName从正在创建的缓存中移除
afterSingletonCreation(beanName);
}
if (newSingleton) {
//若此时bean首次创建，则将此bean示例加入到单例缓存中
addSingleton(beanName, singletonObject);
}
}
return singletonObject;
}
}
分析方法，getSingleton执行逻辑如下：
- 查看当前缓存中是否已经存在该单例，若存在则直接返回该单例；
- 若不存在，将当前beanName加入到正在创建的缓存集合中，表示当前bean正在创建；
- 调用工厂的getObject方法，获取bean单例；
- 将beanName从正在创建的缓存集合中移除，表示bean已创建结束；
- 将当前bean加入到单例缓存中；
那么工厂又是如何get这个单例的呢，即createBean方法的执行逻辑是什么呢，代码如下：
createBean
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;
...
// Prepare method overrides.
//验证及准备覆盖的方法（对override属性进行标记及验证）
try {
mbdToUse.prepareMethodOverrides();
}
catch (Exception ex) {
...
}
try {
// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
//返回代理来代替真正的实例
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
return bean;
}
}
catch (Throwable ex) {
...
}
try {
//创建常规的单例bean对象（核心方法）
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
...
//返回
return beanInstance;
}
catch (Exception ex) {
...
}
}
分析当前代码，若作为一个常规的bean的创建过程，即没有使用一些别的花里胡哨的拓展，此时核心为doCreateBean方法，具体代码如下：
doCreateBean
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {
// Instantiate the bean.
//实例化bean的包装类
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
//返回包装类BeanWrappe,此时已示例化出一个bean对象，但是还未初始化，即此时是个半成品
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
//获取bean对象
final Object bean = instanceWrapper.getWrappedInstance();
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
...
// Eagerly cache singletons to be able to resolve circular references
// even when triggered by lifecycle interfaces like BeanFactoryAware.
//判断当前是否单例&&允许循环引用&&当前bean正在创建
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
...
//将当前bean的工厂存入一级缓存singletonFactories
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
// Initialize the bean instance.
//初始化bean单例
Object exposedObject = bean;
try {
//填充属性值，如AutoWire之类。。。
populateBean(beanName, mbd, instanceWrapper);
//执行后置处理器beanPostProcessor，bean的初始化的前置和后置，aop就是在这里完成的处理
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
catch (Throwable 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()) {
...
}
}
}
}
// Register bean as disposable.
//注册DisposableBean，如果配置了destroy-methoy，这里需要注册以便于在销毁的时候调用
try {
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
return exposedObject;
}
分析上述代码，执行逻辑如下：
- 根据beanName，查找并获取当前bean工厂中的factoryBeanInstanceCache缓存中bean包装对象；
- 若获取包装对象为空，则调用
createBeanInstance方法构造bean的包装对象，此时bean已被创建，即分配了内存，但还未初始化； - 获取当前的bean对象，并将其实现工厂存入容器的第三级缓存
singletonFactories中（ioc使用三级缓存用以解决循环引用问题）； populateBean填充bean中的属性值；initializeBean初始化指定的bean实例,此处是我们指定的初始化过程，BeanPostProcessor在此处执行；
那么createBeanInstance是如何创建单例的，代码如下：
createBeanInstance
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
// Make sure bean class is actually resolved at this point.
//解析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<?> instanceSupplier = mbd.getInstanceSupplier();
if (instanceSupplier != null) {
return obtainFromSupplier(instanceSupplier, beanName);
}
//若此时工厂方法不为空，则使用工厂方法
if (mbd.getFactoryMethodName() != null) {
return instantiateUsingFactoryMethod(beanName, mbd, args);
}
// Shortcut when re-creating the same 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);
}
}
// Candidate constructors for autowiring?
//此时有多个参数构造函数
Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
return autowireConstructor(beanName, mbd, ctors, args);
}
// Preferred constructors for default construction?
ctors = mbd.getPreferredConstructors();
if (ctors != null) {
return autowireConstructor(beanName, mbd, ctors, null);
}
// No special handling: simply use no-arg constructor.
// 默认构造函数构造
return instantiateBean(beanName, mbd);
}
分析上述代码，排除一些复杂情况，即无工厂，无带参数构造，实际调用方法为最后的instantiateBean(beanName, mbd)方法，即调用优先级为:工厂方法 > 带参数构造方法 > (无参)默认构造方法,instantiateBean(beanName, mbd)查看具体实现：
protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
try {
Object beanInstance;
final BeanFactory parent = this;
if (System.getSecurityManager() != null) {
beanInstance = AccessController.doPrivileged((PrivilegedAction<Object>) () ->
getInstantiationStrategy().instantiate(mbd, beanName, parent),
getAccessControlContext());
}
else {
//实例化bean
beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
}
//实例化bean的包装类
BeanWrapper bw = new BeanWrapperImpl(beanInstance);
initBeanWrapper(bw);
return bw;
}
catch (Throwable ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
}
}
主要方法为instantiate方法，具体实现为：
public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
// Don't override the class with CGLIB if no overrides.
if (!bd.hasMethodOverrides()) {
//获取构造器
Constructor<?> constructorToUse;
synchronized (bd.constructorArgumentLock) {
constructorToUse = (Constructor<?>) bd.resolvedConstructorOrFactoryMethod;
if (constructorToUse == null) {
final Class<?> clazz = bd.getBeanClass();
if (clazz.isInterface()) {
throw new BeanInstantiationException(clazz, "Specified class is an interface");
}
try {
if (System.getSecurityManager() != null) {
constructorToUse = AccessController.doPrivileged(
(PrivilegedExceptionAction<Constructor<?>>) clazz::getDeclaredConstructor);
}
else {
constructorToUse = clazz.getDeclaredConstructor();
}
bd.resolvedConstructorOrFactoryMethod = constructorToUse;
}
catch (Throwable ex) {
throw new BeanInstantiationException(clazz, "No default constructor found", ex);
}
}
}
//实例化对象
return BeanUtils.instantiateClass(constructorToUse);
}
else {
// Must generate CGLIB subclass.
return instantiateWithMethodInjection(bd, beanName, owner);
}
}
BeanUtils.instantiateClass
public static <T> T instantiateClass(Constructor<T> ctor, Object... args) throws BeanInstantiationException {
Assert.notNull(ctor, "Constructor must not be null");
try {
ReflectionUtils.makeAccessible(ctor);
if (KotlinDetector.isKotlinReflectPresent() && KotlinDetector.isKotlinType(ctor.getDeclaringClass())) {
return KotlinDelegate.instantiateClass(ctor, args);
}
else {
Class<?>[] parameterTypes = ctor.getParameterTypes();
Assert.isTrue(args.length <= parameterTypes.length, "Can't specify more arguments than constructor parameters");
Object[] argsWithDefaultValues = new Object[args.length];
for (int i = 0 ; i < args.length; i++) {
if (args[i] == null) {
Class<?> parameterType = parameterTypes[i];
argsWithDefaultValues[i] = (parameterType.isPrimitive() ? DEFAULT_TYPE_VALUES.get(parameterType) : null);
}
else {
argsWithDefaultValues[i] = args[i];
}
}
//实例化对象
return ctor.newInstance(argsWithDefaultValues);
}
}
catch (InstantiationException ex) {
throw new BeanInstantiationException(ctor, "Is it an abstract class?", ex);
}
catch (IllegalAccessException ex) {
throw new BeanInstantiationException(ctor, "Is the constructor accessible?", ex);
}
catch (IllegalArgumentException ex) {
throw new BeanInstantiationException(ctor, "Illegal arguments for constructor", ex);
}
catch (InvocationTargetException ex) {
throw new BeanInstantiationException(ctor, "Constructor threw exception", ex.getTargetException());
}
}
分析上述两段代码，由于我们此时使用的都是无参构造器，即此时两段代码可以简化为：
Class<?> clazz = bd.getBeanClass();
Constructor<?> ctor=clazz.getDeclaredConstructor();
ctor.newInstance(argsWithDefaultValues);
即此时是使用反射机制，构造出bean实例；
用于填充属性值得populateBean方法具体实现如下：
populateBean
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
//若此时bean为空，则直接返回
if (bw == null) {
if (mbd.hasPropertyValues()) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
}
else {
// Skip property population phase for null instance.
return;
}
}
// Give any InstantiationAwareBeanPostProcessors the opportunity to modify the
// state of the bean before properties are set. This can be used, for example,
// to support styles of field injection.
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
return;
}
}
}
}
//获取当前bean需要填充的属性值
PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
//如果给一个类设置了 : AUTOWIRE_BY_NAME 和 AUTOWIRE_BY_TYPE, 那么类中的属性, 会根据规则自动注入, 而不需要@Autowired或@Resource了
//默认情况下, 是 AUTOWIRE_NO, 所以这里默认是不执行
int resolvedAutowireMode = mbd.getResolvedAutowireMode();
if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
// Add property values based on autowire by name if applicable.
if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
autowireByName(beanName, mbd, bw, newPvs);
}
// Add property values based on autowire by type if applicable.
if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
autowireByType(beanName, mbd, bw, newPvs);
}
pvs = newPvs;
}
//当前bean是否有自定义的初始化注入过程
boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
//是否需要深度检查
boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);
PropertyDescriptor[] filteredPds = null;
if (hasInstAwareBpps) {
if (pvs == null) {
pvs = mbd.getPropertyValues();
}
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
//执行此定义的注入过程
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
if (filteredPds == null) {
filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
}
pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
return;
}
}
pvs = pvsToUse;
}
}
}
if (needsDepCheck) {
if (filteredPds == null) {
filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
}
//深度检查
checkDependencies(beanName, mbd, filteredPds, pvs);
}
if (pvs != null) {
//将属性值应用到属性值中
applyPropertyValues(beanName, mbd, bw, pvs);
}
}
除去各种条件，核心为最后一句applyPropertyValues(beanName, mbd, bw, pvs),具体实现如下：
protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {
//没有要填充的属性，直接返回
if (pvs.isEmpty()) {
return;
}
if (System.getSecurityManager() != null && bw instanceof BeanWrapperImpl) {
((BeanWrapperImpl) bw).setSecurityContext(getAccessControlContext());
}
MutablePropertyValues mpvs = null;
List<PropertyValue> original;
if (pvs instanceof MutablePropertyValues) {
mpvs = (MutablePropertyValues) pvs;
if (mpvs.isConverted()) {
// Shortcut: use the pre-converted values as-is.
try {
bw.setPropertyValues(mpvs);
return;
}
catch (BeansException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Error setting property values", ex);
}
}
original = mpvs.getPropertyValueList();
}
else {
original = Arrays.asList(pvs.getPropertyValues());
}
TypeConverter converter = getCustomTypeConverter();
if (converter == null) {
converter = bw;
}
BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);
// Create a deep copy, resolving any references for values.
List<PropertyValue> deepCopy = new ArrayList<>(original.size());
boolean resolveNecessary = false;
//遍历要填充的属性
for (PropertyValue pv : original) {
//当前属性是否已填充
if (pv.isConverted()) {
deepCopy.add(pv);
}
else {
//属性名
String propertyName = pv.getName();
//属性值或引用
Object originalValue = pv.getValue();
if (originalValue == AutowiredPropertyMarker.INSTANCE) {
Method writeMethod = bw.getPropertyDescriptor(propertyName).getWriteMethod();
if (writeMethod == null) {
throw new IllegalArgumentException("Autowire marker for property without write method: " + pv);
}
originalValue = new DependencyDescriptor(new MethodParameter(writeMethod, 0), true);
}
//解析originalValue，此时为RuntimeBeanReference类型，若是ref，返回给bean对象，若还未示例化，则先示例化该引用的bean单例；
Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);
Object convertedValue = resolvedValue;
boolean convertible = bw.isWritableProperty(propertyName) &&
!PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName);
if (convertible) {
//将值赋予属性
convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter);
}
// Possibly store converted value in merged bean definition,
// in order to avoid re-conversion for every created bean instance.
if (resolvedValue == originalValue) {
if (convertible) {
pv.setConvertedValue(convertedValue);
}
deepCopy.add(pv);
}
else if (convertible && originalValue instanceof TypedStringValue &&
!((TypedStringValue) originalValue).isDynamic() &&
!(convertedValue instanceof Collection || ObjectUtils.isArray(convertedValue))) {
pv.setConvertedValue(convertedValue);
deepCopy.add(pv);
}
else {
resolveNecessary = true;
deepCopy.add(new PropertyValue(pv, convertedValue));
}
}
}
if (mpvs != null && !resolveNecessary) {
mpvs.setConverted();
}
// Set our (possibly massaged) deep copy.
try {
bw.setPropertyValues(new MutablePropertyValues(deepCopy));
}
catch (BeansException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Error setting property values", ex);
}
}
通过跟踪代码，我们将上述代码简化为以下：
protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {
//没有要填充的属性，直接返回
if (pvs.isEmpty()) {
return;
}
...
MutablePropertyValues mpvs = null;
List<PropertyValue> original;
...
original = Arrays.asList(pvs.getPropertyValues());
...
boolean resolveNecessary = false;
//遍历要填充的属性
for (PropertyValue pv : original) {
//当前属性是否已填充
if (pv.isConverted()) {
deepCopy.add(pv);
}
else {
//属性名
String propertyName = pv.getName();
//属性值或引用
Object originalValue = pv.getValue();
...
//解析originalValue，此时为RuntimeBeanReference类型，若是ref，返回给bean对象，若还未示例化，则先示例化该引用的bean单例；
Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);
Object convertedValue = resolvedValue;
boolean convertible = bw.isWritableProperty(propertyName) &&
!PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName);
if (convertible) {
//将值赋予属性
convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter);
}
...
}
}
...
}
简化代码后，我们发现，在resolveValueIfNecessary方法中实现了示例化该属性的引用对象，进入代码查看实现：
简化部分无关代码：
public Object resolveValueIfNecessary(Object argName, @Nullable Object value) {
// We must check each value to see whether it requires a runtime reference
// to another bean to be resolved.
if (value instanceof RuntimeBeanReference) {
RuntimeBeanReference ref = (RuntimeBeanReference) value;
return resolveReference(argName, ref);
}
...
}
进入具体实现方法：
//解决工厂中对另一个bean的引用。
private Object resolveReference(Object argName, RuntimeBeanReference ref) {
try {
Object bean;
Class<?> beanType = ref.getBeanType();
//是否是父工厂的中的bean的引用
if (ref.isToParent()) {
获取父bean工厂
BeanFactory parent = this.beanFactory.getParentBeanFactory();
if (parent == null) {
throw new BeanCreationException(
this.beanDefinition.getResourceDescription(), this.beanName,
"Cannot resolve reference to bean " + ref +
" in parent factory: no parent factory available");
}
if (beanType != null) {
//通过工厂获取bean
bean = parent.getBean(beanType);
}
else {
//通过工厂获取bean
bean = parent.getBean(String.valueOf(doEvaluate(ref.getBeanName())));
}
}
else {
String resolvedName;
if (beanType != null) {
NamedBeanHolder<?> namedBean = this.beanFactory.resolveNamedBean(beanType);
bean = namedBean.getBeanInstance();
resolvedName = namedBean.getBeanName();
}
else {
resolvedName = String.valueOf(doEvaluate(ref.getBeanName()));
//获取当前工厂中的该bean
bean = this.beanFactory.getBean(resolvedName);
}
this.beanFactory.registerDependentBean(resolvedName, this.beanName);
}
if (bean instanceof NullBean) {
bean = null;
}
return bean;
}
catch (BeansException ex) {
throw new BeanCreationException(
this.beanDefinition.getResourceDescription(), this.beanName,
"Cannot resolve reference to bean '" + ref.getBeanName() + "' while setting " + argName, ex);
}
}
分析代码，我们能够看出，在该方法中，通过传入beanName，调用beanFactory.getBean方法，而这个方法在上述的分析中我们知道，若是在当前工厂的缓存中没有，则示例化一个，即此时可总结为：当要填充的属性值得引用还尚未示例化时，则现将其引用示例，再将此实例赋值给该属性；
initializeBean
initializeBean方法是使用工厂回调以及初始化方法和bean后处理器初始化给定的bean实例。
具体代码如下：
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()) {
//执行初始化前的前置操作
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
try {
//执行初始化方法
invokeInitMethods(beanName, wrappedBean, mbd);
}
catch (Throwable ex) {
throw new BeanCreationException(
(mbd != null ? mbd.getResourceDescription() : null),
beanName, "Invocation of init method failed", ex);
}
if (mbd == null || !mbd.isSynthetic()) {
//执行初始化后的后置操作
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}
作为普通的bean，上述代码可以简述为：
protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
Object wrappedBean = bean;
//执行初始化前的前置操作
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
//执行初始化方法
invokeInitMethods(beanName, wrappedBean, mbd);
//执行初始化后的后置操作
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
return wrappedBean;
}
自此，单例bean工厂的getObject（）过程结束，当工厂生产出bean后，将其加入实例缓存中：
addSingleton
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);
}
}
591
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
