本文要分析的方法:
1.getSingleton(beanName)从单例缓存中取值
2.getObjectForBeanInstance(sharedInstance, name, beanName, null)获取一个普通的bean或FactoryBean
3.isPrototypeCurrentlyInCreation(beanName)判断是否正在创建beanName的实例,是则报错
4.getParentBeanFactory()检查BeanFactory中是否已经有了bean,但此时的parentBeanFactory 应该是null
5.markBeanAsCreated(beanName)判断是否只是类型检查,如果不是则把beanName放入标识为已创建bean的set集合中
6.getMergedLocalBeanDefinition(beanName)获取bean定义
7.checkMergedBeanDefinition检查bean定义是否是抽象类,是则报错
8.getDependsOn取出bean的依赖,如@autowired修饰的成员变量
9.isDependent(beanName, dependsOnBean)判断是否多次依赖
10.registerDependentBean(dependsOnBean, beanName)把依赖bean放入dependentBeanMap,dependenciesForBeanMap中
11.getBean(dependsOnBean)获取依赖的bean实例
1.getSingleton(beanName)从单例缓存中取值
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
//从singletonObjects缓存中取
Object singletonObject = this.singletonObjects.get(beanName);
//没取到的话,判断singletonsCurrentlyInCreation是否有beanName
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
synchronized (this.singletonObjects) {
//从earlySingletonObjects缓存中取
singletonObject = this.earlySingletonObjects.get(beanName);
//没取到,判断allowEarlyReference的值
if (singletonObject == null && allowEarlyReference) {
//从singletonFactories中取
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
//取到了把singletonObject放入earlySingletonObjects并从singletonFactories移除
if (singletonFactory != null) {
singletonObject = singletonFactory.getObject();
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
}
return (singletonObject != NULL_OBJECT ? singletonObject : null);
}
此方法完成功能:
1.从singletonObjects缓存中取
2.没取到的话,判断singletonsCurrentlyInCreation是否有beanName
3.从earlySingletonObjects缓存中取
4.没取到,判断allowEarlyReference的值
5.从singletonFactories中取
6.取到了把singletonObject放入earlySingletonObjects并从singletonFactories移除
singletonObjects作用:储存已创建的单例bean,但不包括非懒加载bean和factorybean
earlySingletonObjects作用:储存非懒加载bean和factorybean
singletonFactories作用储存factoryBean
2.getObjectForBeanInstance(sharedInstance, name, beanName, null)获取一个普通的bean或FactoryBean
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.
//是一个废弃的Factory并且不是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.
是一个废弃的Factory或不是FactoryBean的子类则报错,直接返回实例
if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
return beanInstance;
}
Object object = null;
//如果bean定义为null,则从factoryBeanObjectCache取缓存
if (mbd == null) {
object = getCachedObjectForFactoryBean(beanName);
}
//如果没有,通过 getObjectFromFactoryBean(factory, beanName, !synthetic)方法取。
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)) {
mbd = getMergedLocalBeanDefinition(beanName);
}
boolean synthetic = (mbd != null && mbd.isSynthetic());
object = getObjectFromFactoryBean(factory, beanName, !synthetic);
}
return object;
}
此方法完成的功能:
1.是一个废弃的Factory并且不是FactoryBean的子类则报错
2.如果bean定义为null,则从factoryBeanObjectCache取缓存
3.如果没有,通过 getObjectFromFactoryBean(factory, beanName, !synthetic)方法取。
2.1getObjectFromFactoryBean(factory, beanName, !synthetic)方法:
protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
//factory是单例并且singletonObjects含有beanName的key
if (factory.isSingleton() && containsSingleton(beanName)) {
synchronized (getSingletonMutex()) {
//从factoryBeanObjectCache中获取beanName的缓存
Object object = this.factoryBeanObjectCache.get(beanName);
//没取到,通过doGetObjectFromFactoryBean获取
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)
//从factoryBeanObjectCache取值,取到直接返回取到值
Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
if (alreadyThere != null) {
object = alreadyThere;
}
else {
//没取到且object 且shouldPostProcess为true,执行postProcessObjectFromFactoryBean方法
//获取,并放入factoryBeanObjectCache缓存中
if (object != null && shouldPostProcess) {
try {
object = postProcessObjectFromFactoryBean(object, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(beanName,
"Post-processing of FactoryBean's singleton object failed", ex);
}
}
this.factoryBeanObjectCache.put(beanName, (object != null ? object : NULL_OBJECT));
}
}
return (object != NULL_OBJECT ? object : null);
}
}
else {
Object object = doGetObjectFromFactoryBean(factory, beanName);
if (object != null && shouldPostProcess) {
try {
object = postProcessObjectFromFactoryBean(object, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex);
}
}
return object;
}
}
此方法完成的功能:
1.factory是单例并且singletonObjects含有beanName的key
2.从factoryBeanObjectCache中获取beanName的缓存
3.没取到,通过doGetObjectFromFactoryBean方法获取
4.从factoryBeanObjectCache取值,取到直接返回取到值
5.没取到且object 且shouldPostProcess为true,执行postProcessObjectFromFactoryBean方法,获取,并放入factoryBeanObjectCache缓存中
2.1.1没取到,通过doGetObjectFromFactoryBean方法获取
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(new PrivilegedExceptionAction<Object>() {
@Override
public Object run() throws Exception {
return factory.getObject();
}
}, acc);
}
catch (PrivilegedActionException pae) {
throw pae.getException();
}
}
else {
object = factory.getObject();
}
}
catch (FactoryBeanNotInitializedException ex) {
throw new BeanCurrentlyInCreationException(beanName, ex.toString());
}
catch (Throwable ex) {
throw new BeanCreationException(beanName, "FactoryBean threw exception on object creation", ex);
}
// Do not accept a null value for a FactoryBean that's not fully
// initialized yet: Many FactoryBeans just return null then.
if (object == null && isSingletonCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(
beanName, "FactoryBean which is currently in creation returned null from getObject");
}
return object;
}
主要是执行factory.getObject();方法。
2.1.5.没取到且object 且shouldPostProcess为true,执行postProcessObjectFromFactoryBean方法,获取,并放入factoryBeanObjectCache缓存中
protected Object postProcessObjectFromFactoryBean(Object object, String beanName) {
return applyBeanPostProcessorsAfterInitialization(object, beanName);
}
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;
}
这里主要执行了了bean的后处理器中postProcessAfterInitialization方法。BeanPostProcessor 是在之前文章中refresh()方法放进去的。
此时getBean方法的前俩步就分析完了。总结一下:
先从单例缓存中取实例,取到之后判断是普通bean还是factoryBean,如果是普通则直接返回实例,如果是factoryBean则调用factory.getObeject方法返回实例。
接下来继续分析没有创建实例或不是单例的情况。
3.isPrototypeCurrentlyInCreation(beanName)判断是否正在创建beanName的实例,是则报错
protected boolean isPrototypeCurrentlyInCreation(String beanName) {
Object curVal = this.prototypesCurrentlyInCreation.get();
return (curVal != null &&
(curVal.equals(beanName) || (curVal instanceof Set && ((Set<?>) curVal).contains(beanName))));
}
此方法判断了类型为prototype的bean是否正在创建,在创建则报错
4.getParentBeanFactory()检查BeanFactory中是否已经有了bean,但此时的parentBeanFactory 应该是null
5.markBeanAsCreated(beanName)判断是否只是类型检查,如果不是则把beanName放入标识为已创建bean的set集合中
protected void markBeanAsCreated(String beanName) {
if (!this.alreadyCreated.contains(beanName)) {
this.alreadyCreated.add(beanName);
}
}
6.getMergedLocalBeanDefinition(beanName)获取bean定义
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));
}
先从mergedBeanDefinitions缓存里面取,没有则到getMergedBeanDefinition方法里取。
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.
//从mergedBeanDefinitions缓存中取
if (containingBd == null) {
mbd = this.mergedBeanDefinitions.get(beanName);
}
//没取到,如果没有父bean,那么此bean为rootbean
if (mbd == null) {
if (bd.getParentName() == null) {
// Use copy of given root bean definition.
if (bd instanceof RootBeanDefinition) {
mbd = ((RootBeanDefinition) bd).cloneBeanDefinition();
}
else {
mbd = new RootBeanDefinition(bd);
}
}
//没取到且有父bean,创建父BeanDefinition,并做好重写的关联关系
else {
// Child bean definition: needs to be merged with parent.
BeanDefinition pbd;
try {
String parentBeanName = transformedBeanName(bd.getParentName());
if (!beanName.equals(parentBeanName)) {
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.
mbd = new RootBeanDefinition(pbd);
mbd.overrideFrom(bd);
}
// Set default singleton scope, if not configured before.
//没配置scop,默认是单例
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.
此时containingBd是null,
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;
}
}
此方法完成的功能:
1.从mergedBeanDefinitions缓存中取
2.没取到,如果没有父bean,那么此bean为rootbean
3.没取到且有父bean,创建父BeanDefinition,并把子beanDefinition中的个属性通过mbd.overrideFrom(bd);方法赋到父BeanDefinition中。
4.没配置scop,默认是单例
5.缓存合并之后的实例
7.checkMergedBeanDefinition检查bean定义是否是抽象类,是则报错
8.getDependsOn取出bean的依赖,如@autowired修饰的成员变量
9.isDependent(beanName, dependsOnBean)判断是否多次依赖和循环依赖
private boolean isDependent(String beanName, String dependentBeanName, Set<String> alreadySeen) {
String canonicalName = canonicalName(beanName);
if (alreadySeen != null && alreadySeen.contains(beanName)) {
return false;
}
Set<String> dependentBeans = this.dependentBeanMap.get(canonicalName);
if (dependentBeans == null) {
return false;
}
if (dependentBeans.contains(dependentBeanName)) {
return true;
}
for (String transitiveDependency : dependentBeans) {
if (alreadySeen == null) {
alreadySeen = new HashSet<String>();
}
alreadySeen.add(beanName);
if (isDependent(transitiveDependency, dependentBeanName, alreadySeen)) {
return true;
}
}
return false;
}
dependentBeanMap中的数据在下一步放入。
10.registerDependentBean(dependsOnBean, beanName)把依赖bean放入
dependentBeanMap,dependenciesForBeanMap中
public void registerDependentBean(String beanName, String dependentBeanName) {
// A quick check for an existing entry upfront, avoiding synchronization...
String canonicalName = canonicalName(beanName);
Set<String> dependentBeans = this.dependentBeanMap.get(canonicalName);
if (dependentBeans != null && dependentBeans.contains(dependentBeanName)) {
return;
}
// No entry yet -> fully synchronized manipulation of the dependentBeans Set
synchronized (this.dependentBeanMap) {
dependentBeans = this.dependentBeanMap.get(canonicalName);
if (dependentBeans == null) {
dependentBeans = new LinkedHashSet<String>(8);
this.dependentBeanMap.put(canonicalName, dependentBeans);
}
dependentBeans.add(dependentBeanName);
}
synchronized (this.dependenciesForBeanMap) {
Set<String> dependenciesForBean = this.dependenciesForBeanMap.get(dependentBeanName);
if (dependenciesForBean == null) {
dependenciesForBean = new LinkedHashSet<String>(8);
this.dependenciesForBeanMap.put(dependentBeanName, dependenciesForBean);
}
dependenciesForBean.add(canonicalName);
}
}
dependentBeanMap作用:用于解决循环依赖问题。
dependenciesForBeanMap作用:通过此map可以知道user这个bean被多少个bean依赖了
11.getBean(dependsOnBean)获取依赖的bean实例
这是一个回调方法。我们就是从这个方法开始分析的。所以此处不分析了