getBean方法在BeanFactory中实现，实现的类有5个
在这5个类中AbstractBeanFactory完成了getBean()方法的具体实现
public Object getBean(String name) throws BeansException {
return doGetBean(name, null, null, false);
}
public <T> T getBean(String name, Class<T> requiredType) throws BeansException {
return doGetBean(name, requiredType, null, false);
}
public Object getBean(String name, Object... args) throws BeansException {
return doGetBean(name, null, args, false);
}
public <T> T getBean(String name, Class<T> requiredType, Object... args) throws
BeansException {
return doGetBean(name, requiredType, args, false);
}这几个方法最终调用的是doGetBean方法
protected <T> T doGetBean(final String name, final Class<T> requiredType,
final Object[] args, boolean typeCheckOnly)
throws BeansException {
//去除&符号，因为当配置文件中<bean>的class属性配置的实现类是FactoryBean时，通过 getBean()方法返回的不是FactoryBean本身，
//而是FactoryBean#getObject()方法所返回的对象，相当于FactoryBean#getObject()代理了getBean()方法，如果希望获取FactoryBean的实例，需要在beanName前加上“&”符号，即getBean("&beanName")
//在这里要获取的是bean的实例，所以要去掉&符号
final String beanName = transformedBeanName(name);
Object bean;
// Eagerly check singleton cache for manually registered singletons.
//-------------------------------------方法1------------------------------------------//
//从缓存中获取单利的bean
Object sharedInstance = getSingleton(beanName);
//-------------------------------------方法1------------------------------------------//
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 + "'");
}
}
//从已经加载的object中获取bean
//-------------------------------------方法2------------------------------------------//
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
//-------------------------------------方法2------------------------------------------//
}
else {
// Fail if we're already creating this bean instance:
// We're assumably within a circular reference.
//检查要获取的bean是不是当前线程正在创建中的bean
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
// Check if bean definition exists in this factory.
//检查当前BeanFactory的父类BeanFactory是不是不为空，并且要获取的bean不包含在当前BeanFactory中
BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
// Not found -> check parent.
//还原要获取的bean的beanName
String nameToLookup = originalBeanName(name);
//调用parentBeanFactory获取bean
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);
}
}
//typeCheckOnly默认为false
if (!typeCheckOnly) {
//如果当前bean不在正在创建中的bean的缓存集合（alreadyCreated）中，就加进去
markBeanAsCreated(beanName);
}
try {
//合并要获取的bean的属性并把属性赋值给一个RootBeanDefinition
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
//检查合并之后的RootBeanDefinition的是不是抽象的，还会检查如果获取bean的参数不空的情况下，bean的类型是singleton的就会报错，因为单利情况下bean都是一样的，只有prototype情况下才能不一致
checkMergedBeanDefinition(mbd, beanName, args);
// Guarantee initialization of beans that the current bean depends on.
//获取当前bean依赖的bean的名称的数组
String[] dependsOn = mbd.getDependsOn();
//如果依赖不为空就先加载依赖到的bean
if (dependsOn != null) {
for (String dependsOnBean : dependsOn) {
getBean(dependsOnBean);
//将要获取的bean的beanName和所依赖到的bean的beanName之间的关系缓存起来
registerDependentBean(dependsOnBean, beanName);
}
}
// Create bean instance.
//开始创建单利bean实例
if (mbd.isSingleton()) {
//--------------------------------------方法4------------------------------//
sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
public Object getObject() throws BeansException {
try {
//--------------------------------------方法3------------------------------//
return createBean(beanName, mbd, args);
//--------------------------------------方法3------------------------------//
}
catch (BeansException ex) {
// Explicitly remove instance from singleton cache: It might have been put there
// eagerly by the creation process, to allow for circular reference resolution.
// Also remove any beans that received a temporary reference to the bean.
destroySingleton(beanName);
throw ex;
}
}
});
//--------------------------------------方法4------------------------------//
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
//不是单例的情况
else if (mbd.isPrototype()) {
// It's a prototype -> create a new instance.
Object prototypeInstance = null;
try {
//将需要创建的bean的beanName放到ThreadLocal中
beforePrototypeCreation(beanName);
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
//将需要创建的bean的beanName从ThreadLocal中移除
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 '" + scopeName + "'");
}
try {
Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() {
public Object getObject() throws BeansException {
//将需要创建的bean的beanName放到ThreadLocal中
beforePrototypeCreation(beanName);
try {
return createBean(beanName, mbd, args);
}
finally {
//将需要创建的bean的beanName从ThreadLocal中移除
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;
}
}
// Check if required type matches the type of the actual bean instance.
if (requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) {
try {
return getTypeConverter().convertIfNecessary(bean, requiredType);
}
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. getSingleton方法DefaultSingletonBeanRegistry类中，代码如下
public Object getSingleton(String beanName) {
return getSingleton(beanName, true);
}
//具体实现
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
//在已经注册了的单例map集合（singletonObjects）中获取特定beanName的bean
Object singletonObject = this.singletonObjects.get(beanName);
//检查这个bean是不是null，并且这个bean不在正在创建中的bean的map缓存
（singletonsCurrentlyInCreation）中
if(singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
synchronized (this.singletonObjects) {
//从已经缓存了的单利对象集合中获取beanName对应的Bean
singletonObject = this.earlySingletonObjects.get(beanName);
//如果不存在，并且允许早期引用当前创建的对象
if(singletonObject == null && allowEarlyReference) {
//根据beanName获取在可以在调用时返回单例Object实例）的工厂。
ObjectFactory<?> singletonFactory =
this.singletonFactories.get(beanName);
//如果返回的工厂不为空就把对应的beanName放到earlySingletonObjects中，并移除singletonFactories中的值
if (singletonFactory != null) {
singletonObject = singletonFactory.getObject();
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
}
//如果获取到的对象是空，就返回null
return (singletonObject != NULL_OBJECT ? singletonObject : null);
}单例在Spring的同一个容器内只会被创建一次，后续在获取bean，就直接从单例缓存中获取了。这里也只是尝试获取，首先尝试从缓存中加载，如果加载不成功则再次尝试从singletonFactories中加载。因为在创建单例bean 的时候会存在依赖注入的情况，而在创建依赖的时候为了避免循环依赖，在Spring中创建bean 的原则是不等bean创建完就会将创建bean 的ObjectFactory提早曝光加入到缓存中，一旦下一个bean创建时候需要依赖上一个bean则直接使用ObjectFactory。
2. getObjectForBeanInstance方法AbstractBeanFactory中
//name：getBean方法传入的name，beanName：处理过后的name，mbd：null
protected Object getObjectForBeanInstance(Object beanInstance, String name,
String beanName, RootBeanDefinition mbd) {
// Don't let calling code try to dereference the factory if the bean isn't a factory.
//如果要获取的bean是FactoryBean的引用，并且缓存的对象不是FactoryBean类型。意思就是要获取的bean实现了FactoryBean（属于工厂），但是获取的实例又不是FactoryBean类型的抛错。bean是否是工厂是由它是否实现FactoryBean接口决定的
if (BeanFactoryUtils.isFactoryDereference(name)
&& !(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.
//如果创建实例不是FactoryBean实例，或者是factoryBean的引用
if (!(beanInstance instanceof FactoryBean) ||
BeanFactoryUtils.isFactoryDereference(name)) {
return beanInstance;
}
Object object = null;
//根据处理过的beanName获取FactoryBean，上面方法传进来的mbd为null
if (mbd == null) {
object = getCachedObjectForFactoryBean(beanName);
}
//如果获取到的FactoryBean为空，说明这个bean没有实现FactoryBean接口
if (object == null) {
// Return bean instance from factory.
FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
// Caches object obtained from FactoryBean if it is a singleton.
//如果bean已经加载过，则获取合并过后的RootBeanDefinition
if (mbd == null && containsBeanDefinition(beanName)) {
//-----------------------------------------合并父类和子类bean------------------------------------------------------//
mbd = getMergedLocalBeanDefinition(beanName);
//-----------------------------------------------------------------------------------------------//
}
boolean synthetic = (mbd != null && mbd.isSynthetic());
object = getObjectFromFactoryBean(factory, beanName, !synthetic);
}
return object;
}
//合并父类和子类bean 的方法
//第一步
protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws
BeansException {
// Quick check on the concurrent map first, with minimal locking.
//根据beanName检查是否存在已经合并过的bean
RootBeanDefinition mbd = this.mergedBeanDefinitions.get(beanName);
if (mbd != null) {
return mbd;
}
return getMergedBeanDefinition(beanName, getBeanDefinition(beanName));
}
//第二步
protected RootBeanDefinition getMergedBeanDefinition(String beanName,
BeanDefinition bd) throws BeanDefinitionStoreException {
return getMergedBeanDefinition(beanName, bd, null);
}//第三步
//containingBd null
protected RootBeanDefinition getMergedBeanDefinition(String beanName,
BeanDefinition bd, BeanDefinition containingBd) throws
BeanDefinitionStoreException {
synchronized (this.mergedBeanDefinitions) {
RootBeanDefinition mbd = null;
// Check with full lock now in order to enforce the same merged instance.
//通过beanName检查是否已经存在合并过的BeanDefinition
if (containingBd == null) {
mbd = this.mergedBeanDefinitions.get(beanName);
}
if (mbd == null) {
//查看是否存在父bean
if (bd.getParentName() == null) {
// Use copy of given root bean definition.
//如果不存在父bean，并且是RootBeanDefinition类型的bean，就复制一份
RootBeanDefinition并设置给mbd
if (bd instanceof RootBeanDefinition) {
mbd = ((RootBeanDefinition) bd).cloneBeanDefinition();
}
//如果不是就把bd中的值复制mbd
else {
mbd = new RootBeanDefinition(bd);
}
}else {
// Child bean definition: needs to be merged with parent.
//如果这个bean是一个子bean，就需要跟父bean进行合并
BeanDefinition pbd;
try {
//处理父bean的beanName
String parentBeanName = transformedBeanName(bd.getParentName());
//如果要过去的bean的beanName于父类的不一样，就行合并
if (!beanName.equals(parentBeanName)) {
//此方法最终调用的还是getMergedBeanDefinition方法
pbd = getMergedBeanDefinition(parentBeanName);
} else {
if (getParentBeanFactory() instanceof
ConfigurableBeanFactory) {
pbd = ((ConfigurableBeanFactory) getParentBeanFactory()).getMergedBeanDefinition(parentBeanName);
}else {
throw new NoSuchBeanDefinitionException(
bd.getParentName(),"Parent name '" + bd.getParentName() + "' is
equal to bean name '" + beanName +
"': cannot be resolved without an AbstractBeanFactory parent");
}
}
}catch (NoSuchBeanDefinitionException ex) {
throw new BeanDefinitionStoreException(
bd.getResourceDescription(), beanName,
"Could not resolve parent bean definition '"
+ bd.getParentName() + "'", ex);
}
// Deep copy with overridden values.
//复制合并之后的属性到要返回的RootBeanDefinition中
mbd = new RootBeanDefinition(pbd);
//将传入的BeanDefinition的属性复制一遍到新的RootBeanDefinition中
mbd.overrideFrom(bd);
}
// Set default singleton scope, if not configured before.
//设置是否单利的
if (!StringUtils.hasLength(mbd.getScope())) {
mbd.setScope(RootBeanDefinition.SCOPE_SINGLETON);
}
// A bean contained in a non-singleton bean cannot be a singleton itself.
// Let's correct this on the fly here, since this might be the result of
// parent-child merging for the outer bean, in which case the original inner bean
// definition will not have inherited the merged outer bean's singleton status.
//如果外部的bean不是单利的，但是合并之后的bean是单利的那么就将合并之后的按照外部的bean的单利情况来设定
if (containingBd != null && !containingBd.isSingleton() &&
mbd.isSingleton()) {
mbd.setScope(containingBd.getScope());
}
// Only cache the merged bean definition if we're already about to create an
// instance of the bean, or at least have already created an instance before.
//保存到缓存中
if (containingBd == null && isCacheBeanMetadata() &&
isBeanEligibleForMetadataCaching(beanName)) {
this.mergedBeanDefinitions.put(beanName, mbd);
}
}
return mbd；
}如果从缓存中得到了bean的原始状态，则需要对bean进行实例化。缓存中记录的只是最原始的bean状态，并不一定是我们最终想要的bean。
假如我们需要对工厂bean进行处理，那么这里得到的其实是工厂bean的初始状态，但是我们正真需要的是工程bean中定义的factory-method方法中返回的bean，而getObjectForBeanInstance就是完成这个工作的
3. 获取单例对象时候调用DefaultSingletonBeanRegistry类getSingleton方法的第二个参数ObjectFactory实现了ObjectFactory接口的getObject方法，调用的createBean方法，createBean方法在AbstractBeanFactory类中定义，具体实现在AbstractAutowireCapableBeanFactory类中实现
protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args)
throws BeanCreationException {
if (logger.isDebugEnabled()) {
logger.debug("Creating instance of bean '" + beanName + "'");
}
// 确保此时实际解析了bean类
//-----------------------------------------------方法1-----------------------------------------------//
resolveBeanClass(mbd, beanName);
//-----------------------------------------------方法1-----------------------------------------------//
// Prepare method overrides.
try {
mbd.prepareMethodOverrides();
}catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(mbd.getResourceDescription(),
beanName, "Validation of method overrides failed", ex);
}
try {
// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
//-----------------------------------------------方法2-----------------------------------------------//
//如果bean实现了实例化前处理器接口的，则需要在实例化之前调用这个方法
//bean的生命周期的中实现了InstantiationAwareBeanPostProcessor会在这里调用实现的postProcessBeforeInstantiation
Object bean = resolveBeforeInstantiation(beanName, mbd);
//-----------------------------------------------方法2-----------------------------------------------//
if (bean != null) {
return bean;
}
}catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"BeanPostProcessor before instantiation of bean failed", ex);
}
//-----------------------------------------------方法3-----------------------------------------------//
Object beanInstance = doCreateBean(beanName, mbd, args);
//-----------------------------------------------方法3-----------------------------------------------//
if (logger.isDebugEnabled()) {
logger.debug("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
}方法1：resolveBeanClass在AbstractBeanFactory中定义
protected Class<?> resolveBeanClass(final RootBeanDefinition mbd, String beanName, final Class<?>... typesToMatch)
throws CannotLoadBeanClassException {
try {
//如果传入的RootBeanDefinition已经解析过，就直接返回RootBeanDefinition对象中的beanCalss
if (mbd.hasBeanClass()) {
return mbd.getBeanClass();
}
//不管能不能获取系统安全性都去获取RootBeanDefinition对象中的class
if (System.getSecurityManager() != null) {
return AccessController.doPrivileged(new PrivilegedExceptionAction<Class<?>>() {
public Class<?> run() throws Exception {
return 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);
}
方法2resolveBeforeInstantiation在AbstractAutowireCapableBeanFactory中定义
protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
Object bean = null;
//beforeInstantiationResolved默认为false
if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
// Make sure bean class is actually resolved at this point.
//检查这个bean是不是存在beanClass，是不是不是合成的，是否实现了InstantiationAwareBeanPostProcessor（bean实例化之后但在设置显式属性或自动装配之前的处理）接口
if (mbd.hasBeanClass() && !mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
//--------------------------方法1-------------------------//
bean = applyBeanPostProcessorsBeforeInstantiation(mbd.getBeanClass(), beanName);
//--------------------------方法1-------------------------//
if (bean != null) {
//--------------------------方法2-------------------------//
//挨个调用postProcessAfterInitialization方法
bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
//--------------------------方法2-------------------------//
}
}
mbd.beforeInstantiationResolved = (bean != null);
}
return bean;
}
//--------------------------方法1-------------------------//
protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName)
throws BeansException {
//获取这个bean的所有BeanPostProcessor
for (BeanPostProcessor bp : getBeanPostProcessors()) {
//如果是InstantiationAwareBeanPostProcessor类型的，就调用实现的方法
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
//调用实现的postProcessBeforeInstantiation方法
Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
if (result != null) {
return result;
}
}
}
return null;
}
//--------------------------方法2-------------------------//
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
throws BeansException {
Object result = existingBean;
for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
result = beanProcessor.postProcessAfterInitialization(result, beanName);
if (result == null) {
return result;
}
}
return result;
}4.public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) 方法
这个方法与上面的getSingleton不同之处在于这个方法是在创建了bean对象，并初始化之后调用的，作用是从bean对象中获取单例的bean同时放到单例缓存中
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(beanName, "'beanName' must not be null");
synchronized (this.singletonObjects) {
//在已经注册了的单例map集合（singletonObjects）中获取特定beanName的bean
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
if (this.singletonsCurrentlyInDestruction) {
throw new BeanCreationNotAllowedException(beanName,
"Singleton bean creation not allowed while the singletons of this factory are in destruction " +
"(Do not request a bean from a BeanFactory in a destroy method implementation!)");
}
if (logger.isDebugEnabled()) {
logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
}
//singletonObjects中获取不到bean的时候，说明是新创建的bean，这个时候需要先检查满足其中一个
//1.当前创建检查中排除的beanName集合中包含这个创建中的单例beanName
//2.当前正在创建的单例beanName集合中不包含这个单例bean的beanName
beforeSingletonCreation(beanName);
boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
if (recordSuppressedExceptions) {
this.suppressedExceptions = new LinkedHashSet<Exception>();
}
try {
//从创建的bean中获取bean对象
singletonObject = singletonFactory.getObject();
}
catch (BeanCreationException ex) {
if (recordSuppressedExceptions) {
for (Exception suppressedException : this.suppressedExceptions) {
ex.addRelatedCause(suppressedException);
}
}
throw ex;
}
finally {
if (recordSuppressedExceptions) {
this.suppressedExceptions = null;
}
//从当前正在创建的单例beanName集合中删除当前的beanName
afterSingletonCreation(beanName);
}
//加入到单例缓存中
addSingleton(beanName, singletonObject);
}
//返回单例对象
return (singletonObject != NULL_OBJECT ? singletonObject : null);
}
}
7855
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
