标签：convert mutex lookup 执行 start 方法调用 can nal from
上面四篇文章讲了Spring是如何将配置文件一步一步转化为BeanDefinition的整个流程,下面就到了正式创建Bean对象实例的环节了，我们一起继续学习吧。
Resource resource = new ClassPathResource("beanFactory.xml");
BeanFactory beanFactory = new XmlBeanFactory(resource);
Student student = beanFactory.getBean(Student.class);仍然使用我们最开的一串代码来讲解，前四章我们说了那么多其实只是创建了BeanFactory这个容器，并将BeanDefinition对象解析完毕，而真正的对象创建则是在BeanFactory.getBean()中执行的。
一切起源于BeanFactory.getBean()，而对getBean()的实现是在AbstractBeanFactory这个类中实现的，所以我们着眼此类进行源码的阅读。如下为AbstractBeanFactory的继承实现图
getBean()方法调用了本类中自定义的doGetBean方法，接下来进入doGetBean()方法观察。
protected <T> T doGetBean(
final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
throws BeansException {
//1、解析beanName,找出bean真正的名称
final String beanName = transformedBeanName(name);
Object bean;
//2.尝试从单例缓存池中直接获取对象
Object sharedInstance = getSingleton(beanName);
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 + "'");
}
}
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
else {
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
//3.该容器缓存中没有，开始尝试加载父容器，检查父容器中是否存在该Bean对象
BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
String nameToLookup = originalBeanName(name);
if (args != null) {
return (T) parentBeanFactory.getBean(nameToLookup, args);
}
else {
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
}
if (!typeCheckOnly) {
markBeanAsCreated(beanName);
}
//4.父容器中仍然不存在，获取解析好的BeanDefinition，开始准备自己创建Bean
try {
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);//获取bean的根路径信息
checkMergedBeanDefinition(mbd, beanName, args);
//重要一步，检查依赖关系，提前创建依赖的bean对象。
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
for (String dep : dependsOn) {
if (isDependent(beanName, dep)) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
}
registerDependentBean(dep, beanName);
getBean(dep);
}
}
//5.检查BeanDefinition的scope属性，并执行不同的创建方法，总体大同小异，着重关注单例的创建方法即可。
if (mbd.isSingleton()) {
//6、极为重要的一点，通过getSingleton(String beanName,ObjectFactory objectFactory)创建对象，并且实例化getObject()方法
sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
@Override
public Object getObject() throws BeansException {
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("No Scope registered for scope name '" + scopeName + "'");
}
try {
Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() {
@Override
public Object getObject() throws BeansException {
beforePrototypeCreation(beanName);
try {
return createBean(beanName, mbd, args);
}
finally {
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;
}
}
if (requiredType != null && bean != null && !requiredType.isInstance(bean)) {
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;
}上面的代码很长，乍一看真的会让初学者头皮发麻，但是没关系，我们将它拆解开来一步一步分析。
至此，一个bean的完整创建流程就走完了。具体的细节，我们接下来一个一个慢慢的看。
首先，我们进入第一段代码
在transformedBeanName(beanName)中，传入的参数并非真正的beanName，这里的参数可能是别名，也可能是factoryBean的名称，所以要进行一系列的解析，主要的解析分为两步：
//解析是否是FactoryBean：BeanFactoryUtils.transformedBeanName(String name)
public static String transformedBeanName(String name) {
Assert.notNull(name, "'name' must not be null");
String beanName = name;
while (beanName.startsWith(BeanFactory.FACTORY_BEAN_PREFIX)) {
beanName = beanName.substring(BeanFactory.FACTORY_BEAN_PREFIX.length());
}
return beanName;
} 代码很简单，就是判断beanName是否是以“&”开头，然后进行截取。 //判断别名：SimpleAliasRegistry.canonicalName(String name)
public String canonicalName(String name) {
String canonicalName = name;
String resolvedName;
do {
//从别名集合中循环查找，直到最底层真正的bean名称
resolvedName = this.aliasMap.get(canonicalName);
if (resolvedName != null) {
canonicalName = resolvedName;
}
}
while (resolvedName != null);
return canonicalName;
}依然很简单，尝试从实现定义好的别名集合中进行查询，寻找真正的bean。接下来是doGetBean中的第三个方法，getSingleton(String beanName, boolean allowEarlyReference)。
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
//1.尝试从单例缓存中直接获取对象
Object singletonObject = this.singletonObjects.get(beanName);
//2.如果单例缓存中无法获取对象，且该对象在正在创建对象标记池里。
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
synchronized (this.singletonObjects) {
//3.从提前创建对象池中获取该对象
singletonObject = this.earlySingletonObjects.get(beanName);
//4.对象仍然为空且允许循环依赖
if (singletonObject == null && allowEarlyReference) {
//5.尝试从ObjectFactory池中获取对象的ObjectFactory，并创建该对象。
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
singletonObject = singletonFactory.getObject();
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
}
return (singletonObject != NULL_OBJECT ? singletonObject : null);
}
public boolean isSingletonCurrentlyInCreation(String beanName) {
return this.singletonsCurrentlyInCreation.contains(beanName);
}此方法代码其实不难理解，主要的难点是几个概念上的问题。首先观察该方法中用到的该类的几个参数。
/** Cache of singleton objects: bean name --> bean instance */ private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(256);/** Names of beans that are currently in creation */ private final Set<String> singletonsCurrentlyInCreation = Collections.newSetFromMap(new ConcurrentHashMap<String, Boolean>(16));/** Cache of early singleton objects: bean name --> bean instance */ private final Map<String, Object> earlySingletonObjects = new HashMap<String, Object>(16);/** Cache of singleton factories: bean name --> ObjectFactory */ private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<String, ObjectFactory<?>>(16);小tip:ObjectFactory、BeanFactory、FactoryBean之间的关系和联系
getObjectForBeanInstance()是一个非常重要的方法，Spring在获取了每个Bean的对象之后,都要调用该方法完成最后的步骤以取得我们真正想要的Bean。说到很多人肯定会疑惑，什么是“真正需要”,点进该方法，我们就知道了。
protected Object getObjectForBeanInstance(
Object beanInstance, String name, String beanName, RootBeanDefinition mbd) {
if (BeanFactoryUtils.isFactoryDereference(name) && !(beanInstance instanceof FactoryBean)) {
throw new BeanIsNotAFactoryException(transformedBeanName(name), beanInstance.getClass());
}
//判断实例不是FactoryBean类型或该实例名称以获取FactoryBean开头 ，满足任何一个条件直接返回实例
//即满足两个条件无非有两个条件1.该对象不是FactoryBean,判断短路直接返回。2.该对象是FactoryBean，且用户想直接获取FactoryBean
if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
return beanInstance;
}
Object object = null;
if (mbd == null) {
object = getCachedObjectForFactoryBean(beanName);
}
if (object == null) {
//通过上述，至此可以完全确定该对象是Factory对象，下方就是通过对象的factory-method创建对象的过程。
FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
if (mbd == null && containsBeanDefinition(beanName)) {
mbd = getMergedLocalBeanDefinition(beanName);
}
boolean synthetic = (mbd != null && mbd.isSynthetic());
object = getObjectFromFactoryBean(factory, beanName, !synthetic);
}
return object;
}上述重要就是一个短路判断，如果该对象不是一个FactoryBean或者用户试图直接获取FactoryBean对象，则该对象就已经是我们想要的对象，直接返回即可，否则的话就意味着我们需要通过FactoryBean内部定义好的factory-method来创建我们需要的Bean对象。而我们追入getObjectFromFactoryBean()中，查看如下代码：
//FactoryBeanRegistrySupport.getObjectFromFactoryBean(...)
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);
Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
if (alreadyThere != null) {
object = alreadyThere;
}
else {
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;
}
}而遗憾的是我们还是没有看到真正创建对象的方法，但通过前面的阅读，我们已经可以发现Spring在一个方法的真正核心处理部分处，都会以doXXXX开头，而其余都是对这个核心处理的一层层包装与协助。
在观察核心代码之前，我们先观察后面一个重要的方法。postProcessObjectFromFactoryBean()，在spring的整个架构中给予了用户各种拓展和自定义的权利，这也是Spring被广泛称赞：代码优美的原因之一。而这里的执行后处理器操作就是很重要的一环，进入该方法的子类AbstractAutowireCapableBeanFactory观察Spirng是如何让代码变得如此优美的。
//AbstractAutowireCapableBeanFactory.java
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;
}//BeanPostProcessor.java
Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;
Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;观察代码，可以知道Spring循环了Bean所注册的所有BeanPostProcess，并在这里依次调用了其postProcessAfterInitialization()方法，而该方法的实现交由用户来自己实现。于是乎，通过解析我们就能知道:在Spring中：如果想让一个Bean在初始化完成后做一些特殊处理，实现BeanPost.postProcessAfterInitialization()即可。最后有一个小提醒：我们一定要清晰的认识到，此时我们是在修饰一个FactoryBean创建的Bean对象，而并非正常流程创建的Bean对象哦，例如我们一直讨论的这个FactoryBean,它本身作为一个Bean对象是在什么时候执行了PostPorcess方法了呢？后续我们拭目以待吧
了解完处理器之后，让我们点入doGetObjectFromFactoryBean()，发现里面的代码就非常简单明了。
//FactoryBeanRegistrySupport.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 {
//调用Factory的getObject方法
return factory.getObject();
}
}, acc);
}catch (PrivilegedActionException pae) {
throw pae.getException();
}
}else {
//调用Factory的getObject方法
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);
}
if (object == null && isSingletonCurrentlyInCreation(beanName)){
throw new BeanCurrentlyInCreationException(
beanName, "FactoryBean which is currently in creation returned null from getObject");
}
return object;
}一层一层终于我们到了最里边，在这里我们发现最终对象正是由当初获取的FactoryBean对象的getObject()方法完成。如果读到这里已经有些绕不过来，想不起自己从何处而来的话，往上翻一翻，看清楚自己一路走来之路哦。下面我们就重新回到起源之路上，继续往下探索。但由于真正的Bean的创建流程很长，所以这篇文章先写到这里，下面单开一篇文章来写Bean对象的实例化。
Spring源码学习-容器BeanFactory(五) Bean的创建-探寻Bean的新生之路
标签：convert mutex lookup 执行 start 方法调用 can nal from
原文地址：https://www.cnblogs.com/ZzlevolFlash/p/10660260.html
