Java经典面试题最全汇总208道(三)

前言 

短时间提升自己最快的手段就是背面试题，最近总结了Java常用的面试题，分享给大家，希望大家都能圆梦大厂，加油，我命由我不由天。

websocket应用的是哪个协议

WebSocket是一个允许Web应用程序(通常指浏览器)与服务器进行双向通信的协议。

HTML5的WebSocket API主要是为浏览器端提供了一个基于TCP协议实现全双工通信的方法。

WebSocket优势： 浏览器和服务器只需要要做一个握手的动作，在建立连接之后，双方可以在任意时刻，相互推送信息。

同时，服务器与客户端之间交换的头信息很小。

106、说一下 tcp 粘包是怎么产生的？

发送方需要等缓冲区满才能发送出去，造成粘包；

接收方不及时接收缓冲区的包，造成粘包；

107、请列举出在 JDK 中几个常用的设计模式？

1、单例模式

作用：保证类只有一个实例。

JDK中体现：Runtime类。

2、静态工厂模式

作用：代替构造函数创建对象，方法名比构造函数清晰。

JDK中体现：Integer.valueOf、Class.forName

3、抽象工厂

作用：创建某一种类的对象。

JDK中体现：Java.sql包。

4、原型模式

clone()；

原型模式的本质是拷贝原型来创建新的对象，拷贝是比new更快的创建对象的方法，当需要大批量创建新对象而且都是同一个类的对象的时候考虑使用原型模式。

一般的克隆只是浅拷贝（对象的hash值不一样，但是对象里面的成员变量的hash值是一样的）。

有些场景需要深拷贝，这时我们就要重写clone方法，以ArrayList为例：

5、适配器模式

作用：使不兼容的接口相容。

JDK中体现：InputStream、OutputStream。

6、装饰器模式

作用：为类添加新的功能，防止类继承带来的类爆炸。

JDK中体现：io类、Collections、List。

7、外观模式

作用：封装一组交互类，一直对外提供接口。

JDK中体现：logging包。

8、享元模式

作用：共享对象、节省内存。

JDK中体现：Integer.valueOf、String常量池。

9、代理模式

作用：

（1）透明调用被代理对象，无须知道复杂实现细节；

（2）增加被代理类的功能；

JDK中体现：动态代理。

10、迭代器模式

作用：将集合的迭代和集合本身分离。

JDK中体现：Iterator

11、命令模式

作用：封装操作，使接口一致。

JDK中体现：Runable、Callable、ThreadPoolExecutor。

108、什么是设计模式？你是否在你的代码里面使用过任何设计模式？

1、什么是设计模式？

设计模式是解决软件开发某些特定问题而提出的一些解决方案，也可以理解为解决问题的一些固定思路。

通过设计模式可以帮助我们增强代码的可复用性、可扩展性、灵活性。

我们使用设计模式的最终目的是实现代码的高内聚、低耦合。

2、设计模式的七大原则

单一职责原则接口隔离原则依赖倒转原则里式替换原则开闭原则迪米特法则合成复用原则

3、你是否在你的代码里面使用过任何设计模式？

（1）单例模式

JDK种的runtime，Spring种的singeton。

（2）简单工厂模式

Spring的BeanFactory，根据传入一个唯一标识来获得bean对象。

（3）原型模式

clone()

（4）代理模式

Spring的AOP中，Spring实现AOP功能的原理就是代理模式，①JDK动态代理。②CGLIB动态代理，使用Advice（通知）对类进行方法级别的切面增强。

（5）装饰器模式

为类添加新的功能，防止类爆炸；

IO流、数据源包装，Spring中用到的装饰器模式表现在Wrapper。

109、Java 中什么叫单例设计模式？请用 Java 写出线程安全的单例模式

1. 保证程序只有一个对象的实例，叫做单例模式；
2. 内部类的方式实现单例模式，是线程安全的；
3. 双重验证方式实现单例模式也是线程安全的；

110、在 Java 中，什么叫观察者设计模式（observer design pattern）？

1、观察者模式是一种一对多的依赖关系，让多个观察者同时监听某一主题对象。当这个主题对象发生变化时，会通知所有观察者对象，使它们能够自动更新自己。

2、Java提供的对观察者模式的支持

在Java语言的java.util库里面，提供了一个Observable类以及一个Observer接口，构成Java语言对观察者模式的支持。

（1）Observer接口

这个接口只定义了一个方法，即update()方法，当被观察者对象的状态发生变化时，被观察者对象的notifyObservers()方法就会调用这一方法。

public interface Observer {
    void update(Observable o, Object arg);
}

（2）Observable类

被观察者类都是java.util.Observable类的子类。

java.util.Observable提供公开的方法支持观察者对象，这些方法中有两个对Observable的子类非常重要：一个是setChanged()，另一个是notifyObservers()。

第一方法setChanged()被调用之后会设置一个内部标记变量，代表被观察者对象的状态发生了变化。

第二个是notifyObservers()，这个方法被调用时，会调用所有登记过的观察者对象的update()方法，使这些观察者对象可以更新自己。

111、使用工厂模式最主要的好处是什么？在哪里使用？

1、工厂模式好处

良好的封装性、代码结构清晰；扩展性好，如果想增加一个产品，只需扩展一个工厂类即可；典型的解耦框架；

2、在哪里使用？

需要生成对象的地方；不同数据库的访问；

112、请解释自动装配模式的区别？

有五种自动装配的方式，可以用来指导 Spring 容器用自动装配方式来进行依赖注入。

1、no

默认的方式是不进行自动装配，通过显式设置 ref 属性来进行装配。

2、byName

通过参数名 自动装配，Spring 容器在配置文件中发现 bean的 autowire 属性被设置成 byname，之后容器试图匹配、装配和该 bean 的属性具有相同名字的 bean。

3、byType:

通过参数类型自动装配，Spring 容器在配置文件中发现 bean的 autowire 属性被设置成 byType，之后容器试图匹配、装配和该 bean 的属性具有相同类型的 bean。

如果有多个 bean 符合条件，则抛出错误。

4、constructor

这个方式类似于 byType， 但是要提供给构造器参数，如果没有确定的带参数的构造器参数类型，将会抛出异常。

5、autodetect

首先尝试使用 constructor 来自动装配，如果无法工作，则使用 byType 方式。

113、举一个用 Java 实现的装饰模式(decorator design pattern)？它是作用于对象层次还是类层次？

1. 在Java IO中运用了装饰器模式，inputStream作为抽象类，其下有几个实现类，表示从不同的数据源输入：
2. byteArrayInputStreamfileInputStreamStringBufferInputStreamPipedInputStream，从管道产生输入；
3. SequenceInputStream，可将其他流收集合并到一个流内；
4. FilterInputStream作为装饰器在JDK中是一个普通类，其下面有多个具体装饰器比如BufferedInputStream、DataInputStream等。
5. FilterInputStream内部封装了基础构件：

protected volatile InputStream in;

而BufferedInputStream在调用其read()读取数据时会委托基础构件来进行更底层的操作，而它自己所起的装饰作用就是缓冲，在源码中可以很清楚的看到这一切。

114、什么是 Spring 框架？Spring 框架有哪些主要模块？

Spring是一个控制反转和面向切面的容器框架。

Spring有七大功能模块：

1、Core

Core模块是Spring的核心类库，Core实现了IOC功能。

2、AOP

Apring AOP模块是Spring的AOP库，提供了AOP（拦截器）机制，并提供常见的拦截器，供用户自定义和配置。

3、orm

提供对常用ORM框架的管理和支持，hibernate、mybatis等。

4、Dao

Spring提供对JDBC的支持，对JDBC进行封装。

5、Web

对Struts2的支持。

6、Context

Context模块提供框架式的Bean的访问方式，其它程序可以通过Context访问Spring的Bean资源，相当于资源注入。

7、MVC

MVC模块为spring提供了一套轻量级的MVC实现，即Spring MVC。

115、使用 Spring 框架能带来哪些好处？

1、轻量级框架、容器

Spring是一个容器，管理对象的生命周期和配置。基于一个可配置原型prototype，你的bean可以使单利的，也可以每次需要时都生成一个新的实例。

2、控制反转IOC

Spring通过控制反转实现松耦合。

3、支持AOP

Spring提供对AOP的支持，它允许将一些通用任务，如安全、事务、日志等进行集中式处理，从而提高了程序的复用性。

4、轻量级框架

5、方便测试

Spring提供Junit4的支持，可以通过注解方便测试spring程序。

6、对Java中很多API进行了封装

7、方便集成各种优秀框架

如Struts、hibernate、mybstis。

8、支持声明式事务处理

只需通过配置就可以完成对事务的管理，而无须手动编程。

116、Spring IOC、AOP举例说明

1、IOC理论的背景

我们都知道，在采用面向对象方法设计的软件系统中，它的底层实现都是由N个对象组成的，所有的对象通过彼此的合作，最终实现系统的业务逻辑。

如果我们打开机械式手表的后盖，就会看到与上面类似的情形，各个齿轮分别带动时针、分针和秒针顺时针旋转，从而在表盘上产生正确的时间。

图1中描述的就是这样的一个齿轮组，它拥有多个独立的齿轮，这些齿轮相互啮合在一起，协同工作，共同完成某项任务。我们可以看到，在这样的齿轮组中，如果有一个齿轮出了问题，就可能会影响到整个齿轮组的正常运转。

齿轮组中齿轮之间的啮合关系,与软件系统中对象之间的耦合关系非常相似。

对象之间的耦合关系是无法避免的，也是必要的，这是协同工作的基础。现在，伴随着工业级应用的规模越来越庞大，对象之间的依赖关系也越来越复杂，经常会出现对象之间的多重依赖性关系

因此，架构师和设计师对于系统的分析和设计，将面临更大的挑战。对象之间耦合度过高的系统，必然会出现牵一发而动全身的情形。

耦合关系不仅会出现在对象与对象之间，也会出现在软件系统的各模块之间，以及软件系统和硬件系统之间。如何降低系统之间、模块之间和对象之间的耦合度，是软件工程永远追求的目标之一。

为了解决对象之间的耦合度过高的问题，软件专家Michael Mattson提出了IOC理论，用来实现对象之间的“解耦”，目前这个理论已经被成功地应用到实践当中，很多的J2EE项目均采用了IOC框架产品Spring。

2、什么是控制反转

IOC是Inversion of Control的缩写，多数书籍翻译成“控制反转”，还有些书籍翻译成为“控制反向”或者“控制倒置”。

1996年，Michael Mattson在一篇有关探讨面向对象框架的文章中，首先提出了IOC 这个概念。

对于面向对象设计及编程的基本思想，前面我们已经讲了很多了，不再赘述，简单来说就是把复杂系统分解成相互合作的对象，这些对象类通过封装以后，内部实现对外部是透明的，从而降低了解决问题的复杂度，而且可以灵活地被重用和扩展。

IOC理论提出的观点大体是这样的：借助于“第三方”实现具有依赖关系的对象之间的解耦，如下图：

大家看到了吧，由于引进了中间位置的“第三方”，也就是IOC容器，使得A、B、C、D这4个对象没有了耦合关系，齿轮之间的传动全部依靠“第三方”了，全部对象的控制权全部上缴给“第三方”IOC容器，所以，IOC容器成了整个系统的关键核心，它起到了一种类似“粘合剂”的作用，把系统中的所有对象粘合在一起发挥作用，如果没有这个“粘合剂”，对象与对象之间会彼此失去联系，这就是有人把IOC容器比喻成“粘合剂”的由来。

我们再来做个试验：把上图中间的IOC容器拿掉，然后再来看看这套系统（拿掉IoC容器后的系统）：

我们现在看到的画面，就是我们要实现整个系统所需要完成的全部内容。

这时候，A、B、C、D这4个对象之间已经没有了耦合关系，彼此毫无联系，这样的话，当你在实现A的时候，根本无须再去考虑B、C和D了，对象之间的依赖关系已经降低到了最低程度。

所以，如果真能实现IOC容器，对于系统开发而言，这将是一件多么美好的事情，参与开发的每一成员只要实现自己的类就可以了，跟别人没有任何关系！

我们再来看看，控制反转(IOC)到底为什么要起这么个名字？我们来对比一下：

软件系统在没有引入IOC容器之前，如图1所示，对象A依赖于对象B，那么对象A在初始化或者运行到某一点的时候，自己必须主动去创建对象B或者使用已经创建的对象B。

无论是创建还是使用对象B，控制权都在自己手上。

软件系统在引入IOC容器之后，这种情形就完全改变了，如图3所示，由于IOC容器的加入，对象A与对象B之间失去了直接联系

所以，当对象A运行到需要对象B的时候，IOC容器会主动创建一个对象B注入到对象A需要的地方。

通过前后的对比，我们不难看出来：对象A获得依赖对象B的过程,由主动行为变为了被动行为，控制权颠倒过来了，这就是“控制反转”这个名称的由来。

3、IOC的别名：依赖注入（DI）

2004年，Martin Fowler探讨了同一个问题，既然IOC是控制反转，那么到底是“哪些方面的控制被反转了呢？”

经过详细地分析和论证后，他得出了答案：“获得依赖对象的过程被反转了”。

控制被反转之后，获得依赖对象的过程由自身管理变为了由IOC容器主动注入。

于是，他给“控制反转”取了一个更合适的名字叫做“依赖注入（Dependency Injection）”。

他的这个答案，实际上给出了实现IOC的方法：注入。

所谓依赖注入，就是由IOC容器在运行期间，动态地将某种依赖关系注入到对象之中。

所以，依赖注入(DI)和控制反转(IOC)是从不同的角度的描述的同一件事情，就是指通过引入IOC容器，利用依赖关系注入的方式，实现对象之间的解耦。

我们举一个生活中的例子，来帮助理解依赖注入的过程。

大家对USB接口和USB设备应该都很熟悉吧，USB为我们使用电脑提供了很大的方便，现在有很多的外部设备都支持USB接口。

现在，我们利用电脑主机和USB接口来实现一个任务：从外部USB设备读取一个文件。

电脑主机读取文件的时候，它一点也不会关心USB接口上连接的是什么外部设备，而且它确实也无须知道。

它的任务就是读取USB接口，挂接的外部设备只要符合USB接口标准即可。所以，如果我给电脑主机连接上一个U盘，那么主机就从U盘上读取文件；

如果我给电脑主机连接上一个外置硬盘，那么电脑主机就从外置硬盘上读取文件。

挂接外部设备的权力由我作主，即控制权归我，至于USB接口挂接的是什么设备，电脑主机是决定不了，它只能被动的接受。

电脑主机需要外部设备的时候，根本不用它告诉我，我就会主动帮它挂上它想要的外部设备，你看我的 服务是多么的到位。这就是我们生活中常见的一个依赖注入的例子。

在这个过程中，我就起到了IOC容器的作用。

通过这个例子,依赖注入的思路已经非常清楚：当电脑主机读取文件的时候，我就把它所要依赖的外部设备，帮他挂接上。整个外部设备注入的过程和一个被依赖的对象在系统运行时被注入另外一个对象内部的过程完全一样。

我们把依赖注入应用到软件系统中，再来描述一下这个过程：

对象A依赖于对象B,当对象 A需要用到对象B的时候，IOC容器就会立即创建一个对象B送给对象A。

IOC容器就是一个对象制造工厂，你需要什么，它会给你送去，你直接使用就行了，而再也不用去关心你所用的东西是如何制成的，也不用关心最后是怎么被销毁的，这一切全部由IOC容器包办。

在传统的实现中，由程序内部代码来控制组件之间的关系。

我们经常使用new关键字来实现两个组件之间关系的组合，这种实现方式会造成组件之间耦合。

IOC很好地解决了该问题，它将实现组件间关系从程序内部提到外部容器，也就是说由容器在运行期将组件间的某种依赖关系动态注入组件中。

4、IOC为我们带来了什么好处

我们还是从USB的例子说起，使用USB外部设备比使用内置硬盘，到底带来什么好处？

第一、USB设备作为电脑主机的外部设备，在插入主机之前，与电脑主机没有任何的关系，只有被我们连接在一起之后，两者才发生联系，具有相关性。

所以，无论两者中的任何一方出现什么的问题，都不会影响另一方的运行。

这种特性体现在软件工程中，就是可维护性比较好，非常便于进行单元测试，便于调试程序和诊断故障。

代码中的每一个Class都可以单独测试，彼此之间互不影响，只要保证自身的功能无误即可，这就是组件之间低耦合或者无耦合带来的好处。

第二、USB设备和电脑主机的之间无关性，还带来了另外一个好处，生产USB设备的厂商和生产电脑主机的厂商完全可以是互不相干的人，各干各事，他们之间唯一需要遵守的就是USB接口标准。

这种特性体现在软件开发过程中，好处可是太大了。

每个开发团队的成员都只需要关心实现自身的业务逻辑，完全不用去关心其它的人工作进展，因为你的任务跟别人没有任何关系，你的任务可以单独测试，你的任务也不用依赖于别人的组件，再也不用扯不清责任了。

所以，在一个大中型项目中，团队成员分工明确、责任明晰，很容易将一个大的任务划分为细小的任务，开发效率和产品质量必将得到大幅度的提高。

第三、同一个USB外部设备可以插接到任何支持USB的设备，可以插接到电脑主机，也可以插接到DV机，USB外部设备可以被反复利用。在软件工程中，这种特性就是可复用性好，我们可以把具有普遍性的常用组件独立出来，反复利用到项目中的其它部分，或者是其它项目，当然这也是面向对象的基本特征。

显然，IOC不仅更好地贯彻了这个原则，提高了模块的可复用性。符合接口标准的实现，都可以插接到支持此标准的模块中。

第四、同USB外部设备一样，模块具有热插拔特性。IOC生成对象的方式转为外置方式，也就是把对象生成放在配置文件里进行定义，这样，当我们更换一个实现子类将会变得很简单，只要修改配置文件就可以了，完全具有热插拨的特性。

以上几点好处，难道还不足以打动我们，让我们在项目开发过程中使用IOC框架吗？

5、IOC容器的技术剖析

IOC中最基本的技术就是“反射(Reflection)”编程，目前.Net C#、Java和PHP5等语言均支持，其中PHP5的技术书籍中，有时候也被翻译成“映射”。有关反射的概念和用法，大家应该都很清楚，通俗来讲就是根据给出的类名（字符串方式）来动态地生成对象。

这种编程方式可以让对象在生成时才决定到底是哪一种对象。

反射的应用是很广泛的，很多的成熟的框架，比如象Java中的Hibernate、Spring框架，.Net中 NHibernate、Spring.Net框架都是把“反射”做为最基本的技术手段。

反射技术其实很早就出现了，但一直被忽略，没有被进一步的利用。

当时的反射编程方式相对于正常的对象生成方式要慢至少得10倍。

现在的反射技术经过改良优化，已经非常成熟，反射方式生成对象和通常对象生成方式，速度已经相差不大了，大约为1-2倍的差距。

我们可以把IOC容器的工作模式看做是工厂模式的升华，可以把IOC容器看作是一个工厂，这个工厂里要生产的对象都在配置文件中给出定义，然后利用编程语言的的反射编程，根据配置文件中给出的类名生成相应的对象。

从实现来看，IOC是把以前在工厂方法里写死的对象生成代码，改变为由配置文件来定义，也就是把工厂和对象生成这两者独立分隔开来，目的就是提高灵活性和可维护性。

6、IOC容器的一些产品

Sun ONE技术体系下的IOC容器有：轻量级的有Spring、Guice、Pico Container、Avalon、HiveMind；

重量级的有EJB；

不轻不重的有JBoss，Jdon等等。

Spring框架作为Java开发中SSH(Struts、Spring、Hibernate)三剑客之一，大中小项目中都有使用，非常成熟，应用广泛，EJB在关键性的工业级项目中也被使用，比如某些电信业务。

Net技术体系下的IOC容器有：Spring.Net、Castle等等。

Spring.Net是从Java的Spring移植过来的IOC容器，Castle的IOC容器就是Windsor部分。

它们均是轻量级的框架，比较成熟，其中Spring.Net已经被逐渐应用于各种项目中。

7、使用IOC框架应该注意什么

使用IOC框架产品能够给我们的开发过程带来很大的好处，但是也要充分认识引入IOC框架的缺点，做到心中有数，杜绝滥用框架。

（1）软件系统中由于引入了第三方IOC容器，生成对象的步骤变得有些复杂，本来是两者之间的事情，又凭空多出一道手续

所以，我们在刚开始使用IOC框架的时候，会感觉系统变得不太直观。所以，引入了一个全新的框架，就会增加团队成员学习和认识的培训成本，并且在以后的运行维护中，还得让新加入者具备同样的知识体系。

（2）由于IOC容器生成对象是通过反射方式，在运行效率上有一定的损耗。如果你要追求运行效率的话，就必须对此进行权衡。

（3）、具体到IOC框架产品(比如：Spring)来讲，需要进行大量的配制工作，比较繁琐，对于一些小的项目而言，客观上也可能加大一些工作成本。

（4）IOC框架产品本身的成熟度需要进行评估，如果引入一个不成熟的IOC框架产品，那么会影响到整个项目，所以这也是一个隐性的风险。

我们大体可以得出这样的结论：一些工作量不大的项目或者产品，不太适合使用IOC框架产品。另外，如果团队成员的知识能力欠缺，对于IOC框架产品缺乏深入的理解，也不要贸然引入。

最后，特别强调运行效率的项目或者产品，也不太适合引入IOC框架产品，象WEB2.0网站就是这种情况。

117、什么是控制反转(IOC)？什么是依赖注入？

借助Spring实现具有依赖关系的对象之间的解耦。

对象A运行需要对象B，由主动创建变为IOC容器注入，这便是控制反转。

获得依赖对象的过程被反转了，获取依赖对象的过程由自身创建变为由IOC容器注入，这便是依赖注入。

118、BeanFactory 和 ApplicationContext 有什么区别？

1、BeanFactory是Spring的最底层接口，包含bean的定义，管理bean的加载，实例化，控制bean的生命周期，特点是每次获取对象时才会创建对象。

ApplicationContext是BeanFactory的子接口，拥有BeanFactory的全部功能，并且扩展了很多高级特性，每次容器启动时就会创建所有的对象。

• ApplicationContext的额外功能：继承MessageSource，支持国际化；
• 统一的资源文件访问方式；
• 提供在监听器中注册bean；
• 同时加载过个配置文件；
• 载入多个（有继承关系）上下文，使得每个上下文都专注于一个特定的层次，比如应用的web层；

2、BeanFactory通常以编程的方式被创建，ApplicationContext可以以声明的方式创建，如使用ContextLoader。

3、BeanFactory 和 ApplicationContext都支持BeanPostProcessor，BeanFactoryPostProcessor，但BeanFactory需要手动注册，ApplicationContext则是自动注册。

119、什么是 JavaConfig？

JavaConfig是Spring3.0新增的概念，就是以注解的形式取代Spring中繁琐的xml文件。

JavaConfig结合了xml的解耦和java编译时检查的优点。

1. @Configuration，表示这个类是配置类；
2. @ComponentScan，相当于xml的<context:componentScan basepackage=>；
3. @Bean，相当于xml的<bean id="student" class="com.guor.entity">；
4. @EnableWebMvc，相当于xml的<mvc:annotation-driven>；
5. @ImportResource，相当于xml的<import resource="application-context-cache.xml">；
6. @PropertySource，用于读取properties配置文件；
7. @Profile，一般用于多环境配置，激活时可用
8. @ActiveProfile("dev")注解；

120、什么是 ORM 框架？

ORM（Object-relational mapping），对象关系映射。

是为了解决面向对象与关系型数据库存在的不匹配问题。

ORM框架的优点：

1. 开发效率更高
2. 数据访问更抽象、
3. 轻便支持面向对象封装

121、Spring 有几种配置方式？

1、xml配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
 
    <bean id="jackma" class="com.tyq.dto.User">
        <property name="name" value="jackma" />
        <property name="age" value="55" />
        <property name="dog" ref="jm" />
     </bean>
 
    <bean id="jm" class="com.tyq.dto.Dog">
        <property name="name" value="jack" />
        <property name="breed" value="金毛" />
        <property name="age" value="2" />
    </bean>
</beans>

2、基于注解的方式

项目越来越大，基于xml配置太麻烦，Spring 2.x时代提供了声明bean的注解。

（1）Bean的定义

@Component、@Controller、@Service、@Repository。

（2）Bean的注入

@Autowire

3、基于Java的方式

Spring 3.x以后，可以通过Java代码装配Bean。

@Configuration
public class DemoConfig {
    @Bean
    public User zs(){
        return new User();
    }
    @Bean
    public Dog dog(){
        return  new Dog();
    }
    @Bean  //两个狗
    public Dog haqi(){
        return new Dog();
    }
}

@Component("zs")
public class User {
    private String name;
    private int age;
    private Dog dog;
 
  //get，set方法略
}

 原来就是配置类啊，通过@Bean、@Component、getBean方式进行Bean的注册和发现。

122、请解释 Spring Bean 的生命周期？

1. 通过构造器或工厂方法创建bean实例；
2. 为bean的属性赋值；
3. 调用bean的初始化方法；
4. 使用bean；
5. 当容器关闭时，调用bean的销毁方法；

123、Spring Bean 的作用域之间有什么区别？

Spring容器中的bean可以分为5个范围：

1. singleton：这种bean范围是默认的，这种范围确保不管接受多少请求，每个容器中只哟一个bean的实例，单例模式；
2. prototype：为每一个bean提供一个实例；
3. request：在请求bean范围内为每一个来自客户端的网络请求创建一个实例，在请求完毕后，bean会失效并被垃圾回收器回收；
4. session：为每个session创建一个实例，session过期后，bean会随之消失；
5. global-session：global-session和Portlet应用相关。当你的应用部署在Portlet容器中工作时，它包含很多portlet。如果你想要声明让所有的portlet公用全局的存储变量的话，那么全局变量需要存储在global-session中。

124、如何在 Spring Boot 中禁用 Actuator 端点安全性？

默认情况下，所有敏感的HTTP端点都是安全的，只有具有Actuator角色的用户才能访问它们。

安全性是使用标准的HTTPServletRequest.isUserInRole方法实施的。

我们可以使用management.security.enable = false来禁用安全性。

只有在执行机构端点在防火墙后访问时，才建议禁用安全性。

125、什么是 Spring inner beans？

在Spring框架中，无论何时bean被使用时，当仅被调用一个属性。

可以将这个bean声明为内部bean。

内部bean可以用setter注入“属性”和构造方法注入“构造参数”的方式来实现。比如，在我们的应用程序中，一个Customer类引用了一个Person类，我们要做的是创建一个Person实例，然后再Customer内部使用。

package com;
 
public class Customer {
    private Person person;
}
 
class Person{
    private int id;
    private String name;
    private int age;
}

<bean id="CustomerBean" class="com.Customer">
	<property name="person">
		<bean class="com.person">
			<property name="id" value=1 />
			<property name="name" value="素小暖" />
			<property name="age" value=18 />
		</bean>
	</property>
</bean>