测试一下25道Spring经典面试题你会几道？循环依赖面试详解

前言

先看看什么是循环依赖
当一个ClassA依赖于ClassB，然后ClassB又反过来依赖ClassA，这就形成了一个循环依赖：
ClassA -> ClassB -> ClassA
循环依赖-->2个或以上bean 互相持有对方，最终形成闭环.
Spring中循环依赖的场景:
1、构造器的循环依赖。（spring也无能为力）
2、setter循环依赖：
field属性的循环依赖【setter方式 单例，默认方式-->通过递归方法找出当前Bean所依赖的Bean，然后提前缓存【会放入Cach中】起来。通过提前暴露 -->暴露一个exposedObject用于返回提前暴露的Bean。】
Spring是先将Bean对象实例化【依赖无参构造函数】--->再设置对象属性的
Spring先用构造器实例化Bean对象----->将实例化结束的对象放到一个Map中，并且Spring提供获取这个未设置属性的实例化对象的引用方法。结合我们的实例来看，，当Spring实例化了A、B、C后，紧接着会去设置对象的属性，此时A依赖B，就会去Map中取出存在里面的单例B对象，以此类推，不会出来循环的问题喽。

下面说一下Spring是如果解决循环依赖的

第一种：构造器参数循环依赖
Spring容器会将每一个正在创建的Bean 标识符放在一个“当前创建Bean池”中，Bean标识符在创建过程中将一直保持在这个池中。
因此如果在创建Bean过程中发现自己已经在“当前创建Bean池”里时将抛出BeanCurrentlyInCreationException异常表示循环依赖；而对于创建完毕的Bean将从“当前创建Bean池”中清除掉。
首先我们先初始化三个Bean。

public class StudentA {

    private StudentB studentB ;

    public void setStudentB(StudentB studentB) {
        this.studentB = studentB;
    }

    public StudentA() {
    }

    public StudentA(StudentB studentB) {
        this.studentB = studentB;
    }
}
public class StudentB {

    private StudentC studentC ;

    public void setStudentC(StudentC studentC) {
        this.studentC = studentC;
    }

    public StudentB() {
    }

    public StudentB(StudentC studentC) {
        this.studentC = studentC;
    }
}
public class StudentC {

    private StudentA studentA ;

    public void setStudentA(StudentA studentA) {
        this.studentA = studentA;
    }

    public StudentC() {
    }

    public StudentC(StudentA studentA) {
        this.studentA = studentA;
    }
}

OK，上面是很基本的3个类，，StudentA有参构造是StudentB。StudentB的有参构造是StudentC，StudentC的有参构造是StudentA ，这样就产生了一个循环依赖的情况，
我们都把这三个Bean交给Spring管理，并用有参构造实例化。

<bean id="a" class="com.zfx.student.StudentA">
        <constructor-arg index="0" ref="b"></constructor-arg>
    </bean>
    <bean id="b" class="com.zfx.student.StudentB">
        <constructor-arg index="0" ref="c"></constructor-arg>
    </bean>
    <bean id="c" class="com.zfx.student.StudentC">
        <constructor-arg index="0" ref="a"></constructor-arg>
    </bean>

下面是测试类：
public class Test {

    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("com/zfx/student/applicationContext.xml");
        //System.out.println(context.getBean("a", StudentA.class));
    }
}

执行结果报错信息为：

Caused by: org.springframework.beans.factory.BeanCurrentlyInCreationException:
    Error creating bean with name ‘a‘: Requested bean is currently in creation: Is there an unresolvable circular reference?

如果大家理解开头那句话的话，这个报错应该不惊讶，Spring容器先创建单例StudentA，StudentA依赖StudentB，然后将A放在“当前创建Bean池”中，此时创建StudentB,StudentB依赖StudentC ,然后将B放在“当前创建Bean池”中,此时创建StudentC，StudentC又依赖StudentA， 但是，此时Student已经在池中，所以会报错，，因为在池中的Bean都是未初始化完的，所以会依赖错误 ，（初始化完的Bean会从池中移除）
第二种：setter方式单例，默认方式
如果要说setter方式注入的话，我们最好先看一张Spring中Bean实例化的图

如图中前两步骤得知：Spring是先将Bean对象实例化之后再设置对象属性的

修改配置文件为set方式注入

<!--scope="singleton"(默认就是单例方式)  -->
    <bean id="a" class="com.zfx.student.StudentA" scope="singleton">
        <property name="studentB" ref="b"></property>
    </bean>
    <bean id="b" class="com.zfx.student.StudentB" scope="singleton">
        <property name="studentC" ref="c"></property>
    </bean>
    <bean id="c" class="com.zfx.student.StudentC" scope="singleton">
        <property name="studentA" ref="a"></property>
    </bean>

下面是测试类：

public class Test {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("com/zfx/student/applicationContext.xml");
        System.out.println(context.getBean("a", StudentA.class));
    }
}

打印结果为：

`[email protected]`

为什么用set方式就不报错了呢 ？
我们结合上面那张图看，Spring先是用构造实例化Bean对象 ，此时Spring会将这个实例化结束的对象放到一个Map中，并且Spring提供了获取这个未设置属性的实例化对象引用的方法。
结合我们的实例来看，，当Spring实例化了StudentA、StudentB、StudentC后，紧接着会去设置对象的属性，此时StudentA依赖StudentB，就会去Map中取出存在里面的单例StudentB对象，以此类推，不会出来循环的问题喽、
下面是Spring源码中的实现方法。以下的源码在Spring的Bean包中的DefaultSingletonBeanRegistry.java类中

/* Cache of singleton objects: bean name --> bean instance（缓存单例实例化对象的Map集合） /
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(64);

/** Cache of singleton factories: bean name --> ObjectFactory（单例的工厂Bean缓存集合） */
private final Map<String, ObjectFactory> singletonFactories = new HashMap<String, ObjectFactory>(16);

/** Cache of early singleton objects: bean name --> bean instance（早期的单身对象缓存集合） */
private final Map<String, Object> earlySingletonObjects = new HashMap<String, Object>(16);

/** Set of registered singletons, containing the bean names in registration order（单例的实例化对象名称集合） */
private final Set<String> registeredSingletons = new LinkedHashSet<String>(64);
/**
 * 添加单例实例
 * 解决循环引用的问题
 * Add the given singleton factory for building the specified singleton
 * if necessary.
 * <p>To be called for eager registration of singletons, e.g. to be able to
 * resolve circular references.
 * @param beanName the name of the bean
 * @param singletonFactory the factory for the singleton object
 */
protected void addSingletonFactory(String beanName, ObjectFactory singletonFactory) {
    Assert.notNull(singletonFactory, "Singleton factory must not be null");
    synchronized (this.singletonObjects) {
        if (!this.singletonObjects.containsKey(beanName)) {
            this.singletonFactories.put(beanName, singletonFactory);
            this.earlySingletonObjects.remove(beanName);
            this.registeredSingletons.add(beanName);
        }
    }
}

**第三种：setter方式原型，prototype**
修改配置文件为：

<bean id="a" class="com.zfx.student.StudentA" scope="prototype">
<property name="studentB" ref="b"></property>
</bean>
<bean id="b" class="com.zfx.student.StudentB" scope="prototype">
<property name="studentC" ref="c"></property>
</bean>
<bean id="c" class="com.zfx.student.StudentC" scope="prototype">
<property name="studentA" ref="a"></property>
</b
```ean>


scope="prototype" 意思是 每次请求都会创建一个实例对象。
两者的区别是：有状态的bean都使用Prototype作用域，无状态的一般都使用singleton单例作用域。
测试用例：

public class Test {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("com/zfx/student/applicationContext.xml");
//此时必须要获取Spring管理的实例，因为现在scope="prototype" 只有请求获取的时候才会实例化对象
System.out.println(context.getBean("a", StudentA.class));
}
}


打印结果：

Caused by: org.springframework.beans.factory.BeanCurrentlyInCreationException:
Error creating bean with name ‘a‘: Requested bean is currently in creation: Is there an unresolvable circular reference?



为什么原型模式就报错了呢？
对于“prototype”作用域Bean，Spring容器无法完成依赖注入，因为“prototype”作用域的Bean，Spring容器不进行缓存，因此无法提前暴露一个创建中的Bean。

# 大家可以再回过头来看看以下Spring面试题，你自己能答对几道呢？
1 、什么是 Spring  框架？Spring  框架有哪些主要模块？
2 、使用 Spring  框架能带来哪些好处？
3 、什么是控制反转(IOC) ？什么是依赖注入？
4 、请解释下 Spring  框架中的 IoC ？
5 、BeanFactory 和 和 ApplicationContext  有什么区别？
6 、Spring  有几种配置方式？
7 、如何用基于 XML  配置的方式配置 Spring ？
8 、如何用基于 Java  配置的方式配置 Spring ？
9 、怎样用注解的方式配置 Spring ？
10 、请解释 Spring Bean  的生命周期？
11 、Spring Bean  的作用域之间有什么区别？
12 、什么是 Spring inner beans ？
13 、Spring  框架中的单例 Beans  是线程安全的么？
14 、请举例说明如何在 Spring  中注入一个 Java Collection ？
15 、如何向 Spring Bean  中注入一个 Java.util.Properties
16 、请解释 Spring Bean  的自动装配？
17 、请解释自动装配模式的区别？
18 、如何开启基于注解的自动装配？
19 、请举例解释@Required  注解？
20 、请举例解释@Autowired  注解？
21 、请举例说明@Qualifier  注解？
22 、构造方法注入和设值注入有什么区别？
23 、Spring  框架中有哪些不同类型的事件？
24 、FileSystemResource 和 和 ClassPathResource  有何区别？
25 、Spring  框架中都用到了哪些设计模式？

**欢迎大家一起交流，喜欢文章记得点个赞，感谢支持！**

原文地址：https://blog.51cto.com/14442094/2424661

时间： 2024-10-11 13:26:36

测试一下25道Spring经典面试题你会几道？循环依赖面试详解的相关文章

Spring Data Redis简介以及项目Demo，RedisTemplate和 Serializer详解

一.概念简介: Redis: Redis是一款开源的Key-Value数据库,运行在内存中,由ANSI C编写,详细的信息在Redis官网上面有,因为我自己通过google等各种渠道去学习Redis,走了不少弯路,所以总结一条我认为不错的学习路径给大家: 1.<The Little Redis Book> 是一本开源PDF,只有29页的英文文档,看完后对Redis的基本概念应该差不多熟悉了,剩下的可以去Redis官网熟悉相关的命令. 2.<Redis设计与实现> 如果想继续深入,推

【甘道夫】HBase（0.96以上版本）过滤器Filter详解及实例代码

说明: 本文参考官方Ref Guide,Developer API和众多博客,并结合实测代码编写,详细总结HBase的Filter功能,并附上每类Filter的相应代码实现. 本文尽量遵从Ref Guide中"9.4. Client Request Filters"的行文顺序,便于读者对比查看,但内容比官方文档更加详实. 欢迎转载,请注明来源: http://blog.csdn.net/u010967382/article/details/37653177 目录: 引言 -- 参数基础

转载 CSS3 经典教程系列：CSS3 盒阴影（box-shadow）详解

目标大纲 文章转载 CSS3 经典教程系列:CSS3 盒阴影(box-shadow)详解 IE中CSS-filter滤镜小知识大全

20 道 Spring Boot 面试题

转自:微信公众号:Java技术栈(id: javastack) 面试了一些人,简历上都说自己熟悉 Spring Boot, 或者说正在学习 Spring Boot,一问他们时,都只停留在简单的使用阶段,很多东西都不清楚,也让我对面试者大失所望. 下面,我给大家总结下有哪些 Spring Boot 的面试题,这是我经常拿来问面试者的,希望对你有帮助. 1.什么是 Spring Boot? Spring Boot 是 Spring 开源组织下的子项目,是 Spring 组件一站式解决方案,主要是简化

Spring之依赖配置详解

通过以上的学习,对spring容器和DI的概念应该比较清晰了,DI(依赖注入)作为spring的核心,spring当然提供了一套完善的机制来进行依赖注入.前篇文章从概念上介绍了依赖注入,本篇着重学习spring依赖注入的方法,这里主要采用xml的方式. 基本注入 构造器注入和设值注入是依赖注入的两种主要方式,spring对此有很完善的实现,下面首先以代码的形式进行简要的说明. 构造器注入 Spring容器通过调用bean的构造函数(可能带有几个参数,每个参数代表一个依赖)完成构造器注入.通过静态

spring学习——Ioc基础四（Di之循环依赖）

一. 什么是循环依赖 循环依赖就是循环引用,就是两个或多个Bean相互之间的持有对方,比如CircleA引用CircleB,CircleB引用CircleC,CircleC引用CircleA,则它们最终反映为一个环.此处不是循环调用,循环调用是方法之间的环调用.如图3-5所示: 图3-5 循环引用 循环调用是无法解决的,除非有终结条件,否则就是死循环,最终导致内存溢出错误. Spring容器循环依赖包括构造器循环依赖和setter循环依赖,那Spring容器如何解决循环依赖呢?首先让我们来定义循

Spring MVC 学习总结（二）——控制器定义与@RequestMapping详解

一.控制器定义 控制器提供访问应用程序的行为,通常通过服务接口定义或注解定义两种方法实现. 控制器解析用户的请求并将其转换为一个模型.在Spring MVC中一个控制器可以包含多个Action(动作.方法). 1.1.实现接口Controller定义控制器 Controller是一个接口,处在包org.springframework.web.servlet.mvc下,接口中只有一个未实现的方法,具体的接口如下所示: package org.springframework.web.servlet.

Scala 深入浅出实战经典 第53讲：Scala中结构类型实战详解

王家林亲授<DT大数据梦工厂>大数据实战视频 Scala 深入浅出实战经典(1-64讲)完整视频.PPT.代码下载:百度云盘:http://pan.baidu.com/s/1c0noOt6 腾讯微云:http://url.cn/TnGbdC 360云盘:http://yunpan.cn/cQ4c2UALDjSKy 访问密码 45e2土豆:http://www.tudou.com/programs/view/pR_4sY0cJLs/优酷:http://v.youku.com/v_show/id_

Scala 深入浅出实战经典 第57讲：Scala中Dependency Injection实战详解

王家林亲授<DT大数据梦工厂>大数据实战视频 Scala 深入浅出实战经典(1-87讲)完整视频.PPT.代码下载:百度云盘:http://pan.baidu.com/s/1c0noOt6 腾讯微云:http://url.cn/TnGbdC 360云盘:http://yunpan.cn/cQ4c2UALDjSKy 访问密码 45e2土豆:http://www.tudou.com/programs/view/5LnLNDBKvi8/优酷:http://v.youku.com/v_show/id_