[面试题]Spring

标签：面试题 Spring 使用 事务 Bean AOP 注解

1. [面试题]Java【基础】
2. [面试题]Java【虚拟机】
3. [面试题]Java【并发】
4. [面试题]Java【集合】
5. [面试题]MySQL
6. [面试题]Maven
7. [面试题]Spring Boot
8. [面试题]Spring Cloud
9. [面试题]Spring MVC
10. [面试题]Spring

Spring 是一个很庞大的技术体系，可以说包容一切，所以本文我们按照下面的顺序，罗列各种面试题：

Spring 整体相关的面试

Spring IoC 相关的面试题

Spring AOP 相关的面试题

Spring Transaction 相关的面试题

Spring Data Access 相关的面试题

Spring 整体

什么是 Spring Framework？

Spring 是一个开源应用框架，旨在降低应用程序开发的复杂度。

它是轻量级、松散耦合的。

它的轻量级主要是相对于 EJB 。随着 Spring 的体系越来越庞大，大家被 Spring 的配置搞懵逼了，所以后来出了 Spring Boot 。

它具有分层体系结构，允许用户选择组件，同时还为 J2EE 应用程序开发提供了一个有凝聚力的框架。

它可以集成其他框架，如 Spring MVC、Hibernate、MyBatis 等，所以又称为框架的框架( 粘合剂、脚手架 )。

Spring Framework 中有多少个模块，它们分别是什么？

如下是一张比较早期版本的 Spring Framework 的模块图：

我们按照一个一个分块来说。

Spring 核心容器

对应图中，Core Container 。

该层基本上是 Spring Framework 的核心。它包含以下模块：

Spring Core

Spring Bean

核心容器提供 Spring 框架的基本功能。核心容器的主要组件是 BeanFactory，它是工厂模式的实现。BeanFactory使用控制反转 （IOC）模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。

Spring Context

Spring 上下文是一个配置文件，向 Spring 框架提供上下文信息。Spring 上下文包括企业服务，例如
JNDI、EJB、电子邮件、国际化、事件机制、校验和调度功能。

SpEL (Spring Expression Language)

Spring 表达式语言全称为 “Spring Expression Language”，缩写为 “SpEL” ，类似于 Struts2
中使用的 OGNL 表达式语言，能在运行时构建复杂表达式、存取对象图属性、对象方法调用等等，并且能与 Spring功能完美整合，如能用来配置 Bean 定义。

或者说，这块就是 Spring IoC 。

数据访问

该层提供与数据库交互的支持。它包含以下模块：

JDBC (Java DataBase Connectivity)

Spring 对 JDBC 的封装模块，提供了对关系数据库的访问。

ORM (Object Relational Mapping)

Spring ORM 模块，提供了对 hibernate5 和 JPA 的集成。hibernate5 是一个 ORM 框架。JPA 是一个
Java 持久化 API 。

OXM (Object XML Mappers)

Spring 提供了一套类似 ORM 的映射机制，用来将 Java 对象和 XML 文件进行映射。这就是 Spring 的对象 XML 映射功能，有时候也成为 XML 的序列化和反序列化。

Transaction

Spring 简单而强大的事务管理功能，包括声明式事务和编程式事务。

Web

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

WebMVC

MVC 框架是一个全功能的构建 Web 应用程序的 MVC 实现。通过策略接口，MVC 框架变成为高度可配置的，MVC 容纳了大量视图技术，其中包括 JSP、Velocity、Tiles、iText 和 POI。

WebFlux

基于 Reactive 库的响应式的 Web 开发框架。

WebSocket

Spring 4.0 的一个最大更新是增加了对 Websocket 的支持。Websocket 提供了一个在 Web
应用中实现高效、双向通讯，需考虑客户端(浏览器)和服务端之间高频和低延时消息交换的机制。一般的应用场景有：在线交易、网页聊天、游戏、协作、数据可视化等。

AOP

该层支持面向切面编程。它包含以下模块：

AOP

通过配置管理特性，Spring AOP 模块直接将面向方面的编程功能集成到了 Spring 框架中。所以，可以很容易地使 Spring
框架管理的任何对象支持 AOP。Spring AOP 模块为基于 Spring 的应用程序中的对象提供了事务管理服务。通过使用 Spring
AOP，不用依赖 EJB 组件，就可以将声明性事务管理集成到应用程序中。

Aspects

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

Instrumentation

该层为类检测和类加载器实现提供支持，了解下即可。

其它

JMS (Java Messaging Service)

提供了一个 JMS 集成框架，简化了 JMS API 的使用 。

Test

该模块为使用 JUnit 和 TestNG 进行测试提供支持。

Messaging

该模块为 STOMP 提供支持。它还支持注解编程模型，该模型用于从 WebSocket 客户端路由和处理 STOMP 消息。

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

下面列举了一些使用 Spring 框架带来的主要好处：

注意，下文中加粗的内容，这是本句话的关键。

DI ：Dependency Injection(DI) 方法，使得构造器和 JavaBean、properties 文件中的依赖关系一目了然。

轻量级：与 EJB 容器相比较，IoC 容器更加趋向于轻量级。这样一来 IoC 容器在有限的内存和 CPU 资源的情况下，进行应用程序的开发和发布就变得十分有利。

面向切面编程(AOP)： Spring 支持面向切面编程，同时把应用的业务逻辑与系统的服务分离开来。

集成主流框架：Spring 并没有闭门造车，Spring 集成了已有的技术栈，比如 ORM 框架、Logging 日期框架、J2EE、Quartz 和 JDK Timer ，以及其他视图技术。

模块化：Spring 框架是按照模块的形式来组织的。由包和类的命名，就可以看出其所属的模块，开发者仅仅需要选用他们需要的模块即可。

便捷的测试：要 测试一项用Spring开发的应用程序 十分简单，因为测试相关的环境代码都已经囊括在框架中了。更加简单的是，利用 JavaBean 形式的 POJO 类，可以很方便的利用依赖注入来写入测试数据。

Web 框架：Spring 的 Web 框架亦是一个精心设计的 Web MVC 框架，为开发者们在 Web 框架的选择上提供了一个除了主流框架比如 Struts 、过度设计的、不流行 Web 框架的以外的有力选项。

事务管理：Spring 提供了一个便捷的事务管理接口，适用于小型的本地事物处理（比如在单 DB 的环境下）和复杂的共同事物处理（比如利用 JTA 的复杂 DB 环境）。

异常处理：Spring 提供一个方便的 API ，将特定技术的异常(由JDBC, Hibernate, 或 JDO 抛出)转化为一致的、Unchecked 异常。

当然，Spring 代码优点的同时，一定会带来相应的缺点：

每个框架都有的问题，调试阶段不直观，后期的 bug 对应阶段，不容易判断问题所在。要花一定的时间去理解它。

把很多 JavaEE 的东西封装了，在满足快速开发高质量程序的同时，隐藏了实现细节。

这就导致，很多工程师，离开了 Spring 之后，就不知道怎么工作了。从 Java 工程师，变成了 Spring 工程师。对于有追求的我们，还是需要知其然，知其所以然。

Spring 框架中都用到了哪些设计模式？

Spring 框架中使用到了大量的设计模式，下面列举了比较有代表性的：

代理模式 — 在 AOP 和 remoting 中被用的比较多。

单例模式 — 在 Spring 配置文件中定义的 Bean 默认为单例模式。

模板方法 — 用来解决代码重复的问题。比如 RestTemplate

前端控制器 — Spring提供了 DispatcherServlet 来对请求进行分发。

视图帮助(View Helper) — Spring 提供了一系列的 JSP 标签，高效宏来辅助将分散的代码整合在视图里。

依赖注入 — 贯穿于 BeanFactory / ApplicationContext 接口的核心理念。

工厂模式 — BeanFactory 用来创建对象的实例。

Spring IoC

下面，我们会将分成 IoC 和 Bean 两部分来分享 Spring 容器的内容。IoC ，侧重在于容器。Bean ，侧重在于被容器管理的 Bean 。

什么是 Spring IoC 容器？

注意，正确的拼写是 IoC 。

Spring 框架的核心是 Spring IoC 容器。容器创建 Bean 对象，将它们装配在一起，配置它们并管理它们的完整生命周期。

Spring 容器使用依赖注入来管理组成应用程序的 Bean 对象。

容器通过读取提供的配置元数据 Bean Definition 来接收对象进行实例化，配置和组装的指令。

该配置元数据 Bean Definition 可以通过 XML，Java 注解或 Java Config 代码提供。

什么是依赖注入？

在依赖注入中，你不必主动、手动创建对象，但必须描述如何创建它们。

你不是直接在代码中将组件和服务连接在一起，而是描述配置文件中哪些组件需要哪些服务。

然后，再由 IoC 容器将它们装配在一起。

另外，依赖注入的英文缩写是 Dependency Injection ，简称 DI 。

IoC 和 DI 有什么区别？

IoC 是个更宽泛的概念，DI 是更具体的。引用郑烨的一篇博客，引用郑烨的一篇博客，我眼中的Spring

Dependency Injection原来，它叫 IoC 。Martin Flower 发话了，是个框架都有 IoC ，这不足以新生容器反转的“如何定位插件的具体实现”，于是，它有了个新名字，Dependency Injection
。其实，它就是一种将调用者与被调用者分离的思想，Uncle Bob 管它叫DIP（Dependency Inversion
Principle），并把它归入OO设计原则。同 Spring 相比，它更早进入我的大脑。一切都是那么朦胧，直至 Spring 出现。慢慢的，我知道了它还分为三种：Interface Injection（type 1）Setter Injection（type
2）Constructor Injection（type 3）。Martin Flower那篇为它更名的大作让我心目关于它的一切趋于完整。在
Spring 中，它是一切的基础。Spring 的种种优势随之而来。于我而言，它为我带来更多的是思维方式的转变，恐怕以后我再也无法写出那种一大块的全功能程序了。

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

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

上面一个问题的三种方式的英文，下面是三种方式的中文。

接口注入

构造函数注入

setter 注入

目前，在 Spring Framework 中，仅使用构造函数和 setter 注入这两种方式。

那么这两种方式各有什么优缺点呢？胖友可以简单阅读 《Spring两种依赖注入方式的比较》，不用太较真。综述来说：

构造函数注入	setter 注入
没有部分注入	有部分注入
不会覆盖 setter 属性	会覆盖 setter 属性
任意修改都会创建一个新实例	任意修改不会创建一个新实例
适用于设置很多属性	适用于设置少量属性

实际场景下，setting 注入使用的更多。

Spring 中有多少种 IoC 容器？

Spring 提供了两种( 不是“个” ) IoC 容器，分别是 BeanFactory、ApplicationContext 。

BeanFactory

BeanFactory 在 spring-beans 项目提供。

BeanFactory ，就像一个包含 Bean 集合的工厂类。它会在客户端要求时实例化 Bean 对象。

ApplicationContext

ApplicationContext 在 spring-context 项目提供。

ApplicationContext 接口扩展了 BeanFactory 接口，它在 BeanFactory 基础上提供了一些额外的功能。内置如下功能：

MessageSource ：管理 message ，实现国际化等功能。

ApplicationEventPublisher ：事件发布。

ResourcePatternResolver ：多资源加载。

EnvironmentCapable ：系统 Environment（profile + Properties）相关。

Lifecycle ：管理生命周期。

Closable ：关闭，释放资源

InitializingBean：自定义初始化。

BeanNameAware：设置 beanName 的 Aware 接口。

另外，ApplicationContext 会自动初始化非懒加载的 Bean 对象们。

简单总结下 BeanFactory 与 ApplicationContext 两者的差异：

可能很多胖友没看过源码，所以会比较难。

BeanFactory	ApplicationContext
它使用懒加载	它使用即时加载
它使用语法显式提供资源对象	它自己创建和管理资源对象
不支持国际化	支持国际化
不支持基于依赖的注解	支持基于依赖的注解

另外，BeanFactory 也被称为低级容器，而 ApplicationContext 被称为高级容器。

请介绍下常用的 BeanFactory 容器？

BeanFactory 最常用的是 XmlBeanFactory 。它可以根据 XML 文件中定义的内容，创建相应的 Bean。

请介绍下常用的 ApplicationContext 容器？

以下是三种较常见的 ApplicationContext 实现方式：

1、ClassPathXmlApplicationContext ：从 ClassPath 的 XML 配置文件中读取上下文，并生成上下文定义。应用程序上下文从程序环境变量中取得。示例代码如下：

ApplicationContext context = new ClassPathXmlApplicationContext(“bean.xml”);

2、FileSystemXmlApplicationContext ：由文件系统中的XML配置文件读取上下文。示例代码如下：

ApplicationContext context = new FileSystemXmlApplicationContext(“bean.xml”);

3、XmlWebApplicationContext ：由 Web 应用的XML文件读取上下文。例如我们在 Spring MVC 使用的情况。

当然，目前我们更多的是使用 Spring Boot 为主，所以使用的是第四种 ApplicationContext 容器，ConfigServletWebServerApplicationContext 。

列举一些 IoC 的一些好处？

它将最小化应用程序中的代码量。

它以最小的影响和最少的侵入机制促进松耦合。

它支持即时的实例化和延迟加载 Bean 对象。

它将使您的应用程序易于测试，因为它不需要单元测试用例中的任何单例或 JNDI 查找机制。

简述 Spring IoC 的实现机制？

简单来说，Spring 中的 IoC 的实现原理，就是工厂模式加反射机制。代码如下：

interface Fruit {

     public abstract void eat();
     
}
class Apple implements Fruit {

    public void eat(){
        System.out.println("Apple");
    }
    
}
class Orange implements Fruit {
    public void eat(){
        System.out.println("Orange");
    }
}

class Factory {

    public static Fruit getInstance(String className) {
        Fruit f = null;
        try {
            f = (Fruit) Class.forName(className).newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return f;
    }
    
}

class Client {

    public static void main(String[] args) {
        Fruit f = Factory.getInstance("io.github.dunwu.spring.Apple");
        if(f != null){
            f.eat();
        }
    }
    
}

Fruit 接口，有 Apple 和 Orange 两个实现类。

Factory 工厂，通过反射机制，创建 className 对应的 Fruit 对象。

Client 通过 Factory 工厂，获得对应的 Fruit 对象。

标签：面试题,Spring,使用,事务,Bean,AOP,注解
From： https://blog.csdn.net/gaozhi0/article/details/139754924