最后
这份《“java高分面试指南”-25分类227页1000+题50w+字解析》同样可分享给有需要的朋友，感兴趣的伙伴们可挑战一下自我，在不看答案解析的情况，测试测试自己的解题水平，这样也能达到事半功倍的效果！（好东西要大家一起看才香）
7.根据 beanName 重新获取 MergedBeanDefinition，在 Spring IoC：finishBeanFactoryInitialization详解 中的代码块2已解析过。
8.2 检查 dep 是否依赖于 beanName，即检查是否存在循环依赖，见代码块6详解。
8.4 将 dep 和 beanName 的依赖关系注册到缓存中，见代码块7详解。
9.1 scope 为 singleton 的 bean 创建（新建了一个 ObjectFactory，并且重写了 getObject 方法），见代码块8详解。
9.1.1、9.2.2、9.3.4 创建 bean 实例，限于篇幅，在下篇文章单独解析。
9.1.2、9.2.4、9.3.6 返回 beanName 对应的实例对象，见代码块1详解。
9.2.1 scope 为 prototype 时创建实例前的操作、9.2.3 scope 为 prototype 时 创建实例后的操作，相对应的两个方法，见代码块11详解。
代码块1：getObjectForBeanInstance
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.
// 1.如果name以“&”为前缀，但是beanInstance不是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.
// 2.1 如果beanInstance不是FactoryBean（也就是普通bean），则直接返回beanInstance
// 2.2 如果beanInstance是FactoryBean，并且name以“&”为前缀，则直接返回beanInstance（以“&”为前缀代表想获取的是FactoryBean本身）
if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
return beanInstance;
}
// 3.走到这边，代表beanInstance是FactoryBean，但name不带有“&”前缀，表示想要获取的是FactoryBean创建的对象实例
Object object = null;
if (mbd == null) {
// 4.如果mbd为空，则尝试从factoryBeanObjectCache缓存中获取该FactoryBean创建的对象实例
object = getCachedObjectForFactoryBean(beanName);
}
if (object == null) {
// Return bean instance from factory.
// 5.只有beanInstance是FactoryBean才能走到这边，因此直接强转
FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
// Caches object obtained from FactoryBean if it is a singleton.
if (mbd == null && containsBeanDefinition(beanName)) {
// 6.mbd为空，但是该bean的BeanDefinition在缓存中存在，则获取该bean的MergedBeanDefinition
mbd = getMergedLocalBeanDefinition(beanName);
}
// 7.mbd是否是合成的（这个字段比较复杂，mbd正常情况都不是合成的，也就是false，有兴趣的可以自己查阅资料看看）
boolean synthetic = (mbd != null && mbd.isSynthetic());
// 8.从FactoryBean获取对象实例
object = getObjectFromFactoryBean(factory, beanName, !synthetic);
}
// 9.返回对象实例
return object;
}
如果对 FactoryBean 不熟悉的，可以回头去看 Spring IoC：finishBeanFactoryInitialization详解 中对 FactoryBean 的简单介绍。
6.mbd 为空，但是该 bean 的 BeanDefinition 在缓存中存在，则获取该 bean 的 MergedBeanDefinition，在 Spring IoC：finishBeanFactoryInitialization详解 中的代码块2已经解析过。
8.从 FactoryBean 获取对象实例，见代码块2详解。
代码块2：getObjectFromFactoryBean
protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
// 1.如果是单例，并且已经存在于单例对象缓存中
if (factory.isSingleton() && containsSingleton(beanName)) {
synchronized (getSingletonMutex()) {
// 2.从FactoryBean创建的单例对象的缓存中获取该bean实例
Object object = this.factoryBeanObjectCache.get(beanName);
if (object == null) {
// 3.调用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);
// 4.如果该beanName已经在缓存中存在，则将object替换成缓存中的
if (alreadyThere != null) {
object = alreadyThere;
} else {
if (object != null && shouldPostProcess) {
try {
// 5.对bean实例进行后置处理，执行所有已注册的BeanPostProcessor的postProcessAfterInitialization方法
object = postProcessObjectFromFactoryBean(object, beanName);
} catch (Throwable ex) {
throw new BeanCreationException(beanName,
“Post-processing of FactoryBean’s singleton object failed”, ex);
}
}
// 6.将beanName和object放到factoryBeanObjectCache缓存中
this.factoryBeanObjectCache.put(beanName, (object != null ? object : NULL_OBJECT));
}
}
// 7.返回object对象实例
return (object != NULL_OBJECT ? object : null);
}
} else {
// 8.调用FactoryBean的getObject方法获取对象实例
Object object = doGetObjectFromFactoryBean(factory, beanName);
if (object != null && shouldPostProcess) {
try {
// 9.对bean实例进行后置处理，执行所有已注册的BeanPostProcessor的postProcessAfterInitialization方法
object = postProcessObjectFromFactoryBean(object, beanName);
} catch (Throwable ex) {
throw new BeanCreationException(beanName, “Post-processing of FactoryBean’s object failed”, ex);
}
}
// 10.返回object对象实例
return object;
}
}
3.调用 FactoryBean 的 getObject 方法获取对象实例，见代码块3详解。
5.对 bean 实例进行后续处理，执行所有已注册的 BeanPostProcessor 的 postProcessAfterInitialization 方法，见代码块4详解。
代码块3：doGetObjectFromFactoryBean
private Object doGetObjectFromFactoryBean(final FactoryBean<?> factory, final String beanName)
throws BeanCreationException {
Object object;
try {
// 1.调用FactoryBean的getObject方法获取bean对象实例
if (System.getSecurityManager() != null) {
AccessControlContext acc = getAccessControlContext();
try {
object = AccessController.doPrivileged(new PrivilegedExceptionAction() {
@Override
public Object run() throws Exception {
// 1.1 带有权限验证的
return factory.getObject();
}
}, acc);
} catch (PrivilegedActionException pae) {
throw pae.getException();
}
} else {
// 1.2 不带权限
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.
// 2.getObject返回的是空值，并且该FactoryBean正在初始化中，则直接抛异常，不接受一个尚未完全初始化的FactoryBean的getObject返回的空值
if (object == null && isSingletonCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(
beanName, “FactoryBean which is currently in creation returned null from getObject”);
}
// 3.返回创建好的bean对象实例
return object;
}
很简单的方法，就是直接调用 FactoryBean 的 getObject 方法来获取到对象实例。
细心的同学可以发现，该方法是以 do 开头，看过 Spring IoC：源码学习总览 的同学知道，我在总览里就特别提到以 do 开头的方法是最终进行实际操作的方法，例如本方法就是 FactoryBean 最终实际进行创建 bean 对象实例的方法。
代码块4：postProcessObjectFromFactoryBean
@Override
protected Object postProcessObjectFromFactoryBean(Object object, String beanName) {
return applyBeanPostProcessorsAfterInitialization(object, beanName);
}
@Override
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
throws BeansException {
Object result = existingBean;
// 1.遍历所有注册的BeanPostProcessor实现类，调用postProcessAfterInitialization方法
for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
// 2.在bean初始化后，调用postProcessAfterInitialization方法
result = beanProcessor.postProcessAfterInitialization(result, beanName);
if (result == null) {
// 3.如果返回null，则不会调用后续的BeanPostProcessors
return result;
}
}
return result;
}
这边走的是 AbstractAutowireCapableBeanFactory 里的方法。通过前面的介绍，我们知道创建的 BeanFactory 为 DefaultListableBeanFactory，而 DefaultListableBeanFactory 继承了 AbstractAutowireCapableBeanFactory，因此这边会走 AbstractAutowireCapableBeanFactory 的重写方法。
在 Spring IoC：registerBeanPostProcessors详解 中已经学过 BeanPostProcessor，在创建完 bean 实例后，会执行 BeanPostProcessor 的 postProcessAfterInitialization 方法。
代码块5：markBeanAsCreated
protected void markBeanAsCreated(String beanName) {
if (!this.alreadyCreated.contains(beanName)) {
synchronized (this.mergedBeanDefinitions) {
// 1.如果alreadyCreated缓存中不包含beanName
if (!this.alreadyCreated.contains(beanName)) {
// Let the bean definition get re-merged now that we’re actually creating
// the bean… just in case some of its metadata changed in the meantime.
// 2.将beanName的MergedBeanDefinition从mergedBeanDefinitions缓存中移除，
// 在之后重新获取MergedBeanDefinition，避免BeanDefinition在创建过程中发生变化
clearMergedBeanDefinition(beanName);
// 3.将beanName添加到alreadyCreated缓存中，代表该beanName的bean实例已经创建（或即将创建）
this.alreadyCreated.add(beanName);
}
}
}
}
protected void clearMergedBeanDefinition(String beanName) {
this.mergedBeanDefinitions.remove(beanName);
}
2.这边会将 beanName 对应的 MergedBeanDefinition 移除，然后在之后的代码重新获取，主要是为了使用最新的 MergedBeanDefinition 来进行创建操作。
代码块6：isDependent
private boolean isDependent(String beanName, String dependentBeanName, Set alreadySeen) {
// 已经检查过的直接跳过
if (alreadySeen != null && alreadySeen.contains(beanName)) {
return false;
}
// 1.将别名解析为真正的名称
String canonicalName = canonicalName(beanName);
// 2.拿到依赖canonicalName的beanName集合
Set dependentBeans = this.dependentBeanMap.get(canonicalName);
// 3.如果dependentBeans为空，则两者必然还未确定依赖关系，返回false
if (dependentBeans == null) {
return false;
}
// 4.如果dependentBeans包含dependentBeanName，则表示两者已确定依赖关系，返回true
if (dependentBeans.contains(dependentBeanName)) {
return true;
}
// 5.循环检查，即检查依赖canonicalName的所有beanName是否存在被dependentBeanName依赖的（即隔层依赖）
for (String transitiveDependency : dependentBeans) {
if (alreadySeen == null) {
alreadySeen = new HashSet();
}
// 6.已经检查过的添加到alreadySeen，避免重复检查
alreadySeen.add(beanName);
if (isDependent(transitiveDependency, dependentBeanName, alreadySeen)) {
return true;
}
}
return false;
}
这边引入了一个缓存 dependentBeanMap：beanName -> 所有依赖 beanName 对应的 bean 的 beanName 集合。内容比较简单，就是检查依赖 beanName 的集合中是否包含 dependentBeanName，隔层依赖也算。例如：A 依赖了 B，B 依赖了 C，则 A 也算依赖了 C。
代码块7：registerDependentBean
public void registerDependentBean(String beanName, String dependentBeanName) {
// A quick check for an existing entry upfront, avoiding synchronization…
// 1.解析别名
String canonicalName = canonicalName(beanName);
// 2.拿到依赖canonicalName的beanName集合
Set dependentBeans = this.dependentBeanMap.get(canonicalName);
// 3.如果dependentBeans包含dependentBeanName，则表示依赖关系已经存在，直接返回
if (dependentBeans != null && dependentBeans.contains(dependentBeanName)) {
return;
}
// No entry yet -> fully synchronized manipulation of the dependentBeans Set
// 4.如果依赖关系还没有注册，则将两者的关系注册到dependentBeanMap和dependenciesForBeanMap缓存
synchronized (this.dependentBeanMap) {
// 4.1 将dependentBeanName添加到依赖canonicalName的beanName集合中
dependentBeans = this.dependentBeanMap.get(canonicalName);
if (dependentBeans == null) {
dependentBeans = new LinkedHashSet(8);
this.dependentBeanMap.put(canonicalName, dependentBeans);
}
dependentBeans.add(dependentBeanName);
}
synchronized (this.dependenciesForBeanMap) {
// 4.2 将canonicalName添加到dependentBeanName依赖的beanName集合中
Set dependenciesForBean = this.dependenciesForBeanMap.get(dependentBeanName);
if (dependenciesForBean == null) {
dependenciesForBean = new LinkedHashSet(8);
this.dependenciesForBeanMap.put(dependentBeanName, dependenciesForBean);
}
dependenciesForBean.add(canonicalName);
}
}
这边又引入了一个跟 dependentBeanMap 类似的缓存，dependenciesForBeanMap：beanName -> beanName 对应的 bean 依赖的所有 bean 的 beanName 集合。
这两个缓存很容易搞混，举个简单例子：例如 B 依赖了 A，则 dependentBeanMap 缓存中应该存放一对映射：其中 key 为 A，value 为含有 B 的 Set；而 dependenciesForBeanMap 缓存中也应该存放一对映射：其中 key 为：B，value 为含有 A 的 Set。
代码块8：getSingleton
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(beanName, “‘beanName’ must not be null”);
// 1.加锁，避免重复创建单例对象
synchronized (this.singletonObjects) {
// 2.首先检查beanName对应的bean实例是否在缓存中存在，如果已经存在，则直接返回
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
// 3.beanName对应的bean实例不存在于缓存中，则进行Bean的创建
if (this.singletonsCurrentlyInDestruction) {
// 4.当bean工厂的单例处于destruction状态时，不允许进行单例bean创建，抛出异常
throw new BeanCreationNotAllowedException(beanName,
"Singleton bean creation not allowed while 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 + “'”);
}
// 5.创建单例前的操作
beforeSingletonCreation(beanName);
boolean newSingleton = false;
// suppressedExceptions用于记录异常相关信息
boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
if (recordSuppressedExceptions) {
this.suppressedExceptions = new LinkedHashSet();
}
try {
// 6.执行singletonFactory的getObject方法获取bean实例
singletonObject = singletonFactory.getObject();
// 标记为新的单例对象
newSingleton = true;
} catch (IllegalStateException ex) {
// Has the singleton object implicitly appeared in the meantime ->
// if yes, proceed with it since the exception indicates that state.
singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
throw ex;
}
} catch (BeanCreationException ex) {
if (recordSuppressedExceptions) {
for (Exception suppressedException : this.suppressedExceptions) {
ex.addRelatedCause(suppressedException);
}
}
throw ex;
} finally {
if (recordSuppressedExceptions) {
this.suppressedExceptions = null;
}
// 7.创建单例后的操作
afterSingletonCreation(beanName);
}
if (newSingleton) {
// 8.如果是新的单例对象，将beanName和对应的bean实例添加到缓存中（singletonObjects、registeredSingletons）
addSingleton(beanName, singletonObject);
}
}
// 9.返回创建出来的单例对象
return (singletonObject != NULL_OBJECT ? singletonObject : null);
}
}
5.创建单例前的操作，7.创建单例后的操作，这两个方法是对应的，见代码块9详解。
6.执行 singletonFactory 的 getObject 方法获取 bean 实例，该方法会走文章开头 doGetBean 方法的注释 9.1.1。
8.如果是新的单例对象，将 beanName 和对应的单例对象添加到缓存中，见代码块10详解。
代码块9：beforeSingletonCreation、afterSingletonCreation
protected void beforeSingletonCreation(String beanName) {
// 先校验beanName是否为要在创建检查排除掉的（inCreationCheckExclusions缓存），如果不是，
// 则将beanName加入到正在创建bean的缓存中（Set），如果beanName已经存在于该缓存，会返回false抛出异常（这种情况出现在构造器的循环依赖）
if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
}
protected void afterSingletonCreation(String beanName) {
// 先校验beanName是否为要在创建检查排除掉的（inCreationCheckExclusions缓存），如果不是，
// 则将beanName从正在创建bean的缓存中（Set）移除，如果beanName不存在于该缓存，会返回false抛出异常
if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.remove(beanName)) {
throw new IllegalStateException(“Singleton '” + beanName + “’ isn’t currently in creation”);
}
}
inCreationCheckExclusions 是要在创建检查排除掉的 beanName 集合，正常为空，可以不管。这边主要是引入了 singletonsCurrentlyInCreation 缓存：当前正在创建的 bean 的 beanName 集合。在 beforeSingletonCreation 方法中，通过添加 beanName 到该缓存，可以预防出现构造器循环依赖的情况。
为什么无法解决构造器循环依赖？
我们之前在 Spring IoC：finishBeanFactoryInitialization详解 中的代码块7提过，getSingleton 方法是解决循环引用的核心代码。解决逻辑的第一句话：“我们先用构造函数创建一个 “不完整” 的 bean 实例”，从这句话可以看出，构造器循环依赖是无法解决的，因为当构造器出现循环依赖，我们连 “不完整” 的 bean 实例都构建不出来。Spring 能解决的循环依赖有：通过 setter 注入的循环依赖、通过属性注入的循环依赖。
代码块10：addSingleton
protected void addSingleton(String beanName, Object singletonObject) {
synchronized (this.singletonObjects) {
// 1.添加到单例对象缓存
this.singletonObjects.put(beanName, (singletonObject != null ? singletonObject : NULL_OBJECT));
// 2.将单例工厂缓存移除（已经不需要）
this.singletonFactories.remove(beanName);
// 3.将早期单例对象缓存移除（已经不需要）
this.earlySingletonObjects.remove(beanName);
// 4.添加到已经注册的单例对象缓存
this.registeredSingletons.add(beanName);
}
}
代码块11：beforePrototypeCreation、afterPrototypeCreation
protected void beforePrototypeCreation(String beanName) {
// 1.拿到当前线程中正在创建的prototype的bean的beanName集合
Object curVal = this.prototypesCurrentlyInCreation.get();
// 2.如果为空，则将ThreadLocal设置成当前的beanName
if (curVal == null) {
this.prototypesCurrentlyInCreation.set(beanName);
}
// 3.如果不为空，并且是String类型，则代表目前只有一个beanName，将之前和当前的一起封装成Set，设置到ThreadLocal中
else if (curVal instanceof String) {
Set beanNameSet = new HashSet(2);
beanNameSet.add((String) curVal);
beanNameSet.add(beanName);
this.prototypesCurrentlyInCreation.set(beanNameSet);
}
// 4.如果不为空，并且不是String，则必然是Set类型，将当前的beanName加到Set中去
else {
Set beanNameSet = (Set) curVal;
beanNameSet.add(beanName);
}
}
总结
面试难免让人焦虑不安。经历过的人都懂的。但是如果你提前预测面试官要问你的问题并想出得体的回答方式，就会容易很多。
此外，都说“面试造火箭，工作拧螺丝”，那对于准备面试的朋友，你只需懂一个字：刷！
给我刷刷刷刷，使劲儿刷刷刷刷刷！今天既是来谈面试的，那就必须得来整点面试真题，这不花了我整28天，做了份“Java一线大厂高岗面试题解析合集：JAVA基础-中级-高级面试+SSM框架+分布式+性能调优+微服务+并发编程+网络+设计模式+数据结构与算法等”
且除了单纯的刷题，也得需准备一本【JAVA进阶核心知识手册】：JVM、JAVA集合、JAVA多线程并发、JAVA基础、Spring 原理、微服务、Netty与RPC、网络、日志、Zookeeper、Kafka、RabbitMQ、Hbase、MongoDB、Cassandra、设计模式、负载均衡、数据库、一致性算法、JAVA算法、数据结构、加密算法、分布式缓存、Hadoop、Spark、Storm、YARN、机器学习、云计算，用来查漏补缺最好不过。
InCreation.set(beanNameSet);
}
// 4.如果不为空，并且不是String，则必然是Set类型，将当前的beanName加到Set中去
else {
Set beanNameSet = (Set) curVal;
beanNameSet.add(beanName);
}
}
总结
面试难免让人焦虑不安。经历过的人都懂的。但是如果你提前预测面试官要问你的问题并想出得体的回答方式，就会容易很多。
此外，都说“面试造火箭，工作拧螺丝”，那对于准备面试的朋友，你只需懂一个字：刷！
给我刷刷刷刷，使劲儿刷刷刷刷刷！今天既是来谈面试的，那就必须得来整点面试真题，这不花了我整28天，做了份“Java一线大厂高岗面试题解析合集：JAVA基础-中级-高级面试+SSM框架+分布式+性能调优+微服务+并发编程+网络+设计模式+数据结构与算法等”
[外链图片转存中…(img-NGKCn1SB-1714870766441)]
且除了单纯的刷题，也得需准备一本【JAVA进阶核心知识手册】：JVM、JAVA集合、JAVA多线程并发、JAVA基础、Spring 原理、微服务、Netty与RPC、网络、日志、Zookeeper、Kafka、RabbitMQ、Hbase、MongoDB、Cassandra、设计模式、负载均衡、数据库、一致性算法、JAVA算法、数据结构、加密算法、分布式缓存、Hadoop、Spark、Storm、YARN、机器学习、云计算，用来查漏补缺最好不过。
[外链图片转存中…(img-iNridzH0-1714870766441)]
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
