Spring面试题及详细答案 125道（91-110） -- Spring Boot

2025-11-28 11:04:23 分类：spring boot 热度：998 评论： 0

Spring面试题及详细答案 125道（91-110） -- Spring Boot

《前后端面试题》专栏集合了前后端各个知识模块的面试题，包括html，javascript，css，vue，react，java，Openlayers，leaflet，cesium，mapboxGL，threejs，nodejs，mangoDB，SQL，Linux… 。

前后端面试题-专栏总目录

一、本文面试题目录

91. 什么是Spring Boot？它的主要特点是什么？

Spring Boot 是基于Spring框架的快速开发脚手架，旨在简化Spring应用的初始搭建和开发过程，通过自动配置和自动配置减少样板代码，让开发者专注注于业务逻辑。

主要特点：

  1. 自动配置：根据类路径下的依赖自动配置Spring组件（如引入spring-boot-starter-web会自动配置Tomcat和Spring MVC）。
  2. 起步依赖（Starter）：将常用依赖打包成 Starter（如spring-boot-starter-data-jpa），简化依赖管理。
  3. 嵌入式服务器：内置Tomcat、Jetty等服务器，无需部署WAR包，可直接通过java -jar运行。
  4. 无代码生成和XML配置：通过注解和Java配置替代传统XML，减少配置复杂度。
  5. 生产就绪特性：内置监控（Actuator）、健康检查、外部化配置等功能，便于线上运维。
  6. 与Spring生态无缝集成：完美支持Spring Cloud、Spring Security等组件。

92. Spring Boot和Spring的关系是什么？

Spring Boot是Spring框架的扩展和简化工具，两者的关系可概括为：

  1. 依赖关系：Spring Boot基于Spring框架核心（如IoC容器、AOP等），并对其进行封装。
  2. 目标差异：
    • Spring是一个综合性框架，提供IoC、AOP、事务管理等核心功能，但需手动配置大量组件。
    • Spring Boot专注于简化开发流程，通过自动配置、起步依赖等特性减少Spring应用的配置工作。
  3. 兼容性：Spring Boot兼容Spring的所有功能，开发者可在Spring Boot中直接使用Spring的注解和API（如@Autowired、@Service）。
  4. 演进关系：Spring Boot是Spring生态的“加速器”，而非替代品，其出现是为了解决Spring应用开发中的配置繁琐问题。

简言之：Spring Boot = Spring + 自动配置 + 起步依赖 + 嵌入式服务器。

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

Spring Boot的自动配置核心是通过条件注解和类路径扫描，根据项目依赖自动配置Bean。

原理步骤：

  1. @EnableAutoConfiguration触发自动配置
    @SpringBootApplication包含@EnableAutoConfiguration，该注解通过@Import(AutoConfigurationImportSelector.class)导入自动配置类。

  2. 扫描自动配置类
    AutoConfigurationImportSelector从META-INF/spring.factories文件中读取自动配置类全限定名（如DataSourceAutoConfiguration）。

  3. 条件注解过滤
    自动配置类通过条件注解（如@ConditionalOnClass、@ConditionalOnMissingBean）判断是否需要生效：

    • @ConditionalOnClass：类路径存在指定类时生效。
    • @ConditionalOnMissingBean：容器中不存在指定Bean时生效。

  4. 配置Bean
    满足条件的自动配置类通过@Bean注解向容器中注册组件（如DataSourceAutoConfiguration配置数据源）。

示例：
DataSourceAutoConfiguration的简化逻辑：

@Configuration
@ConditionalOnClass({DataSource.class, EmbeddedDatabaseType.class}) // 存在DataSource类时生效
@EnableConfigurationProperties(DataSourceProperties.class)
public class DataSourceAutoConfiguration {
    @Bean
    @ConditionalOnMissingBean // 容器中没有DataSource时自动配置
    public DataSource dataSource(DataSourceProperties properties) {
        return properties.initializeDataSourceBuilder().build();
    }
}

94. 如何自定义Spring Boot的自动配置？

自定义自动配置需实现条件判断和Bean注册，并通过spring.factories声明配置类。

步骤：

  1. 创建自动配置类
    使用@Configuration和条件注解定义配置逻辑。

    // 自定义Redis自动配置
@Configuration
@ConditionalOnClass(RedisTemplate.class) // 存在RedisTemplate时生效
@EnableConfigurationProperties(RedisProperties.class) // 绑定配置属性
public class MyRedisAutoConfiguration {
    @Bean
    @ConditionalOnMissingBean // 不存在RedisTemplate时注册
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);
        // 配置序列化方式等
        return template;
    }
}

  2. 定义配置属性类
    通过@ConfigurationProperties绑定application.yml中的配置。

    @ConfigurationProperties(prefix = "my.redis")
public class RedisProperties {
    private String host = "localhost";
    private int port = 6379;
    // getters/setters
}

  3. 注册自动配置类
    在src/main/resources/META-INF/spring.factories中声明配置类：

    org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
***.example.config.MyRedisAutoConfiguration

  4. 打包与使用
    将项目打包为Starter，其他项目引入依赖后即可自动生效。

95. Spring Boot的starter是什么？它的工作原理是什么？

Starter（起步依赖） 是Spring Boot提供的依赖描述符集合，将某一功能相关的依赖打包，简化依赖引入。

常见Starter：

  • spring-boot-starter-web：Web开发（包含Spring MVC、Tomcat等）。
  • spring-boot-starter-data-jpa：JPA数据访问（包含Hibernate、数据库连接池等）。

工作原理：

  1. 依赖传递：Starter的pom.xml中定义了该功能所需的核心依赖，引入Starter后会自动下载依赖。
  2. 自动配置触发：Starter通常包含自动配置类（在META-INF/spring.factories中声明），Spring Boot启动时扫描并加载这些配置类，自动注册相关Bean。

示例：
引入spring-boot-starter-web后，Maven会自动下载Spring MVC、Tomcat等依赖，Spring Boot会通过WebMvcAutoConfiguration自动配置DispatcherServlet、视图解析器等组件。

96. 如何在Spring Boot中配置数据源？

Spring Boot支持多种数据源配置方式，默认使用HikariCP连接池。

1. 配置默认数据源（application.yml）
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/test?useSSL=false&serverTimezone=UTC
    username: root
    password: 123456
    driver-class-name: ***.mysql.cj.jdbc.Driver # 可选，Spring Boot会自动推断
    hikari: # HikariCP配置
      maximum-pool-size: 10 # 最大连接数
      minimum-idle: 5 # 最小空闲连接
2. 配置多数据源

需手动配置DataSource、SqlSessionFactory等Bean。

@Configuration
public class MultiDataSourceConfig {
    // 主数据源
    @Primary
    @Bean
    @ConfigurationProperties("spring.datasource.master")
    public DataSource masterDataSource() {
        return DataSourceBuilder.create().build();
    }
    
    // 从数据源
    @Bean
    @ConfigurationProperties("spring.datasource.slave")
    public DataSource slaveDataSource() {
        return DataSourceBuilder.create().build();
    }
}

spring:
  datasource:
    master:
      url: jdbc:mysql://localhost:3306/master
      username: root
      password: 123456
    slave:
      url: jdbc:mysql://localhost:3306/slave
      username: root
      password: 123456
3. 使用第三方数据源（如Druid）
  1. 引入依赖：
<dependency>
    <groupId>***.alibaba</groupId>
    <artifactId>druid-spring-boot-starter</artifactId>
    <version>1.2.8</version>
</dependency>
  1. 配置：
spring:
  datasource:
    druid:
      url: jdbc:mysql://localhost:3306/test
      username: root
      password: 123456
      initial-size: 5 # 初始连接数
      max-active: 20 # 最大连接数

97. Spring Boot的核心注解有哪些？请解释@SpringBootApplication的组成。

核心注解
  1. @SpringBootApplication：Spring Boot应用的入口注解，组合了多个注解。
  2. @EnableAutoConfiguration：开启自动配置。
  3. @***ponentScan：扫描@***ponent及其派生注解（@Service、@Controller等）的Bean。
  4. @Configuration：标识配置类，可通过@Bean注册Bean。
  5. @RestController：组合@Controller和@ResponseBody，用于RESTful接口。
  6. @EnableConfigurationProperties：启用配置属性类（绑定application.yml配置）。
@SpringBootApplication的组成
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration // 等同于@Configuration，标识配置类
@EnableAutoConfiguration // 开启自动配置
@***ponentScan(excludeFilters = { // 扫描组件，排除特定过滤器
    @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
    @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class)
})
public @interface SpringBootApplication { ... }
  • @SpringBootConfiguration：继承自@Configuration，表明该类是配置类。
  • @EnableAutoConfiguration：触发自动配置逻辑。
  • @***ponentScan：默认扫描当前类所在包及其子包的组件。

98. 如何禁用Spring Boot的某个自动配置？

当Spring Boot的自动配置不符合需求时，可通过以下方式禁用特定自动配置类：

1. 使用@SpringBootApplication的exclude属性
// 禁用DataSourceAutoConfiguration
@SpringBootApplication(exclude = DataSourceAutoConfiguration.class)
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}
2. 使用@EnableAutoConfiguration的exclude属性
@Configuration
@EnableAutoConfiguration(exclude = {RedisAutoConfiguration.class})
@***ponentScan
public class MyApplication { ... }
3. 通过配置文件禁用

在application.yml中指定要排除的自动配置类：

spring:
  autoconfigure:
    exclude:
      - org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration
      - org.springframework.boot.autoconfigure.redis.RedisAutoConfiguration

适用场景：

  • 自定义数据源时，禁用默认的DataSourceAutoConfiguration。
  • 使用其他缓存框架时，禁用RedisAutoConfiguration。

99. Spring Boot中的 profiles 有什么作用？如何使用？

profiles 用于区分不同环境（如开发、测试、生产）的配置，实现环境隔离。

作用：

  • 不同环境使用不同配置（如数据库地址、日志级别）。
  • 控制Bean在特定环境下生效。
使用方式

  1. 创建多环境配置文件
    命名格式：application-{profile}.yml，如：

    • application-dev.yml（开发环境）
    • application-prod.yml（生产环境）
    # application-dev.yml
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/dev

# application-prod.yml
spring:
  datasource:
    url: jdbc:mysql://prod-server:3306/prod

  2. 激活指定环境

    • 在application.yml中指定：
      spring:
  profiles:
    active: dev # 激活开发环境
    • 通过命令行参数：
      java -jar app.jar --spring.profiles.active=prod
    • 通过环境变量：设置SPRING_PROFILES_ACTIVE=prod。

  3. 条件注册Bean
    使用@Profile注解控制Bean在特定环境生效：

    @Configuration
public class DataSourceConfig {
    @Bean
    @Profile("dev") // 仅开发环境生效
    public DataSource devDataSource() { ... }
    
    @Bean
    @Profile("prod") // 仅生产环境生效
    public DataSource prodDataSource() { ... }
}

100. Spring Boot如何实现热部署？

热部署指修改代码后无需重启应用即可生效，Spring Boot通过spring-boot-devtools实现。

步骤：

  1. 添加依赖（Maven）
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
    <optional>true</optional> <!-- 防止传递依赖 -->
</dependency>

  1. 配置IDE（以IntelliJ IDEA为例）

    • 开启自动编译：File → Settings → Build, Execution, Deployment → ***piler → 勾选Build Project Automatically。
    • 允许运行中编译：按Ctrl+Shift+Alt+/ → 选择Registry → 勾选***piler.automake.allow.when.app.running。

  2. 配置application.yml（可选）

spring:
  devtools:
    restart:
      enabled: true # 启用重启
      exclude: static/**, public/** # 排除不需要重启的目录

原理：
devtools通过监控类路径变化，当文件修改时自动重启Spring容器（速度快于手动重启，因使用了类加载器隔离）。

注意：

  • 热部署不适用于生产环境，仅用于开发。
  • 某些资源（如静态文件）修改后无需重启，可直接生效。

101. Spring Boot的配置文件有哪些格式？它们的区别是什么？

Spring Boot支持两种配置文件格式：properties 和 yaml（或yml）。

格式对比
特性 properties格式 yaml/yml格式
语法 键值对：key=value，层级用.分隔。 缩进表示层级，key: value（冒号后需空格）。
可读性 层级深时较繁琐。 结构清晰，适合复杂层级配置。
数据类型 所有值均为字符串，需手动转换。 支持字符串、数字、布尔、列表等类型。
示例 spring.datasource.url=jdbc:mysql://... spring: datasource: url: jdbc:mysql://...
示例
  1. application.properties
spring.datasource.url=jdbc:mysql://localhost:3306/test
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.hikari.maximum-pool-size=10
  1. application.yml
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/test
    username: root
    password: 123456
    hikari:
      maximum-pool-size: 10

优先级：
同一目录下，properties文件优先级高于yaml文件（若存在同名配置，properties会覆盖yaml）。

102. 如何在Spring Boot中集成MyBatis/hibernate？

集成MyBatis
  1. 引入依赖
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.2.2</version>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <scope>runtime</scope>
</dependency>
  1. 配置数据源（application.yml）
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/test
    username: root
    password: 123456

mybatis:
  mapper-locations: classpath:mapper/*.xml # Mapper.xml路径
  type-aliases-package: ***.example.entity # 实体类包路径
  1. 定义Mapper接口和XML
// UserMapper.java
@Mapper
public interface UserMapper {
    User selectById(Long id);
}

<!-- src/main/resources/mapper/UserMapper.xml -->
<mapper namespace="***.example.mapper.UserMapper">
    <select id="selectById" resultType="User">
        SELECT * FROM user WHERE id = #{id}
    </select>
</mapper>
  1. 使用Mapper
@Service
public class UserService {
    @Autowired
    private UserMapper userMapper;
    
    public User getUser(Long id) {
        return userMapper.selectById(id);
    }
}
集成Hibernate（JPA）
  1. 引入依赖
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <scope>runtime</scope>
</dependency>
  1. 配置JPA（application.yml）
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/test
    username: root
    password: 123456
  jpa:
    hibernate:
      ddl-auto: update # 自动创建表结构
    show-sql: true # 打印SQL
    properties:
      hibernate:
        dialect: org.hibernate.dialect.MySQL8Dialect
  1. 定义实体类和Repository
// User.java
@Entity
@Table(name = "user")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    // getters/setters
}

// UserRepository.java
public interface UserRepository extends JpaRepository<User, Long> {
    // 继承CRUD方法，支持自定义查询
    List<User> findByName(String name);
}
  1. 使用Repository
@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;
    
    public User getUser(Long id) {
        return userRepository.findById(id).orElse(null);
    }
}

103. Spring Boot中的Actuator有什么作用？常用的端点有哪些？

Actuator 是Spring Boot提供的生产就绪特性，用于监控和管理应用程序，通过HTTP或JMX暴露应用内部状态。

作用：

  • 健康检查、metrics收集、日志查看等。
  • 集成监控系统（如Prometheus、Grafana）。
使用步骤
  1. 引入依赖
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
  1. 配置端点（application.yml）
management:
  endpoints:
    web:
      exposure:
        include: health,info,metrics # 暴露的端点（*表示所有）
  endpoint:
    health:
      show-details: always # 显示健康详情
常用端点
端点 作用 访问地址
/health 应用健康状态（如数据库、Redis连接） http://localhost:8080/actuator/health
/info 应用信息（如版本、描述，需自定义） http://localhost:8080/actuator/info
/metrics 应用 metrics（如内存、请求数） http://localhost:8080/actuator/metrics
/env 环境变量和配置属性 http://localhost:8080/actuator/env
/loggers 查看和修改日志级别 http://localhost:8080/actuator/loggers
/shutdown 优雅关闭应用（默认禁用） http://localhost:8080/actuator/shutdown（POST请求）

自定义info端点：

info:
  app:
    name: my-app
    version: 1.0.0
  author: John

104. 如何在Spring Boot中实现日志配置？

Spring Boot默认使用Logback作为日志框架，支持通过配置文件或XML自定义日志。

1. 基本配置（application.yml）
logging:
  level:
    root: info # 根日志级别
    ***.example.service: debug # 特定包日志级别
    org.springframework.web: warn # Spring Web日志级别
  file:
    name: logs/myapp.log # 日志文件路径
  pattern:
    console: "%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n" # 控制台格式
    file: "%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n" # 文件格式
2. 高级配置（Logback XML）

创建src/main/resources/logback-spring.xml，支持更复杂的配置（如滚动日志、多环境适配）：

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <!-- 控制台输出 -->
    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>
    
    <!-- 滚动文件输出 -->
    <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>logs/myapp.log</file>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>logs/myapp.%d{yyyy-MM-dd}.log</fileNamePattern>
            <maxHistory>30</maxHistory> <!-- 保留30天日志 -->
        </rollingPolicy>
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>
    
    <!-- 根日志级别 -->
    <root level="info">
        <appender-ref ref="CONSOLE"/>
        <appender-ref ref="FILE"/>
    </root>
    
    <!-- 特定包日志级别 -->
    <logger name="***.example.service" level="debug" additivity="false">
        <appender-ref ref="CONSOLE"/>
    </logger>
    
    <!-- 多环境配置 -->
    <springProfile name="dev">
        <root level="debug"/>
    </springProfile>
</configuration>
3. 使用日志
@Service
public class UserService {
    private static final Logger logger = LoggerFactory.getLogger(UserService.class);
    
    public void getUser() {
        logger.debug("查询用户开始");
        logger.info("用户查询成功");
        logger.error("用户查询失败", new Exception("错误信息"));
    }
}

105. Spring Boot的启动流程是怎样的？

Spring Boot启动流程可概括为初始化Spring应用上下文并启动嵌入式服务器，核心步骤如下：

  1. 启动入口（main方法）
    调用SpringApplication.run(MyApplication.class, args)，创建SpringApplication实例并执行run()方法。

  2. 初始化SpringApplication

    • 推断应用类型（Servlet/WebFlux/非Web）。
    • 加载初始化器（ApplicationContextInitializer）和监听器（ApplicationListener）。
    • 确定主应用类（包含main方法的类）。

  3. 执行run()方法
    a. 启动监听器：发布ApplicationStartingEvent事件。
    b. 准备环境：加载配置文件、环境变量等，发布ApplicationEnvironmentPreparedEvent。
    c. 创建上下文：根据应用类型创建ApplicationContext（如AnnotationConfigServletWebServerApplicationContext）。
    d. 准备上下文：应用初始化器、关联环境、注册单例Bean（如springApplicationArguments）。
    e. 刷新上下文：

    • 调用AbstractApplicationContext.refresh()，触发BeanFactory初始化、Bean注册和初始化。
    • 自动配置类生效，注册相关Bean（如DispatcherServlet）。
    • 启动嵌入式服务器（如Tomcat），通过ServletWebServerFactory创建服务器。
      f. 完成启动：发布ApplicationReadyEvent事件，应用可用。

核心逻辑：通过事件驱动机制串联各步骤，最终完成Spring容器初始化和服务器启动。

106. Spring Boot中如何使用外部配置文件？（如命令行参数、环境变量）

Spring Boot支持多种外部配置方式，优先级从高到低如下：

  1. 命令行参数
    通过--key=value传递，覆盖其他配置。

    java -jar app.jar --spring.datasource.url=jdbc:mysql://localhost:3306/test

  2. 环境变量
    系统环境变量，如SPRING_DATASOURCE_URL=jdbc:mysql://...（下划线替代点，大写字母）。

  3. 配置文件

    • application-{profile}.yml（指定环境配置）
    • application.yml（默认配置）
    • 外部配置文件（通过--spring.config.location指定路径）：
      java -jar app.jar --spring.config.location=/opt/config/

  4. @PropertySource注解
    加载自定义配置文件：

    @Configuration
@PropertySource("classpath:custom.properties") // 加载自定义配置
public class CustomConfig {
    @Value("${app.name}")
    private String appName;
}

  5. 默认属性
    Spring Boot内置的默认配置。

示例：
通过环境变量和命令行参数配置端口：

  • 环境变量：SPRING_BOOT_SERVER_PORT=8081
  • 命令行：java -jar app.jar --server.port=8082（最终端口为8082，因命令行优先级更高）。

107. 什么是Spring Boot Starter Parent？它的作用是什么？

Spring Boot Starter Parent 是一个特殊的Maven父工程，定义了Spring Boot应用的默认配置和依赖版本。

作用：

  1. 统一依赖版本：管理常用依赖的版本（如Spring Framework、Hibernate等），避免版本冲突。
  2. 默认插件配置：集成spring-boot-maven-plugin等插件，支持打包、运行等功能。
  3. 资源过滤：默认过滤src/main/resources下的配置文件（如替换@...@占位符）。
  4. 编译配置：默认Java版本（如Java 8）、编码（UTF-8）等。

使用方式：
在pom.xml中指定父工程：

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.7.0</version> <!-- Spring Boot版本 -->
</parent>

自定义父工程：
若需使用自己的父工程，可通过dependencyManagement继承Starter Parent的依赖管理：

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>2.7.0</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

108. Spring Boot中如何实现缓存？（如使用@Cacheable）

Spring Boot通过spring-boot-starter-cache支持缓存，整合了Caffeine、EhCache、Redis等缓存框架。

步骤（以Caffeine为例）
  1. 引入依赖
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
</dependency>
<dependency>
    <groupId>***.github.ben-manes.caffeine</groupId>
    <artifactId>caffeine</artifactId>
</dependency>
  1. 启用缓存
    在启动类添加@EnableCaching：
@SpringBootApplication
@EnableCaching // 启用缓存
public class MyApplication { ... }
  1. 配置缓存（application.yml）
spring:
  cache:
    type: caffeine
    caffeine:
      spec: maximumSize=1000,expireAfterWrite=60s # 最大1000条，60秒过期
  1. 使用缓存注解
@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;
    
    // 缓存结果，key为方法参数id
    @Cacheable(value = "userCache", key = "#id")
    public User getUserById(Long id) {
        // 首次调用执行，后续从缓存获取
        return userRepository.findById(id).orElse(null);
    }
    
    // 更新缓存（删除旧缓存）
    @CacheEvict(value = "userCache", key = "#user.id")
    public void updateUser(User user) {
        userRepository.save(user);
    }
    
    // 清除所有缓存
    @CacheEvict(value = "userCache", allEntries = true)
    public void clearCache() {
        // 无需业务逻辑，仅清除缓存
    }
}

常用缓存注解：

  • @Cacheable：方法结果存入缓存。
  • @CacheEvict：删除缓存条目。
  • @CachePut：更新缓存（始终执行方法）。
  • @Caching：组合多个缓存操作。

109. 如何在Spring Boot中进行单元测试？（如使用@SpringBootTest）

Spring Boot提供spring-boot-starter-test简化单元测试，支持测试控制器、服务、Repository等组件。

步骤
  1. 引入依赖
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>
  1. 测试Service层
@SpringBootTest // 加载Spring上下文
public class UserServiceTest {
    @Autowired
    private UserService userService;
    
    @Test
    public void testGetUserById() {
        User user = userService.getUserById(1L);
        assertNotNull(user);
        assertEquals("张三", user.getName());
    }
}
  1. 测试Controller层（使用MockMvc）
@SpringBootTest
@AutoConfigureMockMvc // 自动配置MockMvc
public class UserControllerTest {
    @Autowired
    private MockMvc mockMvc;
    
    @Test
    public void testGetUser() throws Exception {
        // 模拟GET请求
        mockMvc.perform(get("/users/1")
                .contentType(MediaType.APPLICATION_JSON))
                .andExpect(status().isOk()) // 期望状态码200
                .andExpect(jsonPath("$.name").value("张三")); // 期望响应JSON的name字段
    }
}
  1. 测试Repository层（使用@DataJpaTest）
@DataJpaTest // 仅加载JPA相关组件
public class UserRepositoryTest {
    @Autowired
    private UserRepository userRepository;
    
    @Test
    public void testFindByName() {
        User user = new User();
        user.setName("李四");
        userRepository.save(user);
        
        List<User> users = userRepository.findByName("李四");
        assertFalse(users.isEmpty());
    }
}

常用注解：

  • @SpringBootTest：加载完整Spring上下文。
  • @MockBean：模拟Bean（替代真实依赖）。
  • @Test：标识测试方法（JUnit 5）。

110. Spring Boot 2.x和1.x有哪些主要区别？

Spring Boot 2.x在性能、依赖、功能等方面对1.x进行了重大升级，主要区别如下：

  1. 最低依赖版本提升

    • Java：2.x要求Java 8+，1.x支持Java 6+。
    • Spring Framework：2.x基于Spring 5.x，1.x基于Spring 4.x。

  2. 自动配置增强

    • 2.x重构了部分自动配置类（如WebMvcAutoConfiguration），支持更多条件注解。
    • 引入@ConditionalOnClass的派生注解（如@ConditionalOnWebApplication）。

  3. 嵌入式服务器

    • 2.x默认使用***ty作为WebFlux服务器，Tomcat版本升级至9.0+。
    • 1.x默认Tomcat 8.5。

  4. Actuator改进

    • 2.x重构了Actuator，端点路径默认前缀为/actuator（1.x无前缀）。
    • 支持自定义端点，安全控制更灵活。

  5. 缓存支持

    • 2.x引入CaffeineCacheManager作为默认缓存管理器（1.x默认ConcurrentMapCacheManager）。

  6. 响应式编程支持

    • 2.x新增对WebFlux的支持，实现响应式Web开发（1.x仅支持Spring MVC）。

  7. 配置绑定

    • 2.x使用@ConfigurationProperties绑定更灵活，支持松散绑定（如myProp可匹配my-prop）。

  8. Maven插件

    • 2.x的spring-boot-maven-plugin支持分层构建，优化Docker镜像大小。

升级注意事项：

  • 需升级Java版本至8+。
  • 部分自动配置类包路径变化（如org.springframework.boot.autoconfigure.web → org.springframework.boot.autoconfigure.web.servlet）。
  • 自定义Starter需适配2.x的自动配置机制。

二、125道Spring面试题目录列表

文章序号 Spring面试题125道
1 Spring面试题及详细答案125道（01-15）
2 Spring面试题及详细答案125道（16-25）
3 Spring面试题及详细答案125道（26-45）
4 Spring面试题及详细答案125道（46-65）
5 Spring面试题及详细答案125道（66-75）
6 Spring面试题及详细答案125道（76-90）
7 Spring面试题及详细答案125道（91-110）
8 Spring面试题及详细答案125道（111-125）
转载请说明出处内容投诉
CSS教程网 » Spring面试题及详细答案 125道（91-110） -- Spring Boot
行道

行道

分享到：

发表评论

欢迎 访客 发表评论

一个令你着迷的主题！

查看演示 官网购买