Spring Boot相关面试题一、Spring Boot 基础认知（必问，入门级） 1. 什么是Spring Boot

一、Spring Boot 基础认知（必问，入门级）

1. 什么是Spring Boot？它的核心优势是什么？（必问）

答案：

① 定义：Spring Boot是基于Spring Framework开发的快速开发脚手架，核心思想是「约定优于配置（Convention Over Configuration）」，无需手动编写繁琐的XML配置，通过自动配置、起步依赖等特性，简化Spring应用的搭建、开发、部署全流程。

② 核心优势（5点，简洁好记）：

简化配置：无需XML配置，默认配置满足绝大多数场景，自定义配置仅需修改配置文件。
起步依赖（Starter）：一键引入相关依赖，自动管理依赖版本，避免版本冲突。
嵌入式容器：内置Tomcat、Jetty、Undertow，无需单独部署WAR包，直接通过JAR包启动。
开箱即用：集成常用组件（如Spring MVC、MyBatis、Redis），无需额外配置即可使用。
易于部署：打包为可执行JAR包，适配云原生、Docker、K8s等部署场景，简化运维。

2. Spring Boot 和 Spring 的区别与联系是什么？（必问）

答案：

① 联系：Spring Boot 不是对Spring的替代，而是在Spring Framework基础上的封装和增强，完全依赖Spring的IoC、AOP核心特性，本质是“Spring的便捷版”，简化Spring应用的开发和配置。

② 核心区别（3点，直击重点）：

对比维度	Spring	Spring Boot
配置方式	需手动编写XML配置或注解配置，繁琐	约定优于配置，默认配置为主，自定义配置简洁
依赖管理	需手动引入依赖，手动管理版本，易冲突	起步依赖自动引入相关依赖，统一管理版本
部署方式	需打包为WAR包，部署到外部容器（如Tomcat）	内置容器，打包为JAR包，一键启动，无需外部容器

3. Spring Boot 的核心注解是什么？它的组成部分有哪些？（必问）

答案：

① 核心注解：@SpringBootApplication，是Spring Boot应用的入口注解，标注在主类上，用于开启Spring Boot的自动配置、包扫描等核心功能。

② 核心组成（3个注解，缺一不可）：

@SpringBootConfiguration：本质是@Configuration的特殊形式，标识当前类是Spring配置类，允许通过@Bean注册组件。
@ComponentScan：自动扫描当前类所在包及其子包下的@Component、@Service、@Controller等注解，将其注册到IoC容器。
@EnableAutoConfiguration：开启Spring Boot自动配置核心功能，通过导入自动配置选择器，加载所有符合条件的自动配置类。

4. Spring Boot 支持哪些配置文件格式？优先级是什么？（高频）

答案：

① 支持的配置文件格式（3种，常用前2种）：

application.yml：推荐使用，语法简洁、层次清晰，支持换行和缩进，可读性强。
application.properties：传统格式，键值对形式，语法简单，兼容性好。
application.yaml：与yml格式一致，仅后缀不同，使用较少。

② 配置文件优先级（从高到低，后加载的覆盖先加载的）：

命令行参数（如--server.port=8081）； 2. 系统环境变量； 3. application-dev.yml/properties（开发环境，需通过spring.profiles.active=dev激活）； 4. application.yml/properties（默认配置文件）； 5. application-default.yml/properties（默认 fallback 配置）。

5. Spring Boot 如何实现多环境配置？（高频，实战性）

答案：

核心两种方式，推荐第一种，简洁高效：

方式1：多配置文件拆分（最常用）
- 1. 新建不同环境的配置文件：application-dev.yml（开发）、application-test.yml（测试）、application-prod.yml（生产）。
- 1. 在默认配置文件application.yml中，通过spring.profiles.active=dev指定激活的环境（dev/test/prod）。
- 1. 启动时也可通过命令行参数指定：java -jar xxx.jar --spring.profiles.active=prod。
方式2：单文件多环境（通过---分隔）
- 在application.yml中，用---分隔不同环境的配置，通过spring.profiles指定环境名称，再用spring.profiles.active激活。

二、Spring Boot 核心原理（必问，进阶级）

1. Spring Boot 自动配置的原理是什么？（必问，核心难点）

答案：

自动配置是Spring Boot的灵魂，核心是「注解驱动 + 条件判断 + 配置加载」，完整流程（简洁易懂，面试直接答）：

入口触发：@SpringBootApplication中的@EnableAutoConfiguration注解，导入AutoConfigurationImportSelector（自动配置选择器）。
加载配置类：AutoConfigurationImportSelector通过SpringFactoriesLoader，加载类路径下的自动配置文件：
1. Spring Boot 1.x/2.x：META-INF/spring.factories文件；
2. Spring Boot 3.x：META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports文件。
条件过滤：自动配置类（如WebMvcAutoConfiguration、DataSourceAutoConfiguration）通过@Conditional系列注解（如@ConditionalOnClass、@ConditionalOnMissingBean）进行条件判断，只有满足条件（如类路径存在对应依赖）的配置类才会生效。
配置绑定：通过@ConfigurationProperties注解，将配置文件（application.yml）中的参数，绑定到对应的配置类（如ServerProperties、DataSourceProperties），实现自定义配置。

核心关键点：自动配置的本质是「Spring IoC容器的Bean自动注册」，默认配置可通过自定义配置文件、自定义配置类覆盖，实现“约定优先、自定义可选”。

2. Spring Boot 起步依赖（Starter）的原理是什么？（必问）

答案：

① 定义：起步依赖（Starter）是Spring Boot简化依赖管理的核心机制，本质是「Maven/Gradle依赖描述文件」，打包一组相关的依赖库，并提供默认配置，实现“一键引入，开箱即用”。

② 核心原理（3点）：

依赖聚合：Starter本身不包含业务代码，仅在其pom.xml中声明功能所需的所有核心依赖和传递依赖（如spring-boot-starter-web自动引入Spring MVC、Tomcat、Jackson等）。
版本管理：Spring Boot通过父工程spring-boot-dependencies，统一管理所有Starter的依赖版本，避免版本冲突。
自动配置关联：Starter通常会关联对应的自动配置类，这些配置类通过上述自动配置机制加载，引入Starter后，自动配置类自动生效，完成组件初始化。

③ 命名规范：官方Starter命名为spring-boot-starter-xxx（如spring-boot-starter-web）；第三方Starter命名为xxx-spring-boot-starter（如mybatis-spring-boot-starter）。

3. Spring Boot 嵌入式容器的原理是什么？如何切换容器？（高频）

答案：

① 核心原理：Spring Boot将Tomcat、Jetty、Undertow等Web容器集成到应用中，通过代码启动容器，无需外部部署，核心流程：

依赖加载：引入spring-boot-starter-web时，默认引入spring-boot-starter-tomcat（Tomcat容器）。
容器初始化：Spring Boot启动时，通过EmbeddedWebApplicationContext初始化嵌入式容器，加载容器配置（如端口、线程池）。
应用部署：容器初始化完成后，将Spring应用上下文关联到容器，监听指定端口，接收HTTP请求。

② 切换容器（以Tomcat切换为Undertow为例）：

<!-- 排除默认Tomcat依赖 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <exclusions>
        <exclusion>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
        </exclusion>
    </exclusions>
</dependency>
<!-- 引入Undertow容器依赖 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-undertow</artifactId>
</dependency>

4. Spring Boot 如何实现自动装配Bean？和Spring手动装配有什么区别？（高频）

答案：

① Spring Boot 自动装配Bean的方式（3种，核心）：

自动配置类：通过上述自动配置机制，自动注册Bean（如DataSource、RedisTemplate）。
注解扫描：通过@ComponentScan扫描@Component、@Service、@Controller等注解，自动注册Bean。
自定义配置类：通过@Configuration + @Bean注解，手动注册Bean（补充自动配置的不足）。

② 与Spring手动装配的区别：

Spring手动装配：需手动编写XML配置（<bean>标签）或注解配置（@Bean），每个Bean都需手动声明，繁琐。
Spring Boot自动装配：基于约定，自动注册大部分常用Bean，无需手动声明，仅需在需要自定义时补充配置，效率极高。

5. Spring Boot 的启动流程是什么？（难点，高频）

答案：

核心流程（简化版，面试重点答关键步骤）：

启动入口：执行主类的SpringApplication.run(XXXApplication.class, args)方法。
初始化SpringApplication：创建SpringApplication实例，初始化监听器、应用类型（Web/非Web）、资源加载器等。
准备环境：加载系统环境变量、配置文件（application.yml），创建Environment对象，绑定配置参数。
创建应用上下文：根据应用类型，创建对应的ApplicationContext（Web应用为EmbeddedWebApplicationContext）。
自动配置：执行自动配置流程，加载自动配置类，注册Bean到IoC容器。
刷新上下文：刷新ApplicationContext，完成Bean的初始化、依赖注入、AOP增强等。
启动嵌入式容器：若为Web应用，初始化嵌入式容器（Tomcat），启动容器并监听端口。
执行启动后逻辑：调用ApplicationRunner、CommandLineRunner接口的方法，执行自定义启动后操作。

三、Spring Boot 实战应用（必问，实战级）

1. Spring Boot 如何集成MyBatis？核心配置有哪些？（必问，实战）

答案：

核心步骤（4步，清晰可落地）：

引入依赖：在pom.xml中引入MyBatis Starter和数据库驱动（MySQL）：  `` <dependency> `` <groupId>org.mybatis.spring.boot</groupId> `` <artifactId>mybatis-spring-boot-starter</artifactId> `` <version>2.3.0</version>  `` </dependency> ``  `` <dependency> `` <groupId>com.mysql</groupId> `` <artifactId>mysql-connector-j</artifactId> `` <scope>runtime</scope> ``</dependency>
配置数据库和MyBatis：在application.yml中配置数据源和MyBatis核心参数： spring: `` datasource: `` url: jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC `` username: root `` password: 123456 `` driver-class-name: com.mysql.cj.jdbc.Driver `` mybatis: `` mapper-locations: classpath:mapper/*.xml # mapper.xml文件路径 `` type-aliases-package: com.example.entity # 实体类包路径 `` configuration: ``map-underscore-to-camel-case: true # 开启下划线转驼峰（如user_name → userName）
编写Mapper接口：用@Mapper注解标注Mapper接口，或在主类用@MapperScan("com.example.mapper")批量扫描。
编写Mapper.xml：在resources/mapper目录下，编写SQL语句，映射接口方法。

核心配置说明：mapper-locations指定Mapper.xml路径；type-aliases-package简化实体类全类名书写；map-underscore-to-camel-case解决数据库字段与实体类属性命名不一致问题。

2. Spring Boot 如何实现热部署？（高频，开发效率相关）

答案：

核心两种方式，推荐第一种（Spring Boot官方推荐）：

方式1：使用spring-boot-devtools（最常用）
- 引入依赖： <dependency> `` <groupId>org.springframework.boot</groupId> `` <artifactId>spring-boot-devtools</artifactId> `` <scope>runtime</scope> `` <optional>true</optional> ``</dependency>
- 开启自动重启：在application.yml中配置（可选，默认开启）： spring: `` devtools: `` restart: `` enabled: true # 开启自动重启 ``additional-paths: src/main/java # 监听的文件路径
- IDE配置（IDEA）：打开File → Settings → Build, Execution, Deployment → Compiler，勾选“Build project automatically”，即可实现代码修改后自动重启。
方式2：使用Spring Loaded（了解即可），需引入对应依赖，配置JVM参数，不如devtools便捷，目前使用较少。

注意：热部署仅用于开发环境，生产环境需禁用（避免代码修改导致应用异常）。

3. Spring Boot 如何实现接口参数校验？（高频，实战）

答案：

核心使用JSR-380规范（如@NotNull、@NotBlank），配合Spring Boot Validation Starter，步骤如下：

引入依赖： <dependency> `` <groupId>org.springframework.boot</groupId> `` <artifactId>spring-boot-starter-validation</artifactId> ``</dependency>
在实体类字段上添加校验注解： public class User { `` @NotNull(message = "用户ID不能为空") `` private Long id; ```` @NotBlank(message = "用户名不能为空") `` @Length(min = 2, max = 10, message = "用户名长度为2-10位") `` private String username; ```` @Email(message = "邮箱格式不正确") `` private String email; `` // getter/setter ``}
在Controller接口方法上添加@Valid注解，触发参数校验，并通过BindingResult接收校验结果： @PostMapping("/add") `` public Result addUser(@Valid @RequestBody User user, BindingResult bindingResult) { `` // 校验失败，返回错误信息 `` if (bindingResult.hasErrors()) { `` List<String> errors = bindingResult.getFieldErrors().stream() `` .map(FieldError::getDefaultMessage) `` .collect(Collectors.toList()); `` return Result.fail(errors); `` } `` // 校验通过，执行业务逻辑 `` userService.addUser(user); `` return Result.success(); ``}

常用校验注解：@NotNull（不能为null）、@NotBlank（不能为null且不能为空白）、@Length（字符串长度）、@Email（邮箱格式）、@Min/@Max（数值范围）。

4. Spring Boot 事务管理如何实现？@Transactional注解失效的原因有哪些？（必问，实战难点）

答案：

① 事务管理实现方式（2种，重点声明式）：

声明式事务（推荐）：通过@Transactional注解实现，无需手动控制事务，代码侵入性低，Spring Boot自动开启事务管理（无需@EnableTransactionManagement）。 @Service `` public class UserService { `` @Autowired `` private UserMapper userMapper; ```` // 声明式事务，默认回滚运行时异常 `` @Transactional(rollbackFor = Exception.class) `` public void addUser(User user) { `` userMapper.insert(user); `` // 模拟异常，事务回滚 `` int i = 1 / 0; `` } ``}
编程式事务：通过TransactionTemplate手动控制事务，灵活性高，代码侵入性强，适用于复杂事务场景。

② @Transactional注解失效的6种常见原因（面试重点答）：

1. 注解标注在非public方法上（Spring事务仅对public方法生效）。
1. 异常类型不匹配：未指定rollbackFor，抛出的是检查异常（如IOException），默认只回滚运行时异常和Error。
1. 方法内手动捕获异常，未重新抛出（Spring无法感知异常，无法回滚）。
1. 事务传播行为配置错误（如配置为SUPPORTS，当前无事务时，以非事务方式执行）。
1. 目标Bean未被Spring管理（未用@Component、@Service等注解注册）。
1. 同一类中，事务方法调用另一事务方法，被调用方法的事务失效（AOP动态代理问题，调用的是目标对象自身方法）。

5. Spring Boot Actuator 是什么？核心作用是什么？（高频，运维相关）

答案：

① 定义：Spring Boot Actuator是Spring Boot提供的「应用监控和运维组件」，通过暴露HTTP端点，提供应用的运行状态、指标统计、健康检查等功能，帮助开发者和运维人员快速定位问题。

② 核心使用步骤：

引入依赖： <dependency> `` <groupId>org.springframework.boot</groupId> `` <artifactId>spring-boot-starter-actuator</artifactId> ``</dependency>
配置暴露端点（application.yml）： management: `` endpoints: `` web: `` exposure: `` include: health,info,metrics,loggers # 暴露的端点 `` endpoint: `` health: ``show-details: always # 显示健康检查详细信息

③ 核心端点（常用4个）：

/actuator/health：应用健康检查，返回应用是否正常运行（如数据库、Redis连接是否正常）。
/actuator/info：应用信息，可配置应用名称、版本、作者等。
/actuator/metrics：应用指标，如JVM内存、CPU使用率、HTTP请求数、接口响应时间。
/actuator/loggers：日志管理，可动态修改日志级别（无需重启应用）。

四、Spring Boot 版本差异与扩展（高频，进阶）

1. Spring Boot 1.x、2.x、3.x 的核心区别是什么？（必问）

答案：

核心区别（3点重点，简洁好记）：

底层依赖：
- 1.x：基于Spring Framework 4.x，最低支持Java 6/7，兼容Java 8。
- 2.x：基于Spring Framework 5.x，最低支持Java 8，支持响应式编程（WebFlux）。
- 3.x：基于Spring Framework 6.x，最低支持Java 17（强制），迁移到Jakarta EE（包名从javax.改为jakarta.）。
核心特性：
- 1.x：奠定约定优于配置思想，基础自动配置、起步依赖。
- 2.x：增强自动配置，新增WebFlux、Micrometer监控、Undertow容器支持。
- 3.x：支持GraalVM原生镜像（毫秒级启动）、AOT编译、Java 17新特性，移除过时API。
配置变更：
- 3.x 用AutoConfiguration.imports文件替代1.x/2.x的spring.factories文件，管理自动配置类。
- 3.x 移除@ConfigurationProperties的宽松绑定，仅支持kebab-case格式（如下划线格式不再兼容）。

2. Spring Boot 如何集成Spring Security？核心作用是什么？（高频）

答案：

① 核心作用：Spring Security是Spring生态的安全框架，用于实现「身份认证」（验证用户是否合法）和「权限控制」（控制用户可访问的资源），保护Spring Boot应用的接口安全。

② 核心集成步骤：

引入依赖： <dependency> `` <groupId>org.springframework.boot</groupId> `` <artifactId>spring-boot-starter-security</artifactId> ``</dependency>
编写配置类（Spring Boot 3.x，替代WebSecurityConfigurerAdapter）： @Configuration `` @EnableWebSecurity `` public class SecurityConfig { `` // 密码加密方式（BCrypt） `` @Bean `` public PasswordEncoder passwordEncoder() { `` return new BCryptPasswordEncoder(); `` } ```` // 配置安全规则 `` @Bean `` public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception { `` return http `` .authorizeHttpRequests(auth -> auth `` .requestMatchers("/login", "/register").permitAll() // 放行登录/注册接口 `` .anyRequest().authenticated() // 其他接口需认证 `` ) `` .formLogin(form -> form.permitAll()) // 开启表单登录 `` .csrf(csrf -> csrf.disable()) // 开发环境禁用CSRF `` .build(); `` } ``}
自定义用户认证：实现UserDetailsService接口，从数据库查询用户信息，完成认证。

3. Spring Boot 如何实现异步处理？@Async注解的使用注意事项是什么？（高频）

答案：

① 实现方式：通过@Async注解实现异步处理，配合@EnableAsync开启异步支持，让方法异步执行（无需等待，提升应用响应速度）。

② 核心步骤：

在配置类或主类上标注@EnableAsync，开启异步支持。
在需要异步执行的方法上标注@Async： @Service `` public class AsyncService { `` // 异步方法，无需等待执行完成 `` @Async `` public void sendEmail(String email) { `` // 模拟发送邮件耗时操作 `` try { `` Thread.sleep(3000); `` } catch (InterruptedException e) { `` e.printStackTrace(); `` } `` System.out.println("邮件发送成功：" + email); `` } ``}

③ 使用注意事项（3点核心）：

@Async标注的方法必须是public方法（Spring异步仅对public方法生效）。
同一类中，异步方法调用另一异步方法，被调用方法的异步失效（AOP动态代理问题）。
异步方法返回值建议用Future，用于获取异步执行结果；无需返回值则返回void。