Spring Boot相关问题及答案（2024）

辞暮尔尔-烟火年年

已于 2024-01-31 11:38:59 修改

阅读量952

点赞数 22

分类专栏： SpringBoot 复习面试专栏框架文章标签： spring boot 后端

于 2023-12-16 08:00:00 首次发布

本文链接：https://blog.csdn.net/qq_43012298/article/details/135020369

版权

复习面试专栏同时被 3 个专栏收录

56 篇文章 12 订阅

订阅专栏

框架

14 篇文章 0 订阅

订阅专栏

SpringBoot

4 篇文章 0 订阅

订阅专栏

1、Spring Boot 的核心配置文件有哪些？它们有什么区别？

Spring Boot 提供了一种快捷的方式来开发一个独立的、生产级别的基于Spring框架的应用。它通过约定优于配置的原则来减少项目搭建的复杂性。Spring Boot应用的核心配置通常是通过外部配置文件进行的，这些文件可以是 properties 文件或者 YAML 文件。

Spring Boot 核心配置文件主要包括：

application.properties：这是 Spring Boot 默认的配置文件，它用于指定应用程序在不同环境下运行时所需要的参数。该文件位于 src/main/resources 目录下。
application.yml：另外一种配置文件是 YAML 文件，它以数据为中心并且格式更为紧凑和可读。Spring Boot 也支持 .yml 文件作为配置文件，位于 src/main/resources 目录下。

它们之间的区别：

格式不同：

Properties：简洁的键值对格式，每个条目占一行。

server.port=8080
spring.datasource.url=jdbc:mysql://localhost/test

YAML：使用缩进表示层级关系，更适合表示复杂的层次结构。

server:
  port: 8080
spring:
  datasource:
    url: jdbc:mysql://localhost/test

可读性：
- Properties：由于没有层级和缩进，当配置项非常多的时候，.properties 文件可能难以阅读。
- YAML：由于其缩进和格式化的特性，.yml 文件在表示复杂层次结构的时候更易于理解。
支持的数据结构：
- Properties：主要支持简单的键值对，不适合复杂的层级结构。
- YAML：可以很好地支持数组和对象，更适合复杂的配置结构。

使用场景：

如果配置相对简单，不含复杂的层次结构，可以选择 .properties 文件。
如果配置较为复杂，需要表示列表或者嵌套的对象，.yml 文件是更好的选择。

Profile-specific 配置文件：

Spring Boot 允许你定义特定于 profile 的配置文件。这些文件遵循 application-{profile}.properties 或 application-{profile}.yml 的命名约定，其中 {profile} 是你定义的 profile 名称（比如 dev, test, prod）。这使得你可以针对不同的环境配置不同的参数，而在运行应用程序时可以通过激活相应的 profile 来使用它们。

多环境配置：

在实际开发中，通常需要根据不同的环境（开发、测试、生产）来改变配置。Spring Boot 允许你通过在 application.properties 或 application.yml 文件中指定 spring.profiles.active 属性来激活特定的 profile。

配置文件的加载顺序：

Spring Boot 在启动时会按照一定的顺序来加载配置文件。这个顺序大致如下：

application.properties 或 application.yml 中的默认配置。
Profile-specific 的配置文件，如 application-{profile}.properties 或 application-{profile}.yml。
在启动命令中通过 --spring.config.location 指定的配置文件。
环境变量或系统属性中的配置。

配置属性的覆盖：

如果在多个配置文件中定义了同一属性，Spring Boot 会根据其加载顺序来决定最终使用哪个值。后加载的配置文件中的值会覆盖先前加载的文件中的值。

通过上述机制，Spring Boot 提供了一种灵活而强大的配置管理方式，允许开发者根据实际需求选择合适的配置格式，并且能够适应不同环境下的配置需求。

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

Spring Boot 的自动配置是其核心特性之一，它极大地简化了Spring应用的配置。自动配置的原理基于约定优于配置的理念，目的是尽可能减少开发人员的配置工作。以下是Spring Boot自动配置背后的机制和原理：

1. `@SpringBootApplication` 注解

当你在主类上添加 @SpringBootApplication 注解时，它实际上是一个组合注解，它整合了以下三个重要的注解：

@SpringBootConfiguration：表明这是一个Spring Boot的配置类。
@EnableAutoConfiguration：启用Spring Boot的自动配置机制。
@ComponentScan：让Spring Boot扫描到当前包及其子包中的所有组件。

2. `@EnableAutoConfiguration` 注解

这个注解是自动配置的核心，它告诉Spring Boot根据添加的jar依赖来“猜测”你可能想要配置的组件。例如，如果classpath下存在H2数据库的jar包，那么它可能会自动配置一个内存数据库。

@EnableAutoConfiguration 注解背后的主要原理是利用Spring Factories Loader机制。

3. Spring Factories Loader

Spring Boot 使用Spring Factories Loader机制来加载 META-INF/spring.factories 文件中配置的类。这些类通常是实现了特定接口或继承了特定类的Java配置类（带有 @Configuration 注解的类）。

在Spring Boot的jar包中，例如spring-boot-autoconfigure，META-INF/spring.factories 文件中会包含一系列的自动配置类，如下所示：

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration,\
org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration,...

上述配置表明了哪些类将被考虑用于自动配置。

4. 条件注解

自动配置类使用了大量的条件注解来确保只在合适的条件下激活某项配置：

@ConditionalOnClass：当classpath上存在指定类时，配置才会生效。
@ConditionalOnMissingClass：当classpath上缺少指定类时，配置才会生效。
@ConditionalOnBean：当指定的Bean存在时，配置才会生效。
@ConditionalOnMissingBean：当指定的Bean不存在时，配置才会生效。
@ConditionalOnProperty：当指定的配置属性有一个明确的值时，配置才会生效。
@ConditionalOnResource：当指定的资源存在时，配置才会生效。
@ConditionalOnWebApplication：当应用是一个Web应用时，配置才会生效。
@ConditionalOnNotWebApplication：当应用不是一个Web应用时，配置才会生效。

…等等。

这些注解允许Spring Boot在不同的情况下应用不同的配置，从而避免了类和Bean的冗余创建。

5. 自动配置的顺序

自动配置类被设计为具有特定的顺序，因此关键配置（如数据源配置）先于次要配置（如JPA提供者配置）加载。

6. 覆盖自动配置

如果默认的自动配置不符合你的需求，你可以通过定义自己的配置类来覆盖它。Spring Boot在考虑哪些配置类要应用时，会为用户提供的配置类赋予更高的优先级。

结论

自动配置使得开发者可以用最少的努力创建一个符合生产标准的Spring应用。它通过一系列条件注解、配置类和Spring Factories Loader机制来提供这种“魔法”，确保只有在适当的条件下应用配置。这种智能的配置方式极大地减少了手动配置的工作，同时也提供了足够的灵活性来覆盖或扩展默认的配置。

3、什么是 Spring Boot Starter？我应该如何使用它们？

Spring Boot Starters 是 Spring Boot 的一个核心特性，提供了一种快速便捷的方式来集成和配置Spring相关技术栈的各种模块。每个 Starter 都是一个预定义的依赖描述符，它们将所需的库和配置自动化集成到你的应用程序中。

什么是 Spring Boot Starter？

预设的依赖集合：每个 Starter 都包含了开发特定类型应用所需的依赖库。例如，如果你正在构建一个web应用，你可以通过添加 spring-boot-starter-web 来自动化集成 Spring MVC, Tomcat 和 Jackson 等依赖。
自动配置：Starters 包含了自动配置的支持，这意味着它们会利用 Spring Boot 的自动配置能力，为你的应用程序提供合理的默认配置，减少了显式配置的需要。
简化项目依赖管理：Starters 使得依赖管理变得简单。你不需要担心各种库的兼容版本，因为 Starter 已经为你解决了这些问题。

如何使用 Spring Boot Starters？

使用 Spring Boot Starters 的基本步骤如下：

1. 创建 Spring Boot 应用

你可以使用 Spring Initializr（https://start.spring.io/）来创建一个新的 Spring Boot 项目，选择你需要的 Starter 依赖。

2. 添加 Starter 依赖

在你的 pom.xml 文件（如果项目是 Maven 构建的）或 build.gradle 文件（如果项目是 Gradle 构建的）中添加所需的 Starter 依赖。例如，对于 Maven 项目，如果你想添加 web 功能，你将做如下配置：

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

3. 开发你的应用程序

由于添加了 Starter，你现在可以直接使用集成的库来编写你的应用程序。例如，对于 spring-boot-starter-web，你可以直接编写 @RestController 类来处理Web请求，无需手动配置 Spring MVC。

4. 运行你的应用程序

使用 Spring Boot 的 Maven 或 Gradle 插件，你可以容易地运行你的应用程序。如果你使用的是 Maven，可以使用以下命令：

mvn spring-boot:run

对于 Gradle，使用：

gradle bootRun

5. 自定义配置

尽管 Starters 提供了很多默认配置，但你仍然可以根据需要自定义配置。你可以在 application.properties 或 application.yml 文件中覆盖默认配置。

常见的 Spring Boot Starters

Spring Boot 提供了多种官方 Starter，包括但不限于：

spring-boot-starter-web：用于构建Web应用，包括 RESTful 应用。
spring-boot-starter-data-jpa：用于使用 Spring Data JPA 与 Hibernate。
spring-boot-starter-security：用于使用 Spring Security。
spring-boot-starter-test：用于测试 Spring Boot 应用，包含JUnit, Hamcrest 和 Mockito。
spring-boot-starter-thymeleaf：用于使用 Thymeleaf 模板引擎渲染 web 视图。
spring-boot-starter-data-rest：用于快速构建基于 Hypermedia 的 RESTful web 服务。
spring-boot-starter-mail：用于使用 Spring Framework 的邮件发送功能。

结论

Spring Boot Starters 是 Spring Boot 设计理念的体现，简化了项目配置和库管理，让开发者可以专注于业务逻辑的实现。通过这些预打包的依赖组合，你可以快速地启动和运行Spring Boot应用程序，并且很容易地添加额外的技术栈支持。

4、Spring Boot 中的 Actuator 是做什么的？

Spring Boot Actuator 是 Spring Boot 的一个子项目，它为应用程序添加了若干生产级的监控和管理功能。通过提供一系列可用的端口，Actuator 允许开发者快速查看应用程序的内部情况，无论是运行状况、指标信息、配置详情，还是应用环境等。

Actuator的主要特性

1. 应用监控

Actuator 提供了多种监控应用程序的方式，包括：

Metrics：收集的基本指标信息，如内存使用情况、GC 活动、Web 请求计数等。
Health：健康检查端点，可以显示应用程序健康状况，如数据库连接、磁盘空间等。
HTTP Traces：显示HTTP请求的轨迹记录。
Audit Events：如果应用程序中包括Spring Security，它可以显示安全审计相关事件。

2. 应用管理

Actuator 还提供了一些端点用于管理应用程序，例如：

Beans：显示应用程序中所有Spring Beans的完整列表。
Env：显示来自所有 PropertySource 的所有环境属性。
Loggers：允许查看和修改日志记录器的配置。
Thread Dump：提供了线程活动的快照。
Heap Dump：提供了一种下载JVM堆信息的方式，用于进行更深入的分析。

3. 应用信息

Actuator 还能提供一些有关应用程序和运行环境的详细信息：

Info：显示自定义的应用程序信息，通常包括应用程序版本、描述等。
Conditions：提供自动配置时的条件评估报告，这有助于调试自动配置问题。

使用 Spring Boot Actuator

要在 Spring Boot 应用程序中使用 Actuator，你需要在项目的依赖管理文件中加入 spring-boot-starter-actuator。以 Maven 为例，你可以在 pom.xml 文件中添加以下依赖：

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>
</dependencies>

添加了 Actuator 依赖后，多个端点会自动启用。但是，出于安全考虑，某些端点（如 env 和 heapdump）默认是关闭的。你可以通过配置文件开启它们：

management.endpoints.web.exposure.include=health,info,env

安全性

由于 Actuator 端点可能会泄露敏感信息，因此合理配置 Actuator 的安全性是非常重要的。在生产环境中，通常建议：

通过 management.endpoints.web.exposure.include 和 management.endpoints.web.exposure.exclude 属性来限制可访问的端点。
使用 Spring Security 或相似的安全框架来保护 Actuator 端点，确保只有授权的用户能够访问。
在配置安全规则时，确保敏感端点如 env 和 shutdown 被严格保护。

自定义 Actuator 端点

Spring Boot Actuator 也支持自定义端点，允许你根据业务需求开发特定的管理端点。你可以通过实现 Endpoint 接口或 @Endpoint 注解来创建自定义端点，并通过 @ReadOperation、@WriteOperation 和 @DeleteOperation 注解来定义操作。

结论

Spring Boot Actuator 是 Spring Boot 应用的一个强大功能，它为应用提供了监控和管理能力，使得运维任务更加容易和直观。无论是在开发还是在生产环境中，Actuator 都是构建健壮、可维护应用程序的一个重要工具。

5、如何在 Spring Boot 中管理事务？

在 Spring Boot 中，事务管理通常通过 Spring Framework 的事务抽象来完成。Spring 提供了一套一致的编程式和声明式事务管理机制，可以与 JDBC、JPA、Hibernate 等多种数据访问技术无缝集成。现在，让我们深入了解 Spring Boot 中的事务管理。

1. 声明式事务管理

在 Spring Boot 中，最常见和推荐的事务管理方式是声明式事务管理。它主要通过 @Transactional 注解实现，可以应用于类或方法级别。

使用 @Transactional 注解

类级别：如果将 @Transactional 注解放在类上，那么该类中的所有公共方法都会被应用事务。
方法级别：如果只想在特定的方法上应用事务，可以将 @Transactional 注解放在方法上。

如何工作

当你在一个方法上添加 @Transactional 注解时，Spring 将创建一个代理对象来包装这个方法。
每次调用该方法时，代理对象会检查是否存在一个活跃的事务，如果没有，它会开启一个新的事务。
如果该方法正常完成，事务会被提交；如果出现异常，事务会被回滚。

配置事务行为

@Transactional 注解提供了多个参数来定制事务的行为，如：

propagation：定义了事务的传播行为，比如 Propagation.REQUIRED、Propagation.REQUIRES_NEW、Propagation.SUPPORTS 等。
isolation：定义了事务的隔离级别，比如 Isolation.DEFAULT、Isolation.SERIALIZABLE 等。
timeout：定义事务的超时限制。
readOnly：指示事务是否是只读事务。
rollbackFor / noRollbackFor：定义哪些异常应该触发事务回滚。

举例使用 @Transactional

@Service
public class BankingService {

    @Transactional(rollbackFor = Exception.class)
    public void transferMoney(Long fromAccountId, Long toAccountId, BigDecimal amount) {
        // 逻辑：从一个账户扣钱，给另一个账户加钱
        // ...
    }
}

2. 编程式事务管理

尽管声明式事务管理通常是首选方法，但在某些特定的情况下，你可能需要对事务进行更细粒度的控制，这时可以使用编程式事务管理。

编程式事务管理通常涉及使用 TransactionTemplate 或直接使用 PlatformTransactionManager。这样可以在方法内部控制事务的精确边界，但是这种方式代码更加繁琐，可读性和维护性较差。

使用 `TransactionTemplate`

@Service
public class BankingService {

    private final TransactionTemplate transactionTemplate;

    @Autowired
    public BankingService(PlatformTransactionManager transactionManager) {
        this.transactionTemplate = new TransactionTemplate(transactionManager);
    }

    public void transferMoney(Long fromAccountId, Long toAccountId, BigDecimal amount) {
        transactionTemplate.execute(status -> {
            // 事务逻辑
            try {
                // 从一个账户扣钱
                // 给另一个账户加钱
                // ...
                return null;
            } catch (Exception ex) {
                status.setRollbackOnly();
                throw ex;
            }
        });
    }
}

3. 事务同步和异步处理

同步处理：在常见的事务处理中，事务的开始、提交和回滚都是在同一个线程和同步执行的。
异步处理：如果在一个异步方法中使用 @Transactional，那么事务将在调用异步方法的线程中开始，而不是在异步执行的线程中。因此，如果需要在异步执行中管理事务，应该在异步方法内部处理事务逻辑。

4. 事务管理器

在 Spring Boot 中，根据使用的数据访问技术，通常会自动配置相应的事务管理器。例如：

DataSourceTransactionManager：用于 JDBC 或 myBatis 等。
JpaTransactionManager：用于 JPA，比如 Hibernate。
HibernateTransactionManager：专门为 Hibernate 定制。

如果需要使用多个数据源，可能就需要配置多个事务管理器，并在 @Transactional 注解中指明使用哪个事务管理器：

@Transactional(value = "transactionManagerForDB2")
public void someServiceMethod() {
    // ...
}

5. 事务日志和监控

为了提高事务的可见性和调试能力，可以使用日志记录和监控工具来记录事务的活动和性能指标。

总结

在 Spring Boot 中管理事务是通过 @Transactional 注解和 TransactionTemplate 类实现的，提供了灵活的事务控制策略。声明式事务管理是首选方法，因为它简单且减少了样板代码。编程式事务管理提供了更细粒度的控制，但是代码更加复杂。正确配置和使用事务对于保证数据库操作的一致性及数据完整性至关重要。

6、Spring Boot项目如何打成war包而不是jar包？

要将Spring Boot应用程序打包为WAR文件，你需要进行以下配置：

在Maven的pom.xml文件中，将元素更改为war。

提供一个SpringBootServletInitializer扩展，并重写configure方法，以便于你的应用程序可以使用Servlet 3.0 API的自动配置特性。

修改后的configure方法应该返回一个应用程序的实例：

@Override
protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
    return application.sources(YourApplication.class);
}

7、Spring Boot支持哪些数据访问技术？

在 Spring Boot 项目中，默认情况下，构建的产物是一个可执行的 JAR 文件，这个 JAR 文件包含了嵌入式的 Servlet 容器（如 Tomcat），以及所有的依赖和资源。但是，如果你想要将你的应用部署到一个独立的 Servlet 容器或 Java EE 应用服务器上，你可能需要将它打包成一个 WAR 文件。以下是将 Spring Boot 应用打包成 WAR 文件的详细步骤：

1. 更新 Maven 或 Gradle 构建配置

无论你是使用 Maven 还是 Gradle，你都需要修改你的构建配置文件，以指示构建系统产生 WAR 文件而不是 JAR 文件。

对于 Maven：

在 pom.xml 文件中，你需要做以下的更改：

将 <packaging> 元素的值从 jar 改为 war。
排除内嵌的 Tomcat 依赖，因为你会部署到外部的 Servlet 容器中。

<packaging>war</packaging>
...
<dependencies>
    <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>
    ...
</dependencies>

对于 Gradle：

在 build.gradle 文件中，你需要应用 war 插件，并且也许需要排除嵌入式的 Servlet 容器依赖。

apply plugin: 'war'

configurations {
    providedRuntime
}

dependencies {
    providedRuntime 'org.springframework.boot:spring-boot-starter-tomcat'
    ...
}

2. 修改 Spring Boot 应用的启动类

接下来，你需要修改你的 Spring Boot 主应用类，以便它可以同时作为一个独立的应用运行，也可以作为一个部署到外部容器中的 WAR 文件运行。

为了实现这一点，你需要继承 SpringBootServletInitializer 并重写 configure 方法：

import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;

@SpringBootApplication
public class MyApplication extends SpringBootServletInitializer {

    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
        return application.sources(MyApplication.class);
    }

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

SpringBootServletInitializer 是 Spring Boot 的一个扩展类，它允许将 Spring Boot 应用初始化为一个 Servlet 3.0 应用。重写 configure 方法确保了在不同的部署环境中使用相同的启动类。

3. 构建 WAR 文件

一旦你完成了上述的配置更改，你就可以构建你的项目了。如果你使用 Maven，可以通过以下命令构建：

mvn clean package

如果你使用 Gradle，可以通过以下命令构建：

gradle clean build

构建成功后，你会在项目的 target/ 或 build/libs/ 目录中找到构建好的 WAR 文件，你可以将这个 WAR 文件部署到任何标准的 Java Servlet 容器中，如 Apache Tomcat、Jetty 或者任意 Java EE 兼容的应用服务器中。

4. 部署 WAR 文件

部署 WAR 文件通常涉及将 WAR 文件复制到服务器的特定部署目录中，或者通过服务器管理界面上传 WAR 文件。具体步骤取决于你使用的具体 Servlet 容器或应用服务器。

5. 注意事项

打包成 WAR 文件后，Spring Boot 的嵌入式 Web 服务器将不再被使用，而是使用外部的 Servlet 容器来提供 Web 服务。这意味着所有的 HTTP 请求都将由外部容器来处理。

最后，当你在外部容器中运行你的应用时，你可能需要对其进行适当的配置，例如 JDBC 数据源和 JNDI 查找，因为嵌入式容器中的某些自动配置可能不再适用。

通过遵循上述步骤，你可以将你的 Spring Boot 应用打包成 WAR 文件，并将其部署到任何 Java Servlet 容器中。

8、Spring Boot中的Profiles

在 Spring Boot 中，Profiles 提供了一种分离部署环境的方法，可以用于区分开发、测试、生产等不同的环境。利用 Profiles，我们可以控制哪些组件在哪个环境下激活，哪些配置应该在特定环境下使用。这是通过在组件定义或配置文件中指定环境标识符来实现的。

使用 Profiles 的优势：

环境隔离：不同环境的配置可以保持分离，避免将测试设置部署到生产环境。
条件化的配置：可以根据当前激活的 Profile 启用或禁用特定的 beans。
动态配置：在运行时可以激活或切换 Profiles，从而改变应用的行为。

定义 Profiles

Profiles 可以通过多种方式定义：

在 application.properties 或 application.yml 文件中：

# application.properties
spring.profiles.active=dev

# application.yml
spring:
  profiles:
    active: dev

在组件类上使用 @Profile 注解：

@Service
@Profile("dev")
public class DevDatabaseService implements DatabaseService {
    // 开发环境的实现
}

@Service
@Profile("prod")
public class ProdDatabaseService implements DatabaseService {
    // 生产环境的实现
}

激活 Profiles

Profiles 可以通过多种方式激活：

环境变量：
```
export SPRING_PROFILES_ACTIVE=dev
```

系统属性：

在启动 JVM 时设置：

java -Dspring.profiles.active=dev -jar your-app.jar

命令行参数：

java -jar your-app.jar --spring.profiles.active=dev

在 application.properties 或 application.yml 中设置（如上所示）。

程序化方式：

在 SpringApplication 实例中设置：

SpringApplication app = new SpringApplication(MyApplication.class);
app.setAdditionalProfiles("dev");
app.run(args);

配置文件的 Profile-specific 属性

Spring Boot 允许你为不同的 Profiles 创建特定的配置文件，这些文件采用以下命名格式：

application-{profile}.properties
application-{profile}.yml

例如，对于 “dev” Profile，你可以创建一个 application-dev.properties 文件，Spring Boot 在激活 “dev” Profile 时会加载该文件。

使用 Profile-specific 配置

在 Profile-specific 的配置文件中，你可以定义仅在该 Profile 激活时应用的设置。例如：

application-dev.properties:

app.database.url=jdbc:h2:mem:devdb

application-prod.properties:

app.database.url=jdbc:mysql://localhost/proddb

使用 @Value 注解或 @ConfigurationProperties 类可以注入这些值。

组合 Profiles

Profiles 还可以组合使用。如果你有多个 Profiles 都需要被激活，你可以这样设定：

在配置文件中设置多个 Profiles：
```
spring.profiles.active=dev,hsqldb
```

使用命令行参数：

java -jar your-app.jar --spring.profiles.active=dev,hsqldb

Profile 表达式

从 Spring 5.1 和 Spring Boot 2.1 开始，@Profile 注解支持使用表达式。这意味着你可以使用逻辑操作符 (!, &, |) 来定义更复杂的 Profile 策略。例如：

@Profile("dev & !test")

这个例子表明，仅当 “dev” Profile 激活且 “test” Profile 未激活时，相关的组件才会被注册。

总结

Profiles 是 Spring Boot 提供的强大功能，允许开发者为不同环境定义和管理配置。它们确保了应用的配置可以根据环境的需求调整，同时保持代码的整洁和易于管理。正确使用 Profiles 可以让环境之间的切换变得非常简单和可靠。

9、如何实现Spring Boot应用程序的安全性？

在 Spring Boot 应用程序中实现安全性，通常涉及到集成 Spring Security 框架。Spring Security 提供了一系列可定制的安全功能，包括认证（Authentication）、授权（Authorization）、防止跨站点请求伪造（CSRF）和会话管理等。

以下是一些实现 Spring Boot 应用程序安全性的步骤和要点：

1. 集成 Spring Security

首先，你需要在你的项目中添加 Spring Security 的依赖。对于 Maven 项目，可以在 pom.xml 中添加：

<dependencies>
    <!-- ... 其他依赖 ... -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-security</artifactId>
    </dependency>
</dependencies>

对于 Gradle 项目，在 build.gradle 中添加：

dependencies {
    // ... 其他依赖 ...
    implementation 'org.springframework.boot:spring-boot-starter-security'
}

2. 配置用户存储

Spring Security 支持多种用户存储机制，包括内存存储、数据库、LDAP 等。例如，你可以使用内存中的用户存储进行测试：

@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.inMemoryAuthentication()
            .withUser("user").password(passwordEncoder().encode("password")).roles("USER")
            .and()
            .withUser("admin").password(passwordEncoder().encode("admin")).roles("ADMIN");
    }
    
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

在实际的生产环境中，你可能会使用数据库来存储用户信息，并使用 JPA 或 MyBatis 等 ORM 框架来管理：

@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    private DataSource dataSource;

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.jdbcAuthentication()
            .dataSource(dataSource)
            .usersByUsernameQuery("SELECT username, password, enabled FROM users WHERE username = ?")
            .authoritiesByUsernameQuery("SELECT username, authority FROM authorities WHERE username = ?");
    }
    
    // PasswordEncoder bean 如前所示
}

3. 配置 HTTP 安全

使用 WebSecurityConfigurerAdapter 可以自定义 HTTP 安全配置。例如，你可以定义哪些 URL 需要被保护，哪些不需要，以及需要什么样的角色权限等：

@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
                .antMatchers("/", "/home").permitAll()  // 允许所有用户访问
                .antMatchers("/admin/**").hasRole("ADMIN")  // 仅限管理员访问
                .anyRequest().authenticated()  // 所有其他的路径都需要认证
                .and()
            .formLogin()
                .loginPage("/login")  // 指定登录页面
                .permitAll()  // 允许用户访问登录页面
                .and()
            .logout()
                .permitAll()  // 允许用户注销
                .and()
            .csrf().disable();  // 禁用 CSRF 保护，仅为示例，实际应用中不推荐
    }
    
    // 其他配置 ...
}

4. 使用方法安全性

Spring Security 还提供了方法级别的安全性。通过使用 @PreAuthorize、@PostAuthorize、@Secured 等注解，你可以控制方法调用的安全性：

@Service
public class SomeService {

    @PreAuthorize("hasRole('ADMIN')")
    public void adminOnlyMethod() {
        // 仅管理员可以调用的方法
    }
}

为了启用方法安全性，你需要在配置类上添加 @EnableGlobalMethodSecurity：

@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class MethodSecurityConfig extends GlobalMethodSecurityConfiguration {
    // 安全配置
}

5. 使用密码加密

在 Spring Security 中，密码应该加密存储和验证。可以使用 PasswordEncoder 接口来实现密码的加密：

@Bean
public PasswordEncoder passwordEncoder() {
    return new BCryptPasswordEncoder();
}

6. 自定义用户详情服务

如果你需要更加灵活的用户管理，可以实现 UserDetailsService 接口，提供自定义的用户加载逻辑：

@Service
public class MyUserDetailsService implements UserDetailsService {

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        // 自定义如何根据用户名查找用户，如何校验用户，以及授予用户权限
        // ...
    }
}

7. 处理认证和授权失败

可以自定义认证失败和授权失败的处理方式：

http
    // ...
    .exceptionHandling()
        .authenticationEntryPoint(new Http403ForbiddenEntryPoint())  // 认证失败处理
    .and()
    .accessDeniedHandler(new AccessDeniedHandlerImpl())  // 授权失败处理
    // ...

总结

Spring Boot 应用程序的安全性可以通过集成 Spring Security 框架来实现。这通常涉及到设置用户存储、配置 HTTP 安全规则、实现方法级别的安全控制以及自定义认证和授权机制。Spring Security 提供了一套完整的安全解决方案来帮助开发者构建安全的应用程序。

10、在Spring Boot中，你是如何处理应用程序配置的？

在Spring Boot中，处理应用程序配置通常涉及以下几个方面：

1. 配置文件

Spring Boot支持多种类型的外部配置文件，其中最常见的是application.properties和application.yml。这些文件位于项目的src/main/resources目录中，可以用来配置数据库连接、服务器端口、自定义属性等。

例如，在application.properties中：

server.port=8081
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=dbuser
spring.datasource.password=dbpass
my.custom.property=customValue

或者在application.yml中：

server:
  port: 8081
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydb
    username: dbuser
    password: dbpass
my:
  custom:
    property: customValue

2. Profile-specific配置

Spring Boot允许你为不同的环境（如开发、测试、生产）创建特定的配置文件，例如application-dev.properties、application-test.properties和application-prod.properties。启动应用程序时，可以通过设置spring.profiles.active来指定激活哪个Profile。

3. 命令行参数

Spring Boot允许你在启动时通过命令行参数覆盖配置文件中的属性。例如：

java -jar myapp.jar --server.port=8083

4. 环境变量

环境变量也可以用来覆盖配置属性。Spring Boot遵循特定的命名规则将环境变量映射到配置属性上。例如，要设置server.port，可以在你的环境中设置环境变量SERVER_PORT。

5. 配置类

使用@Configuration注解，你可以创建配置类，这些类可以包含@Bean方法来定义Spring容器管理的bean，或使用@ConfigurationProperties注解将外部配置绑定到这些类上。

例如：

@Configuration
@ConfigurationProperties(prefix = "my")
public class MyProperties {
    private String customProperty;

    // standard getters and setters
}

然后，在配置文件中：

my.custom-property=customValue

6. `@Value`注解

可以使用@Value注解将配置文件中的值注入到组件中。例如：

@Component
public class MyBean {

    @Value("${my.custom.property}")
    private String customProperty;

    // ...
}

7. 命令行运行器和应用程序监听器

对于在应用程序启动时需要执行的特定配置任务，你可以实现CommandLineRunner或ApplicationRunner接口，也可以使用ApplicationListener或@EventListener来监听特定的Spring事件。

例如：

@Component
public class MyStartupRunner implements CommandLineRunner {

    @Override
    public void run(String... args) {
        // 在应用程序启动时执行的逻辑
    }
}

8. 使用Spring Cloud Config

对于分布式系统，Spring Cloud Config提供了一个中心化的外部配置服务。这允许你将配置存储在远程仓库中（如git），并在运行时动态地为应用程序提供配置。

9. 加密配置

对于敏感信息（如数据库密码），可以使用Spring Cloud Config的加密和解密功能来保护配置值，或者使用Jasypt等库来加密配置文件中的敏感信息。

总结

Spring Boot提供了多种灵活的选项来处理应用程序配置，它支持不同的配置文件格式、允许通过环境变量、命令行参数以及程序化方式来覆盖配置值，并且可以通过Profiles来管理不同环境下的配置。使用@ConfigurationProperties和@Value注解可以方便地绑定配置到bean属性，而对于复杂的配置需求，可以使用Spring Cloud Config等工具来进行中心化管理。

11、Spring与SpringBoot

Spring 和 Spring Boot 是Java社区中非常流行的两个项目，它们都是由同一个组织（Pivotal，现已成为VMware的一部分）维护的。Spring Boot 是建立在Spring框架之上的，其设计旨在简化Spring应用程序的设置和开发流程。尽管它们有很多相似之处，但也有一些关键的区别。

Spring Framework

Spring框架是一个全面的编程和配置模型，为现代基于Java的企业应用提供了一个全面的基础架构支持。Spring处理了Java EE（Enterprise Edition）开发中许多常见的困难，如事务管理、数据访问、消息传递、Web应用程序开发等。

主要特性：

依赖注入（DI）：Spring通过依赖注入促进了松耦合。
面向切面编程（AOP）：Spring支持面向切面编程，允许定义通用功能并将其应用于无关的业务逻辑中。
声明式事务管理：Spring提供了一种声明式事务管理模式，这使得事务管理更加容易且风险更小。
抽象和数据访问：Spring的数据访问框架降低了编写数据访问代码的复杂性。
MVC框架：Spring的Web MVC框架是一个富特性的构建Web应用程序的框架。

Spring Boot

Spring Boot 旨在简化Spring应用程序的创建和开发过程，特别是微服务。它通过提供约定优于配置的原则，大量的自动配置，以及对产生独立应用程序的支持来实现这一点。

主要特性：

自动配置：Spring Boot会自动配置Spring应用程序，基于你添加的jar依赖来配置你的应用程序行为。
独立性：Spring Boot应用程序打包为单一的可执行JAR或WAR文件，内嵌Web服务器。
没有代码生成，无需XML配置：Spring Boot应用程序不需要XML配置文件，也不需要代码生成。
生产准备特性：Spring Boot提供了生产级别的监控、健康检查和外部化配置等特性。
微服务架构：Spring Boot设计之初就是为了简化微服务应用的开发和部署。

相同点

都是Spring生态系统的一部分：Spring Boot和Spring都是Spring生态系统的一部分，并且Spring Boot是构建在Spring之上的。
依赖注入和AOP：Spring Boot使用Spring框架的依赖注入和面向切面编程。
模块化：Spring和Spring Boot都支持模块化，可以根据需要引入不同的启动器和依赖。

不同点

配置：Spring通常依赖于XML或注解配置，而Spring Boot旨在通过自动配置尽量减少显式配置。
快速启动和开发：Spring Boot通过提供默认配置帮助开发者快速启动和开发Spring应用程序，而标准的Spring框架则需要更多的引导和配置。
独立性：Spring Boot应用程序可以打包为单个JAR文件，并且可以作为独立Java应用启动，而不需要外部Servlet容器。
组件版本管理：Spring Boot应用程序的依赖版本是预先定义好的，可以通过继承Spring Boot的父项目来实现。这种方式简化了库的版本控制，避免了版本冲突。
微服务支持：Spring Boot是为简化微服务架构中的服务创建和部署而设计，而Spring是一个更一般性的框架。

结论

Spring Boot不是替代Spring框架的，而是为了解决使用Spring框架时可能遇到的复杂性问题。如果您正在构建一个大型系统，需要细粒度的配置控制，Spring框架是合适的选择。如果您希望快速启动和开发，尤其是构建微服务或简单的RESTful服务，Spring Boot可能是更好的选择。Spring Boot旨在让在Spring框架上的开发变得快速和简单，同时还提供了Spring框架的全部强大功能。

12、Spring Boot 和 Spring Cloud

Spring Boot 和 Spring Cloud 是创建现代微服务应用程序的两个流行的Spring项目，它们共同工作以简化分布式系统的开发。虽然这两个项目紧密相连，但它们的关注点和提供的功能有所不同。

Spring Boot

Spring Boot 是一个快速开发框架，它的目标是简化Spring应用的创建和开发过程。

自动配置：Spring Boot 自动配置尝试猜测开发者希望如何配置Spring应用。基于classpath中的jar依赖，它自动配置Spring框架和第三方库。
独立性：Spring Boot 使得应用可封装为单个JAR或WAR文件，内嵌了Web服务器，因此无需外部的Servlet容器。
无代码生成和XML配置：Spring Boot 鼓励使用Java配置，尽管也支持属性文件和YAML文件。它旨在尽可能减少配置代码量。
微服务就绪：Spring Boot 支持构建独立的、生产级别的服务，这些服务可以轻松地打包、运行并扩展。
运行时洞察：通过Actuator模块，提供对应用程序运行时行为的深入洞察，如监控和健康检查。

Spring Cloud

Spring Cloud 聚焦于云端可伸缩的微服务应用的常见模式，它整合并简化了分布式系统的基础设施服务。

服务发现：Spring Cloud 包含了服务发现工具，如Netflix Eureka，允许微服务在动态变化的云环境中找到彼此。
配置管理：通过Spring Cloud Config，可以管理所有环境中的应用配置，支持配置信息的集中存储并在运行时动态改变。
路由和过滤：通过Zuul等工具，Spring Cloud 提供了智能路由和过滤功能，允许服务动态地路由和过滤请求。
客户端负载均衡：使用Ribbon或Spring Cloud LoadBalancer实现客户端侧的负载均衡。
断路器：Hystrix等断路器帮助微服务在分布式环境中优雅地处理失败和延迟。
分布式消息传递：Spring Cloud Stream 和 Spring Cloud Bus 提供了构建消息驱动的微服务的能力。

让我们深入了解一下它们之间的相似点和不同点：

相似点

基于Spring框架：Spring Boot 和 Spring Cloud 都是构建在Spring框架之上的，它们利用了Spring的依赖注入和面向切面编程等核心功能。
简化配置：两者都旨在简化配置，减少开发者需要编写的样板代码量。Spring Boot 提供了大量的自动配置，而 Spring Cloud 建立在Spring Boot之上，提供了用于服务发现、配置管理等的自动配置。
开箱即用：Spring Boot 和 Spring Cloud 都遵循"开箱即用"的原则，但同时它们也提供了丰富的配置选项以满足不同的需求。
微服务支持：它们都为构建微服务架构提供支持，其中Spring Boot 是创建独立的微服务应用程序的基础，而 Spring Cloud 提供了在微服务间进行交互所需要的一些通用模式的实现。

不同点

主要关注点：
- Spring Boot：旨在简化新Spring应用的初始搭建以及开发过程，提供了快速和广泛的开发体验。它通过自动配置、起步依赖和运行时配置来简化Spring应用开发。
- Spring Cloud：关注云配置和云服务发现，是在分布式系统（如微服务架构）环境下构建和部署应用程序的工具集。它包括配置管理、服务发现、断路器、智能路由、微代理、控制总线、一次性令牌等多种微服务相关的模式。
模块和组件：
- Spring Boot：提供了对嵌入式服务器（如Tomcat、Jetty或Undertow）、数据访问（包括SQL和NoSQL数据库）、安全、缓存、REST API开发、消息服务等的支持。
- Spring Cloud：是一系列框架的集合，包括Spring Cloud Netflix（服务发现Eureka、断路器Hystrix、智能路由Zuul）、Spring Cloud Config（配置服务器）、Spring Cloud Bus（用于传播集群中的状态改变），以及Spring Cloud Security（安全相关的云端特性）等。
部署和运行环境：
- Spring Boot：可以在任何地方运行Spring Boot应用程序，无论是传统的应用服务器、虚拟机还是容器（如Docker），甚至是云环境。
- Spring Cloud：通常用在云环境中，尤其是微服务部署在分布式和动态环境（如云平台）中时。
独立性：
- Spring Boot：可以独立运行，不需要Spring Cloud来构建和运行应用程序。
- Spring Cloud：通常依赖于Spring Boot的自动配置和运行时环境，但是提供了在Spring Boot之上构建分布式系统必须的特性。

结论

简而言之，Spring Boot 主要是关注于快速开发单个微服务和独立应用程序，而 Spring Cloud 是关注全局的、分布式的服务协调和管理。Spring Boot 可以单独使用，而 Spring Cloud 通常是基于Spring Boot开发的微服务之间的协调器。它们共同为微服务架构提供一站式解决方案，从单个微服务的创建和运行，到整个微服务集群的治理和维护。

13、如何自定义Starter

自定义实现一个Spring Boot Starter可以分为以下步骤：

步骤 1：创建Maven项目

首先，你需要创建一个新的Maven项目。你可以通过IDE来生成，或者使用mvn命令行工具。如果使用IDE，通常会提供向导来创建maven项目。

步骤 2：添加依赖项

在项目的pom.xml中，除了需要添加Spring Boot的依赖之外，也需添加你想要集成的任何第三方库。

<dependencies>
    <!-- Spring Boot核心Starter -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>
    <!-- 你需要集成的第三方库 -->
    <dependency>
        <groupId>com.example</groupId>
        <artifactId>example-library</artifactId>
        <version>版本号</version>
    </dependency>
    <!-- ...其他需要的依赖... -->
</dependencies>

步骤 3：编写自动配置

自动配置是Spring Boot的核心特性，它通过在classpath上检测特定的类并基于条件来配置beans。编写自己的自动配置类非常简单。只需使用@Configuration注解标注类，然后添加条件性注解。例如：

@Configuration
@ConditionalOnClass(ExampleService.class)
@ConditionalOnProperty(name = "example.enabled", matchIfMissing = true)
@EnableConfigurationProperties(ExampleProperties.class)
public class ExampleAutoConfiguration {

    @Autowired
    private ExampleProperties properties;

    @Bean
    @ConditionalOnMissingBean
    public ExampleService exampleService() {
        return new ExampleService(properties.getUrl(), properties.getTimeout());
    }
}

这里的ExampleProperties是一个配置属性类，配置属性使用@ConfigurationProperties来进行绑定。

@ConfigurationProperties(prefix = "example")
public class ExampleProperties {

    /**
     * 是否启用ExampleService
     */
    private boolean enabled = true;

    /**
     * 更多的属性...
     */
    private String url;
    private int timeout;

    // ... getters and setters ...
}

@EnableConfigurationProperties注解用来启用属性类的自动绑定功能。

步骤 4：创建`spring.factories`文件

在src/main/resources/META-INF目录下创建一个名为spring.factories的文件，然后注册你的自动配置类。

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

步骤 5：打包和部署

确保项目pom.xml中设置了正确的<groupId>、<artifactId>和版本号<version>。然后使用Maven进行打包。

mvn clean package

如果你想要发布到Maven Central Repository，你需要有适当的权限和配置。这通常涉及到一些额外的步骤来签名和准备你的库。若只是局部使用，你可以安装到本地的Maven仓库。

mvn install

或者部署到你公司内部的Maven仓库。

mvn deploy

步骤 6：使用Starter

在其它项目中，只需在pom.xml添加刚才自定义的Starter依赖即可使用。

<dependency>
    <groupId>你的groupId</groupId>
    <artifactId>你的artifactId</artifactId>
    <version>你的版本号</version>
</dependency>

接着，在application.properties或application.yml中配置属性：

example.enabled=true
example.url=http://localhost:8080
example.timeout=30

你的ExampleService将会根据这些属性自动配置。

注意事项：

确保不要在自动配置类中进行过于复杂的操作，因为这会影响应用启动时间。
使用条件注解来保证你的Starter不会冲突或重复配置。
遵循Spring Boot官方文档关于创建自定义Starter的最佳实践。
为Starter提供一个详细的README或文档说明如何使用以及提供的配置选项。
使用延迟初始化策略，避免在应用启动时过早创建类实例。
测试你的Starter确保在不同应用场景下都能正常工作。

14、为什么要自定义Starters

自定义Spring Boot Starter的核心原因在于Spring框架的一个主要目标：简化配置和提高开发效率。通过自定义Starter，开发者可以进一步利用Spring Boot的自动配置机制，封装常用的模式、库或者框架的配置，从而实现以下目标：

1. 提高代码复用性

Starter可以封装特定功能或服务的配置和组件，使其在不同项目中易于复用。这意味着开发者不需要在每个新项目中从头开始设置相同的配置。

2. 简化项目依赖

通过将所有相关依赖集中于一个Starter中，开发者可以通过引入一个单独的依赖来减少项目pom.xml或build.gradle文件的复杂性。

3. 维护和版本管理

单独维护Starter可确保在多个项目间共享类似的配置和依赖版本，这样做有助于统一管理和升级依赖，减少版本冲突的问题。

4. 保证最佳实践

自定义Starter可以内建最佳实践，封装构建过程中所学到的经验和常用模式。这有助于推广这些最佳实践至整个团队或组织。

5. 更好的默认配置

相比于通用的解决方案，自定义Starter可以为特定的业务场景提供更合适的默认配置，这可以进一步简化开发过程。

6. 减少错误配置

Starter可以通过预置配置和条件检查来减少配置错误的可能性，这对于复杂的或者需要多步骤配置的库尤其有用。

7. 安全性和合规性

如果某个库或框架需要按照特定的方式配置以满足安全性或合规性要求，自定义Starter可以确保这些配置不会被遗漏，从而降低了因配置不当而导致安全隐患的风险。

8. 加快项目启动时间

由于新项目可以通过添加单个依赖迅速获得所需的所有配置，Starter可以显著提高新项目的启动速度和开发效率。

9. 测试性的提高

通过封装配置和服务，Starter本身也可以作为一个单元进行测试，确保提供给其他项目的配置是经过测试和验证的，减少了项目中潜在的错误。

10. 社区支持

对于一些大型组织或开源社区，创建特定的Starter可以对外提供，可以帮助社区用户更容易地整合和使用相关的技术栈。

结论

确切地说，自定义Spring Boot Starter是框架提供的一种扩展点，目的是让开发者可以按照"约定大于配置"的原则，以最小的努力实现应用构建和设定。自定义Starter的使用可以大幅简化Spring Boot应用的初始化和配置，更加专注于业务逻辑的实现，而不是琐碎的配置工作。在大型应用和多个微服务之间共享自定义的Starter在一定程度上也可以促进代码和架构的一致性。

辞暮尔尔-烟火年年

关注

22
点赞
踩
21

收藏

觉得还不错? 一键收藏
打赏
0
评论
Spring Boot相关问题及答案（2024）

1、Spring Boot 的核心配置文件有哪些？它们有什么区别？Spring Boot的主要配置文件是application.properties和application.yml。它们都用于配置应用程序的各种属性，如服务器端口、数据库连接和自定义属性等。区别在于它们的格式：application.properties是一个传统的属性文件，每个配置项都是一个简单的键值对，例如server.port=8080。
复制链接

扫一扫