目录
下面为非第一次getBean(已经初始化过一次),获取的最短路径
1、如果源名称以&开头,则判断是否为NullBean,判断是否不存在(直接抛异常),返回工厂本身
2、获取正常的Bean(非FactoryBean类型),则直接返回。
3、不是获取FactoryBean本身,但是获取的是FactoryBean类型的Bean
之所以先写了ApplicationContext的refresh方法再写继续写BeanFactory的getBean核心方法,是因为觉得项目中根本不会直接使用BeanFactory肯定还是会使用ApplicationContext。并且每个Bean的生命周期会在getBean中完成,其中就会回调所有的BeanPostProcessor的postProcessBeforeInitialization和postProcessAfterInitialization方法。
先梳理一下getBean的整个过程(只分析单利Bean)
1、首先会从缓存中获取;否则(第一次)需要根据之前注入的BeanDefinition进行创建。
2、创建之前需要先处理ovverride和前置准备;在创建时会有依赖注入的情况(需要解决循环依赖的问题),则再分析真正的创建
3、创建过程:创建Bean实例;记录创建Bean的工厂;属性注入;初始化Bean(Bean的生命周期在这里完成,包括注册DisposableBean)
下面为非第一次getBean(已经初始化过一次),获取的最短路径
开始:
@Override
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 {
final String beanName = transformedBeanName(name);
// Eagerly check singleton cache for manually registered singletons.
Object sharedInstance = getSingleton(beanName);
// 省略
}
1、获取真实的BeanName(传入的可能是别名等)
调用getBean方法时候,传入的字符串可能是别名,或者是FactoryBean类型则可能传入&开头的,以获取FactoryBean本身。所以需要考虑各种情况,拿到真是的bean名称。
protected String transformedBeanName(String name) {
return canonicalName(BeanFactoryUtils.transformedBeanName(name));
}
1)、判断是否为获取FactoryBean
public static String transformedBeanName(String name) {
if (!name.startsWith(BeanFactory.FACTORY_BEAN_PREFIX)) {
return name;
}
return transformedBeanNameCache.computeIfAbsent(name, beanName -> {
do {
beanName = beanName.substring(BeanFactory.FACTORY_BEAN_PREFIX.length());
}
while (beanName.startsWith(BeanFactory.FACTORY_BEAN_PREFIX));
return beanName;
});
}
判断名称是否以&开头,不是则直接返回当前字符串;是则是获取FactoryBean本身,则需要截取字符串,缓存获取FactoryBean的名称。缓存到BeanFactoryUtils的
Map<String, String> transformedBeanNameCache
2)、 判断是否为别名
public String canonicalName(String name) {
String canonicalName = name;
String resolvedName;
do {
resolvedName = this.aliasMap.get(canonicalName);
if (resolvedName != null) {
canonicalName = resolvedName;
}
}
while (resolvedName != null);
return canonicalName;
}
当前字符串要不是Bean名称本身,要不是就是别名。那么直接在别名中获取一下,有则返回别名,否则返回Bean名称本身。
2、从缓存中获取实例(如果已经调用过getBean)
@Override
@Nullable
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;
}
如果第一次调用getBean初始化完成后,则会将实例化的Bean放入DefaultSingletonBeanRegistry的singletonObjects容器中;为了解决单利循环依赖的问题,则在依赖注入时,会提前将未完成的Bean提前放入earlySingletonObjects容器中。创建Bean的工厂与Bean名称的关系存储在singletonFactories容器中。
- 先直接先看是否初始化完成,如果没有拿到,则判断是否正在创建中。
- 如果是则从earlySingletonObjects中进行获取。并且当前allowEarlyReference参数为true,则如果正在依赖注入创建中,直接从工厂中获取
- 如果工厂已经存在,则直接getBean调用工厂的getBean方法,并且提前暴露放到earlySingletonObjects中。
3、判断返回真正获取的对象
if (sharedInstance != null && args == null) {
// 省略日志
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
上面获取到的可能就是需要返回的Bean,但是当前可能需要获取的是FactoryBean本身(是否或者FactoryBean已经缓存到BeanFactoryUtils的transformedBeanNameCache中)。获取时传入了上面获取的实例,源名称,Bean名称,RootBeanDefinition为null。
@Override
protected Object getObjectForBeanInstance(
Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {
String currentlyCreatedBean = this.currentlyCreatedBean.get();
if (currentlyCreatedBean != null) {
registerDependentBean(beanName, currentlyCreatedBean);
}
return super.getObjectForBeanInstance(beanInstance, name, beanName, mbd);
}
判断当前是否正在有依赖注入的Bean没有初始化完成(非第一次调用则肯定已经初始化完成了),在继续调用父类AbstractBeanFactory的方法。
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.
if (BeanFactoryUtils.isFactoryDereference(name)) {
if (beanInstance instanceof NullBean) {
return beanInstance;
}
if (!(beanInstance instanceof FactoryBean)) {
throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass());
}
if (mbd != null) {
mbd.isFactoryBean = true;
}
return beanInstance;
}
// 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.
if (!(beanInstance instanceof FactoryBean)) {
return beanInstance;
}
Object object = null;
if (mbd != null) {
mbd.isFactoryBean = true;
}
else {
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)) {
mbd = getMergedLocalBeanDefinition(beanName);
}
boolean synthetic = (mbd != null && mbd.isSynthetic());
object = getObjectFromFactoryBean(factory, beanName, !synthetic);
}
return object;
}
1、如果源名称以&开头,则判断是否为NullBean,判断是否不存在(直接抛异常),返回工厂本身
2、获取正常的Bean(非FactoryBean类型),则直接返回。
3、不是获取FactoryBean本身,但是获取的是FactoryBean类型的Bean
3-1)、从缓存中获取(非第一次)
getCachedObjectForFactoryBean(beanName);
则在AbstractBeanFactory的父类FactoryBeanRegistrySupport,的factoryBeanObjectCache容器中获取
@Nullable
protected Object getCachedObjectForFactoryBean(String beanName) {
return this.factoryBeanObjectCache.get(beanName);
}
3-2)、获取实例(第一次获取)
那么上面获取到的beanInstance为FactoryBean,先或者合并的BeanDefinition,再判断是否为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) {
// 直接用FactoryBean中调用getObject方法获取,或者判断是否正在创建中
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;
}
}
// 省略非单利
}
先用synchronized锁住singletonObjects,又从缓存中获取一遍。
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());
}
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) {
if (isSingletonCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(
beanName, "FactoryBean which is currently in creation returned null from getObject");
}
object = new NullBean();
}
return object;
}
否则直接从FactoryBean中获取,但是可能或者不到,则判断是否正在创建中,则后面从创建中获取。主要的方法就是FactoryBean#getObject方法。第一次获取,则也会执行FactoryBean类型的Bean的生命周期的 回调BeanPostProcess的方法。比如之前修改jpa的JpaRepository子类(通过JpaRepositoryFactoryBean#getObject创建)就有该回调。如下:
@Override
protected Object postProcessObjectFromFactoryBean(Object object, String beanName) {
return applyBeanPostProcessorsAfterInitialization(object, beanName);
}
但是只回调了所有BeanPostProcessor的postProcessAfterInitialization方法:
@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;
}
最后将FactoryBean通过getObject方法,获取到的对象放入factoryBeanObjectCache缓存,第二次就可以从该容器中获取了