SpringBoot面试问题_springboot面试题-CSDN博客

本文链接：https://blog.csdn.net/F_windy/article/details/146072677

SpringBoot高频面试问题

一、为什么使用springboot？

使用 Spring Boot 的主要原因在于它极大地简化了 Spring 应用的开发、配置和部署流程，特别适合快速构建生产级应用。以下是它的核心优势：

1. 开箱即用，简化配置

自动配置（Auto-Configuration）
Spring Boot 根据项目依赖（如数据库、安全框架）自动配置应用，无需手动编写 XML 或注解配置。例如，引入 spring-boot-starter-data-jpa 后，它会自动配置数据源和 JPA 相关组件。
约定优于配置
大部分配置采用默认值（如端口 8080、上下文路径 /），开发者只需按需覆盖即可。

2. 内嵌服务器（Embedded Server）

直接集成 Tomcat、Jetty 或 Undertow，无需单独部署 WAR 包到外部服务器，通过 java -jar 即可运行应用。
简化本地开发和测试，也适合微服务架构中的轻量化部署。

3. Starter 依赖管理

通过 Starter POMs（如 spring-boot-starter-web、spring-boot-starter-security）一键引入相关技术栈的依赖，避免版本冲突问题。
示例：添加 spring-boot-starter-web 会同时引入 Spring MVC、Tomcat 和 Jackson 等必要依赖。

4. 快速构建独立应用

通过 Spring Initializr（官网或 IDE 集成）快速生成项目骨架，支持 Maven/Gradle。
适合敏捷开发，几分钟即可搭建一个可运行的 REST API 服务。

5. 生产级特性

Actuator 模块：提供健康检查、指标监控、日志管理等运维功能，方便实时监控应用状态。
外部化配置：支持通过 application.properties 或 application.yml 灵活管理不同环境（开发、测试、生产）的配置。

6. 与 Spring 生态无缝集成

兼容 Spring 全家桶（Spring Data、Spring Security、Spring Cloud 等），适合构建微服务、响应式应用或传统单体架构。
与 Spring Cloud 结合，可快速实现服务注册、配置中心、熔断器等微服务组件。

7. 社区与生态强大

Spring 社区活跃，文档丰富，遇到问题容易找到解决方案。
众多第三方库（如 MyBatis、Redis）提供了与 Spring Boot 集成的 Starter，简化整合流程。

适用场景

微服务开发：轻量级、独立部署的特性适合微服务架构。
快速原型开发：初创项目或验证想法时，快速交付 MVP（最小可行产品）。
传统企业应用：简化 CRUD 应用开发，提升效率。

总结

Spring Boot 通过自动化配置、内嵌服务器和标准化依赖管理，大幅降低了 Spring 应用的门槛，让开发者更专注于业务逻辑而非框架配置。对于追求高效开发和部署的团队来说，它是现代 Java 后端开发的首选框架之一。

二、SpringBoot用到哪些设计模式？

Spring Boot（以及其底层的 Spring 框架）广泛使用了多种设计模式，这些模式帮助简化开发、提高扩展性，并保持代码的灵活性和可维护性。以下是 Spring Boot 中常见的设计模式及其应用场景：

1. 单例模式（Singleton）

应用场景：Spring 容器管理的 Bean 默认是单例的（通过 @Scope("singleton") 控制）。

示例：

@Service
public class UserService { 
    // 容器中只有一个 UserService 实例
}

作用：减少对象创建开销，确保全局唯一性。

2. 工厂模式（Factory Pattern）

应用场景：Bean 的创建和管理通过 BeanFactory 和 ApplicationContext 实现。

示例：

ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
UserService userService = context.getBean(UserService.class);

作用：解耦对象的创建与使用，集中管理 Bean 生命周期。

3. 模板方法模式（Template Method）

应用场景：Spring 提供大量模板类（如 JdbcTemplate、RestTemplate），定义操作流程，允许子类重写特定步骤。

示例：

jdbcTemplate.execute("SELECT * FROM users", (ResultSet rs) -> {
    // 处理结果集
    return null;
});

作用：抽象通用流程，减少重复代码。

4. 代理模式（Proxy Pattern）

应用场景：AOP（面向切面编程）通过动态代理（JDK Proxy 或 CGLIB）实现。

示例：@Transactional 注解通过代理对象管理事务。

@Transactional
public void updateUser(User user) {
    // 数据库操作
}

作用：在不修改原有代码的情况下增强功能（如日志、事务）。

5. 观察者模式（Observer Pattern）

应用场景：Spring 事件驱动模型（ApplicationEvent 和 ApplicationListener）。

示例：

// 定义事件
public class UserCreatedEvent extends ApplicationEvent { ... }

// 发布事件
context.publishEvent(new UserCreatedEvent(this, user));

// 监听事件
@Component
public class UserEventListener implements ApplicationListener<UserCreatedEvent> {
    @Override
    public void onApplicationEvent(UserCreatedEvent event) { ... }
}

作用：实现松耦合的事件通知机制。

6. 适配器模式（Adapter Pattern）

应用场景：Spring MVC 中的 HandlerAdapter 处理不同类型的 Controller（如 @Controller、HttpRequestHandler）。
示例：RequestMappingHandlerAdapter 适配基于注解的 Controller。
作用：统一接口调用，兼容不同实现。

7. 装饰者模式（Decorator Pattern）

应用场景：Bean 的包装增强（如 BeanDefinitionDecorator）。
示例：通过 BeanPostProcessor 对 Bean 进行额外处理（如日志装饰）。
作用：动态扩展对象功能。

8. 策略模式（Strategy Pattern）

应用场景：多种算法的动态切换（如缓存策略、事务管理策略）。
示例：PlatformTransactionManager 接口的不同实现（JDBC、JTA）。
```
@Autowired
private PlatformTransactionManager transactionManager;
```
作用：解耦算法实现，灵活替换。

9. 组合模式（Composite Pattern）

应用场景：处理树形结构，如 Spring Security 的权限配置。

示例：

http.authorizeRequests()
    .antMatchers("/public/**").permitAll()
    .antMatchers("/admin/**").hasRole("ADMIN");

作用：统一处理简单和复杂的对象结构。

10. 责任链模式（Chain of Responsibility）

应用场景：Spring Security 的过滤器链（FilterChainProxy）、Spring MVC 的拦截器链。
示例：请求依次经过多个 Filter 或 HandlerInterceptor。
作用：解耦请求处理者，动态组合处理流程。

11. 建造者模式（Builder Pattern）

应用场景：复杂对象的逐步构建（如 RestTemplateBuilder、SpringApplicationBuilder）。

示例：

RestTemplate restTemplate = new RestTemplateBuilder()
    .rootUri("https://api.example.com")
    .setConnectTimeout(Duration.ofSeconds(5))
    .build();

作用：简化复杂对象的配置过程。

12. 外观模式（Facade Pattern）

应用场景：Spring Boot 的自动配置（@EnableAutoConfiguration）封装了复杂的配置逻辑。
示例：添加 spring-boot-starter-web 依赖后，自动配置 Tomcat、Spring MVC。
作用：对外提供简化接口，隐藏子系统复杂性。

总结

Spring Boot 通过灵活运用这些设计模式，实现了以下目标：

简化开发：通过工厂、模板方法等模式减少重复代码。
解耦与扩展：代理、策略等模式提高组件替换和功能扩展能力。
高效管理：单例、责任链等模式优化资源利用和流程控制。

这些模式不仅是 Spring Boot 的核心设计思想，也是其能够成为高效、灵活框架的关键原因。

三、怎么理解SpringBoot中的约定大于配置？

在 Spring Boot 中，约定大于配置（Convention Over Configuration） 是一种核心设计理念，旨在通过预设合理的默认行为和约定，减少开发者需要手动编写的配置代码，从而提升开发效率并降低项目的复杂性。以下是具体理解：

1. 什么是“约定大于配置”？

核心理念：框架提供一套默认规则（约定），开发者只需在需要时覆盖这些规则，而非从零开始配置一切。
目标：减少重复的样板代码，让开发者专注于业务逻辑，而非框架配置。

2. Spring Boot 中的约定体现

（1）项目结构与命名约定

目录结构：
Spring Boot 默认约定 src/main/java 为代码根目录，src/main/resources 存放配置文件（如 application.properties/application.yml），static 和 templates 分别存放静态资源和模板文件。
开发者只需按约定放置文件，框架会自动识别。

src/
├── main/
│   ├── java/          # Java 代码
│   ├── resources/
│       ├── static/    # 静态资源（CSS、JS）
│       ├── templates/ # 模板文件（Thymeleaf、Freemarker）
│       └── application.yml  # 主配置文件

配置文件命名：
默认加载 application.properties 或 application.yml。按环境区分时，约定使用 application-{profile}.properties（如 application-dev.yml）。

（2）自动配置（Auto-Configuration）

根据依赖自动配置：
引入 Starter 依赖（如 spring-boot-starter-data-jpa）后，Spring Boot 会自动配置数据库连接、JPA 实体管理器等组件，无需手动编写 DataSource 或 EntityManagerFactory 的 Bean。

<!-- 添加依赖后自动配置 H2 数据库和 JPA -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
    <scope>runtime</scope>
</dependency>

条件化加载：
通过 @ConditionalOnClass、@ConditionalOnMissingBean 等注解，仅在满足条件时启用配置。例如，若未手动定义 DataSource Bean，则自动配置嵌入式数据库（如 H2）。

（3）默认值约定

服务器端口：默认使用 8080，无需配置。
上下文路径：默认为 /，可通过 server.servlet.context-path 修改。
日志配置：默认输出到控制台，支持通过 logback-spring.xml 覆盖。

（4）RESTful 接口映射

URL 路径：Controller 的 @RequestMapping 默认映射到类名和方法名的组合（如 /api/users）。
HTTP 方法：使用 @GetMapping、@PostMapping 等注解简化 RESTful 风格的路由定义。

3. 为什么需要“约定大于配置”？

减少决策成本：新手无需纠结配置文件的位置或 Bean 的命名，快速上手。
标准化项目结构：团队协作时，统一约定降低沟通成本。
快速启动：通过 Starter 依赖和自动配置，几分钟内即可运行一个生产级应用。
灵活覆盖：默认约定不满足需求时，可通过配置文件或自定义 Bean 轻松覆盖。

4. 如何覆盖默认约定？

配置文件：在 application.yml 中修改默认值。

server:
  port: 9090       # 修改端口
  servlet:
    context-path: /api  # 修改上下文路径
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydb  # 覆盖数据源

自定义 Bean：显式定义 Bean 以覆盖自动配置。

@Configuration
public class CustomConfig {
    @Bean
    public DataSource myDataSource() {
        // 自定义数据源
        return new HikariDataSource();
    }
}

禁用自动配置：通过 @EnableAutoConfiguration(exclude={...}) 排除特定配置。

@SpringBootApplication(exclude = {DataSourceAutoConfiguration.class})
public class MyApp { ... }

5. 实际开发中的意义

微服务场景：快速搭建多个独立服务，避免重复配置。
快速原型开发：验证业务逻辑时，无需关注底层细节。
企业级应用：减少 XML 配置，提升可维护性。

总结

Spring Boot 的“约定大于配置”通过 默认行为 和 标准化约定，将开发者从繁琐的配置中解放出来。其核心在于：

开箱即用：通过 Starter 依赖和自动配置快速集成技术栈。
灵活扩展：允许开发者按需覆盖默认规则。
统一规范：降低团队协作成本，提升代码可读性。

这一设计使 Spring Boot 成为高效、轻量且易于扩展的框架，尤其适合现代敏捷开发的需求。

四、SpringBoot的项目结构是怎么样的？

Spring Boot 的项目结构遵循 约定大于配置 的原则，通过标准化的目录和文件布局，减少手动配置的复杂性。以下是一个典型的 Spring Boot 项目结构及其核心组成部分：

标准项目结构示例

my-spring-boot-app/
├── src/
│   ├── main/
│   │   ├── java/              # Java 源代码
│   │   │   └── com/
│   │   │       └── example/
│   │   │           └── myapp/
│   │   │               ├── Application.java       # 启动类（入口）
│   │   │               ├── controller/           # 控制器层（REST API）
│   │   │               ├── service/              # 业务逻辑层
│   │   │               ├── repository/           # 数据访问层（DAO/JPA）
│   │   │               ├── model/                # 实体类（POJO/JPA）
│   │   │               ├── config/               # 自定义配置类
│   │   │               └── exception/            # 自定义异常处理
│   │   └── resources/         # 资源文件
│   │       ├── static/        # 静态资源（CSS、JS、图片）
│   │       ├── templates/     # 模板文件（Thymeleaf、Freemarker）
│   │       ├── application.yml      # 主配置文件
│   │       └── application-dev.yml  # 开发环境配置文件
│   └── test/                 # 测试代码
│       └── java/
│           └── com/
│               └── example/
│                   └── myapp/
│                       └── ApplicationTests.java  # 单元测试类
├── target/                   # 构建输出目录（编译后的文件）
├── pom.xml                   # Maven 构建配置（或 build.gradle）
└── README.md                 # 项目说明文档

核心目录与文件详解

1. `src/main/java`：Java 源代码

启动类（Application.java）
通常位于根包（如 com.example.myapp）下，包含 main 方法，是 Spring Boot 的入口。
使用 @SpringBootApplication 注解，触发自动配置和组件扫描。
```
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}
```
分层结构（按功能模块划分）：
- controller：处理 HTTP 请求（如 @RestController）。
- service：业务逻辑层（如 @Service）。
- repository：数据访问层（如 @Repository 或 Spring Data JPA 接口）。
- model：实体类（如 JPA 的 @Entity）。
- config：自定义配置类（如 @Configuration）。

2. `src/main/resources`：资源文件

application.yml / application.properties
主配置文件，用于设置数据库连接、服务器端口、日志级别等。
支持多环境配置（如 application-dev.yml、application-prod.yml）。
```
# application.yml 示例
server:
  port: 8080
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydb
    username: root
    password: 123456
```
static/
存放静态资源（HTML、CSS、JS、图片），可通过 URL 直接访问（如 http://localhost:8080/static/js/app.js）。
templates/
存放服务端渲染的模板文件（如 Thymeleaf 的 .html 文件）。

3. `src/test/java`：单元测试

测试类通常与主代码结构镜像，使用 @SpringBootTest 注解启动集成测试。

@SpringBootTest
class UserServiceTest {
    @Autowired
    private UserService userService;
    
    @Test
    void testCreateUser() {
        // 测试逻辑
    }
}

4. 构建配置文件（`pom.xml` 或 `build.gradle`）

Maven：通过 pom.xml 管理依赖和插件。

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

约定大于配置的体现

默认包扫描
Spring Boot 会自动扫描启动类所在包及其子包中的组件（如 @Component、@Service），无需手动配置 <context:component-scan>。
配置文件自动加载
无需指定配置路径，默认加载 resources/application.yml。
静态资源路径
静态文件放在 static/ 目录下即可直接访问，无需额外配置。

自定义项目结构

若需覆盖默认约定，可通过以下方式：

修改配置文件路径
指定 spring.config.location 启动参数：

java -jar myapp.jar --spring.config.location=classpath:/custom-config/

自定义静态资源路径
在 application.yml 中配置：

spring:
  web:
    resources:
      static-locations: classpath:/my-static/

调整包扫描路径
使用 @ComponentScan 注解指定扫描范围：

@SpringBootApplication
@ComponentScan(basePackages = {"com.example.core", "com.example.myapp"})
public class Application { ... }

最佳实践

分层清晰：严格区分 Controller、Service、Repository 层，避免代码耦合。
按模块分包：大型项目可按业务模块分包（如 user、order）。
多环境配置：使用 application-{profile}.yml 管理开发、测试、生产环境配置。

总结

Spring Boot 的项目结构通过 标准化的目录布局 和 默认约定，使开发者能够快速搭建应用，专注于业务逻辑而非配置细节。其核心优势在于：

快速启动：无需手动配置目录和路径。
易于维护：分层明确，符合企业级应用规范。
灵活扩展：支持按需覆盖默认行为。

五、SpringBoot自动装配原理是什么？

Spring Boot 的自动装配（Auto-Configuration）是其核心特性之一，它通过简化配置和依赖管理，大大提高了开发效率。自动装配的原理主要基于以下几个关键点：

1. `@SpringBootApplication` 注解

• @SpringBootApplication 是一个组合注解，它包含了 @Configuration、@EnableAutoConfiguration 和 @ComponentScan 三个注解。
• 其中，@EnableAutoConfiguration 是自动装配的核心，它启用了 Spring Boot 的自动配置机制。

2. `@EnableAutoConfiguration` 注解

• @EnableAutoConfiguration 通过 @Import 注解引入了 AutoConfigurationImportSelector 类。
• AutoConfigurationImportSelector 负责加载并应用所有符合条件的自动配置类。

3. `spring.factories` 文件

• Spring Boot 的自动配置类是通过 META-INF/spring.factories 文件来定义的。
• 在这个文件中，org.springframework.boot.autoconfigure.EnableAutoConfiguration 键下列出了所有的自动配置类。
• 这些自动配置类通常以 XXXAutoConfiguration 命名，并在类上使用 @Configuration 注解。

4. 条件化配置

• 自动配置类通常会使用 @Conditional 注解（如 @ConditionalOnClass、@ConditionalOnMissingBean 等）来根据特定条件决定是否应用该配置。
• 例如，@ConditionalOnClass 表示只有在类路径中存在指定的类时，才会应用该配置。

5. 自动配置类的加载

• 在应用启动时，Spring Boot 会扫描 spring.factories 文件，加载所有自动配置类。
• 然后，根据条件化配置的规则，决定是否将这些自动配置类注册为 Spring 容器中的 Bean。

6. 默认配置

• 自动配置类通常会提供一些默认的 Bean 定义和配置，这些默认值可以在 application.properties 或 application.yml 文件中进行覆盖。

7. 自定义自动配置

• 开发者也可以通过创建自己的 spring.factories 文件和自动配置类，来实现自定义的自动装配逻辑。

示例

假设你有一个 MyAutoConfiguration 类：

@Configuration
@ConditionalOnClass(MyService.class)
public class MyAutoConfiguration {

    @Bean
    @ConditionalOnMissingBean
    public MyService myService() {
        return new MyService();
    }
}

然后在 META-INF/spring.factories 文件中添加：

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.example.MyAutoConfiguration

当应用启动时，如果类路径中存在 MyService 类，并且没有其他 MyService Bean 被定义，Spring Boot 会自动创建一个 MyService Bean。

总结

Spring Boot 的自动装配机制通过 @EnableAutoConfiguration 注解、spring.factories 文件和条件化配置，实现了在应用启动时自动加载和配置所需的 Bean。这一机制大大简化了 Spring 应用的配置过程，使得开发者可以更专注于业务逻辑的实现。

六、Spring自动装配的原理？

1. `@SpringBootApplication` 注解

2. `@EnableAutoConfiguration` 注解

3. `spring.factories` 文件

4. 条件化配置

5. 自动配置类的加载

6. 默认配置

• 自动配置类通常会提供一些默认的 Bean 定义和配置，这些默认值可以在 application.properties 或 application.yml 文件中进行覆盖。

7. 自定义自动配置

• 开发者也可以通过创建自己的 spring.factories 文件和自动配置类，来实现自定义的自动装配逻辑。

示例

假设你有一个 MyAutoConfiguration 类：

@Configuration
@ConditionalOnClass(MyService.class)
public class MyAutoConfiguration {

    @Bean
    @ConditionalOnMissingBean
    public MyService myService() {
        return new MyService();
    }
}

然后在 META-INF/spring.factories 文件中添加：

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.example.MyAutoConfiguration

当应用启动时，如果类路径中存在 MyService 类，并且没有其他 MyService Bean 被定义，Spring Boot 会自动创建一个 MyService Bean。

总结

七、写过SpringBoot starter吗?

是的，我了解如何编写一个自定义的 Spring Boot Starter。Spring Boot Starter 是一种模块化的方式，用于将一组相关的依赖项和配置打包在一起，方便其他项目快速集成和使用。编写自定义 Starter 通常包括以下几个步骤：

1. 项目结构

创建一个 Maven 或 Gradle 项目，通常包含以下模块：
• 核心模块：包含业务逻辑和功能实现。
• 自动配置模块：包含 Spring Boot 的自动配置类。
• Starter 模块：仅包含依赖项，用于引入核心模块和自动配置模块。

2. 核心模块

在核心模块中实现你的功能逻辑。例如，假设我们要实现一个简单的日志打印功能：

public class MyService {
    public void printMessage(String message) {
        System.out.println("MyService: " + message);
    }
}

3. 自动配置模块

创建一个自动配置类，用于在 Spring Boot 启动时自动配置你的功能。

3.1 创建自动配置类

import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MyAutoConfiguration {

    @Bean
    @ConditionalOnMissingBean // 如果没有自定义的 MyService Bean，则创建默认的
    public MyService myService() {
        return new MyService();
    }
}

3.2 注册自动配置类

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

org.springframework.boot.autoconfigure.EnableAutoConfiguration=com.example.MyAutoConfiguration

4. Starter 模块

创建一个 Starter 模块，用于引入核心模块和自动配置模块。

4.1 添加依赖

在 pom.xml 中添加核心模块和自动配置模块的依赖：

<dependencies>
    <dependency>
        <groupId>com.example</groupId>
        <artifactId>my-core</artifactId>
        <version>1.0.0</version>
    </dependency>
    <dependency>
        <groupId>com.example</groupId>
        <artifactId>my-autoconfig</artifactId>
        <version>1.0.0</version>
    </dependency>
</dependencies>

4.2 发布 Starter

将 Starter 模块发布到 Maven 仓库，供其他项目使用。

5. 使用自定义 Starter

在其他 Spring Boot 项目中引入你的 Starter 依赖：

<dependency>
    <groupId>com.example</groupId>
    <artifactId>my-starter</artifactId>
    <version>1.0.0</version>
</dependency>

然后可以直接使用 MyService：

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

@Component
public class MyComponent {

    private final MyService myService;

    @Autowired
    public MyComponent(MyService myService) {
        this.myService = myService;
    }

    public void doSomething() {
        myService.printMessage("Hello, Custom Starter!");
    }
}

6. 可选：配置属性

如果需要支持配置属性，可以创建一个 @ConfigurationProperties 类，并在自动配置类中使用它。

6.1 创建配置属性类

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

@ConfigurationProperties(prefix = "my.service")
public class MyServiceProperties {
    private String message = "Default Message";

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }
}

6.2 在自动配置类中使用配置属性

import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@EnableConfigurationProperties(MyServiceProperties.class)
public class MyAutoConfiguration {

    private final MyServiceProperties properties;

    public MyAutoConfiguration(MyServiceProperties properties) {
        this.properties = properties;
    }

    @Bean
    @ConditionalOnMissingBean
    public MyService myService() {
        MyService myService = new MyService();
        myService.printMessage(properties.getMessage());
        return myService;
    }
}

6.3 在 `application.properties` 中配置

my.service.message=Custom Message

总结

编写一个自定义 Spring Boot Starter 的核心步骤包括：

实现功能逻辑（核心模块）。
创建自动配置类（自动配置模块）。
打包依赖项（Starter 模块）。
发布和使用 Starter。

通过这种方式，你可以将复杂的功能封装成 Starter，方便其他项目快速集成。

八、SpringBoot常用注解有哪些？有关配置的注解是哪个？

在 Spring Boot 中，注解（Annotations）是开发过程中非常重要的一部分，它们用于简化配置、定义组件、管理依赖注入等。以下是一些 重要的注解，以及一个专门用于配置的注解。

1. 核心注解

1.1 `@SpringBootApplication`

• 作用：标记主类，是 Spring Boot 应用的入口。
• 包含：@Configuration、@EnableAutoConfiguration 和 @ComponentScan 的组合。
• 示例：

@SpringBootApplication
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}

1.2 `@RestController`

• 作用：标记一个类为 RESTful 控制器，返回 JSON/XML 数据。
• 示例：

@RestController
public class MyController {
    @GetMapping("/hello")
    public String hello() {
        return "Hello, World!";
    }
}

1.3 `@RequestMapping`

• 作用：映射 HTTP 请求到控制器方法。
• 示例：

@RestController
@RequestMapping("/api")
public class MyController {
    @GetMapping("/hello")
    public String hello() {
        return "Hello, World!";
    }
}

1.4 `@Autowired`

• 作用：自动注入依赖。
• 示例：

@Service
public class MyService {
    public void doSomething() {
        System.out.println("Doing something...");
    }
}

@RestController
public class MyController {
    @Autowired
    private MyService myService;

    @GetMapping("/do")
    public String doSomething() {
        myService.doSomething();
        return "Done!";
    }
}

1.5 `@Component`

• 作用：标记一个类为 Spring 组件（Bean）。
• 衍生注解：@Service、@Repository、@Controller 等。

1.6 `@Configuration`

• 作用：标记一个类为配置类，定义 Bean。
• 示例：

@Configuration
public class MyConfig {
    @Bean
    public MyService myService() {
        return new MyService();
    }
}

1.7 `@Bean`

• 作用：在配置类中定义 Bean。
• 示例：

@Configuration
public class MyConfig {
    @Bean
    public MyService myService() {
        return new MyService();
    }
}

1.8 `@Value`

• 作用：注入配置文件中的属性值。
• 示例：

@RestController
public class MyController {
    @Value("${app.name}")
    private String appName;

    @GetMapping("/name")
    public String getAppName() {
        return appName;
    }
}

2. 配置相关注解

2.1 `@ConfigurationProperties`

• 作用：将配置文件中的属性绑定到一个 Java 对象。
• 示例：

@ConfigurationProperties(prefix = "app")
public class AppProperties {
    private String name;
    private String version;

    // Getters and Setters
}

2.2 `@PropertySource`

• 作用：加载自定义的配置文件。
• 示例：

@Configuration
@PropertySource("classpath:myapp.properties")
public class MyConfig {
    @Value("${app.name}")
    private String appName;
}

2.3 `@Profile`

• 作用：根据环境激活特定的配置或 Bean。
• 示例：

@Configuration
@Profile("dev")
public class DevConfig {
    @Bean
    public MyService myService() {
        return new MyService("Dev Mode");
    }
}

3. 其他重要注解

3.1 `@EnableAutoConfiguration`

• 作用：启用 Spring Boot 的自动配置机制。

3.2 `@ComponentScan`

• 作用：扫描指定包下的组件（@Component、@Service、@Repository 等）。

3.3 `@ConditionalOnProperty`

• 作用：根据配置文件中的属性条件决定是否加载 Bean。
• 示例：

@Bean
@ConditionalOnProperty(name = "app.feature.enabled", havingValue = "true")
public MyFeature myFeature() {
    return new MyFeature();
}

3.4 `@Scheduled`

• 作用：定义定时任务。
• 示例：

@Component
public class MyScheduler {
    @Scheduled(fixedRate = 5000)
    public void run() {
        System.out.println("Task executed every 5 seconds");
    }
}

3.5 `@Transactional`

• 作用：标记方法或类为事务性操作。
• 示例：

@Service
public class MyService {
    @Transactional
    public void performTransaction() {
        // Database operations
    }
}

总结

最重要的配置相关注解

• @ConfigurationProperties：用于将配置文件中的属性绑定到 Java 对象。
• @PropertySource：用于加载自定义的配置文件。
• @Profile：用于根据环境激活特定的配置或 Bean。

其他核心注解

• @SpringBootApplication
• @RestController
• @Autowired
• @Component
• @Configuration
• @Bean
• @Value

这些注解是 Spring Boot 开发中的核心工具，熟练掌握它们可以极大地提高开发效率。

SpringBoot面试问题

SpringBoot高频面试问题

一、为什么使用springboot？

1. 开箱即用，简化配置

2. 内嵌服务器（Embedded Server）

3. Starter 依赖管理

4. 快速构建独立应用

5. 生产级特性

6. 与 Spring 生态无缝集成

7. 社区与生态强大

适用场景

总结

二、SpringBoot用到哪些设计模式？

1. 单例模式（Singleton）

2. 工厂模式（Factory Pattern）

3. 模板方法模式（Template Method）

4. 代理模式（Proxy Pattern）

5. 观察者模式（Observer Pattern）

6. 适配器模式（Adapter Pattern）

7. 装饰者模式（Decorator Pattern）

8. 策略模式（Strategy Pattern）

9. 组合模式（Composite Pattern）

10. 责任链模式（Chain of Responsibility）

11. 建造者模式（Builder Pattern）

12. 外观模式（Facade Pattern）

总结

三、怎么理解SpringBoot中的约定大于配置？

1. 什么是“约定大于配置”？

2. Spring Boot 中的约定体现

（1）项目结构与命名约定

（2）自动配置（Auto-Configuration）

（3）默认值约定

（4）RESTful 接口映射

3. 为什么需要“约定大于配置”？

4. 如何覆盖默认约定？

5. 实际开发中的意义

总结

四、SpringBoot的项目结构是怎么样的？

标准项目结构示例

核心目录与文件详解

1. src/main/java：Java 源代码

2. src/main/resources：资源文件

3. src/test/java：单元测试

4. 构建配置文件（pom.xml 或 build.gradle）

约定大于配置的体现

自定义项目结构

最佳实践

总结

五、SpringBoot自动装配原理是什么？

1. @SpringBootApplication 注解

2. @EnableAutoConfiguration 注解

3. spring.factories 文件

4. 条件化配置

5. 自动配置类的加载

6. 默认配置

7. 自定义自动配置

示例

总结

六、Spring自动装配的原理？

1. @SpringBootApplication 注解

2. @EnableAutoConfiguration 注解

3. spring.factories 文件

4. 条件化配置

5. 自动配置类的加载

6. 默认配置

7. 自定义自动配置

示例

总结

七、写过SpringBoot starter吗?

1. 项目结构

2. 核心模块

3. 自动配置模块

3.1 创建自动配置类

3.2 注册自动配置类

4. Starter 模块

4.1 添加依赖

4.2 发布 Starter

5. 使用自定义 Starter

6. 可选：配置属性

6.1 创建配置属性类

1. `src/main/java`：Java 源代码

2. `src/main/resources`：资源文件

3. `src/test/java`：单元测试

4. 构建配置文件（`pom.xml` 或 `build.gradle`）

1. `@SpringBootApplication` 注解

2. `@EnableAutoConfiguration` 注解

3. `spring.factories` 文件

1. `@SpringBootApplication` 注解

2. `@EnableAutoConfiguration` 注解

3. `spring.factories` 文件

6.3 在 `application.properties` 中配置

1.1 `@SpringBootApplication`

1.2 `@RestController`

1.3 `@RequestMapping`

1.4 `@Autowired`

1.5 `@Component`

1.6 `@Configuration`

1.7 `@Bean`

1.8 `@Value`

2.1 `@ConfigurationProperties`

2.2 `@PropertySource`

2.3 `@Profile`

3.1 `@EnableAutoConfiguration`

3.2 `@ComponentScan`

3.3 `@ConditionalOnProperty`

3.4 `@Scheduled`

3.5 `@Transactional`