无Spring不编程，Spring面试必知必会

阅读文本大约需要3分钟。

从事JAVA开发的朋友都知道，Spring是JAVA开发中不可缺少的框架。Spring在面试、开发和工作中的地位现在是独一无二的。比如SpringBoot、SpringColud等都是目前开发中非常流行的框架。1、一般问题1.1、不同版本的 Spring Framework 主要功能是什么？

Version

Feature

Spring 2.5

发布于 2007 年。这是第一个支持注释的版本。

Spring 3.0

发布于 2009 年。它被完全利用了 Java5 改进，并为 JEE6 提供支持。

Spring 4.0

发布于 2013 年。这是第一个完全支持的人。 JAVA8 的版本。

1.2、什么是 Spring Framework？

Spring 它是一个开源应用框架，旨在降低应用程序开发的复杂性。它是轻量级和松散耦合。它具有分层系统结构，允许用户选择组件 J2EE 应用程序开发提供了一个具有凝聚力的框架。它可以集成其他框架，如 Structs、Hibernate、EJB 等，所以也叫框架框架。

1.3、列举 Spring Framework 的优点。

由于 Spring Frameworks 对于分层架构，用户可以自由选择所需的组件。Spring Framework 支持 POJO(Plain Old Java Object) 编程具有持续集成和可测试性。由于依赖注入和控制反转，JDBC 简化。它是免费开源的。

1.4、Spring Framework 不同的功能有哪些？

轻量级 - Spring 代码量和透明度都很轻。

IOC - 控制反转

AOP - 切面编程可以将应用程序的业务逻辑与系统服务分开，实现高内聚。

容器 - Spring 负责创建和管理对象（Bean）生命周期及配置。

MVC - 对 web 该应用程序提供了高度的可配置性，其他框架的集成也非常方便。

事务管理 - 为事务管理提供一般抽象层。Spring 容器较少的环境也可以使用事务支持。

JDBC 异常 - Spring 的 JDBC 抽象层提供了一个不正常的层次结构，简化了错误的处理策略。

1.5、Spring Framework 有多少个模块，它们是什么？

Spring 核心容器 – 这一层基本上是 Spring Framework 核心。它包含以下模块：

• Spring Core
• Spring Bean
• SpEL (Spring Expression Language)
• Spring Context

数据访问/集成 – 该层为与数据库交互提供支持。它包含以下模块：

• JDBC (Java DataBase Connectivity)
• ORM (Object Relational Mapping)
• OXM (Object XML Mappers)
• JMS (Java Messaging Service)
• Transaction

Web – 这一层提供了创建 Web 支持应用程序。它包含以下模块：

• Web
• Web – Servlet
• Web – Socket
• Web – Portlet

AOP

• 该层支持面向切面的编程

Instrumentation

• 该层支持类检测和类加载器的实现。

Test

• 该层为使用 JUnit 和 TestNG 测试提供支持。

几个杂项模块：

Messaging – 该模块为 STOMP 提供支持。它还支持注释编程模型 WebSocket 客户端路由及处理 STOMP 消息。

Aspects – 该模块为与 AspectJ 集成提供支持。

1.6、什么是 Spring 配置文件？

Spring 配置文件是 XML 文件。该文件主要包含类信息。它描述了这些类别是如何相互配置和引入的。但是，XML 配置文件冗长、更干净。如果没有正确的规划和编写，就很难管理大型项目。

1.7、Spring 应用程序中有哪些不同的组件？

Spring 应用一般包括以下组件：

• 接口- 定义功能。
• Bean 类- 它包含属性，它包含属性，它包含属性，它包含属性，setter 和 getter 方法、函数等。
• Spring 面向切面编程（AOP）- 为切面编程提供功能。
• Bean 配置文件- 包含类信息以及如何配置。
• 用户程序- 它使用接口。

1.8、使用 Spring 有哪些方法？

使用 Spring 以下方式：

• 成熟 Spring Web 应用程序。
• 作为第三方 Web 框架，使用 Spring Frameworks 中间层。
• 远程使用。
• 作为企业级 Java Bean，它可以包装现有的 POJO（Plain Old Java Objects）。

2、依赖注入（Ioc）2.1、什么是 Spring IOC 容器？

Spring 框架的核心是 Spring 容器。容器创建对象，将它们组装在一起，配置它们，并管理它们的完整生命周期。Spring 容器使用依赖注入来管理组成应用程序的组件。该容器通过读取提供的配置元数据来接收对象进行实例化、配置和组装的指令。元数据可以通过 XML，Java 注解或 Java 代码提供。

2.2、依赖注入是什么？

在依赖注入中，您不需要创建对象，但必须描述如何创建它们。您不是直接将组件和服务连接到代码中，而是描述配置文件中需要哪些组件。由 IoC 容器将它们组装在一起。

2.3、依赖注入可以通过多少种方式完成？

通常，依赖注入可以通过三种方式完成：

• 注入结构函数
• setter 注入
• 接口注入

在 Spring Framework 只使用结构函数和 setter 注入。

2.4、注入和区分结构函数 setter 注入。

注入结构函数

setter 注入

没有部分注入

有部分注入

不会覆盖 setter 属性

会覆盖 setter 属性

任何修改都将创建一个新的例子

任何修改都不会创建一个新的例子

适用于设置多个属性

适用于设置少量属性

2.5、spring 中有多少种 IOC 容器？

BeanFactory - BeanFactory 就像一个包含 bean 集合工厂类别。当客户端要求时，它将实例化 bean。

ApplicationContext - ApplicationContext 接口扩展了 BeanFactory 接口。它在 BeanFactory 在此基础上提供了一些额外的功能。

2.6、区分 BeanFactory 和 ApplicationContext。

BeanFactory

ApplicationContext

它使用懒惰的加载

它使用即时加载

它利用语法显式提供资源对象

它自己创建和管理资源对象

不支持国际化

支持国际化

基于依赖的注释不支持

支持基于依赖的注释

2.7、列举 IoC 一些好处。

IoC 一些好处是：

• 它将在应用程序中最小化代码量。
• 它将使您的应用程序易于测试，因为它不需要单元测试用例中的任何单例或 JNDI 查找机制。
• 以最小的影响和最小的入侵机制促进松耦合。
• 它支持即时实例化和延迟加载服务。

2.8、Spring IoC 实现机制。

Spring 中的 IoC 实现原理是工厂模式和反射机制。

示例：

interfaceFruit {publicabstractvoid eat();}classAppleimplementsFruit {publicvoid eat(){System.out.println("Apple");    }}classOrangeimplementsFruit {publicvoid eat(){System.out.println("Orange");    }}classFactory {publicstaticFruit getInstance(StringClassName) {Fruit f=null;try {            f=(Fruit)Class.forName(ClassName).newInstance();        } catch (Exception e) {            e.printStackTrace();        }return f;    }}classClient {publicstaticvoid main(String[] a) {Fruit f=Factory.getInstance("io.github.dunwu.spring.Apple");if(f!=null){            f.eat();        }    }}

3、Beans3.1、什么是 spring bean？

• 它们是构成用户应用程序主干的对象。
• Bean 由 Spring IoC 容器管理。
• 它们由 Spring IoC 实例化、配置、装配和管理容器。
• Bean 构建基于用户提供给容器的配置元数据。

3.2、spring 提供了哪些配置方法？

基于 xml 配置

bean 所需的依赖项和服务是 XML 指定格式的配置文件。这些配置文件通常包含许多 bean 在应用程序中定义和特定的配置选项。它们通常是 bean 标签开头。例如:

<beanid="studentbean"class="org.edureka.firstSpring.StudentBean"><propertyname="name"value="Edureka"></property></bean>

基于注释配置

您可以在相关类别、方法或字段声明中使用注释 bean 配置为组件本身，而不是使用 XML 来描述 bean 装配。默认情况下，Spring 注解装配在容器中没有打开。因此，在使用它之前，您需要在使用它之前 Spring 在配置文件中使用。例如:

<beans><context:annotation-config/><!-- bean definitions go here --></beans>

基于 Java API 配置

Spring 的 Java 通过使用配置 @Bean 和 @Configuration 来实现。

1、 @Bean 注解扮演与 <bean/> 相同元素的角色。2.、 @Configuration 允许简单地调用同一类中的其他类别 @Bean 方法来定义 bean 依赖关系。

例如：

@ConfigurationpublicclassStudentConfig {@BeanpublicStudentBean myStudent() {returnnewStudentBean();    }}

3.3、spring 支持集中 bean scope？

Spring bean 支持 5 种 scope：

Singleton - 每个 Spring IoC 容器只有一个单实例。

Prototype - 每一个请求都会产生一个新的例子。

Request - 每一次 HTTP 请求会产生一个新的例子，应该是 bean 仅在当前 HTTP 请求内有效。

Session - 每一次 HTTP 所有的请求都会产生新的要求 bean，同时该 bean 仅在当前 HTTP session 内有效。

Global-session - 类似于标准 HTTP Session 但它只是基于作用域， portlet 的 web 只有在应用中才有意义。Portlet 规范定义了全局 Session 所有构成某一概念的概念 portlet web 各种不同的应用 portlet 所共享。在 global session 在作用域中定义 bean 局限于全局 portlet Session 在生命周期范围内。如果你在 web 中使用 global session 识别作用域 bean，那么 web 会自动当成 session 使用类型。

仅当用户使用支持时 Web 的 ApplicationContext 只有最后三个才能使用。

3.4、spring bean 容器的生命周期是什么？

spring bean 容器的生命周期流程如下：

1、Spring 根据配置中的容器 bean 实例化的定义 bean。2、Spring 所有属性的使用依赖于注入填充，如 bean 中定义的配置。3、如果 bean 实现 BeanNameAware 接口，工厂通过传输 bean 的 ID 来调用 setBeanName()。4、如果 bean 实现 BeanFactoryAware 接口，工厂通过传递自己的例子来调用 setBeanFactory()。5、如果存在与 bean 关联的任何 BeanPostProcessors，则调用 preProcessBeforeInitialization() 方法。6、如果为 bean 指定了 init 方法（ <bean> 的 init-method 属性)，然后调用它。7、最后，如果存在和 bean 关联的任何 BeanPostProcessors，则将调用 postProcessAfterInitialization() 方法。8、如果 bean 实现 DisposableBean 接口，当 spring 当容器关闭时，它会被调用 destory()。9、如果为 bean 指定了 destroy 方法（ <bean> 的 destroy-method 属性)，然后调用它。

3.5、什么是 spring 的内部 bean？

只有将 bean 用作另一个 bean 只有在属性的时候才能做到 bean 声明为内部 bean。为了定义 bean，Spring 的基于 XML 配置元数据在 <property> 或 <constructor-arg>中提供了 <bean> 使用元素。内部 bean 总是匿名的，它们总是作为原型。

例如，假设我们有一个 Student 其中引用了类 Person 类别。在这里，我们只创建一个 Person 类实例并在 Student 中使用它。

Student.java

publicclassStudent {privatePerson person;//Setters and Getters}publicclassPerson {privateString name;privateString address;//Setters and Getters}

bean.xml

<beanid=“StudentBean" class="com.edureka.Student"><propertyname="person"><!--This is inner bean --><beanclass="com.edureka.Person"><propertyname="name"value=“Scott"></property><propertyname="address"value=“Bangalore"></property></bean></property></bean>

3.6、什么是 spring 装配

当 bean 在 Spring 当容器组合在一起时，它被称为组装或 bean 装配。Spring 容器需要知道需要什么 bean 以及容器应该如何使用依赖注入 bean 绑定在一起，同时组装 bean。

3.7、自动组装的方式有哪些？

Spring 容器可以自动组装 bean。也就是说，可以通过检查 BeanFactory 的内容让 Spring 自动解析 bean 的协作者。

不同模式的自动组装：

no - 这是默认设置，意味着没有自动组装。显式应使用 bean 装配引用。

byName - 它根据 bean 注入对象依赖项的名称。它匹配并组装其属性和 XML 同名文件中定义的相同名称 bean。

byType - 根据类型注入对象依赖项。如果属性的类型和 XML 文件中的一个 bean 如果名称匹配，则匹配并组装属性。

构造函数 - 它通过调用类的结构函数注入依赖项。它有大量的参数。

autodetect - 首先，容器试图通过构造函数使用 autowire 组装，如果没有，试着通过 byType 自动装配。

3.8、自动装配的局限性是什么？

覆盖的可能性 - 你可以一直用 <constructor-arg> 和 <property> 设置指定的依赖项，覆盖自动组装。基本元数据类型 - 简单属性(如原始数据类型、字符串和类别)不能自动组装。令人困惑的性质 - 总是喜欢使用清晰的组装，因为自动组装不太准确。

4、注解4.1、基于注释的容器配置是什么？

不使用 XML 来描述 bean 组装时，开发人员通过在相关类别、方法或字段声明中使用注释将配置移动到组件类本身。它可以用作 XML 设置的替代方案。例如:

Spring 的 Java 通过使用配置 @Bean 和 @Configuration 来实现。

@Bean 注解扮演与 相同元素的角色。@Configuration 允许简单地调用同一类中的其他类别 @Bean 方法来定义 bean 依赖关系。

例如：

@ConfigurationpublicclassStudentConfig {@BeanpublicStudentBean myStudent() {returnnewStudentBean();    }}

4.2、如何在 spring 注解装配中启动？

默认情况下，Spring 注解装配在容器中没有打开。因此，为了使用基于注解装配，我们必须通过配置 <context：annotation-config/> 元素在 Spring 在配置文件中使用。

4.3、@Component, @Controller, @Repository, @Service 有何区别？

@Component：这将 java 类标记为 bean。它是任何 Spring 管理组件的一般结构造型。spring 组件扫描机制现在可以将其捡起并拉入应用环境中。

@Controller：这将一类标记为 Spring Web MVC 控制器。标有它的 Bean 自动导入 IoC 容器中。

@Service：这种注释是组件注释的特化。它不正确 @Component 注释提供任何其他行为。您可以在服务类别中使用它 @Service 而不是 @Component，因为它以更好的方式指定了意图。

@Repository：该注释具有类似的用途和功能 @Component 特化注释。它是 DAO 它将提供额外的好处。它将 DAO 导入 IoC 容器将未经检查的异常资格转换为 Spring DataAccessException。

4.4、@Required 注释有什么用？

@Required 应用于 bean 属性 setter 方法。此注释仅指示配置时必须使用 bean 定义中的显式属性值或自动组装填充受影响 bean 属性。如果没有填充受影响的属性。 bean 如果属性，容器将被抛出 BeanInitializationException。

示例：

publicclassEmployee {privateString name;@Requiredpublicvoid setName(String name){this.name=name;    }publicstring getName(){return name;    }}

4.5、@Autowired 注释有什么用？

@Autowired 它可以更准确地控制应该在哪里以及如何自动组装。此注释用于 setter 方法、构造函数、任何名称或多个参数的属性或方法自动组装 bean。默认情况下，注入类型驱动。

publicclassEmployee {privateString name;@Autowiredpublicvoid setName(String name) {this.name=name;    }publicstring getName(){return name;    }}

4.6、@Qualifier 注释有什么用？

当您创建多种类型的相同类型时 bean 并希望只使用属性组件中的一个 bean 你可以用的时候@Qualifier 注解和 @Autowired 哪一个应该通过指定准确地组装 bean 消除歧义。

比如这里我们分别有两类，Employee 和 EmpAccount。在 EmpAccount 中，使用@Qualifier 指定必须组装 id 为 emp1 的 bean。

Employee.java

publicclassEmployee {privateString name;@Autowiredpublicvoid setName(String name) {this.name=name;    }publicstring getName() {return name;    }}

EmpAccount.java

publicclassEmpAccount {privateEmployee emp;@Autowired@Qualifier(emp1)publicvoid showName() {System.out.println(“Employee name : ”+emp.getName);    }}

4.7、@RequestMapping 注释有什么用？

@RequestMapping 用于特定注释 HTTP 请求方法映射到处理相应请求的控制器中的特定类别/方法。此注释可应用于两个级别：

类别级别：映射请求 URL

方法等级：映射 URL 以及 HTTP 请求方法

5、数据访问5.1、spring DAO 有什么用？

Spring DAO 使得 JDBC，Hibernate 或 JDO 这种数据访问技术更容易以统一的方式工作。这使得用户很容易在持久性技术之间切换。它还允许您在编写代码时不考虑捕获每种技术的不同异常。

5.2、列举 Spring DAO 异常抛出。

5.3、spring JDBC API 中间有哪些类别？

• JdbcTemplate
• SimpleJdbcTemplate
• NamedParameterJdbcTemplate
• SimpleJdbcInsert
• SimpleJdbcCall

5.4、使用 Spring 访问 Hibernate 有哪些方法？

我们可以用两种方法 Spring 访问 Hibernate：

1、 使用 Hibernate 控制反转模板和回调 2、 扩展 HibernateDAOSupport 并应用 AOP 拦截器节点

5.5、列举 spring 支持的事务管理类型

Spring 支持两种类型的事务管理：

1、 程序化事务管理:在此过程中，在编程的帮助下管理事务。它为您提供了极大的灵活性，但很难维护。2、 声明事务管理：在此，事务管理与业务代码分离。仅使用注释或基于 XML 管理事务的配置。

5.6、spring 支持哪些 ORM 框架

• Hibernate
• iBatis
• JPA
• JDO
• OJB

6、AOP6.1、什么是 AOP？

AOP(Aspect-Oriented Programming), 即 面向切面编程， 它与 OOP( Object-Oriented Programming, 面向对象编程) 相辅相成, 提供了与 OOP 抽象软件结构视角不同. 在 OOP 中, 我们以类(class)作为我们的基本单位， 而 AOP Aspect(切面)中的基本单元是Aspect(切面)

6.2、什么是 Aspect？

aspect 由 pointcount 和 advice 组成, 它包含了横切逻辑的定义， 它还包括连接点的定义. Spring AOP 负责实施切面框架， 它将切面定义的横切逻辑编织到切面指定的连接点中. AOP 重点是如何增强编织目标对象的连接点， 这里有两个工作：

1、如何通过 pointcut 和 advice 定位到特定的 joinpoint 上 2、如何在 advice 编写切面代码.

可以简单地认为， 使用 @Aspect 注释的类别是切面.

6.3、什么是切点（JoinPoint）

程序运行中的一些时间点， 例如，执行一种方法， 或异常处理.

在 Spring AOP 中, join point 总是方法的执行点。

6.4、什么是通知（Advice）？

特定 JoinPoint 处的 Aspect 所采取的动作称为 Advice。Spring AOP 使用一个 Advice 作为拦截器，在 JoinPoint “周围”维护一系列拦截器。

6.5、有哪些类型的通知？（Advice）？

Before- 这些类型的 Advice 在 joinpoint 该方法以前执行并使用过 @Before 配置注释标记。

After Returning- 这些类型的 Advice 正常执行连接点法后执行并使用@AfterReturning 配置注释标记。

After Throwing- 这些类型的 Advice 仅在 joinpoint 抛出异常退出并使用该方法 @AfterThrowing 注释标记配置时执行。

After (finally)- 这些类型的 Advice 无论退出方法是正常的还是异常的，在连接点方法后执行并使用 @After 配置注释标记。

Around- 这些类型的 Advice 在连接点之前和之后执行并使用 @Around 配置注释标记。

6.6、指出在 spring aop 中 concern 和 cross-cutting concern 区别。

concern 这是我们想要在应用程序的特定模块中定义的行为。它可以定义为我们想要实现的功能。

cross-cutting concern 这是一种适用于整个应用程序的行为，会影响整个应用程序。例如，日志记录、安全性和数据传输是应用程序几乎每个模块都需要注意的问题，因此它们是跨领域的问题。

6.7、AOP 实现的方法有哪些？

实现 AOP 技术主要分为两类：

静态代理

指使用 AOP 编译框架提供的命令，以便在编译阶段生成 AOP 因此，代理也被称为编译增强；

• 编译时编织(实现特殊编译)
• 编织类加载(实现特殊类加载器)。

动态代理

在运行过程中，“临时”在内存中产生 AOP 因此，动态代理也被称为运行时增强。

• JDK 动态代理
• CGLIB

6.8、Spring AOP and AspectJ AOP 有什么区别？

Spring AOP 以动态代理为基础实现；AspectJ 基于静态代理的实现。Spring AOP 只支持方法级别 PointCut；提供完整的 AOP 它还支持属性级别的支持 PointCut。

6.9、如何理解 Spring 中的代理？

将 Advice 应用于目标对象后创建的对象称为代理。在客户对象的情况下，目标对象与代理对象相同。

Advice + TargetObject = Proxy

6.10、什么是编织（Weaving）？

创建一个 advice 并链接一个对象 aspect 与其他应用类型或对象一起称为编织（Weaving）。在 Spring AOP 编织在运行过程中执行。请参考下图：

7、MVC7.1、Spring MVC 框架有什么用？

Spring Web MVC 框架提供 模型-视图-控制器 用于开发灵活、松散耦合的架构和可用组件 Web 应用程序。MVC 该模型有助于分离应用程序的不同方面，如输入逻辑、业务逻辑和 UI 在所有这些元素之间提供松散耦合的逻辑。

7.2、描述一下 DispatcherServlet 的工作流程

DispatcherServlet 一幅图可以说明工作流程：

1、发送到服务器 HTTP 请求前端控制器 DispatcherServlet 捕获。

2、 DispatcherServlet 根据 -servlet.xml 请求中的配置 URL 分析，获得要求的资源标识符（URI）。然后根据该 URI，调用 HandlerMapping 获得该 Handler 所有相关对象(包括配置) Handler 对象以及 Handler 对象对应的拦截器)，最后HandlerExecutionChain 以对象的形式返回。

3、 DispatcherServlet 根据获得的 Handler，选择合适的 HandlerAdapter。(附注:如果成功 HandlerAdapter之后，将开始执行拦截器 preHandler(...)方法）。

4、提取 Request模型数据，填充 Handler入参，开始执行 Handler（ Controller)。在填充 Handler根据您的配置，Spring 为您做一些额外的工作：

• HttpMessageConveter：请求消息(如 Json、xml 等数据)转换为对象，将对象转换为指定的响应信息。
• 数据转换：数据转换请求信息。例如String转换成Integer、Double等。
• 数据根式化：数据格式化请求信息。例如，将字符串转换为格式化数字或格式化日期。
• 数据验证：验证数据的有效性（长度、格式等）BindingResult或Error中。

5、Handler(Controller)执行完成后，方向 DispatcherServlet 返回一个 ModelAndView 对象；

6、根据返回的 ModelAndView，选择合适的 ViewResolver(必须已注册 Spring 容器中的 ViewResolver)返回给 DispatcherServlet。

7、 ViewResolver 结合 Model和 View，渲染视图。

8、视图负责将渲染结果返回客户端。

7.3、介绍一下 WebApplicationContext

WebApplicationContext 是 ApplicationContext 扩展。它有 Web 应用程序所需的一些额外功能。它与普通功能相匹配 ApplicationContext 分析主题和决定哪一个 servlet 关联能力不同。

注意我每天的进步一点一点的进步