spring-framework源码阅读——bean的加载
先来看看我们的测试代码
ClassPathResource classPathResource = new ClassPathResource("beanFactoryTest.xml");
DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(factory);
reader.loadBeanDefinitions(classPathResource);
MyTestBean bean = (MyTestBean) factory.getBean("myTestBean");
bean的加载主要是MyTestBean bean = (MyTestBean) factory.getBean(“myTestBean”)。这个方法在AbstractBeanFactory这个类中，我们来看看这个方法，这里我为了节省空间，删掉了一些logger和异常。
public Object getBean(String name) throws BeansException {
return doGetBean(name, null, null, false);
}
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
//1.转换对应的beanName
final String beanName = transformedBeanName(name);
Object bean;
//2.尝试从缓存中加载单例
// Eagerly check singleton cache for manually registered singletons.
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
//3.从缓存中拿到的是初始bean，要对bean进行实例化
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
else {
// Fail if we're already creating this bean instance:
// We're assumably within a circular reference.
//4.多半是产生了循环依赖，原型模式不允许循环依赖，如果当前bean是原型模式，抛出异常
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
// Check if bean definition exists in this factory.
//5.检查当前工厂是否有 bean definition，如果没有，就去父类工厂找
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) {
markBeanAsCreated(beanName);
}
try {
//6.将xml配置文件的GenericBeanDefinition转换为RootBeanDefinition
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
checkMergedBeanDefinition(mbd, beanName, args);
// Guarantee initialization of beans that the current bean depends on.
String[] dependsOn = mbd.getDependsOn();
//7.寻找依赖，若存在依赖则要递归地实例化依赖的bean
if (dependsOn != null) {
for (String dep : dependsOn) {
if (isDependent(beanName, dep)) {
throw new BeanCreationException();
}
registerDependentBean(dep, beanName);
try {
getBean(dep);
}
catch (NoSuchBeanDefinitionException ex) {
throw new BeanCreationException();
}
}
}
// Create bean instance.
//8.根据不同的scope进行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);
}
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();
final Scope scope = this.scopes.get(scopeName);
if (scope == null) {
throw new IllegalStateException();
}
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) {
cleanupAfterBeanCreationFailure(beanName);
throw ex;
}
}
// Check if required type matches the type of the actual bean instance.
//9.类型转换
if (requiredType != null && !requiredType.isInstance(bean)) {
try {
T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
if (convertedBean == null) {
throw new BeanNotOfRequiredTypeException();
}
return convertedBean;
}
catch (TypeMismatchException ex) {
}
}
return (T) bean;
}
下面我们按顺序来看一下具体的过程
1.转换对应的beanName
final String beanName = transformedBeanName(name)。
beanName一般来说就是我们传进去的name，但是如果是类似FactoryBean，name=“&person”，那么beanName要去掉前缀&，name就是person。
如果参数name是个别名，那么要转换成别名最终指向的beanName，如果别名A指向别名B，别名B又指向名称为C的bean，则最终返回的名字是C
2.尝试从缓存中加载单例
Object sharedInstance = getSingleton(beanName)
public Object getSingleton(String beanName) {
return getSingleton(beanName, true);
}
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();
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
}
return singletonObject;
}
spring中如果是单例模式，那么这个对象的实例就不会重复创建，如果已经创建了，只需从缓存中取出。
所以这里先尝试从缓存singletonObjects中加载实例，如果没有的话，判断是否是在创建单例bean，如果是单例的话，尝试从earlySingletonObjects中加载实例。
如果也没有的话再从singletonFactories中获取ObjectFactory，如果ObjectFactory存在，就调用ObjectFactory的getObject方法来创建bean，如果上述都没有的话，就返回null
前面提到的这几个变量都是map，简单介绍一下这些map
- singletonObjects：缓存单例对象，bean name 对应 bean instance
- earlySingletonObjects：缓存早期的单例对象，也是bean name 对应 bean instance，和singletonObjects的区别在于singletonObjects中的bean实例是完整的实例，这里的bean实例只是一个初始的bean，这主要是为了解决循环依赖
- singletonFactory：缓存单例的创建bean的工厂，bean name 对应 ObjectFactory
3.从缓存中拿到的是初始bean，要对bean进行实例化
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
这个方法主要对FactoryBean对象进行处理，如果名字以&开头，代表用户要得到的是FactoryBean的实例，否则，代表要获取FactoryBean创建出来的实例。
protected Object getObjectForBeanInstance(
Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {
// Don't let calling code try to dereference the factory if the bean isn't a factory.
//isFactoryDereference方法里面只判断了name是否以&开头
if (BeanFactoryUtils.isFactoryDereference(name)) {
if (beanInstance instanceof NullBean) {
return beanInstance;
}
if (!(beanInstance instanceof FactoryBean)) {
throw new BeanIsNotAFactoryException(transformedBeanName(name), beanInstance.getClass());
}
}
// Now we have the bean instance, which may be a normal bean or a FactoryBean.
// If it's a FactoryBean, we use it to create a bean instance, unless the
// caller actually wants a reference to the factory.
//如果是beanInstance是一个普通bean，我们直接返回这个bean，如果是FactoryBean，并且
//name以&开头的话，用户需要的是FactoryBean本身，我们也只需直接返回这个bean
if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
return beanInstance;
}
//到这里就表示beanInstance是FactoryBean，并且用户需要的是FactoryBean创建出来的bean
Object object = null;
if (mbd == null) {
//尝试从缓存中加载bean
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)) {
//返回合并的RootBeanDefinition，主要对于bean中还有子bean的情况
mbd = getMergedLocalBeanDefinition(beanName);
}
//是否是用户定义的而不是应用程序本身定义的
boolean synthetic = (mbd != null && mbd.isSynthetic());
//从FactoryBean获取其创建的实例
object = getObjectFromFactoryBean(factory, beanName, !synthetic);
}
return object;
}
这里我们主要来看看如何从FactoryBean获取实例的。进入object = getObjectFromFactoryBean(factory, beanName, !synthetic)查看。
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;
}
}
先来看一下beforeSingletonCreation和afterSingletonCreation：
protected void beforeSingletonCreation(String beanName) {
if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
}
这里主要是this.singletonsCurrentlyInCreation.add(beanName)这个动作：记录加载状态，将正要创建的bean记录在缓存中，这样便可以对循环依赖进行检测。
protected void afterSingletonCreation(String beanName) {
if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.remove(beanName)) {
throw new IllegalStateException("Singleton '" + beanName + "' isn't currently in creation");
}
}
和前面类似，当bean加载结束后需要移除缓存中对bean的正在加载状态的记录。
除了这些，这段代码主要的就是doGetObjectFromFactoryBean方法和postProcessObjectFromFactoryBean方法，我们先来看看doGetObjectFromFactoryBean，这个方法主要就是调用factory.getObject()来创建实例的。
private Object doGetObjectFromFactoryBean(final FactoryBean<?> factory, final String beanName)
throws BeanCreationException {
Object object;
try {
//需要权限验证
if (System.getSecurityManager() != null) {
AccessControlContext acc = getAccessControlContext();
try {
object = AccessController.doPrivileged((PrivilegedExceptionAction<Object>) factory::getObject, acc);
}
catch (PrivilegedActionException pae) {
throw pae.getException();
}
}
else {
object = factory.getObject();
}
}
catch (FactoryBeanNotInitializedException ex) {
throw new BeanCurrentlyInCreationException(beanName, ex.toString());
......
}
// Do not accept a null value for a FactoryBean that's not fully
// initialized yet: Many FactoryBeans just return null then.
if (object == null) {
if (isSingletonCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(
beanName, "FactoryBean which is currently in creation returned null from getObject");
}
object = new NullBean();
}
return object;
}
这里的postProcessObjectFromFactoryBean方法在这里其实只是简单地返回了这个对象，没有做什么处理。如果需要可以用子类继承来实现。
4.原型模式的依赖检查
只有在单例情况下才会尝试解决循环依赖，但是如果是原型情况，则不允许循环依赖，会直接报错。
5.检测父类工厂是否有bean Definition
如果缓存没有数据，并且当前加载的xml配置文件不包含beanName所对应的配置，就会到parentBeanFactory去尝试下，然后再去递归地调用getBean方法。
6.将xml配置文件的GenericBeanDefinition转换为RootBeanDefinition
从xml配置文件中读取到的bean信息是存储在GenericBeanDefinition中的，通过getMergedLocalBeanDefinition方法将其转换成RootBeanDefinition，如果当前bean有父类bean，则要把所有信息合并在一起，用RootBeanDefinition保存所有的信息。
7.寻找依赖，递归地实例化依赖的bean
因为bean的初始化过程可能用到某些属性，有些属性可能会依赖于其他的bean，那么这时候就需要先加载依赖的bean，所以在初始化一个bean的时候首先会初始化这个bean对应的依赖
8.根据不同的scope进行bean的创建
来看看单例的获取。来看看代码是怎么调用的
sharedInstance = getSingleton(beanName, () -> {
try {
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
......
}
});
这里是用了回调方法，使得程序可以在单例创建的前后做一些准备和处理,来看一下做了哪些处理。
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(beanName, "Bean name must not be null");
synchronized (this.singletonObjects) {
//由于是单例，所以先尝试从缓存中获取，如果获取到了就不需要创建了
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
//如果缓存没有才进行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!)");
}
//创建前处理
beforeSingletonCreation(beanName);
boolean newSingleton = false;
boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
if (recordSuppressedExceptions) {
this.suppressedExceptions = new LinkedHashSet<>();
}
try {
//获取实例
singletonObject = singletonFactory.getObject();
newSingleton = true;
}
catch (IllegalStateException ex) {
......
}
catch (BeanCreationException ex) {
......
throw ex;
}
finally {
if (recordSuppressedExceptions) {
this.suppressedExceptions = null;
}
//创建后处理
afterSingletonCreation(beanName);
}
if (newSingleton) {
addSingleton(beanName, singletonObject);
}
}
return singletonObject;
}
}
beforeSingletonCreation和afterSingletonCreation我们在前面已经提到过了。
来看一下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);
}
}
将结果记录到缓存并删除加载bean过程中记录的各种中间状态。
singletonObject = singletonFactory.getObject()这句代码中的singletonFactory就是我们前面lambda表达式传入的参数
sharedInstance = getSingleton(beanName, () -> {
try {
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
......
}
});
所以真正的获取bean的方法是在ObjectFactory类型的实例singletonFactory中实现的。
所以在这里调用ObjectFactory的getObject()方法，就进入到了return createBean(beanName, mbd, args)中
@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
RootBeanDefinition mbdToUse = mbd;
// Make sure bean class is actually resolved at this point, and
// clone the bean definition in case of a dynamically resolved Class
// which cannot be stored in the shared merged bean definition.
//根据给的bean befinition来解析class
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
// Prepare method overrides.
//验证及准备覆盖的方法，检查是否存在这个方法
try {
mbdToUse.prepareMethodOverrides();
}
catch (BeanDefinitionValidationException ex) {
......
}
try {
// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
// 给BeanPostProcessors一个机会来返回代理来替代真正的实例
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
return bean;
}
}
catch (Throwable ex) {
throw new BeanCreationException(......);
}
try {
// 以do开头，我们就知道是创建bean的真正的逻辑实现
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
return beanInstance;
}
catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
......
}
catch (Throwable ex) {
throw new BeanCreationException(......);
}
}
- prepareMethodOverrides方法是对override属性进行验证和准备。spring配置中存在lookup-method和replaced-method，这两个配置的加载都是统一放到BeanDefinition中的methodOverride属性中。在bean实例化过程中，如果有methodOverride属性，会动态地为当前bean生成代理并使用对应的拦截器为bean做增强处理。
- resolveBeforeInstantiation，解析当前bean是否有短路的实例，如果有，我们就直接返回这个bean，没有的话，就返回null
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.
// 判断 工厂是否持有InstantiationAwareBeanPostProcessor属性
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
// 获取这个bean的目标类型
Class<?> targetType = determineTargetType(beanName, mbd);
if (targetType != null) {
bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
if (bean != null) {
bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
}
}
}
mbd.beforeInstantiationResolved = (bean != null);
}
return bean;
}
再来看看applyBeanPostProcessorsBeforeInstantiation和applyBeanPostProcessorsAfterInitialization方法
protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
if (result != null) {
return result;
}
}
}
return null;
}
applyBeanPostProcessorsBeforeInstantiation方法对后处理器中的InstantiationAwareBeanPostProcessor类型的处理器进行postProcessBeforeInstantiation方法的调用。如果返回了一个实例，则用这个实例替代原来的目标实例。
@Override
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;
}
如果前面applyBeanPostProcessorsBeforeInstantiation返回了一个不为null的实例，我们知道这个实例会替代原来的实例来使用，所以需要对这个实例进行后处理。
如果前面我们没有得到实例，那么就需要自己创造了。
- 创建bean。我们来看看真正的创建bean的逻辑实现——doCreateBean方法
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {
// Instantiate the bean.
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
//如果是单例则尝试中从缓存中加载factoryBean实例
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
// 根据指定的bean使用对应的策略创建新的实例，如：工厂方法、构造函数自动注入、简单初始化
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
final Object bean = instanceWrapper.getWrappedInstance();
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
// Allow post-processors to modify the merged bean definition.
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;
}
}
// 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) {
if (logger.isTraceEnabled()) {
logger.trace("Eagerly caching bean '" + beanName +
"' to allow for resolving potential circular references");
}
//为避免后期循环依赖，可以在bean初始化完成前先将创建实例的objectFactory加入工厂
//getEarlyBeanReference方法对bean进行依赖引用，主要是用 //SmartInstantiationAwareBeanPostProcessor类型的处理器的getEarlyBeanReference方法
//AOP就是在这里将advice动态织入bean中，若没有则直接返回bean。
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
// Initialize the bean instance.
Object exposedObject = bean;
try {
//对bean进行填充，将各个属性值注入，如果存在依赖其他bean的属性，则递归初始化依赖的bean
populateBean(beanName, mbd, instanceWrapper);
//调用初始化方法，比如init-method
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
catch (Throwable ex) {
......
}
if (earlySingletonExposure) {
Object earlySingletonReference = getSingleton(beanName, false);
//用循环依赖的话earlySingletonReference就不为空
if (earlySingletonReference != null) {
//如果exposedObject在初始化方法中没有改变，也就是没有增强
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);
}
}
//如果不为空表示当前bean所依赖的bean没有全部创建出来
if (!actualDependentBeans.isEmpty()) {
throw new BeanCurrentlyInCreationException(......);
}
}
}
}
// Register bean as disposable.
try {
// 根据scope注册bean
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
return exposedObject;
}
doCreateBean方法完全可以单独写一篇文章细讲了，里面的各个方法都做了很多大量并且细致的工作，很多函数逻辑很复杂，代码量很大，这里就不细讲了，
9.类型转换
有时候返回的bean是一个Sring类型的，但是requireType却是Integer类型的，所以需要将bean转换成指定的类型，当然String转为Integer只是一个最简单的一种转换，spring提供了各种各样的转换器，用户也可以自定义转换器来满足需求。
