2020-04-232023-06-10系统学习系列

Counter not initialized! More info at console err msg.℃ ℃ 8.6k 14 分钟

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
	// 检查缓存中是否存在实例
	Object singletonObject = this.singletonObjects.get(beanName);
	// 缓存中不存在且单例在创建中，说明单例存在循环依赖
	if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
		synchronized (this.singletonObjects) {
			singletonObject = this.earlySingletonObjects.get(beanName);
			if (singletonObject == null && allowEarlyReference) {
				ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
				if (singletonFactory != null) {
					singletonObject = singletonFactory.getObject();
					// 解决单例模式下的循环依赖，还在实例化过程中的单例，先放到earlySingletonObjects缓存
					this.earlySingletonObjects.put(beanName, singletonObject);
					this.singletonFactories.remove(beanName);
				}
			}
		}
	}
	return singletonObject;
}

if (isFactoryBean(beanName)) {
	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());
		}
		if (isEagerInit) {
			getBean(beanName);
		}
	}
}
else {
	getBean(beanName);
}

Object object = this.factoryBeanObjectCache.get(beanName);
if (object == null) {
	// 缓存不存在，调用工厂方法获取bean实例
	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 {
				// 尽可能保证所有bean初始化后都调用注册的BeanPostProcessor的postProcessAfterInitialization方法进行处理
				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);
		}
	}
}

if (isPrototypeCurrentlyInCreation(beanName)) {
	throw new BeanCurrentlyInCreationException(beanName);
}

String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
	for (String dep : dependsOn) {
		// 前置依赖的bean也依赖自己，产生循环依赖
		if (isDependent(beanName, dep)) {
			throw new BeanCreationException(mbd.getResourceDescription(), beanName,
					"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
		}
		// 建立产生依赖的bean和被依赖的bean之间的关联关系，维护在bean工厂
		registerDependentBean(dep, beanName);
		try {
			// 加载前置依赖的bean
			getBean(dep);
		}
		catch (NoSuchBeanDefinitionException ex) {
			throw new BeanCreationException(mbd.getResourceDescription(), beanName,
					"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
		}
	}
}

if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
    throw new BeanCurrentlyInCreationException(beanName);
}

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) {
				// bean实例化前置处理
				bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
				if (bean != null) {
					// 如果bean实例化前置处理返回了bean实例，则调用bean初始化后置处理器
					bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
				}
			}
		}
		// 标记bean是否在实例化前置处理中生成
		mbd.beforeInstantiationResolved = (bean != null);
	}
	return bean;
}

if (mbd.getFactoryMethodName() != null) {
	return instantiateUsingFactoryMethod(beanName, mbd, args);
}

String factoryBeanName = mbd.getFactoryBeanName();
if (factoryBeanName != null) {
	if (factoryBeanName.equals(beanName)) {
		throw new BeanDefinitionStoreException(mbd.getResourceDescription(), beanName,
				"factory-bean reference points back to the same bean definition");
	}
	factoryBean = this.beanFactory.getBean(factoryBeanName);
	if (mbd.isSingleton() && this.beanFactory.containsSingleton(beanName)) {
		throw new ImplicitlyAppearedSingletonException();
	}
	factoryClass = factoryBean.getClass();
	isStatic = false;
}
else {
	// It's a static factory method on the bean class.
	if (!mbd.hasBeanClass()) {
		throw new BeanDefinitionStoreException(mbd.getResourceDescription(), beanName,
				"bean definition declares neither a bean class nor a factory-bean reference");
	}
	factoryBean = null;
	// xml的factory-method配置方式，从beanClass里反射生成factory，调用工厂方法得到bean实例
	factoryClass = mbd.getBeanClass();
	isStatic = true;
}

Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
		mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
	return autowireConstructor(beanName, mbd, ctors, args);
}
return instantiateBean(beanName, mbd);

BeanWrapper bw = new BeanWrapperImpl(beanInstance);
registerCustomEditors(bw);

protected void registerCustomEditors(PropertyEditorRegistry registry) {
	PropertyEditorRegistrySupport registrySupport =
			(registry instanceof PropertyEditorRegistrySupport ? (PropertyEditorRegistrySupport) registry : null);
	if (registrySupport != null) {
		registrySupport.useConfigValueEditors();
	}
	if (!this.propertyEditorRegistrars.isEmpty()) {
		for (PropertyEditorRegistrar registrar : this.propertyEditorRegistrars) {
			try {
				// 调用beanFactory的注册器propertyEditorRegistrars，注册PropertyEditor到BeanWrapper
				registrar.registerCustomEditors(registry);
			}
			catch (BeanCreationException ex) {
				...
				throw ex;
			}
		}
	}
	if (!this.customEditors.isEmpty()) {
		this.customEditors.forEach((requiredType, editorClass) ->
				registry.registerCustomEditor(requiredType, BeanUtils.instantiateClass(editorClass)));
	}
}

protected void applyMergedBeanDefinitionPostProcessors(RootBeanDefinition mbd, Class<?> beanType, String beanName) {
	for (BeanPostProcessor bp : getBeanPostProcessors()) {
		if (bp instanceof MergedBeanDefinitionPostProcessor) {
			MergedBeanDefinitionPostProcessor bdp = (MergedBeanDefinitionPostProcessor) bp;
			bdp.postProcessMergedBeanDefinition(mbd, beanType, beanName);
		}
	}
}

boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
			isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
	// 工厂方法生成earlyReference，如果有SmartInstantiationAwareBeanPostProcessor，回调bpp得到earlyReference
	// 这就是为啥用工厂来返回earlyReference而不是直接把bean放到earlySingleton缓存的原因
	addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}

protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
	Object exposedObject = bean;
	if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
		for (BeanPostProcessor bp : getBeanPostProcessors()) {
			if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
				SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
				exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
			}
		}
	}
	return exposedObject;
}

protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
	Assert.notNull(singletonFactory, "Singleton factory must not be null");
	synchronized (this.singletonObjects) {
		if (!this.singletonObjects.containsKey(beanName)) {
			this.singletonFactories.put(beanName, singletonFactory);
			this.earlySingletonObjects.remove(beanName);
			this.registeredSingletons.add(beanName);
		}
	}
}

if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
	for (BeanPostProcessor bp : getBeanPostProcessors()) {
		if (bp instanceof InstantiationAwareBeanPostProcessor) {
			InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
			if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
				return;
			}
		}
	}
}

PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);

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;
}

protected void autowireByName(
	String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
	// 返回没有用<property>声明的引用类型属性名
	String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
	for (String propertyName : propertyNames) {
		// beanFactory是否包含bean定义或者bean已经加载并缓存在beanFactory
		if (containsBean(propertyName)) {
			Object bean = getBean(propertyName);
			pvs.add(propertyName, bean);
			registerDependentBean(propertyName, beanName);
		}
	}
}

protected void autowireByType(String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
		... ...

Object autowiredArgument = resolveDependency(desc, beanName, autowiredBeanNames, converter);
	if (autowiredArgument != null) {
		// 依赖的bean实例添加到属性
		pvs.add(propertyName, autowiredArgument);
	}
}

public Object doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName,
	@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
	... ...

// 按类型查找与之匹配的bean，如果依赖的bean已经加载完成，从BeanFactory里获取bean实例，否则只加载依赖的beanClass
	Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);
	... ...

// 如果按类型查找到超过一个可注入的bean，@Primary修饰的bean优先作为候选
	// 不存在@Primary修饰的bean，则抛异常NoUniqueBeanDefinitionException
	if (matchingBeans.size() > 1) {
		autowiredBeanName = determineAutowireCandidate(matchingBeans, descriptor);
		if (autowiredBeanName == null) {
			if (isRequired(descriptor) || !indicatesMultipleBeans(type)) {
				return descriptor.resolveNotUnique(type, matchingBeans);
			}
			else {
				// In case of an optional Collection/Map, silently ignore a non-unique case:
				// possibly it was meant to be an empty collection of multiple regular beans
				// (before 4.3 in particular when we didn't even look for collection beans).
				return null;
			}
		}
		instanceCandidate = matchingBeans.get(autowiredBeanName);
	}
	... ...

// 说明依赖的bean还未加载完成，调用BeanFactory.getBean加载bean
	// 循环依赖时，返回的是earlyBean
	if (instanceCandidate instanceof Class) {
		instanceCandidate = descriptor.resolveCandidate(autowiredBeanName, type, this);
	}
	Object result = instanceCandidate;
	... ...

return result;
}

if (hasInstAwareBpps) {
	for (BeanPostProcessor bp : getBeanPostProcessors()) {
		if (bp instanceof InstantiationAwareBeanPostProcessor) {
			InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
			// 回调`InstantiationAwareBeanPostProcessor.postProcessPropertyValues`方法修改beanDefinition.propertyValues
			// 回调`AutowiredAnnotationBeanPostProcessor`，注入@Autowired的依赖、注入计算后的@Value表达式（SPEL、环境变量占位符）的值
			pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
			if (pvs == null) {
				return;
			}
		}
	}
}

public PropertyValues postProcessPropertyValues(
	PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeanCreationException {

// 寻找使用@Value注解或者@Autowired注解的属性
	InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);
	try {
		// 解析使用@Value注解或者@Autowired注解的属性值，并赋值给bean
		metadata.inject(bean, beanName, pvs);
	}
	catch (BeanCreationException ex) {
		throw ex;
	}
	catch (Throwable ex) {
		throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", ex);
	}
	return pvs;
}

private InjectionMetadata findAutowiringMetadata(String beanName, Class<?> clazz, @Nullable PropertyValues pvs) {
	... ...

ReflectionUtils.doWithLocalFields(targetClass, field -> {
		// 寻找使用@Value注解或者@Autowired注解的属性
		AnnotationAttributes ann = findAutowiredAnnotation(field);
		if (ann != null) {
			if (Modifier.isStatic(field.getModifiers())) {
				if (logger.isWarnEnabled()) {
					logger.warn("Autowired annotation is not supported on static fields: " + field);
				}
				return;
			}
			boolean required = determineRequiredStatus(ann);
			currElements.add(new AutowiredFieldElement(field, required));
		}
	});
}

private AnnotationAttributes findAutowiredAnnotation(AccessibleObject ao) {
	if (ao.getAnnotations().length > 0) {  // autowiring annotations have to be local
		for (Class<? extends Annotation> type : this.autowiredAnnotationTypes) {
			AnnotationAttributes attributes = AnnotatedElementUtils.getMergedAnnotationAttributes(ao, type);
			if (attributes != null) {
				return attributes;
			}
		}
	}
	return null;
}

public AutowiredAnnotationBeanPostProcessor() {
	this.autowiredAnnotationTypes.add(Autowired.class);
	this.autowiredAnnotationTypes.add(Value.class);
	... ...
}

public Object resolveValueIfNecessary(Object argName, @Nullable Object value) {
	// bean的依赖引用类型在beanDefinition.propertyValues里的属性类型是RuntimeBeanReference
	if (value instanceof RuntimeBeanReference) {
		RuntimeBeanReference ref = (RuntimeBeanReference) value;
		// 如果依赖的属性是引用bean，byName从beanFactory获取bean
		return resolveReference(argName, ref);
	}
	... ...

else if (value instanceof TypedStringValue) {
		TypedStringValue typedStringValue = (TypedStringValue) value;
		// 使用beanExpressionResolver解析xml配置的表达式字面量
		// ApplicationContext给beanFactory注册的beanExpressionResolver是StandardBeanExpressionResolver，它内部使用SpelParser解析spel表达式
		Object valueObject = evaluate(typedStringValue);
		return valueObject;
	}
   }

public <T> T convertIfNecessary(@Nullable String propertyName, @Nullable Object oldValue, @Nullable Object newValue,
	@Nullable Class<T> requiredType, @Nullable TypeDescriptor typeDescriptor) throws IllegalArgumentException {
	// Custom editor for this type?
	// 寻找该类型的自定义属性编辑器
	PropertyEditor editor = this.propertyEditorRegistry.findCustomEditor(requiredType, propertyName);
	... ...

if (editor != null && !(convertedValue instanceof String)) {
		try {
			editor.setValue(convertedValue);
    		Object newConvertedValue = editor.getValue();
			if (newConvertedValue != convertedValue) {
				convertedValue = newConvertedValue;
				editor = null;
			}
		}
		catch (Exception ex) {}
	}
	if (convertedValue instanceof String) {
		if (editor != null) {
			String newTextValue = (String) convertedValue;
			return doConvertTextValue(oldValue, newTextValue, editor);
		}
		else if (String.class == requiredType) {
			returnValue = convertedValue;
		}
	}
}

private Object doConvertTextValue(@Nullable Object oldValue, String newTextValue, PropertyEditor editor) {
	try {
		editor.setValue(oldValue);
	}
	catch (Exception ex) {}
	editor.setAsText(newTextValue);
	return editor.getValue();
}

// 基于bd.pv，填充bean属性值
bw.setPropertyValues(new MutablePropertyValues(deepCopy));

private void invokeAwareMethods(String beanName, Object bean) {
	if (bean instanceof Aware) {
		if (bean instanceof BeanNameAware) {
			((BeanNameAware) bean).setBeanName(beanName);
		}
		if (bean instanceof BeanClassLoaderAware) {
			ClassLoader bcl = getBeanClassLoader();
			if (bcl != null) {
				((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
			}
		}
		if (bean instanceof BeanFactoryAware) {
			((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
		}
	}
}

public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
	throws BeansException {
	Object result = existingBean;
	for (BeanPostProcessor processor : getBeanPostProcessors()) {
		Object current = processor.postProcessBeforeInitialization(result, beanName);
		if (current == null) {
			return result;
		}
		result = current;
	}
	return result;
}

// 如果bean实现InitializingBean接口，调用bean的afterPropertiesSet方法
boolean isInitializingBean = (bean instanceof InitializingBean);
if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
	((InitializingBean) bean).afterPropertiesSet();
}

// 反射调用bean的init方法（init方法声明在bean的xml定义文件）
if (mbd != null && bean.getClass() != NullBean.class) {
	String initMethodName = mbd.getInitMethodName();
	if (StringUtils.hasLength(initMethodName) &&
			!(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
			!mbd.isExternallyManagedInitMethod(initMethodName)) {
		invokeCustomInitMethod(beanName, bean, mbd);
	}
}

public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName) throws BeansException {
	Object result = existingBean;
	for (BeanPostProcessor processor : getBeanPostProcessors()) {
		Object current = processor.postProcessAfterInitialization(result, beanName);
		if (current == null) {
			return result;
		}
		result = current;
	}
	return result;
}

if (earlySingletonExposure) {
	// 查询singletonEarlyReference
	Object earlySingletonReference = getSingleton(beanName, false);
	// earlyReference不为空说明存在循环依赖
	if (earlySingletonReference != null) {
		// exposedObject == bean 说明bean未被bpps在初始化处理时代理
		if (exposedObject == bean) {
			exposedObject = earlySingletonReference;
		}
		// bean已被代理，与earlySingletonReference不一致，依赖该bean的其他beans拿到的并不是真正的bean
		// allowRawInjectionDespiteWrapping=true表示允许这种情况，默认为false
		else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
			// 依赖当前bean的其他已加载的beans
			String[] dependentBeans = getDependentBeans(beanName);
			Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
			// 筛除typeCheckOnly加载的dependentBeans
			for (String dependentBean : dependentBeans) {
				// org.springframework.beans.factory.support.AbstractBeanFactory.getBean(java.lang.String) 方法加载bean不是typeCheckOnly
				// 所以如果依赖当前bean的其他beans是调用getBean加载的，就是actualDependentBeans了
				if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
					actualDependentBeans.add(dependentBean);
				}
			}
			// 有其他已加载的beans依赖当前bean，且当前bean已被代理，则抛异常
			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.");
			}
		}
	}
}

protected void registerDisposableBeanIfNecessary(String beanName, Object bean, RootBeanDefinition mbd) {
	AccessControlContext acc = (System.getSecurityManager() != null ? getAccessControlContext() : null);
	if (!mbd.isPrototype() && requiresDestruction(bean, mbd)) {
		if (mbd.isSingleton()) {
		registerDisposableBean(beanName,
				new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));
		}
		else {
			... ...
		}
	}
}

   protected boolean requiresDestruction(Object bean, RootBeanDefinition mbd) {
	return (bean.getClass() != NullBean.class &&
			(DisposableBeanAdapter.hasDestroyMethod(bean, mbd) || (hasDestructionAwareBeanPostProcessors() &&
					DisposableBeanAdapter.hasApplicableProcessors(bean, getBeanPostProcessors()))));
}

   public static boolean hasDestroyMethod(Object bean, RootBeanDefinition beanDefinition) {
	if (bean instanceof DisposableBean || bean instanceof AutoCloseable) {
		return true;
	}
	String destroyMethodName = beanDefinition.getDestroyMethodName();
	if (AbstractBeanDefinition.INFER_METHOD.equals(destroyMethodName)) {
		return (ClassUtils.hasMethod(bean.getClass(), CLOSE_METHOD_NAME) ||
				ClassUtils.hasMethod(bean.getClass(), SHUTDOWN_METHOD_NAME));
	}
	return StringUtils.hasLength(destroyMethodName);
}

   @Override
public void destroy() {
	if (!CollectionUtils.isEmpty(this.beanPostProcessors)) {
		for (DestructionAwareBeanPostProcessor processor : this.beanPostProcessors) {
			processor.postProcessBeforeDestruction(this.bean, this.beanName);
		}
	}

if (this.invokeDisposableBean) {
		if (logger.isDebugEnabled()) {
			logger.debug("Invoking destroy() on bean with name '" + this.beanName + "'");
		}
		try {
			if (System.getSecurityManager() != null) {
				AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
					((DisposableBean) this.bean).destroy();
					return null;
				}, this.acc);
			}
			else {
				((DisposableBean) this.bean).destroy();
			}
		}
		catch (Throwable ex) {
			String msg = "Invocation of destroy method failed on bean with name '" + this.beanName + "'";
			if (logger.isDebugEnabled()) {
				logger.warn(msg, ex);
			}
			else {
				logger.warn(msg + ": " + ex);
			}
		}
	}

if (this.destroyMethod != null) {
		invokeCustomDestroyMethod(this.destroyMethod);
	}
	else if (this.destroyMethodName != null) {
		Method methodToCall = determineDestroyMethod(this.destroyMethodName);
		if (methodToCall != null) {
			invokeCustomDestroyMethod(methodToCall);
		}
	}
}

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);
	}
}