《炸裂！掌握这些 Spring Boot 干货，面试直接 “开挂”！》

Spring Boot 重点、面试题及答案详细整理

一、Spring Boot 重点知识

（一）核心概念

1. 自动配置

Spring Boot 自动配置基于类路径中的依赖、配置文件以及应用上下文里的 Bean 情况，借助条件注解来自动设置 Spring 应用的配置。例如，当类路径中存在 spring - data - jpa 和数据库驱动时，会自动配置数据源、JPA 实体管理器工厂和事务管理器。可通过 @EnableAutoConfiguration 注解的 exclude 属性排除特定的自动配置类。

2. 起步依赖

起步依赖是一系列相关依赖的集合，简化了依赖管理。例如，spring - boot - starter - web 包含了构建 Web 应用所需的所有核心依赖，如 Spring MVC、Tomcat 等。

3. 嵌入式服务器

Spring Boot 支持将 Tomcat、Jetty、Undertow 等服务器嵌入到应用中，无需额外部署到外部服务器。可以通过修改依赖和配置来切换不同的嵌入式服务器。

（二）核心注解

1. @SpringBootApplication

这是一个组合注解，包含 @Configuration（将类标记为配置类）、@EnableAutoConfiguration（开启自动配置）和 @ComponentScan（扫描组件）。通常用于主应用类，启动 Spring Boot 应用。

2. @RestController

是 @Controller 和 @ResponseBody 的组合，用于创建 RESTful 风格的控制器，方法返回值会直接作为 HTTP 响应体。

3. @RequestMapping 及其派生注解

• @RequestMapping：映射 HTTP 请求到控制器方法，可指定请求路径、请求方法等。
• @GetMapping、@PostMapping、@PutMapping、@DeleteMapping：分别对应 HTTP 的 GET、POST、PUT、DELETE 请求方法，是 @RequestMapping 的简化形式。

4. @ConfigurationProperties

用于将配置文件中的属性映射到 Java 对象，通过 prefix 属性指定配置文件中的属性前缀。

（三）配置文件

1. application.properties 或 application.yml

用于配置应用的各种属性，如服务器端口、数据库连接信息等。application.yml 具有更好的层次性和可读性。

2. 多环境配置

通过 application - {profile}.properties 或 application - {profile}.yml 实现多环境配置，如 application - dev.properties 用于开发环境，application - prod.properties 用于生产环境。通过 spring.profiles.active 属性指定当前使用的环境。

（四）数据库操作

1. Spring Data JPA

简化 JPA 开发，通过定义接口继承 JpaRepository 即可实现基本的增删改查操作。支持方法名查询和自定义查询（使用 @Query 注解）。

2. MyBatis

与 Spring Boot 集成后，可使用 XML 或注解方式编写 SQL 语句。通过 @Mapper 注解标记 Mapper 接口，使用 @MapperScan 注解指定 Mapper 接口的扫描路径。

3. 事务管理

使用 @Transactional 注解实现声明式事务管理，可指定事务的传播行为、隔离级别、超时时间等属性。

（五）日志管理

1. 默认日志框架

Spring Boot 默认使用 Logback 作为日志框架，可通过配置文件进行日志级别、输出格式、日志文件位置等的配置。

2. 日志级别

从低到高依次为 TRACE、DEBUG、INFO、WARN、ERROR，可根据不同环境和需求设置不同的日志级别。

（六）监控与管理

1. Spring Boot Actuator

提供生产级别的特性，如健康检查、指标监控、审计等。通过 HTTP 或 JMX 访问各种端点获取应用信息。可通过配置暴露或隐藏特定的端点。

2. 自定义 Actuator 端点

可通过实现 Endpoint 接口或使用 @Endpoint 注解创建自定义的监控和管理端点。

二、面试题及答案

（一）基础概念类

1. 什么是 Spring Boot，它解决了什么问题？

答案：Spring Boot 是一个用于简化 Spring 应用开发的框架，它采用“习惯优于配置”的理念，解决了传统 Spring 应用开发中配置繁琐、依赖管理复杂等问题。通过自动配置和起步依赖，开发者可以快速搭建和开发 Spring 应用，减少了大量的样板代码和配置文件。

2. Spring Boot 自动配置的原理是什么？

答案：Spring Boot 自动配置基于 @EnableAutoConfiguration 注解。当应用启动时，Spring Boot 会扫描类路径下的 META - INF/spring.factories 文件，该文件中列出了所有自动配置类。然后根据条件注解（如 @ConditionalOnClass、@ConditionalOnMissingBean 等）判断是否需要加载这些自动配置类。如果条件满足，则将相应的 Bean 定义注册到 Spring 应用上下文中。

3. 什么是起步依赖，它有什么作用？

答案：起步依赖是 Spring Boot 提供的一种简化依赖管理的方式，它是一组相关依赖的集合。作用包括：

• 简化依赖配置：开发者只需添加一个起步依赖，就可以引入该功能所需的所有核心依赖，无需手动逐个添加。
• 版本管理：起步依赖会自动处理依赖的版本兼容性问题，避免版本冲突。

（二）注解相关类

1. @SpringBootApplication 注解包含了哪些注解，它们的作用分别是什么？

答案：@SpringBootApplication 包含以下三个注解：

• @Configuration：将类标记为配置类，相当于传统的 XML 配置文件，用于定义 Bean 和配置应用。
• @EnableAutoConfiguration：开启 Spring Boot 的自动配置机制，根据类路径中的依赖自动配置 Spring 应用。
• @ComponentScan：扫描指定包及其子包下的组件（如 @Component、@Service、@Repository 等注解标记的类），并将其注册到 Spring 应用上下文中。

2. @RestController 和 @Controller 有什么区别？

答案：

• @Controller：是 Spring MVC 中的注解，用于标记一个类为控制器。控制器中的方法默认返回视图名称，需要配合 @ResponseBody 注解才能将方法返回值作为 HTTP 响应体返回。
• @RestController：是 @Controller 和 @ResponseBody 的组合注解，使用该注解的控制器中的方法默认将返回值作为 HTTP 响应体返回，常用于创建 RESTful 风格的服务。

3. 如何使用 @ConfigurationProperties 注解？

答案：使用步骤如下：

1. 创建一个 Java 类，使用 @ConfigurationProperties 注解标记，并通过 prefix 属性指定配置文件中的属性前缀。
2. 在类中定义与配置文件属性对应的字段，并提供相应的 getter 和 setter 方法。
3. 在配置类中使用 @EnableConfigurationProperties 注解启用该配置属性类，或者将该类标记为 @Component 让 Spring 自动扫描。

示例代码如下：

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Component
@ConfigurationProperties(prefix = "myapp")
public class MyAppProperties {
    private String name;
    private int version;

    // Getters and Setters
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getVersion() {
        return version;
    }

    public void setVersion(int version) {
        this.version = version;
    }
}

在 application.properties 中配置：

myapp.name=My Application
myapp.version=1

（三）配置文件类

1. Spring Boot 支持哪些配置文件格式，它们的优先级是怎样的？

答案：Spring Boot 支持 application.properties 和 application.yml 两种主要的配置文件格式。配置文件的优先级从高到低依次为：

1. 命令行参数
2. 来自 SPRING_APPLICATION_JSON 的属性（环境变量或系统属性中内嵌的内联 JSON）
3. ServletConfig 初始化参数
4. ServletContext 初始化参数
5. JNDI 属性（java:comp/env）
6. Java 系统属性（System.getProperties()）
7. 操作系统环境变量
8. RandomValuePropertySource 配置的 random.* 属性
9. 位于打包的应用之外的 application - {profile}.properties 或 application - {profile}.yml（带 spring.profile）
10. 位于打包的应用之内的 application - {profile}.properties 或 application - {profile}.yml（带 spring.profile）
11. 位于打包的应用之外的 application.properties 或 application.yml
12. 位于打包的应用之内的 application.properties 或 application.yml
13. @Configuration 类上的 @PropertySource 注解
14. 默认属性（使用 SpringApplication.setDefaultProperties 指定）

2. 如何实现 Spring Boot 的多环境配置？

答案：可以通过以下步骤实现多环境配置：

1. 创建不同环境的配置文件，如 application - dev.properties、application - prod.properties。
2. 在 application.properties 或 application.yml 中使用 spring.profiles.active 属性指定当前使用的环境。例如：

spring.profiles.active=dev

或者在 application.yml 中：

spring:
  profiles:
    active: dev

（四）数据库操作类

1. 如何在 Spring Boot 中使用 Spring Data JPA 进行数据库操作？

答案：步骤如下：

1. 添加依赖：在 pom.xml 中添加 spring - boot - starter - data - jpa 和相应的数据库驱动依赖。
2. 定义实体类：使用 @Entity、@Id 等注解定义数据库实体类。
3. 创建仓库接口：继承 JpaRepository 接口，该接口提供了基本的增删改查方法。
4. 在服务层注入仓库接口并使用其方法进行数据库操作。

示例代码如下：

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;

    // Getters and Setters
    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

import org.springframework.data.jpa.repository.JpaRepository;

public interface UserRepository extends JpaRepository<User, Long> {
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;

    public List<User> getAllUsers() {
        return userRepository.findAll();
    }
}

2. Spring Boot 集成 MyBatis 的步骤有哪些？

答案：步骤如下：

1. 添加依赖：在 pom.xml 中添加 mybatis - spring - boot - starter 和相应的数据库驱动依赖。
2. 定义实体类和 Mapper 接口：实体类对应数据库表，Mapper 接口定义数据库操作方法。
3. 编写 SQL 语句：可以使用 XML 文件或注解方式编写 SQL 语句。
4. 配置 Mapper 接口扫描路径：使用 @MapperScan 注解指定 Mapper 接口的扫描路径。

示例代码如下：

import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;

import java.util.List;

@Mapper
public interface UserMapper {
    @Select("SELECT * FROM users")
    List<User> getAllUsers();
}

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@MapperScan("com.example.demo.mapper")
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}

3. 如何在 Spring Boot 中进行事务管理？

答案：在 Spring Boot 中可以使用声明式事务管理，步骤如下：

1. 确保项目中添加了 spring - boot - starter - data - jpa 或 spring - boot - starter - jdbc 等相关依赖。
2. 在服务层的方法上使用 @Transactional 注解标记需要进行事务管理的方法。
3. 可以通过 @Transactional 注解的属性指定事务的传播行为、隔离级别、超时时间等。

示例代码如下：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;

    @Transactional
    public void saveUser(User user) {
        userRepository.save(user);
    }
}

（五）日志管理类

1. Spring Boot 默认使用的日志框架是什么，如何配置日志级别？

答案：Spring Boot 默认使用 Logback 作为日志框架。可以通过在 application.properties 或 application.yml 中配置 logging.level 属性来设置日志级别。例如，设置根日志级别为 INFO：

logging.level.root=INFO

或者在 application.yml 中：

logging:
  level:
    root: INFO

也可以为特定的包或类设置不同的日志级别，如：

logging.level.com.example.demo=DEBUG

2. 如何将日志输出到文件？

答案：可以在 application.properties 或 application.yml 中配置日志文件的位置和名称。例如，在 application.properties 中：

logging.file.name=myapp.log

或者在 application.yml 中：

logging:
  file:
    name: myapp.log

（六）监控与管理类

1. 什么是 Spring Boot Actuator，它有哪些主要功能？

答案：Spring Boot Actuator 是 Spring Boot 提供的一个用于监控和管理应用的模块。主要功能包括：

• 健康检查：通过 /actuator/health 端点检查应用的健康状态，如数据库连接、磁盘空间等。
• 指标监控：通过 /actuator/metrics 端点提供应用的各种指标信息，如请求处理时间、内存使用情况等。
• 审计：记录应用的重要事件，如用户登录、数据修改等。
• 配置信息：通过 /actuator/configprops 和 /actuator/env 端点查看应用的配置属性。

2. 如何自定义 Spring Boot Actuator 端点？

答案：可以通过以下两种方式自定义 Actuator 端点：

• 使用 @Endpoint 注解：创建一个类，使用 @Endpoint 注解标记，并定义相应的操作方法。例如：

import org.springframework.boot.actuate.endpoint.annotation.Endpoint;
import org.springframework.boot.actuate.endpoint.annotation.ReadOperation;
import org.springframework.stereotype.Component;

import java.util.HashMap;
import java.util.Map;

@Component
@Endpoint(id = "custom")
public class CustomEndpoint {
    @ReadOperation
    public Map<String, String> customInfo() {
        Map<String, String> info = new HashMap<>();
        info.put("message", "This is a custom endpoint");
        return info;
    }
}

• 实现 Endpoint 接口：创建一个类实现 Endpoint 接口，并实现相应的方法。

（七）部署与打包类

1. 如何将 Spring Boot 项目打包成可执行的 JAR 文件？

答案：使用 Maven 或 Gradle 进行打包。

• Maven：在项目的 pom.xml 中添加以下插件：

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-maven-pluginartifactId>
        plugin>
    plugins>
build>

然后在命令行中执行 mvn clean package 命令，会在 target 目录下生成可执行的 JAR 文件。

• Gradle：在项目的 build.gradle 中添加以下插件：

plugins {
    id 'org.springframework.boot' version '2.7.5'
    id 'io.spring.dependency-management' version '1.0.15.RELEASE'
}

然后在命令行中执行 gradle clean build 命令，会在 build/libs 目录下生成可执行的 JAR 文件。

2. 如何在生产环境中部署 Spring Boot 应用？

答案：常见的部署方式有：

• 直接部署：将打包好的可执行 JAR 文件上传到服务器，使用 java - jar 命令