文章目录
spring refresh()中finishBeanFactoryInitialization()之doGetBean()详解
上文中简单介绍了finishBeanFactoryInitialization()的流程，本文详细介绍doGetBean()方法中的实现。
doGetBean()是真正获取bean的地方，也是触发依赖注入的地方。
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
//转换beanName(去掉name前面的"&"")
final String beanName = transformedBeanName(name);
Object bean;
//在singleton缓存中查找bean实例 第一次初始化时候返回为空
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
if (logger.isDebugEnabled()) {
if (isSingletonCurrentlyInCreation(beanName)) {
logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
"' that is not fully initialized yet - a consequence of a circular reference");
}
else {
logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
}
}
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
else {
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
//获取父类的BeanFactory
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 {
// No args -> delegate to standard getBean method.
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
}
//把需要创建的bean打上正在创建标记
//上文中markBeanAsCreated(beanName)方法使用，避免重复创建
if (!typeCheckOnly) {
markBeanAsCreated(beanName);
}
try {
//根据BeanName获取BeanDefinition
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
checkMergedBeanDefinition(mbd, beanName, args);
//BeanDefinition里存储的依赖bean挨个取出来进行实例化,递归调用getBean
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);
}
}
}
// Create bean instance.
//创建单例的bean
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);
}
//创建多例的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) {
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.isDebugEnabled()) {
logger.debug("Failed to convert bean '" + name + "' to required type '" +
ClassUtils.getQualifiedName(requiredType) + "'", ex);
}
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
}
return (T) bean;
}
1.transformedBeanName():转换beanName
AbstractBeanFactory类的transformedBeanName()方法，返回bean名称，剥离工厂引用前缀，并将别名解析为规范名称。（因为如果是FactoryBean会带上&符号）
protected String transformedBeanName(String name) {
return canonicalName(BeanFactoryUtils.transformedBeanName(name));
}
1.1、BeanFactoryUtils.transformedBeanName(name)
判断前缀是否带有&，如果有去掉。
public static String transformedBeanName(String name) {
Assert.notNull(name, "'name' must not be null");
String beanName = name;
while (beanName.startsWith(BeanFactory.FACTORY_BEAN_PREFIX)) {
beanName = beanName.substring(BeanFactory.FACTORY_BEAN_PREFIX.length());
}
return beanName;
}
本地测试BeanFactoryUtils类的transformedBeanName()方法
String testString = "&test&chenyl&";
System.out.println(BeanFactoryUtils.transformedBeanName(testString));
//执行结果：test&chenyl&
1.2、canonicalName()
SimpleAliasRegistry类的canonicalName()方法：将别名解析为规范名称
private final Map<String, String> aliasMap = new ConcurrentHashMap<>(16);
public String canonicalName(String name) {
String canonicalName = name;
// Handle aliasing...
String resolvedName;
do {
resolvedName = this.aliasMap.get(canonicalName);
if (resolvedName != null) {
canonicalName = resolvedName;
}
}
while (resolvedName != null);
return canonicalName;
}
最后会查看aliasMap中是否已经存在这个beanName了，如果存在了就用之前的beanName
2.getSingleton():尝试从缓存中获取单例bean
246行代码的意思就是尝试从缓存中获取单例bean。
查看DefaultSingletonBeanRegistry类中的getSingleton():
@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
//在已经注册了的单例map(singletonObjects)中获取beanName的bean实例
Object singletonObject = this.singletonObjects.get(beanName);
//如果bean不存在，且不在正在创建中的bean的map缓存(isSingletonCurrentlyInCreation)中
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
synchronized (this.singletonObjects) {
//从已经缓存了的单例对象集合（earlySingletonObjects）中获取beanName对应的Bean
singletonObject = this.earlySingletonObjects.get(beanName);
//如果bean不存在，且允许早期引用当前创建的对象
if (singletonObject == null && allowEarlyReference) {
//根据beanName获取在可以在调用时返回单例Object实例的工厂(singletonFactories)
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
//如果返回的工厂不为空就把对应的beanName放到earlySingletonObjects中，并移除singletonFactories中的值
if (singletonFactory != null) {
singletonObject = singletonFactory.getObject();
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
}
return singletonObject;
}
singletonObjects：单例缓存池。
其中用到了很多缓存：
/** 缓存beanName和bean实例 key-->beanName,value-->beanInstance */
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
/** 缓存beanName和beanFactory key-->beanName,value-->beanFactory */
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
/** 缓存beanName和bean实例 key-->beanName,value-->beanInstance 该缓存主要为了解决bean的循环依赖引用 */
private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);
/** 缓存所有注册的单例beanName */
private final Set<String> registeredSingletons = new LinkedHashSet<>(256);
- singletonObjects：缓存beanName和bean实例 key–>beanName,value–>beanInstance
- singletonFactories：缓存beanName和beanFactory key–>beanName,value–>beanFactory
- earlySingletonObjects：缓存beanName和bean实例 key–>beanName,value–>beanInstance 该缓存主要为了解决bean的循环依赖引用
- registeredSingletons：缓存所有注册的单例beanName
本地测试getSingleton()：
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(BeanConfig10.class);
PersonScan personScan = context.getBean("personScan",PersonScan.class);
//此处打断点，查看singletonObjects
personScan = context.getBean("personScan",PersonScan.class);
运行结果：
该方法调用了两次getBean方法，第一次会创建新的PersonScan实例，而第二次则会从缓存singletonObjects中获取PersonScan实例。
3.getMergedLocalBeanDefinition():获取合并了的bean定义
合并bean定义的意思：
如果animal类是抽象类，dog继承animal类，那么在该方法中就会把这两个bean定义合并。
查看AbstractBeanFactory类中的getMergedLocalBeanDefinition()接口：
protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws BeansException {
// Quick check on the concurrent map first, with minimal locking.
RootBeanDefinition mbd = this.mergedBeanDefinitions.get(beanName);
if (mbd != null) {
return mbd;
}
return getMergedBeanDefinition(beanName, getBeanDefinition(beanName));
}
现在非常纳闷：this.mergedBeanDefinitions是从何时赋值的？
查看调用栈发现在项目启动的时候执行：refresh()方法中的invokeBeanFactoryPostProcessors()方法时:
532 refresh()–>
694 invokeBeanFactoryPostProcessors()–>
84 PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors()–>
390 DefaultListableBeanFactory.getBeanNamesForType()–>
414 DefaultListableBeanFactory.doGetBeanNamesForType()–>
1210 AbstractBeanFactory.getMergedLocalBeanDefinition()–>
1224 AbstractBeanFactory.getMergedBeanDefinition()–>
1304 this.mergedBeanDefinitions.put(beanName, mbd);
此处，遍历所有this.beanDefinitionNames，把Bean定义转换成RootBeanDefinition，并且放入this.mergedBeanDefinitions的map中
public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory {
/** Map from bean name to merged RootBeanDefinition */
private final Map<String, RootBeanDefinition> mergedBeanDefinitions = new ConcurrentHashMap<>(256);
...
}
4.mbd.getDependsOn()：bean加载顺序前后的校验
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);
}
}
}
举个例子：
@Component
@DependsOn(value = "dog")
public class PersonScan {
private String name;
private Integer age;
public PersonScan(String name, Integer age) {
this.name = name;
this.age = age;
}
}
在加载PersonScan类的时候判断是否有@DependsOn，如果有，则先全部加载。
此文中的PersonScan获取实例之前，首先获取dog的实例。
5.createBean():创建bean实例
从缓存中获取单例bean为null的时候，直接创建bean实例。不管创建单例bean还是创建多例bean还是创建其他域的bean，都会调用createBean()接口。
查看AbstractAutowireCapableBeanFactory类中的createBean():
@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
if (logger.isDebugEnabled()) {
logger.debug("Creating instance of bean '" + beanName + "'");
}
RootBeanDefinition mbdToUse = mbd;
//判断注入的Bean是否可以被实例化，是否可以通过类装载器载入
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
// Prepare method overrides.
//重写prepareMethod
try {
验证及准备覆盖的方法
mbdToUse.prepareMethodOverrides();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
beanName, "Validation of method overrides failed", ex);
}
try {
//如果Bean配置了PostProcessor，那么返回一个Proxy
//第一个BeanPostProcessor扩展点（只有InstantiationAwareBeanPostProcessor接口的实现才会被调用）
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.isDebugEnabled()) {
logger.debug("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);
}
}
5.1、resolveBeanClass():确定并加载bean的class
@Nullable
protected Class<?> resolveBeanClass(final RootBeanDefinition mbd, String beanName, final Class<?>... typesToMatch)
throws CannotLoadBeanClassException {
try {
//如果数据结构中存在BeanClass直接返回
if (mbd.hasBeanClass()) {
return mbd.getBeanClass();
}
if (System.getSecurityManager() != null) {
return AccessController.doPrivileged((PrivilegedExceptionAction<Class<?>>) () ->
doResolveBeanClass(mbd, typesToMatch), getAccessControlContext());
}
else {
return doResolveBeanClass(mbd, typesToMatch);
}
}
catch (PrivilegedActionException pae) {
ClassNotFoundException ex = (ClassNotFoundException) pae.getException();
throw new CannotLoadBeanClassException(mbd.getResourceDescription(), beanName, mbd.getBeanClassName(), ex);
}
catch (ClassNotFoundException ex) {
throw new CannotLoadBeanClassException(mbd.getResourceDescription(), beanName, mbd.getBeanClassName(), ex);
}
catch (LinkageError err) {
throw new CannotLoadBeanClassException(mbd.getResourceDescription(), beanName, mbd.getBeanClassName(), err);
}
}
5.2、resolveBeforeInstantiation():后置处理器中返回AOP的代理对象代替真正的bean实例
当经过前置处理之后，返回的结果若不为空，那么会直接略过后续的Bean的创建而直接返回结果。AOP功能就是基于这里判断的.
@Nullable
protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
Object bean = null;
if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
// Make sure bean class is actually resolved at this point.
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
Class<?> targetType = determineTargetType(beanName, mbd);
if (targetType != null) {
//1.执行InstantiationAwareBeanPostProcessor的postProcessBeforeInstantiation回调方法
bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
if (bean != null) {
//2.执行InstantiationAwareBeanPostProcessor的postProcessAfterInitialization回调方法
bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
}
}
}
mbd.beforeInstantiationResolved = (bean != null);
}
return bean;
}
通过如上代码可以进行实例化的预处理（自定义实例化bean，如创建相应的代理对象）和后置处理（如进行自定义实例化的bean的依赖装配）
5.3、doCreateBean():创建bean
若不走上面的代理创建实例，则走以下的代码创建bean实例：
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {
//包含了真正的bean对象和bean的class，以及PropertyDescriptor集合
BeanWrapper instanceWrapper = null;
//如果是singleTon，从factoryBeanInstanceCache中获取instanceWrapper
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
//如果没有，则自己创建
if (instanceWrapper == null) {
//进行bean的构造方法，创建bean
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
final Object bean = instanceWrapper.getWrappedInstance();
Class<?> beanType = instanceWrapper.getWrappedClass();
//如果不是NullBean，则将resolvedTargetType 属性设置为当前的WrappedClass
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
// Allow post-processors to modify the merged bean definition.
//这边主要是寻找几个meta，@PostConstruct,@Autowire,@Value,@Resource，@PreDestory等
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是单例，且支持循环依赖，且当前bean正在创建，通过往singletonFactories添加一个objectFactory，
//这样后期如果有其他bean依赖该bean 可以从singletonFactories获取到bean，getEarlyBeanReference可以对返回的bean进行修改，这边目前除了可能会返回动态代理对象 其他的都是直接返回bean
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
if (logger.isDebugEnabled()) {
logger.debug("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 {
//填充bean的属性
populateBean(beanName, mbd, instanceWrapper);
//初始化bean
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 " +
"'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
}
}
}
}
// Register bean as disposable.
try {
//注册DisposableBean
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
return exposedObject;
}
6. getObjectForBeanInstance():判断返回一个普通的bean实例还是返回FactoryBean实例
无论是从缓存获取单例bean还是新创建的单例bean，在bean实例化之后都会调用getObjectForBeanInstance方法，该方法的作用就是判断到底是应该返回一个普通的bean的实例还是返回FactoryBean的实例。
调用该方法的目的：检测获得的Bean实例是不是FactoryBean类型的，如果是，那么需要调用该bean对应的FactoryBean实例中的getObject()作为返回值。
protected Object getObjectForBeanInstance(
Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {
//对FactoryBean正确性的验证
//isFactoryDereference(name):判断name是否含有&前缀
if (BeanFactoryUtils.isFactoryDereference(name)) {
//如果时NullBean 直接返回bean实例
if (beanInstance instanceof NullBean) {
return beanInstance;
}
//如果不是FactoryBean，则验证不通过并抛出异常
if (!(beanInstance instanceof FactoryBean)) {
throw new BeanIsNotAFactoryException(transformedBeanName(name), beanInstance.getClass());
}
}
// 到这里我们就有了一个 Bean（beanInstance）实例，当然该实例可能是会是是一个正常的 bean 又或者是一个 FactoryBean
//如果时一个正常的bean直接或者beanName前缀带有& 都直接返回bean实例
if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
return beanInstance;
}
//如果是 FactoryBean，我我们则创建该 Bean
Object object = null;
if (mbd == null) {
//从工厂bean缓存（factoryBeanObjectCache）中获取beanName的bean实例
object = getCachedObjectForFactoryBean(beanName);
}
if (object == null) {
FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
//如果从工厂bean生产的bean是单例模式
if (mbd == null && containsBeanDefinition(beanName)) {
//从容器中获取指定名称的Bean定义，如果继承基类，则合并基类相关属性
mbd = getMergedLocalBeanDefinition(beanName);
}
boolean synthetic = (mbd != null && mbd.isSynthetic());
//调用FactoryBeanRegistrySupport类的getObjectFromFactoryBean方法，
//实现工厂Bean生产Bean对象实例的过程
object = getObjectFromFactoryBean(factory, beanName, !synthetic);
}
return object;
}
6.1、isFactoryDereference():判断name是否含有&前缀
BeanFactoryUtils类的方法：
public static boolean isFactoryDereference(@Nullable String name) {
return (name != null && name.startsWith(BeanFactory.FACTORY_BEAN_PREFIX));
}
6.2、getCachedObjectForFactoryBean():从工厂bean缓存中获取beanName的bean实例
FactoryBeanRegistrySupport类的方法：
@Nullable
protected Object getCachedObjectForFactoryBean(String beanName) {
return this.factoryBeanObjectCache.get(beanName);
}
6.3、getMergedLocalBeanDefinition():从容器中获取指定名称的Bean定义
此方法是在beanInstance为FactoryBean的时候才执行到这里。
AbstractBeanFactory类中的方法：
protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws BeansException {
// Quick check on the concurrent map first, with minimal locking.
RootBeanDefinition mbd = this.mergedBeanDefinitions.get(beanName);
if (mbd != null) {
return mbd;
}
return getMergedBeanDefinition(beanName, getBeanDefinition(beanName));
}
6.4、getObjectFromFactoryBean():实现FactoryBean生产Bean对象实例的过程
此方法是在beanInstance为FactoryBean的时候才执行到这里。
protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
if (factory.isSingleton() && containsSingleton(beanName)) {
synchronized (getSingletonMutex()) {
Object object = this.factoryBeanObjectCache.get(beanName);
if (object == null) {
object = doGetObjectFromFactoryBean(factory, beanName);
// Only post-process and store if not put there already during getObject() call above
// (e.g. because of circular reference processing triggered by custom getBean calls)
Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
if (alreadyThere != null) {
object = alreadyThere;
}
else {
if (shouldPostProcess) {
if (isSingletonCurrentlyInCreation(beanName)) {
// Temporarily return non-post-processed object, not storing it yet..
return object;
}
beforeSingletonCreation(beanName);
try {
object = postProcessObjectFromFactoryBean(object, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(beanName,
"Post-processing of FactoryBean's singleton object failed", ex);
}
finally {
afterSingletonCreation(beanName);
}
}
if (containsSingleton(beanName)) {
this.factoryBeanObjectCache.put(beanName, object);
}
}
}
return object;
}
}
else {
Object object = doGetObjectFromFactoryBean(factory, beanName);
if (shouldPostProcess) {
try {
object = postProcessObjectFromFactoryBean(object, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex);
}
}
return object;
}
}
扫一扫
708
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
