前言：在【spring源码分析】IOC容器初始化（六）中分析了从单例缓存中加载bean对象，由于篇幅原因其核心函数
FactoryBeanRegistrySupport#getObjectFromFactoryBean并未进行详细分析，本文将继续对bean加载过程的分析。
FactoryBeanRegistrySupport#getObjectFromFactoryBean
1 protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) { 2 // 为单例模式，其缓存中存在该bean实例 3 if (factory.isSingleton() && containsSingleton(beanName)) { 4 /** 5 * 做同步，内部其实使用的就是{@link DefaultSingletonBeanRegistry#singletonObjects} 6 */ 7 synchronized (getSingletonMutex()) { 8 // 从缓存中获取指定的factoryBean 9 Object object = this.factoryBeanObjectCache.get(beanName); 10 if (object == null) { 11 // 为空，则从FactoryBean中获取对象 12 object = doGetObjectFromFactoryBean(factory, beanName); 13 // Only post-process and store if not put there already during getObject() call above 14 // (e.g. because of circular reference processing triggered by custom getBean calls) 15 // 再次从缓存中获取bean对象，主要是因为循环依赖 16 Object alreadyThere = this.factoryBeanObjectCache.get(beanName); 17 if (alreadyThere != null) { 18 object = alreadyThere; 19 } else { 20 // 需要后续处理 21 if (shouldPostProcess) { 22 // 如果该Bean处于创建中，则返回处理对象，而不是存储该对象 23 if (isSingletonCurrentlyInCreation(beanName)) { 24 // Temporarily return non-post-processed object, not storing it yet.. 25 return object; 26 } 27 // 单例bean的前置处理 用于添加标志，当前bean正处于创建中 28 beforeSingletonCreation(beanName); 29 try { 30 // 对FactoryBean获取的对象进行后置处理，返回生成的对象 31 object = postProcessObjectFromFactoryBean(object, beanName); 32 } catch (Throwable ex) { 33 throw new BeanCreationException(beanName, 34 "Post-processing of FactoryBean's singleton object failed", ex); 35 } finally { 36 // 单例bean的后置处理 和前置处理相反，前置添加，后置移除 移除标志，当前bean不处于创建中 37 afterSingletonCreation(beanName); 38 } 39 } 40 // 添加到factoryBeanObjectCache中进行缓存 41 if (containsSingleton(beanName)) { 42 this.factoryBeanObjectCache.put(beanName, object); 43 } 44 } 45 } 46 return object; 47 } 48 } else { 49 // 不满足第一个条件，不是单例，或者缓存中不存在，则从FactoryBean中获取对象 50 Object object = doGetObjectFromFactoryBean(factory, beanName); 51 // 需要后续处理 52 if (shouldPostProcess) { 53 try { 54 // 对FactoryBean获取的对象进行后处理 55 // 返回生成的对象 56 object = postProcessObjectFromFactoryBean(object, beanName); 57 } catch (Throwable ex) { 58 throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex); 59 } 60 } 61 return object; 62 } 63 }
分析：
函数分两大分支：
#1.单例且singletonObjects缓存中存在（该分支为同步方法）
- #1.1：FactoryBean为单例，并且缓存中存在该bean对象(containsSingleton方法其实就是判断singletonObjects集合中是否存在bean对象)，首先从缓存中获取factoryBean对象object，如果object=null，则从doGetObjectFromFactoryBean方法中获取对象。注意：这里再次从factoryBeanObjectCache缓存中尝试获取对象(主要是循环依赖问题，有可能这时该bean对象已经加载了，就不用再次加载了)，如果缓存中已存在bean对象，则使用缓存中对象，并直接返回。
- #1.2：如果factoryBeanObjectCache缓存中不存在对象且需要后置处理，则首先判断该bean对象是否正在被创建，如果是，则直接返回，注意这里未进行缓存；然后对单例bean进行前置添加处理(beforeSingletonCreation)、后置处理(postProcessObjectFromFactoryBean)、后置移除标志处理(afterSingletonCreation)。
- #1.3：最后将缓存生成的bean对象
#2.不满足(#1)中的任何一条件
- 首先从doGetObjectFromFactoryBean方法中获取获取bean对象，如果需要后置处理，则调用postProcessObjectFromFactoryBean方法进行处理，最后返回生成过的bean对象。
在上述分析中涉及到几个函数，下面一一进行分析。
FactoryBeanRegistrySupport#doGetObjectFromFactoryBean
1 private Object doGetObjectFromFactoryBean(final FactoryBean<?> factory, final String beanName) 2 throws BeanCreationException { 3 4 Object object; 5 try { 6 // 如果权限不为空 7 if (System.getSecurityManager() != null) { 8 AccessControlContext acc = getAccessControlContext(); 9 try { 10 // 从FactoryBean中获取Bean对象[factory::getObject] 其实与else分支一样的 11 object = AccessController.doPrivileged((PrivilegedExceptionAction<Object>) factory::getObject, acc); 12 } catch (PrivilegedActionException pae) { 13 throw pae.getException(); 14 } 15 } else { 16 // 如果权限为空，则从Factory中获取Bean对象 17 object = factory.getObject(); 18 } 19 } catch (FactoryBeanNotInitializedException ex) { 20 throw new BeanCurrentlyInCreationException(beanName, ex.toString()); 21 } catch (Throwable ex) { 22 throw new BeanCreationException(beanName, "FactoryBean threw exception on object creation", ex); 23 } 24 25 // 进行一波校验 26 // Do not accept a null value for a FactoryBean that's not fully 27 // initialized yet: Many FactoryBeans just return null then. 28 if (object == null) { 29 // 如果bean正在被创建，则抛出异常 30 if (isSingletonCurrentlyInCreation(beanName)) { 31 throw new BeanCurrentlyInCreationException( 32 beanName, "FactoryBean which is currently in creation returned null from getObject"); 33 } 34 object = new NullBean(); 35 } 36 return object; 37 }
分析：
根据是否具有权限，通过FactoryBean#getObject获取bean对象，如果bean对象为null且正在被创建，则抛出异常，否则实例化一个NullBean对象进行返回。
DefaultSingletonBeanRegistry#isSingletonCurrentlyInCreation
1 /** 2 * 正在创建中的单例 Bean 的名字的集合 3 * Names of beans that are currently in creation. 4 */ 5 private final Set<String> singletonsCurrentlyInCreation = 6 Collections.newSetFromMap(new ConcurrentHashMap<>(16)); 7 8 public boolean isSingletonCurrentlyInCreation(String beanName) { 9 return this.singletonsCurrentlyInCreation.contains(beanName); 10 }
分析：
该函数判断bean是否正处于创建之中，该方法要与beforeSingletonCreation和afterSingletonCreation配合起来分析才能明白其重要性，他们记录了bean的加载状态，是检查当前bean是否处于创建中的关键处，对解决bean的循环依赖起着重要作用。
DefaultSingletonBeanRegistry#beforeSingletonCreation
1 protected void beforeSingletonCreation(String beanName) { 2 // 这里会添加到正在创建bean的集合中 3 // 注意第一个条件，如果存在，则为false，直接短路 4 // 只有当第一个条件不存在[false]时，才会去进行添加操作 5 if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) { 6 throw new BeanCurrentlyInCreationException(beanName); 7 } 8 }
分析：
注意这里就会将正在创建的beanName添加到singletonsCurrentlyInCreation集合中，第一个条件是判断该bean是否不会被检测。
DefaultSingletonBeanRegistry#afterSingletonCreation
1 protected void afterSingletonCreation(String beanName) { 2 if (!this.inCreationCheckExclusions.contains(beanName) 3 && !this.singletonsCurrentlyInCreation.remove(beanName)) { // 移除 4 // 如果移除失败，则抛出IllegalStateException异常 5 throw new IllegalStateException("Singleton '" + beanName + "' isn't currently in creation"); 6 } 7 }
分析：
afterSingletonCreation方法与beforeSingletonCreation方法的功能相反，用于将beanName移除正在创建的集合singletonsCurrentlyInCreation，表明bean创建完成。
postProcessObjectFromFactoryBean
该方法的默认实现，就是返回当前bean对象。
1 // FactoryBeanRegistrySupport 2 protected Object postProcessObjectFromFactoryBean(Object object, String beanName) throws BeansException { 3 return object; 4 }
当然，子类可以对该方法进行重写。
1 // AbstractAutowireCapableBeanFactory 2 3 protected Object postProcessObjectFromFactoryBean(Object object, String beanName) { 4 return applyBeanPostProcessorsAfterInitialization(object, beanName); 5 } 6 7 public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName) 8 throws BeansException { 9 10 Object result = existingBean; 11 // 遍历BeanPostProcessor 12 for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) { 13 // 进行处理 14 // TODO: 2019/4/2 具体处理过程需详细查看，这里先走大流程 15 Object current = beanProcessor.postProcessAfterInitialization(result, beanName); 16 // 返回为空，则返回传入的Object对象 17 if (current == null) { 18 return result; 19 } 20 // 修改result 21 result = current; 22 } 23 return result; 24 }
分析：
这里主要是遍历BeanPostProcessor，然后对bean对象进行处理，关于后置处理器的分析后面再做分析。
到这里从单例缓存中获取bean对象的相应源码已分析完成，接下来看单例缓存中无bean对象时，Spring的处理流程，再次将getBean的切入点代码贴出来。
1 protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType, 2 @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException { 3 4 // .........省略从单例缓存中获取bean对象的代码 5 } else { 6 // Fail if we're already creating this bean instance: 7 // We're assumably within a circular reference. 8 // Spring只能解决单例模式下的循环依赖，在原型模式下如果存在循环依赖则抛出异常 9 // 这里检测原型模式下，该bean是否在加载，如果在加载则抛出异常 10 if (isPrototypeCurrentlyInCreation(beanName)) { 11 throw new BeanCurrentlyInCreationException(beanName); 12 } 13 14 // 如果当前容器中没有找到，则从父类容器中加载 15 // Check if bean definition exists in this factory. 16 BeanFactory parentBeanFactory = getParentBeanFactory(); 17 /** 18 * 调用{@link DefaultListableBeanFactory#containsBeanDefinition(String)}方法 19 * 其实就是在beanDefinitionMap中判断是否存在beanName对应的BeanDefinition 20 */ 21 if (parentBeanFactory != null && !containsBeanDefinition(beanName)) { 22 // Not found -> check parent. 23 // 确定原始的beanName 24 String nameToLookup = originalBeanName(name); 25 // 如果父类容器为AbstractBeanFactory，则委托父类处理 26 if (parentBeanFactory instanceof AbstractBeanFactory) { 27 return ((AbstractBeanFactory) parentBeanFactory).doGetBean( 28 nameToLookup, requiredType, args, typeCheckOnly); 29 } else if (args != null) { // 用明确的args从parentBeanFactory中，获取Bean对象 30 // Delegation to parent with explicit args. 31 // 委托给父类构造函数getBean()处理 32 return (T) parentBeanFactory.getBean(nameToLookup, args); 33 } else if (requiredType != null) { // 用明确的requiredType从parentBeanFactory中，获取Bean对象 34 // No args -> delegate to standard getBean method. 35 // 没有args，委托给标准的getBean()处理 36 return parentBeanFactory.getBean(nameToLookup, requiredType); 37 } else { 38 // 直接使用nameToLookup从parentBeanFactory中获取Bean对象 39 return (T) parentBeanFactory.getBean(nameToLookup); 40 } 41 } 42 43 // 如果不仅仅是做类型检查，而是创建bean，这里需要记录 44 if (!typeCheckOnly) { 45 markBeanAsCreated(beanName); 46 } 47 48 try { 49 /** 50 * 从容器中获取beanName对应的GenericBeanDefinition对象，并转换成RootBeanDefinition对象 51 * GenericBeanDefinition的创建{@link BeanDefinitionReaderUtils#createBeanDefinition}方法 52 */ 53 final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName); 54 // 检查合并的BeanDefinition 55 checkMergedBeanDefinition(mbd, beanName, args); 56 57 // Guarantee initialization of beans that the current bean depends on. 58 // 处理所依赖的bean 59 String[] dependsOn = mbd.getDependsOn(); 60 if (dependsOn != null) { 61 for (String dep : dependsOn) { 62 // 若给定的依赖bean已经注册为依赖给定的bean 63 // 即循环依赖情况，抛出BeanCreationException异常 64 if (isDependent(beanName, dep)) { 65 throw new BeanCreationException(mbd.getResourceDescription(), beanName, 66 "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'"); 67 } 68 // 缓存依赖调用 69 registerDependentBean(dep, beanName); 70 try { 71 // 递归处理依赖 Bean 72 getBean(dep); 73 } catch (NoSuchBeanDefinitionException ex) { 74 throw new BeanCreationException(mbd.getResourceDescription(), beanName, 75 "'" + beanName + "' depends on missing bean '" + dep + "'", ex); 76 } 77 } 78 } 79 // bean实例化 80 // Create bean instance. 81 // 单例模式 82 /** 83 * 这里有个已创建bean的重要方法createBean 84 * {@link AbstractAutowireCapableBeanFactory#createBean(String, RootBeanDefinition, Object[])} 85 */ 86 if (mbd.isSingleton()) { 87 sharedInstance = getSingleton(beanName, () -> { 88 try { 89 return createBean(beanName, mbd, args); 90 } catch (BeansException ex) { 91 // Explicitly remove instance from singleton cache: It might have been put there 92 // eagerly by the creation process, to allow for circular reference resolution. 93 // Also remove any beans that received a temporary reference to the bean. 94 // 显式从单例缓存中删除Bean实例 95 // 因为单例模式下为了解决循环依赖，可能它已经存在，所以销毁它 96 destroySingleton(beanName); 97 throw ex; 98 } 99 }); 100 bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd); 101 } else if (mbd.isPrototype()) { // 原型模式 102 // It's a prototype -> create a new instance. 103 Object prototypeInstance = null; 104 try { 105 // 前置处理 106 beforePrototypeCreation(beanName); 107 /** 108 * 创建bean {@link AbstractAutowireCapableBeanFactory#createBean} 109 */ 110 prototypeInstance = createBean(beanName, mbd, args); 111 } finally { 112 /** 113 * 后置处理 与前置处理相反从{@link prototypesCurrentlyInCreation}中移除 114 */ 115 afterPrototypeCreation(beanName); 116 } 117 bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd); 118 } else { //其他作用域 119 // 获得scopeName对应的Scope对象 120 String scopeName = mbd.getScope(); 121 final Scope scope = this.scopes.get(scopeName); 122 if (scope == null) { 123 throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'"); 124 } 125 try { 126 /** 127 * 从指定的scope下创建bean 128 * {@link SimpleThreadScope#get方法} 129 */ 130 Object scopedInstance = scope.get(beanName, () -> { 131 beforePrototypeCreation(beanName); 132 try { 133 return createBean(beanName, mbd, args); 134 } finally { 135 afterPrototypeCreation(beanName); 136 } 137 }); 138 bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd); 139 } catch (IllegalStateException ex) { 140 throw new BeanCreationException(beanName, 141 "Scope '" + scopeName + "' is not active for the current thread; consider " + 142 "defining a scoped proxy for this bean if you intend to refer to it from a singleton", 143 ex); 144 } 145 } 146 } catch (BeansException ex) { 147 cleanupAfterBeanCreationFailure(beanName); 148 throw ex; 149 } 150 } 151 152 // 检查需要的类型是否符合bean的实际类型 153 // Check if required type matches the type of the actual bean instance. 154 if (requiredType != null && !requiredType.isInstance(bean)) { 155 try { 156 T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType); 157 if (convertedBean == null) { 158 throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass()); 159 } 160 return convertedBean; 161 } catch (TypeMismatchException ex) { 162 if (logger.isTraceEnabled()) { 163 logger.trace("Failed to convert bean '" + name + "' to required type '" + 164 ClassUtils.getQualifiedName(requiredType) + "'", ex); 165 } 166 throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass()); 167 } 168 } 169 return (T) bean; 170 }
分析：
#1.首先通过AbstractBeanFactory#isPrototypeCurrentlyInCreation检查bean对象是否处于原型模式下的循环依赖，因为Spring只能解决单例模式下的循环依赖，如果在原型模式下也存在该bean对象，则会抛出异常。
1 // AbstractBeanFactory 2 /** 3 * 原型模式下存储beanName的ThreadLocal<br/> 4 * Names of beans that are currently in creation. 5 */ 6 private final ThreadLocal<Object> prototypesCurrentlyInCreation = 7 new NamedThreadLocal<>("Prototype beans currently in creation"); 8 protected boolean isPrototypeCurrentlyInCreation(String beanName) { 9 Object curVal = this.prototypesCurrentlyInCreation.get(); 10 return (curVal != null && 11 (curVal.equals(beanName) //相等 12 || (curVal instanceof Set && ((Set<?>) curVal).contains(beanName)))); // 包含 13 }
- 这里就是检查原型模式的ThreadLocal中是否已经存在对应的beanName。
#2.AbstractBeanFactory#getParentBeanFactory检查其父类BeanFactory是否存在，如果存在且beanDefinitionMap中不存在该BeanDefinition，则委托其父类通过getBean方法获取bean对象。注意这里首先会通过originalBeanName方法获取原始beanName。
1 // AbstractBeanFactory 2 protected String originalBeanName(String name) { 3 String beanName = transformedBeanName(name); 4 if (name.startsWith(FACTORY_BEAN_PREFIX)) { 5 // 如果beanName以&开头，则在加上&进行返回 因为transformedBeanName中会去掉& 6 beanName = FACTORY_BEAN_PREFIX + beanName; 7 } 8 return beanName; 9 }
- 首先通过transformedBeanName(该方法前面已经分析)获取真正的beanName，如果name以"&"开头，则将beanName加上"&"符号，因为transformedBeanName方法会去掉"&"符号。
#3.判断bean是否需要做类型检查，如果不仅仅做类型检查，则需要调用markBeanAsCreated函数进行记录。
1 // AbstractBeanFactory 2 /** 3 * 已创建Bean的名字集合<br/> 4 * Names of beans that have already been created at least once. 5 */ 6 private final Set<String> alreadyCreated = Collections.newSetFromMap(new ConcurrentHashMap<>(256)); 7 8 9 protected void markBeanAsCreated(String beanName) { 10 // 没有创建 11 if (!this.alreadyCreated.contains(beanName)) { 12 // 做同步 13 synchronized (this.mergedBeanDefinitions) { 14 // 再次进行检查，DoubleCheck模式 15 if (!this.alreadyCreated.contains(beanName)) { 16 // Let the bean definition get re-merged now that we're actually creating 17 // the bean... just in case some of its metadata changed in the meantime. 18 // 从mergedBeanDefinitions中删除beanName，并在下次访问时重新创建它 19 clearMergedBeanDefinition(beanName); 20 // 添加到已创建bean集合中 21 this.alreadyCreated.add(beanName); 22 } 23 } 24 } 25 }
#4. 接下来将对BeanDefinition进行转换，因为最开始创建的BeanDefinition类型为GenericBeanDefinition，getMergedLocalBeanDefinition方法在前面已经进行了分析，这里不在赘述。
#5.调用checkMergedBeanDefinition对转换后的RootBeanDefinition，如果RootBeanDefinition仍为抽象的，则抛出异常，这里抽象的对象还不能进行实例化。代码如下：
1 // AbstractBeanFactory 2 protected void checkMergedBeanDefinition(RootBeanDefinition mbd, String beanName, @Nullable Object[] args) 3 throws BeanDefinitionStoreException { 4 5 if (mbd.isAbstract()) { 6 throw new BeanIsAbstractException(beanName); 7 } 8 }
#6.处理依赖，如果在加载bean对象时，发现它有依赖bean的话，那么在初始化该bean的时候需要先初始化依赖的bean对象
1 // 处理所依赖的bean 2 String[] dependsOn = mbd.getDependsOn(); 3 if (dependsOn != null) { 4 for (String dep : dependsOn) { 5 // 若给定的依赖bean已经注册为依赖给定的bean 6 // 即循环依赖情况，抛出BeanCreationException异常 7 if (isDependent(beanName, dep)) { 8 throw new BeanCreationException(mbd.getResourceDescription(), beanName, 9 "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'"); 10 } 11 // 缓存依赖调用 12 registerDependentBean(dep, beanName); 13 try { 14 // 递归处理依赖 Bean 15 getBean(dep); 16 } catch (NoSuchBeanDefinitionException ex) { 17 throw new BeanCreationException(mbd.getResourceDescription(), beanName, 18 "'" + beanName + "' depends on missing bean '" + dep + "'", ex); 19 } 20 } 21 }
分析：
DefaultSingletonBeanRegistry#isDependent
1 protected boolean isDependent(String beanName, String dependentBeanName) { 2 synchronized (this.dependentBeanMap) { 3 return isDependent(beanName, dependentBeanName, null); 4 } 5 } 6 private boolean isDependent(String beanName, String dependentBeanName, @Nullable Set<String> alreadySeen) { 7 // alreadySeen 已经检测的依赖bean 8 if (alreadySeen != null && alreadySeen.contains(beanName)) { 9 return false; 10 } 11 // 获取原始的beanName 12 String canonicalName = canonicalName(beanName); 13 // 获取当前beanName的依赖集合 14 Set<String> dependentBeans = this.dependentBeanMap.get(canonicalName); 15 // 不存在，则说明不存在注册依赖 16 if (dependentBeans == null) { 17 return false; 18 } 19 // 存在，则证明已经存在注册依赖 20 if (dependentBeans.contains(dependentBeanName)) { 21 return true; 22 } 23 // 递归检测依赖 24 for (String transitiveDependency : dependentBeans) { 25 if (alreadySeen == null) { 26 alreadySeen = new HashSet<>(); 27 } 28 // 添加到alreadySeen 29 alreadySeen.add(beanName); 30 // 递推 31 if (isDependent(transitiveDependency, dependentBeanName, alreadySeen)) { 32 return true; 33 } 34 } 35 return false; 36 }
分析：
这里通过一些列判断，是否依赖的bean是否已经注入，如果注入则返回true，否则返回false。
#7.如果依赖检测通过，则调用registerDependentBean对依赖bean进行注入。
1 // DefaultSingletonBeanRegistry 2 3 /** 4 * 保存的是依赖beanName 映射关系：beanName --> 依赖beanName的集合<br/> 5 * Map between dependent bean names: bean name to Set of dependent bean names. 6 */ 7 private final Map<String, Set<String>> dependentBeanMap = new ConcurrentHashMap<>(64); 8 9 /** 10 * 保存的是依赖 beanName 之间的映射关系：依赖 beanName - > beanName 的集合 11 * Map between depending bean names: bean name to Set of bean names for the bean's dependencies. 12 */ 13 private final Map<String, Set<String>> dependenciesForBeanMap = new ConcurrentHashMap<>(64); 14 15 public void registerDependentBean(String beanName, String dependentBeanName) { 16 // 获取beanName 17 String canonicalName = canonicalName(beanName); 18 19 // 做同步 添加<canonicalName,<dependentBeanName>>到dependentBeanMap中 20 synchronized (this.dependentBeanMap) { 21 Set<String> dependentBeans = 22 this.dependentBeanMap.computeIfAbsent(canonicalName, k -> new LinkedHashSet<>(8)); 23 if (!dependentBeans.add(dependentBeanName)) { 24 return; 25 } 26 } 27 // 做同步 添加<canonicalName,<dependentBeanName>>到dependenciesForBeanMap中 28 synchronized (this.dependenciesForBeanMap) { 29 Set<String> dependenciesForBean = 30 this.dependenciesForBeanMap.computeIfAbsent(dependentBeanName, k -> new LinkedHashSet<>(8)); 31 dependenciesForBean.add(canonicalName); 32 } 33 }
分析：
这里就是就是将依赖的beanName关系添加到dependentBeanMap、dependenciesForBeanMap集合中。
#8.最后通过getBean方法实例化依赖bean对象，该方法会在后面进行分析。
各种scope的Bean创建
在经过单例缓存中获取bean对象、从父类工厂中获取bean对象、处理依赖bean这三步后，接下来来到对各种scope的bean的创建。首先是单例模式bean对象的创建，我们知道singleton为Spring的bean的默认作用域，当然除了singleton之外，还有prototype、request等其他的scope。
#1.singleton的初始化代码如下
1 // AbstractBeanFactory 2 3 if (mbd.isSingleton()) { 4 sharedInstance = getSingleton(beanName, () -> { 5 try { 6 return createBean(beanName, mbd, args); 7 } catch (BeansException ex) { 8 // Explicitly remove instance from singleton cache: It might have been put there 9 // eagerly by the creation process, to allow for circular reference resolution. 10 // Also remove any beans that received a temporary reference to the bean. 11 // 显式从单例缓存中删除Bean实例 12 // 因为单例模式下为了解决循环依赖，可能它已经存在，所以销毁它 13 destroySingleton(beanName); 14 throw ex; 15 } 16 }); 17 bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd); 18 }
分析：
单例模式bean的初始化是从getSingleton方法开始，当然这里还有一个重要的createBean方法，该方法我们留在后面进行分析，首先来看getSingleton方法。
1 // DefaultSingletonBeanRegistry 2 3 public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) { 4 Assert.notNull(beanName, "Bean name must not be null"); 5 // 做同步 6 synchronized (this.singletonObjects) { 7 // 从缓存中检查一遍 8 // 因为singlton模式其实已经复用了创建的bean，所以该步骤必须检查 9 Object singletonObject = this.singletonObjects.get(beanName); 10 // 为空，开始进行加载 11 if (singletonObject == null) { 12 if (this.singletonsCurrentlyInDestruction) { 13 throw new BeanCreationNotAllowedException(beanName, 14 "Singleton bean creation not allowed while singletons of this factory are in destruction " + 15 "(Do not request a bean from a BeanFactory in a destroy method implementation!)"); 16 } 17 if (logger.isDebugEnabled()) { 18 logger.debug("Creating shared instance of singleton bean '" + beanName + "'"); 19 } 20 // 加载前置处理 其实就是打一个标记 21 beforeSingletonCreation(beanName); 22 // 首先将新的newSingleton设置为false 23 boolean newSingleton = false; 24 boolean recordSuppressedExceptions = (this.suppressedExceptions == null); 25 if (recordSuppressedExceptions) { 26 this.suppressedExceptions = new LinkedHashSet<>(); 27 } 28 try { 29 // 初始化bean 30 // 该过程其实是调用createBean()方法 这里是一个回调方法 31 singletonObject = singletonFactory.getObject(); 32 newSingleton = true; 33 } catch (IllegalStateException ex) { 34 // Has the singleton object implicitly appeared in the meantime -> 35 // if yes, proceed with it since the exception indicates that state. 36 singletonObject = this.singletonObjects.get(beanName); 37 if (singletonObject == null) { 38 throw ex; 39 } 40 } catch (BeanCreationException ex) { 41 if (recordSuppressedExceptions) { 42 for (Exception suppressedException : this.suppressedExceptions) { 43 ex.addRelatedCause(suppressedException); 44 } 45 } 46 throw ex; 47 } finally { 48 if (recordSuppressedExceptions) { 49 this.suppressedExceptions = null; 50 } 51 // 一堆异常处理后，进行后置处理 移除标志 52 afterSingletonCreation(beanName); 53 } 54 // 新的bean 加入缓存中 55 if (newSingleton) { 56 addSingleton(beanName, singletonObject); 57 } 58 } 59 return singletonObject; 60 } 61 }
分析（该方法同样为同步方法）：
该方法其实并未真正创建bean对象，获取bean对象的核心点在于singletonObject = singletonFactory.getObject()，但该方法是由createBean回调产生的。这里仅仅是做了一部分准备和预处理步骤：
- 再次从缓存中检查bean是否已经加载过，如果缓存中存在则直接返回。
- beforeSingletonCreation前面已经分析过，记录加载单例bean的状态，表示正在被加载。
- 然后调用singletonFactory.getObject方法实例化bean对象
- afterSingletonCreation前面也分析过了，移除bean正在被加载的标志。
- 将生成的bean对象加入缓存。
DefaultSingletonBeanRegistry#addSingleton
1 /** 2 * Cache of singleton objects: bean name to bean instance. 3 * 存放的是单例 bean 的映射。 4 * <p> 5 * 对应关系为 bean name --> bean instance 6 */ 7 private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256); 8 9 /** 10 * Cache of singleton factories: bean name to ObjectFactory.<br/> 11 * 存放的是 ObjectFactory，可以理解为创建单例 bean 的 factory 。 12 * <p> 13 * 对应关系是 bean name --> ObjectFactory 14 */ 15 private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16); 16 17 /** 18 * Cache of early singleton objects: bean name to bean instance.<br/> 19 * 存放的是早期的 bean，对应关系也是 bean name --> bean instance。 20 * <p> 21 * 它与 {@link #singletonFactories} 区别在于 earlySingletonObjects 中存放的 bean 不一定是完整。 22 * <p> 23 * 从 {@link #getSingleton(String)} 方法中，我们可以了解，bean 在创建过程中就已经加入到 earlySingletonObjects 中了。 24 * 所以当在 bean 的创建过程中，就可以通过 getBean() 方法获取。 25 * <p> 26 * 这个 Map 也是【循环依赖】的关键所在。 27 */ 28 private final Map<String, Object> earlySingletonObjects = new HashMap<>(16); 29 30 /** 31 * 存储已经注册的单例 进行缓存<br/> 32 * Set of registered singletons, containing the bean names in registration order. 33 */ 34 private final Set<String> registeredSingletons = new LinkedHashSet<>(256); 35 36 protected void addSingleton(String beanName, Object singletonObject) { 37 synchronized (this.singletonObjects) { 38 this.singletonObjects.put(beanName, singletonObject); 39 this.singletonFactories.remove(beanName); 40 this.earlySingletonObjects.remove(beanName); 41 this.registeredSingletons.add(beanName); 42 } 43 }
分析：
一个put、两个remove、一个add。
- 由于已经实例化了bean，因此需要将单例bean进行缓存，singletonObjects.put。
- 同理单例BeanFactory和提前曝光的bean也需要移除，singletonFactories.remove和earlySingletonObjects.remove。
- registeredSingletons.add，已实例化的bean需要进行注册。
#2.原型模式
1 if (mbd.isPrototype()) { // 原型模式 2 // It's a prototype -> create a new instance. 3 Object prototypeInstance = null; 4 try { 5 // 前置处理 6 beforePrototypeCreation(beanName); 7 /** 8 * 创建bean {@link AbstractAutowireCapableBeanFactory#createBean} 9 */ 10 prototypeInstance = createBean(beanName, mbd, args); 11 } finally { 12 /** 13 * 后置处理 与前置处理相反从{@link prototypesCurrentlyInCreation}中移除 14 */ 15 afterPrototypeCreation(beanName); 16 } 17 bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd); 18 }
分析：
原型模式下bean的初始化很简单，直接创建一个新Bean实例就可以了。
- beforePrototypeCreation：记录加载原型模式bean的加载状态，前置处理。
- createBean创建实例对象，该方法非常重要，后续会详细进行分析。
- afterPrototypeCreation：移除创建时添加的标志，后置处理与beforePrototypeCreation方法功能相反。
- 最后调用getObjectForBeanInstance获取实例，该方法在【spring源码分析】IOC容器初始化（六）中已经分析，这里不再赘述。
AbstractBeanFactory#beforePrototypeCreation
1 /** 2 * 原型模式下存储beanName的ThreadLocal<br/> 3 * Names of beans that are currently in creation. 4 */ 5 private final ThreadLocal<Object> prototypesCurrentlyInCreation = 6 new NamedThreadLocal<>("Prototype beans currently in creation"); 7 8 protected void beforePrototypeCreation(String beanName) { 9 // 从ThreadLocal中取出对象 10 Object curVal = this.prototypesCurrentlyInCreation.get(); 11 if (curVal == null) { 12 // 如果为空，则设置值 13 this.prototypesCurrentlyInCreation.set(beanName); 14 } else if (curVal instanceof String) { 15 // 如果curVal为String类型，则进行添加 16 Set<String> beanNameSet = new HashSet<>(2); 17 beanNameSet.add((String) curVal); 18 beanNameSet.add(beanName); 19 this.prototypesCurrentlyInCreation.set(beanNameSet); 20 } else { 21 // 否则将curVal转换成set集合，添加beanName 22 Set<String> beanNameSet = (Set<String>) curVal; 23 beanNameSet.add(beanName); 24 } 25 }
分析：
这里的前置处理就是将beanName加入ThreadLocal中，逻辑简单。
AbstractBeanFactory#afterPrototypeCreation
1 protected void afterPrototypeCreation(String beanName) { 2 Object curVal = this.prototypesCurrentlyInCreation.get(); 3 if (curVal instanceof String) { 4 this.prototypesCurrentlyInCreation.remove(); 5 } else if (curVal instanceof Set) { 6 Set<String> beanNameSet = (Set<String>) curVal; 7 beanNameSet.remove(beanName); 8 if (beanNameSet.isEmpty()) { 9 this.prototypesCurrentlyInCreation.remove(); 10 } 11 } 12 }
分析：
后置处理与前置处理beforePrototypeCreation正好相反，将标记从ThreadLocal中移除。
#3.其他作用域
1 // 获得scopeName对应的Scope对象 2 String scopeName = mbd.getScope(); 3 final Scope scope = this.scopes.get(scopeName); 4 if (scope == null) { 5 throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'"); 6 } 7 try { 8 /** 9 * 从指定的scope下创建bean 10 * {@link SimpleThreadScope#get方法} 11 */ 12 Object scopedInstance = scope.get(beanName, () -> { 13 beforePrototypeCreation(beanName); 14 try { 15 return createBean(beanName, mbd, args); 16 } finally { 17 afterPrototypeCreation(beanName); 18 } 19 }); 20 bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd); 21 } catch (IllegalStateException ex) { 22 throw new BeanCreationException(beanName, 23 "Scope '" + scopeName + "' is not active for the current thread; consider " + 24 "defining a scoped proxy for this bean if you intend to refer to it from a singleton", 25 ex); 26 } 27 } 28 } catch (BeansException ex) { 29 cleanupAfterBeanCreationFailure(beanName); 30 throw ex; 31 }
分析：
其他作用域bean的创建过程与原型模式的流程一样，只是获取bean的方式变成了Scope#get(String name,ObjectFactory<?> objectFactory)。
1 // SimpleThreadScope 2 public Object get(String name, ObjectFactory<?> objectFactory) { 3 // 获取scope缓存 4 Map<String, Object> scope = this.threadScope.get(); 5 Object scopedObject = scope.get(name); 6 if (scopedObject == null) { 7 // 这里getObject也是进行方法回调 8 scopedObject = objectFactory.getObject(); 9 // 加入缓存 10 scope.put(name, scopedObject); 11 } 12 return scopedObject; 13 }
这里仅仅是Scope接口的一种实现，该接口还有其他多种实现，其具体源码可查看相应实现类：
至此，Bean加载的大致流程已分析完毕，当然本篇文章并未分析一个很重要的函数createBean，该函数留在后续的文章继续分析。
by Shawn Chen，2019.04.22，下午。