RiftRays's Blog

年轻且优秀 积极且颓废

Spring Boot

置顶 | 发布于 2021-01-01 22:41:03 | 标签: Spring 、 SpringBoot | 55分钟 | 13600字数 | 浏览量::

Spring Boot

概述

Spring Boot是一个开源的Java框架，它是Spring框架的扩展，旨在简化和加速Java应用程序的开发。Spring Boot专注于使构建、配置和部署基于Spring的应用程序变得更加容易。它采用"约定优于配置"的原则，通过提供默认配置和自动化的配置方式，使开发人员能够快速地启动和运行应用程序。

特性

  1. 自动配置：Spring Boot根据项目中所包含的依赖库，自动配置应用程序。这意味着不必手动配置每个细节，大部分情况下只需少量的配置即可。

  2. 起步依赖：Spring Boot引入了"起步依赖"的概念，这是预先配置好的依赖项集合，可以帮助快速地集成各种功能模块（例如数据库、安全性、Web等）到应用程序中。

  3. 嵌入式Web服务器：Spring Boot内置了常用的Web服务器，如Tomcat、Jetty和Undertow，使能够以独立应用程序的形式轻松地运行Web应用。

  4. Actuator：Spring Boot提供了Actuator模块，用于监控和管理应用程序。它可以提供应用程序的健康状况、运行时信息等，方便开发人员进行调试和监控。

  5. 外部化配置：Spring Boot支持将配置从代码中分离，可以通过属性文件、YAML文件、环境变量等方式进行配置，使得应用程序更具灵活性。

  6. 简化的安全性配置：Spring Boot简化了安全性配置，通过起步依赖可以很容易地添加安全性功能，例如身份验证和授权。

  7. 容易集成：Spring Boot与其他Spring生态系统组件无缝集成，例如Spring Data、Spring Security等。

开发步骤

  1. 项目初始化：

    • 创建一个新的Maven或Gradle项目，或者使用现有的项目作为基础。
    • 在项目的构建文件中添加Spring相关依赖，如Spring Boot起步依赖或Spring框架的核心模块。

  2. 定义数据模型：

    • 根据应用程序的需求，定义实体类（POJO）来表示数据模型，这些实体类通常映射到数据库表。
    • 使用注解（如@Entity、@Table等）来标识实体类，并定义实体类的属性以及它们之间的关系（如一对多、多对一等）。

  3. 创建数据访问层：

    • 使用Spring的数据访问技术（如Spring Data JPA或Spring JDBC）来访问数据库。
    • 定义Repository接口，通过方法签名来声明数据查询和操作。Spring将根据方法命名约定自动生成查询。

  4. 创建业务逻辑层：

    • 实现Service层，用于处理业务逻辑。
    • 在Service层中调用数据访问层的方法，处理业务逻辑，并对数据进行处理和转换。

  5. 创建控制器层：

    • 创建Controller类，用于处理HTTP请求和响应。
    • 使用注解（如@RestController、@RequestMapping等）来标识控制器，并定义请求映射。

  6. 配置依赖注入：

    • 使用Spring的依赖注入（DI）机制来管理组件之间的依赖关系。
    • 在类中使用@Autowired注解来标记需要自动注入的依赖。

  7. 配置应用程序：

    • 配置应用程序的属性，可以使用application.properties或application.yml文件进行配置。
    • 定义数据源、日志配置、端口号等应用程序相关的配置信息。

  8. 处理异常和错误：

    • 实现全局异常处理，以处理应用程序中出现的异常和错误情况。
    • 可以使用@ControllerAdvice注解来定义全局异常处理类。

  9. 测试应用程序：

    • 编写单元测试和集成测试来验证应用程序的功能和正确性。
    • 使用JUnit、Mockito等测试框架来编写和运行测试用例。

  10. 运行应用程序：

    • 使用Maven或Gradle构建项目，并生成可执行的JAR或WAR文件。
    • 使用命令行或集成开发环境（IDE）来运行应用程序。

  11. 部署应用程序：

    • 将生成的可执行文件部署到服务器或云平台上，以使应用程序可以在生产环境中运行。

创建Spring Boot项目

  1. 打开浏览器，并访问Spring Initializr网站：https://start.spring.io/

  2. 在Spring Initializr网站上，可以看到一个简单的界面，用于配置新项目的基本信息。需要提供以下信息：

    • 项目信息：输入项目的基本信息，如Group、Artifact、Name和Description。

    • 依赖：选择需要的起步依赖。这些依赖将自动添加到的项目中，并提供所需的功能，如Web、数据访问、安全等。

    • Java版本：选择希望使用的Java版本。

  3. 配置完成后，点击"Generate"按钮，Spring Initializr将生成一个包含配置的项目结构的Zip文件。

  4. 下载生成的Zip文件，并解压到的开发环境中。

  5. 使用喜欢的IDE（如IntelliJ IDEA、Eclipse等），打开解压后的项目文件夹。

  6. 如果使用Maven，可以直接导入为Maven项目，IDE会自动检测并加载Maven依赖。

  7. 开始编写的Spring Boot应用程序的代码，包括控制器、业务逻辑和数据访问等。

  8. 运行Spring Boot应用程序，可以使用IDE的运行按钮或使用命令行运行mvn spring-boot:run。

  9. 通过浏览器或其他工具访问的应用程序，检查是否正常运行。

IDEA创建Spring Boot项目

  1. 打开IntelliJ IDEA，并选择"Create New Project"（创建新项目）。

  2. 在弹出的窗口中，选择"Spring Initializr"选项，然后点击"Next"（下一步）。

  3. 在下一个窗口中，配置项目的基本信息：

    • Project SDK：选择希望使用的Java SDK版本。

    • Spring Initializr Service URL：默认情况下，IntelliJ IDEA会自动使用Spring Initializr服务。如果有特定需求，也可以选择使用本地的Spring Initializr服务。

    • Project：选择"Maven"或"Gradle"作为构建工具。

    • Language：选择Java。

    • Group：输入的项目组织或公司的名称。

    • Artifact：输入项目的名称。

    • Name：输入项目的显示名称。

    • Description：输入项目的描述信息（可选）。

    确保配置正确后，点击"Next"（下一步）。

  4. 在下一个窗口中，选择需要的Spring Boot起步依赖。可以根据项目需求选择Web、数据访问、安全等不同的依赖。选择完成后，点击"Next"（下一步）。

  5. 接下来，选择项目存储路径，并配置项目的命名空间（package）。

  6. 完成以上步骤后，点击"Finish"（完成），IntelliJ IDEA将会为创建一个Spring Boot项目，并自动下载和配置所需的依赖。

  7. 项目创建完成后，可以在IDEA的项目视图中看到项目的结构，其中包含了主应用程序类（通常带有@SpringBootApplication注解）和默认的目录结构。

  8. 开始编写的Spring Boot应用程序的代码，包括控制器、业务逻辑和数据访问等。

  9. 运行Spring Boot应用程序，可以在主应用程序类上点击右键，然后选择"Run 'YourApplicationName'"，或者使用快捷键Shift + F10运行。

  10. 在启动成功后，通过浏览器或其他工具访问的应用程序，检查是否正常运行。

取消启动banner图标

在Spring Boot应用启动时，会默认显示一个启动banner图标，包含Spring Boot的Logo以及项目的名称和版本等信息。有时候，我们可能希望取消这个启动banner图标的显示，以便在控制台中获得更干净的输出。

方法一：通过配置文件取消

可以通过在application.properties或application.yml配置文件中添加如下配置来取消启动banner图标的显示：

spring.main.banner-mode=off

或者在application.yml中：

spring:
  main:
    banner-mode: off

方法二：通过编程方式取消

我们还可以通过编程方式取消启动banner图标的显示，即在Spring Boot应用的主类中添加相应的代码。下面是一个Java代码示例：

import org.springframework.boot.Banner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class MyApplication {

    public static void main(String[] args) {
        SpringApplication app = new SpringApplication(MyApplication.class);
        app.setBannerMode(Banner.Mode.OFF); // 取消启动banner图标的显示
        app.run(args);
    }

}

在上述代码中，我们通过SpringApplication类的setBannerMode()方法将启动banner图标的显示模式设置为Banner.Mode.OFF，从而取消了启动时的图标显示。

Sprin引导类

在Spring Boot中，引导类（Bootstrap Class）是一个Java类，它是Spring Boot应用程序的入口点。引导类通常是一个带有main方法的类，它被用来启动应用程序。

引导类的主要作用是启用Spring Boot框架和自动配置。它会自动扫描应用程序中的组件（组件扫描），加载配置文件，并根据依赖关系和配置信息自动配置应用程序的各种功能。

在引导类中，需要使用@SpringBootApplication注解来标记该类。@SpringBootApplication是一个复合注解，包含了@Configuration、@EnableAutoConfiguration和@ComponentScan三个注解。它们的作用如下：

  1. @Configuration: 声明该类是一个配置类，相当于Spring中的XML配置文件。

  2. @EnableAutoConfiguration: 开启Spring Boot的自动配置功能。它会根据项目的依赖和配置，自动配置各种Spring框架和第三方库的Bean。

  3. @ComponentScan: 启用组件扫描，Spring Boot会自动扫描引导类所在包及其子包下的组件（包括控制器、服务、存储库等），将它们注册为Spring的Bean。

示例引导类代码如下：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class MyApplication {

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

在上述示例中，MyApplication类是引导类，通过SpringApplication.run()方法启动了Spring Boot应用程序。

小贴士

  1. 引导类应该放在项目的根包下或者根包的子包下，这样可以确保@ComponentScan扫描到所有需要注册为Bean的组件。一旦引导类配置好，Spring Boot将会根据其自动配置的特性，简化应用程序的开发和部署过程。

和传统Spring框架对比

特点 Spring Boot 传统 Spring 框架
概述 用于简化Java应用程序开发的开源框架 综合的Java企业级应用程序框架
项目初始化 提供快速初始化项目的工具 需要手动配置和初始化项目
配置简化 配置更简化，采用约定优于配置原则 配置相对复杂，需要显式配置各种组件
使用起步依赖 使用起步依赖（Starter）简化依赖管理 需要手动管理项目所需的依赖
内置嵌入式Web服务器 内置Tomcat、Jetty等嵌入式Web服务器 需要手动部署Web服务器
XML配置 vs Java配置 推荐使用基于Java的配置，如注解和Java Config 主要使用XML配置（也支持注解和Java Config）
组件自动配置 自动配置Spring Bean和其他组件，无需手动配置 需要显式配置Spring Bean和其他组件
环境配置 使用application.properties或application.yaml进行配置 使用properties或XML文件进行配置
版本兼容性 版本兼容性较好，更容易进行升级和迁移 升级和迁移相对复杂，可能需要修改部分配置和代码
微服务和云原生应用支持 优秀的支持微服务和云原生应用开发 支持微服务和云原生应用开发，但需要更多手动配置和集成

小贴士

  1. Spring Boot和传统Spring框架并不是彼此互斥的，Spring Boot是在传统Spring框架的基础上进行进一步简化和封装，目的是提供更便捷的开发体验。
  2. 在选择使用哪种框架时，可以根据项目需求、团队经验以及个人偏好来进行权衡和决策。

与Spring开发的异同

相同点：

  1. 定义数据模型：无论是使用Spring还是Spring Boot，都需要定义数据模型，即实体类（POJO），用于表示数据模型和数据库映射。

  2. 创建数据访问层：在两种情况下，都需要创建数据访问层，使用Spring的数据访问技术（如Spring Data JPA或Spring JDBC）来访问数据库。

  3. 创建业务逻辑层：业务逻辑的处理在Spring和Spring Boot中都是必要的，通过Service层来实现。

  4. 创建控制器层：在Spring和Spring Boot中都需要创建Controller类，用于处理HTTP请求和响应。

  5. 配置依赖注入：在Spring和Spring Boot中，都使用依赖注入（DI）机制来管理组件之间的依赖关系。

  6. 处理异常和错误：在两种情况下，都需要处理异常和错误情况，实现全局异常处理。

  7. 测试应用程序：无论使用Spring还是Spring Boot，编写单元测试和集成测试来验证应用程序的功能和正确性是必要的。

不同点：

  1. 配置方式：最显著的不同是配置方式。在传统的Spring框架中，需要手动配置大部分内容，包括数据源、事务管理、Web容器等，通常需要使用XML配置文件。而在Spring Boot中，采用"约定优于配置"的原则，很多配置都是自动完成的，可以通过属性文件或YAML文件来进行配置。

  2. 起步依赖：Spring Boot引入了起步依赖的概念，通过这种方式，可以很方便地添加所需功能的依赖，而不需要手动选择和配置每个依赖项。这在传统的Spring框架中是没有的。

  3. 嵌入式Web服务器：Spring Boot内置了常用的Web服务器（如Tomcat、Jetty和Undertow），使得可以以独立应用程序的形式运行Web应用，而传统的Spring框架通常需要将应用部署到外部的Web容器中。

  4. 项目初始化：在使用Spring Boot时，可以使用Spring Initializr工具来快速初始化一个Spring Boot项目，选择需要的依赖项和配置，从而大大简化了项目的初始化过程。

  5. 简化配置：由于Spring Boot的自动配置特性，很多常规的配置都不再需要手动编写，使得开发者能够更加专注于业务逻辑的实现。

与Spring配置的差异

配置区别 Spring开发 Spring Boot开发
配置方式 使用XML配置文件进行手动配置 采用"约定优于配置"，使用属性文件或YAML文件进行自动配置
依赖管理 需要手动管理依赖项 引入起步依赖，能够快速添加所需功能的依赖
数据源配置 需要手动配置数据源 自动根据配置文件设置数据源和数据库连接池
Web服务器配置 需要手动部署到外部Web服务器（如Tomcat、Jetty等） 内置嵌入式Web服务器（如Tomcat、Jetty和Undertow），可以独立运行Web应用
项目初始化 手动创建并配置项目 使用Spring Initializr工具快速初始化项目
简化配置 需要手动编写大量常规配置 自动化配置，减少了常规配置的编写
事务管理 需要手动配置事务管理 自动配置事务管理，无需手动设置事务
组件扫描 需要手动配置组件扫描 自动扫描组件，无需手动配置扫描路径
简化REST API开发 需要额外配置REST API（如使用Spring MVC） 内置Spring Web模块，简化REST API的开发
管理端点和健康检查 需要手动配置Actuator端点和健康检查 自动暴露Actuator端点，可用于监控和管理应用程序
自动配置和装配 需要手动配置和装配组件 自动配置和装配组件，减少了手动配置的复杂性

注意：上述表格中的内容是一般性的配置区别，具体差异可能因实际项目和版本而有所不同。Spring Boot的自动化配置使得开发者能够更快速地启动和运行应用程序，而传统的Spring开发可能需要手动处理更多的配置和集成工作。

依赖配置

起步依赖

Spring Boot的起步依赖（Starter Dependencies）是一组预配置的依赖项，它们使能够快速启动和运行特定类型的应用程序。这些依赖项将常用的库和框架集成到项目中，无需手动添加大量依赖项或配置文件，从而简化了开发过程。

Spring Boot的起步依赖通常以spring-boot-starter-*的命名形式出现，其中*表示不同类型的功能或模块。以下是一些常见的Spring Boot起步依赖：

  1. spring-boot-starter-web：用于构建Web应用程序，包含了Spring MVC、Tomcat（或其他嵌入式Web服务器）以及其他与Web开发相关的依赖。

  2. spring-boot-starter-data-jpa：用于使用JPA（Java Persistence API）进行数据持久化，包含了Spring Data JPA和与JPA相关的依赖。

  3. spring-boot-starter-data-mongodb：用于使用MongoDB数据库，包含了Spring Data MongoDB和MongoDB驱动的依赖。

  4. spring-boot-starter-thymeleaf：用于使用Thymeleaf模板引擎进行视图渲染。

  5. spring-boot-starter-security：用于实现基本的安全功能，包含了Spring Security和一些与安全相关的依赖。

  6. spring-boot-starter-test：用于编写单元测试和集成测试，包含了JUnit、Mockito等测试框架的依赖。

  7. spring-boot-starter-actuator：用于监控和管理Spring Boot应用程序，包含了健康检查、监控端点等依赖。

除了上述常见的起步依赖，还有很多其他功能的起步依赖可供选择，涵盖了各种场景和需求。

小贴士

  1. 所有SpringBoot项目要继承的项目，定义了若干个坐标版本号（依赖管理，而非依赖），以达到减少依赖冲突的目的
  2. spring-boot-starter-parent（2.5.0）与 spring-boot-starter-parent（2.4.6）共计57处坐标版本不同
  3. 使用任意坐标时，仅书写GAV中的G和A，V由SpringBoot提供。如发生坐标错误，再指定version（要小心版本冲突）

Jetty比Tomcat更轻量级，可扩展性更强（相较于Tomcat），谷歌应用引擎（GAE）已经全面切换为Jetty

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
        <!--web起步依赖环境中，排除Tomcat起步依赖-->
        <exclusions>
            <exclusion>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-tomcat</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
    <!--添加Jetty起步依赖，版本由SpringBoot的starter控制-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-jetty</artifactId>
    </dependency>
</dependencies>

编写规范

在Spring Boot项目中，可以使用Maven或Gradle来管理依赖项。无论选择哪种构建工具，依赖坐标的编写规范都遵循相应的标准。下面我将分别介绍Maven和Gradle的依赖坐标编写规范：

Maven 依赖坐标编写规范

在Maven的pom.xml文件中，可以通过<dependency>元素来添加依赖项。Maven的依赖坐标包括三个主要部分：groupId、artifactId和version。编写规范如下：

<dependency>
    <groupId>组织或公司标识</groupId>
    <artifactId>项目或模块标识</artifactId>
    <version>版本号</version>
</dependency>

例如，添加Spring Boot的Web起步依赖，可以使用以下坐标：

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

Gradle 依赖坐标编写规范

在Gradle的build.gradle文件中，可以通过dependencies块来添加依赖项。Gradle的依赖坐标由group、name和version组成。编写规范如下：

dependencies {
    implementation group: '组织或公司标识', name: '项目或模块标识', version: '版本号'
}

例如，使用Gradle添加Spring Boot的Web起步依赖，可以使用以下坐标：

dependencies {
    implementation group: 'org.springframework.boot', name: 'spring-boot-starter-web', version: '2.5.2'
}

无论使用Maven还是Gradle，确保依赖坐标编写正确，这样构建工具才能正确解析并下载相应的依赖项。同时，版本号的选择也很重要，确保使用稳定和兼容的版本，以避免潜在的问题和冲突。通过遵循这些规范，可以有效地管理Spring Boot项目的依赖项。

项目配置

配置方式

Spring Boot提供了多种配置形式，使可以根据项目需求选择最合适的配置方式。以下是Spring Boot常见的配置形式：

  1. 应用程序属性配置文件（Application Properties/YAML）：这是最常用的配置方式之一，通过在应用程序的属性配置文件中定义属性键值对来配置应用程序。属性配置文件可以是标准的.properties文件，也可以是更灵活的.yaml或.yml文件。可以在配置文件中设置各种属性，包括数据库连接、服务器端口、日志级别等。

  2. 命令行参数：可以通过命令行传递参数来配置Spring Boot应用程序。例如，可以使用--server.port=8080来指定服务器端口，或使用--spring.datasource.url=jdbc:mysql://localhost:3306/mydb来指定数据库连接URL。

  3. 环境变量：可以使用操作系统的环境变量来配置Spring Boot应用程序。Spring Boot会自动将环境变量与应用程序的属性进行匹配。

  4. Java系统属性：可以通过Java系统属性来配置Spring Boot应用程序。这可以通过在应用程序启动命令中使用-D参数来设置。

  5. 配置类：可以创建一个专门的配置类，并使用注解（如@Configuration、@Bean等）来定义和配置应用程序的组件。

  6. 自定义配置文件：除了应用程序属性配置文件外，还可以使用自定义的配置文件。通过使用@PropertySource注解或在@Configuration类中使用@PropertySources注解，可以引入其他的属性配置文件。

  7. Profile（环境）配置：Spring Boot支持使用不同的环境配置文件，例如application-dev.properties、application-prod.properties等，用于在不同的环境中设置不同的配置。可以使用spring.profiles.active属性指定当前激活的环境配置。

配置文件优先级

Spring Boot项目中同时存在application.yml、application.yaml和application.properties这三个配置文件，Spring Boot会按照一定的优先级顺序加载这些配置文件。具体的优先级如下：application.properties > application.yml > application.yaml

  1. application.properties: 这是最常见的Spring Boot配置文件，默认的配置文件名。如果存在该文件，它将具有最高的优先级。

  2. application.yml和application.yaml: 这两个文件的优先级相同，如果同时存在，它们的配置将会合并。如果想使用application.yml和application.yaml文件中的配置，建议使用yaml格式，因为它更易读、易写。

根据上述优先级，当三个配置文件都存在时，application.properties的配置将拥有最高优先级，而application.yml和application.yaml的配置将会合并，并在有冲突的情况下，后面加载的配置文件会覆盖前面加载的配置文件中的相同配置项。如果在application.yml和application.yaml文件中存在相同配置项的冲突，后加载的配置文件将会覆盖前面加载的配置文件中的相同配置项。

properties

概述

Properties文件是一种常用的配置文件格式，通常用于存储简单的键值对配置信息。它在Java应用程序中广泛用于配置各种参数和选项。

语法规则

  1. 键值对：每行表示一个键值对，用等号（=）或冒号（:）分隔键和值，并且键与值之间没有空格。

    key1=value1
key2:value2

  2. 注释：使用井号（#）或感叹号（!）作为注释的起始字符。注释会被忽略，不会影响配置解析。

    # 这是注释
key=value # 这也是注释

  3. 空行：空行会被忽略，可以用于增加配置文件的可读性。

    key=value

key2=value2

  4. 转义字符：如果键或值中包含等号、冒号、井号或感叹号等特殊字符，可以使用反斜杠（\）进行转义。

    special\=key=value

注意事项

  1. 键和值的顺序不影响配置文件的解析，但是建议保持一致性，便于阅读和维护。

  2. 键是唯一的，不可重复，如果出现重复的键，后面的键值对会覆盖前面的。

  3. 键和值都可以是字符串，不过值会被当作字符串来处理。如果需要其他类型的值，需要在代码中进行类型转换。

  4. Properties文件通常用于存储简单的配置信息，对于复杂的数据结构，可以考虑使用YAML或JSON等格式。

  5. Properties文件是以ISO-8859-1字符集编码的，如果需要包含非ASCII字符，需要进行正确的编码转换。

在Java中，可以使用java.util.Properties类来读取和处理Properties文件，也可以通过Spring框架提供的@PropertySource注解来加载Properties配置文件。确保在使用Properties文件时遵循以上语法规则和注意事项，以确保配置文件能够正确解析和使用。

使用

  1. 创建Properties配置文件：
    在src/main/resources目录下创建一个新的文件，命名为application.properties。

  2. 编写配置信息：
    在application.properties文件中，按照键值对的方式编写配置信息。示例如下：

server.port=8080
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=myuser
spring.datasource.password=mypassword
  1. 加载配置信息：
    与使用YAML配置文件类似，Spring Boot会自动加载application.properties中的配置信息，并将其转换为Java对象供应用程序使用。你可以在代码中通过@Value注解或者@ConfigurationProperties注解来获取配置值。

使用@Value注解示例：

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

@Component
public class MyComponent {
    @Value("${server.port}")
    private int serverPort;

    @Value("${spring.datasource.url}")
    private String dbUrl;

    // 其他业务逻辑
}

或者使用@ConfigurationProperties注解：

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

@Component
@ConfigurationProperties(prefix = "spring.datasource")
public class DataSourceConfig {
    private String url;
    private String username;
    private String password;

    // getter和setter方法
}

或者使用Environment对象：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.core.env.Environment;

@SpringBootApplication
public class MyApp {

    @Autowired
    private Environment environment;

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

    // 在应用程序的某个方法中使用Environment对象
    public void printConfigProperty() {
        String propertyValue = environment.getProperty("spring.datasource.url");
        System.out.println("配置属性的值：" + propertyValue);
    }
}
  1. 运行项目：
    在配置文件编写完成后，启动Spring Boot应用程序，它将自动加载Properties配置文件中的配置，并将其应用于相应的组件。

YAML

概述

YAML（YAML Ain't Markup Language）是一种用于数据序列化的格式，它的设计目标是人类可读性高、易于书写和解析。YAML的文件扩展名可以是.yaml或.yml，这两种扩展名可以互相替代使用，没有本质上的区别。

实际上，.yml是.yaml的简化形式，它是为了在文件名中更方便地表示YAML格式而引入的。YAML规范定义了.yaml作为官方的文件扩展名，但.yml也得到广泛接受并广泛使用，尤其在许多编程框架和工具中，.yml被作为默认的YAML文件扩展名。

因此，yml和yaml在功能和语法上是完全相同的，唯一的区别就是文件扩展名的不同。可以根据个人喜好或特定的编程环境来选择使用.yml或.yaml的文件扩展名。无论选择哪个扩展名，YAML解析器都能够正确地解析文件内容。

语法规则

  1. 键值对：使用冒号(:)表示键值对，键和值之间用空格隔开。
key: value
  1. 列表：使用连字符(-)表示列表中的元素，每个元素占一行，与前面的元素用空格隔开。
- item1
- item2
- item3
  1. 嵌套结构：可以嵌套使用键值对和列表，用空格缩进表示层级关系。
key1:
  subkey1: value1
  subkey2: value2
key2:
  - item1
  - item2
  1. 注释：使用井号(#)表示注释，从#开始到行末的内容都将被视为注释，不会被解析。
# 这是注释
key: value  # 这也是注释
  1. 多行字符串：使用|表示保留换行的多行字符串，内容会保留原格式。
multi-line: |
  This is a
  multi-line
  string.
  1. 折叠多行字符串：使用>表示折叠多行字符串，换行符会被转换为空格。
folded-line: >
  This is a
  folded multi-line
  string.

注意事项

  1. 缩进和格式：YAML使用缩进来表示层级关系，通常使用空格作为缩进，但不要混用空格和制表符。建议在整个配置文件中保持一致的缩进风格，以避免解析错误。

  2. 大小写敏感：YAML是大小写敏感的，因此Key和key是不同的键。要保持键的一致性，以便正确匹配和获取配置项。

  3. 注释：YAML支持使用#符号进行行内注释，但不支持块注释。注释应该放在合适的位置，提高配置文件的可读性，但要注意不要在重要的键值对上方添加注释，以免干扰解析。

  4. 引号：在需要的情况下使用引号来包裹字符串，特别是包含特殊字符或空格的字符串。YAML支持单引号、双引号和折叠式引号。

    key: "value with spaces"
key2: 'single-quoted value'

  5. 特殊字符：一些特殊字符，如:、#、{、}等，需要进行转义处理，使用反斜杠（\）进行转义。

  6. 多行字符串：YAML支持多行字符串，可以使用|或>符号表示。

    • 使用|表示保留换行符，保持多行文本的原样格式。
    • 使用>表示折叠换行符，将多行文本折叠成一行，并用空格替换换行符。
    key1: |
  This is a
  multiline
  text.

key2: >
  This is a
  multiline text.

  7. 数组：YAML中的数组可以使用方括号（[]）表示，数组元素之间使用逗号（,）分隔。

    fruits:
  - apple
  - banana
  - orange

  8. 对象：YAML中的对象可以使用冒号（:）表示，冒号后的值可以是简单的值，也可以是嵌套的对象。

    person:
  name: John
  age: 30
  address:
    city: New York
    zip: "10001"

  9. 类型推断：YAML会根据内容自动推断数据类型，如字符串、整数、布尔值等。确保键值对的值按照预期类型进行书写，避免类型错误。

  10. 包含文件：YAML支持通过!include或!include_dir_merge_list等标签来包含其他文件或目录，但这取决于解析器的支持和配置。

使用

在Spring Boot中，使用YAML配置文件是非常常见和方便的。YAML配置文件可以替代传统的Properties配置文件，并且在Spring Boot项目中，使用YAML配置文件可以更加清晰地组织配置信息，提高可读性和维护性。下面是在Spring Boot中使用YAML配置文件的基本步骤：

  1. 创建YAML配置文件：
    在Spring Boot项目的src/main/resources目录下创建一个新的文件，命名为application.yml或者application.yaml。这是Spring Boot默认加载的配置文件名。

  2. 编写配置信息：
    在application.yml文件中，可以使用YAML的语法来编写配置信息。以下是一个简单的示例：

server:
  port: 8080

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydb
    username: myuser
    password: mypassword
  1. 加载配置信息：
    Spring Boot会自动加载application.yml中的配置信息，并将其转换为Java对象，供应用程序使用。你可以在代码中通过@Value注解或@ConfigurationProperties注解来获取配置值。

示例代码：

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

@Component
public class MyComponent {
    @Value("${server.port}")
    private int serverPort;

    @Value("${spring.datasource.url}")
    private String dbUrl;

    // 其他业务逻辑
}

或者使用@ConfigurationProperties注解：

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

@Component
@ConfigurationProperties(prefix = "spring.datasource")
public class DataSourceConfig {
    private String url;
    private String username;
    private String password;

    // getter和setter方法
}
  1. 运行项目：
    在配置文件编写完成后，启动Spring Boot应用程序，它将自动加载YAML配置文件中的配置，并将其应用于相应的组件。

自定义对象封装数据警告解决方案

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-configuration-processor</artifactId>
    <optional>true</optional>
</dependency>

比较

特点 YAML Properties
结构 使用缩进和层级结构，更具可读性 使用键值对的形式，较为扁平
嵌套支持 支持嵌套结构，可以表示复杂的数据关系 不支持嵌套结构，仅适合简单的键值对配置
注释 支持行内注释和块注释 仅支持行内注释
数据类型推断 自动推断数据类型，支持字符串、整数、浮点数、布尔值等 一般将所有值都视为字符串类型
字符串表示 支持多行字符串和引号表示，可保留换行符 一般使用单行字符串表示，换行使用转义字符
键名大小写敏感 大小写敏感，键名区分大小写 大小写不敏感，键名不区分大小写
特殊字符转义 支持特殊字符转义，使用反斜杠（\）进行转义 特殊字符通常不需要转义
数组和列表 使用短横线（-）表示数组或列表的元素 不直接支持数组或列表，通常使用逗号分隔多个值
文件引入 支持通过!include标签引入其他文件或片段 不支持直接引入其他文件，但可以通过代码或工具实现
扩展性和可读性 结构清晰，易于理解和维护 简单直观，适用于小型配置文件
生态和应用领域的支持 主要在现代开发中使用，如Spring Boot和其他云原生应用 在传统Java应用中广泛使用，特别是基于Java EE的企业应用

需要根据具体的需求和项目环境选择适合的配置文件格式。YAML适合复杂的配置结构和需要更好可读性的场景，而Properties适合简单的键值对配置和传统Java应用的场景。

多环境配置

概述

image-20230719163535835image-20230719163611826image-20230719163735644

在Spring Boot中，你可以使用标准的YAML配置文件来配置多个环境（多环节）的启动参数。通过使用不同的配置文件，你可以为不同的环境提供不同的配置，比如开发环境、测试环境和生产环境。这样可以方便地切换配置，而无需更改代码。

标准的YAML配置文件命名规则是application-{profile}.yml，其中{profile}是你要指定的环境名称，比如dev、test、prod等。默认情况下，Spring Boot会加载名为application.yml的主配置文件，如果存在对应环境的配置文件，例如application-dev.yml，则会根据当前激活的环境加载相应的配置，覆盖主配置文件中的属性。

方式一

  1. 创建application.yml主配置文件：
# application.yml - 主配置文件
myapp:
  name: "My App"
  version: "1.0.0"
  1. 创建application-dev.yml开发环境配置文件：
# application-dev.yml - 开发环境配置文件
myapp:
  db:
    url: "jdbc:mysql://localhost:3306/dev_db"
    username: "dev_user"
    password: "dev_password"
  1. 创建application-test.yml测试环境配置文件：
# application-test.yml - 测试环境配置文件
myapp:
  db:
    url: "jdbc:mysql://localhost:3306/test_db"
    username: "test_user"
    password: "test_password"
  1. 创建application-prod.yml生产环境配置文件：
# application-prod.yml - 生产环境配置文件
myapp:
  db:
    url: "jdbc:mysql://production-server/prod_db"
    username: "prod_user"
    password: "prod_password"

根据上面的配置，当你在不同的环境中启动应用程序时，Spring Boot会自动加载对应的配置文件。例如，在开发环境中启动应用程序，它会加载application.yml和application-dev.yml，从而使用开发环境的数据库配置。

你可以通过在启动命令中指定--spring.profiles.active参数来激活特定的配置环境，比如：

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

这样，应用程序将加载application.yml和application-dev.yml的配置。

方式二

可以在YAML配置文件中进行Spring Boot的多环境配置。Spring Boot支持使用.yml或.yaml格式的配置文件。下面是在YAML配置文件中进行多环境配置的步骤：

  1. 创建配置文件：为每个环境创建不同的YAML配置文件，命名为application-{profile}.yml或application-{profile}.yaml，其中{profile}是环境名称（例如dev表示开发环境，test表示测试环境，prod表示生产环境）。

  2. 配置属性：在每个配置文件中，使用YAML的语法来设置对应环境的属性值。例如，数据库连接信息、日志级别、第三方服务的URL等。

以下是一个示例的YAML配置文件：

# application-dev.yml
spring:
  profiles:
    active: dev

# 数据库配置
datasource:
  url: jdbc:mysql://localhost:3306/devdb
  username: devuser
  password: devpass

# 日志配置
logging:
  level:
    root: INFO
    com.example: DEBUG

# 其他配置项
myapp:
  someProperty: value
  1. 设置当前环境：与前面的方法类似，在应用启动时，可以通过spring.profiles.active属性来指定当前的环境。可以在YAML配置文件中添加以下配置：
spring:
  profiles:
    active: dev
    
# 新的写法如下
spring:
	config:
		active:
			on-profile: dev
  1. 使用@Profile注解：除了配置文件外，仍然可以使用@Profile注解在Java代码中标注特定环境的配置类或方法，以控制在特定环境下是否生效。

配置分类

在 Spring Boot 中，可以通过不同级别的配置文件来覆盖和补充应用程序的配置。以下是 Spring Boot 中的四级配置文件，按优先级从高到低排列：

1级：file:config/application.yml（最高优先级）：位于项目根目录的 config 文件夹下的 application.yml 配置文件。此配置文件具有最高的优先级，任何在该文件中定义的配置将覆盖其他级别的配置。

2级：file:application.yml：位于项目根目录下的 application.yml 配置文件。如果某些配置没有在 file:config/application.yml 中定义，将尝试在此处查找配置。

3级：classpath:config/application.yml：位于 classpath（类路径）下的 config 文件夹下的 application.yml 配置文件。如果某些配置没有在上述两个文件中定义，将尝试在此处查找配置。

4级：classpath:application.yml（最低优先级）：位于 classpath（类路径）下的 application.yml 配置文件。如果所有其他级别的配置都没有定义某些配置，将尝试在此处查找默认配置。

配置文件的优先级由上到下，高优先级的配置将覆盖低优先级的配置。这种配置文件层级的设计使得在不同环境中使用不同的配置变得十分灵活，可以根据需要选择性地覆盖或补充配置，而无需改变应用程序代码。1级与2级留做系统打包后设置通用属性。3级与4级用于系统开发阶段设置通用属性。

存放位置

  1. src/main/resources 目录： 这是默认的配置文件存放位置。将配置文件放在 src/main/resources 目录下可以让 Spring Boot 自动加载并应用这些配置。

  2. 外部目录： 可以通过指定启动时的命令行参数 --spring.config.location 或环境变量 SPRING_CONFIG_LOCATION 来指定外部目录，其中包含应用程序的配置文件。例如，java -jar myapp.jar --spring.config.location=/path/to/config/。

  3. classpath 目录之外的地方： 除了 src/main/resources 目录，Spring Boot 还支持从 classpath 目录之外的其他位置加载配置文件。通过使用 --spring.config.additional-location 参数，可以指定其他的配置文件位置，例如 java -jar myapp.jar --spring.config.additional-location=/path/to/external/config/。

  4. 项目根目录： 在项目根目录中直接放置配置文件也是可以的，但通常不建议这样做，以免混淆项目结构。

配置优先级

参考文档：https://docs.spring.io/spring-boot/docs/current/reference/html/features.html#features.external-config

Spring Boot lets you externalize your configuration so that you can work with the same application code in different environments. You can use a variety of external configuration sources including Java properties files, YAML files, environment variables, and command-line arguments.

Property values can be injected directly into your beans by using the @Value annotation, accessed through Spring’s Environment abstraction, or be bound to structured objects through @ConfigurationProperties.

Spring Boot uses a very particular PropertySource order that is designed to allow sensible overriding of values. Later property sources can override the values defined in earlier ones. Sources are considered in the following order:

  1. Default properties (specified by setting SpringApplication.setDefaultProperties).
  2. @PropertySource annotations on your @Configuration classes. Please note that such property sources are not added to the Environment until the application context is being refreshed. This is too late to configure certain properties such as logging.* and spring.main.* which are read before refresh begins.
  3. Config data (such as application.properties files).
  4. A RandomValuePropertySource that has properties only in random.*.
  5. OS environment variables.
  6. Java System properties (System.getProperties()).
  7. JNDI attributes from java:comp/env.
  8. ServletContext init parameters.
  9. ServletConfig init parameters.
  10. Properties from SPRING_APPLICATION_JSON (inline JSON embedded in an environment variable or system property).
  11. Command line arguments.
  12. properties attribute on your tests. Available on @SpringBootTest and the test annotations for testing a particular slice of your application.
  13. @DynamicPropertySource annotations in your tests.
  14. @TestPropertySource annotations on your tests.
  15. Devtools global settings properties in the $HOME/.config/spring-boot directory when devtools is active.

Maven与SpringBoot多环境兼容

当使用 Maven 和 Spring Boot 进行多环境兼容配置时，可以通过 Maven 的 profiles 和 Spring Boot 的多环境配置文件相结合来实现。下面是详细的步骤：

步骤 1：创建 Maven 的 profiles

  1. 在项目的根目录下，打开 pom.xml 文件。
  2. 在 <project> 元素下添加 <profiles> 元素，用于定义不同的环境配置。
  3. 在 <profiles> 元素中，添加多个 <profile> 元素，每个 <profile> 元素代表一个环境配置（如开发、测试、生产等）。
  4. 在每个 <profile> 元素中，可以设置 <id> 属性来标识该配置，并通过 <properties> 元素设置环境相关的属性值。例如，可以设置数据库连接信息、日志级别等。
  5. 确保每个 <profile> 元素包含 <activation> 元素，用于指定激活该配置的条件。例如，可以根据 Maven 的 activeByDefault 属性或环境变量来激活特定的配置。

示例 pom.xml 文件：

<project>
    <!-- 其他项目配置 -->

    <profiles>
        <!-- 开发环境配置 -->
        <profile>
            <id>dev</id>
            <properties>
                <spring.profiles.active>dev</spring.profiles.active>
                <!-- 其他环境相关的属性 -->
            </properties>
            <activation>
                <activeByDefault>true</activeByDefault>
            </activation>
        </profile>

        <!-- 测试环境配置 -->
        <profile>
            <id>test</id>
            <properties>
                <spring.profiles.active>test</spring.profiles.active>
                <!-- 其他环境相关的属性 -->
            </properties>
        </profile>

        <!-- 生产环境配置 -->
        <profile>
            <id>prod</id>
            <properties>
                <spring.profiles.active>prod</spring.profiles.active>
                <!-- 其他环境相关的属性 -->
            </properties>
        </profile>
    </profiles>

    <!-- 其他项目配置 -->
</project>

步骤 2：创建 Spring Boot 的多环境配置文件

  1. 在 src/main/resources 目录下，创建多个配置文件，每个配置文件代表一个环境配置。例如，可以创建 application-dev.properties（用于开发环境）、application-test.properties（用于测试环境）、application-prod.properties（用于生产环境）等。
  2. 在每个配置文件中，设置与相应环境相关的属性值。例如，可以设置数据库连接信息、日志级别等。

示例 application-dev.properties 文件：

# 开发环境数据库连接信息
spring.datasource.url=jdbc:mysql://localhost:3306/dev_db
spring.datasource.username=dev_user
spring.datasource.password=dev_password

# 开发环境日志级别
logging.level.root=DEBUG

示例 application-test.properties 文件：

# 测试环境数据库连接信息
spring.datasource.url=jdbc:mysql://localhost:3306/test_db
spring.datasource.username=test_user
spring.datasource.password=test_password

# 测试环境日志级别
logging.level.root=INFO

示例 application-prod.properties 文件：

# 生产环境数据库连接信息
spring.datasource.url=jdbc:mysql://production-server:3306/prod_db
spring.datasource.username=prod_user
spring.datasource.password=prod_password

# 生产环境日志级别
logging.level.root=WARN

步骤 3：使用 Maven 配置打包

  1. 使用 Maven 的 maven-resources-plugin 插件配置打包过程，使得对应环境的配置文件能够正确地打包到最终的可执行 Jar 或 War 文件中。
  2. 在 pom.xml 中添加以下插件配置：
<project>
    <!-- 其他项目配置 -->

    <build>
        <plugins>
            <!-- 其他插件配置 -->

            <!-- Maven Resources Plugin 配置 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-resources-plugin</artifactId>
                <version>3.2.0</version>
                <configuration>
                    <delimiters>
                        <delimiter>@</delimiter>
                    </delimiters>
                    <useDefaultDelimiters>false</useDefaultDelimiters>
                    <overwrite>true</overwrite>
                </configuration>
            </plugin>
        </plugins>
    </build>

    <!-- 其他项目配置 -->
</project>

步骤 4：运行应用程序

  1. 使用 Maven 打包应用程序。在项目根目录下执行命令：mvn clean package。
  2. Maven 将根据配置的激活环境打包对应的配置文件到可执行 Jar 或 War 文件中。
  3. 运行应用程序时，可以使用以下方式激活特定的配置文件：
    • 使用命令行参数：java -jar myapp.jar --spring.profiles.active=dev
    • 使用环境变量：export SPRING_PROFILES_ACTIVE=dev（Linux 环境）
    • 在 application.properties 或 application.yml 中指定：spring.profiles.active=dev

通过以上步骤，可以成功实现 Maven 与 Spring Boot 的多环境兼容配置。在不同的环境中，应用程序将使用相应的配置文件，从而确保在不同环境下应用程序的正确运行和部署。

加载Maven对应的属性

对于源码中非 Java 类（例如 XML 配置文件、YAML 配置文件、资源文件等）的操作，如果希望加载 Maven 对应的属性，可以使用 Spring Boot 提供的占位符机制和配置文件加载策略来实现。

  1. 使用占位符机制： 在 Spring Boot 中，可以在配置文件中使用占位符来引用 Maven 的属性。Maven 的属性可以通过 ${} 语法在配置文件中进行引用。

    示例 application.yml 文件：

    server:
  port: ${server.port}
datasource:
  url: ${spring.datasource.url}
  username: ${spring.datasource.username}
  password: ${spring.datasource.password}

    在上述示例中，${server.port}、${spring.datasource.url}、${spring.datasource.username} 和 ${spring.datasource.password} 都是引用了 Maven 中定义的属性，Spring Boot 将在启动时根据 Maven 属性的值进行替换。

  2. 配置文件加载策略： Spring Boot 会自动加载项目根目录下的 application.properties 或 application.yml 配置文件。但如果希望在其他位置放置配置文件，并加载 Maven 的属性，可以通过以下方式实现：

    • 将配置文件放置在 Maven 项目的 src/main/resources 目录中，然后在配置文件中使用占位符引用 Maven 的属性，如前面的示例所示。

    • 如果希望在其他位置放置配置文件（例如外部目录），可以使用 --spring.config.location 参数指定外部配置文件的位置。例如，java -jar myapp.jar --spring.config.location=/path/to/config/。Spring Boot 将自动加载指定位置的配置文件，并根据 Maven 属性的值进行替换。

总之，可以在源码中的非 Java 类中使用 Spring Boot 的占位符机制，通过引用 Maven 的属性来实现配置的加载。同时，可以根据需要选择合适的配置文件加载策略，确保配置文件能够正确加载 Maven 的属性值。这样，可以在不同环境中更加灵活地配置应用程序的属性。

假设有一个 Spring Boot 应用程序，需要配置数据库连接信息，并且希望通过 Maven 属性来设置这些信息。

  1. 首先，在 Maven 的 pom.xml 文件中添加数据库连接信息的属性和开启对默认占位符的解析。
<build>
    <plugins>
        <plugin>
            <artifactId>maven-resources-plugin</artifactId>
            <configuration>
                <encoding>utf-8</encoding>
                <useDefaultDelimiters>true</useDefaultDelimiters>
            </configuration>
        </plugin>
    </plugins>
</build>
<project>
    <!-- 其他项目配置 -->

    <properties>
        <db.url>jdbc:mysql://localhost:3306/mydb</db.url>
        <db.username>myuser</db.username>
        <db.password>mypassword</db.password>
    </properties>

    <!-- 其他项目配置 -->
</project>
  1. 在 src/main/resources 目录下创建 application.yml 配置文件，并在其中使用占位符引用 Maven 的属性。
# src/main/resources/application.yml

spring:
  datasource:
    url: ${db.url}
    username: ${db.username}
    password: ${db.password}
  1. 创建一个简单的 Spring Boot 应用程序，用于测试配置。
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

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

@Component
@ConfigurationProperties(prefix = "spring.datasource")
class DataSourceProperties {
    private String url;
    private String username;
    private String password;

    // Getters and setters

    // Test method to print database connection information
    public void printDatabaseConfig() {
        System.out.println("Database URL: " + url);
        System.out.println("Database Username: " + username);
        System.out.println("Database Password: " + password);
    }
}

在上述示例中，在 pom.xml 中定义了数据库连接信息的 Maven 属性，并在 application.yml 中使用占位符引用这些属性。然后，通过 DataSourceProperties 类使用 @ConfigurationProperties 注解将属性值绑定到类中，并在 printDatabaseConfig 方法中打印出来。

当运行这个应用程序时，Spring Boot 将加载 application.yml 中的配置，将 Maven 的属性值替换到对应的占位符中。这样，就成功地在配置文件中使用了占位符引用 Maven 的属性，实现了动态加载配置。

整合三方技术

整合JUnit

步骤1：添加依赖项
首先，在项目的构建文件（例如pom.xml）中添加所需的依赖项。确保包含JUnit和Spring Boot Test相关的依赖项。

<!-- JUnit 依赖 -->
<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter-api</artifactId>
    <version>5.7.2</version>
    <scope>test</scope>
</dependency>

<!-- Spring Boot Test 依赖 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <version>2.5.4</version>
    <scope>test</scope>
</dependency>

步骤2：编写测试类
创建一个测试类，并使用JUnit的注解标记测试方法。

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.web.client.TestRestTemplate;
import org.springframework.boot.test.web.client.TestRestTemplate;
import org.springframework.boot.test.web.client.TestRestTemplate.HttpClientOption;
import org.springframework.boot.test.web.client.TestRestTemplate.ResponseExtractor;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.RequestEntity;
import org.springframework.http.ResponseEntity;
import org.springframework.test.context.junit.jupiter.SpringJUnitConfig;
import org.springframework.web.client.RestTemplate;

import static org.junit.jupiter.api.Assertions.assertEquals;

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class MyControllerTest {

    @Autowired
    private TestRestTemplate restTemplate;

    @Test
    public void testHelloEndpoint() {
        String url = "/hello";
        ResponseEntity<String> response = restTemplate.getForEntity(url, String.class);
        assertEquals(HttpStatus.OK, response.getStatusCode());
        assertEquals("Hello, World!", response.getBody());
    }
}

在上面的示例中，使用了@SpringBootTest注解来标记测试类，并指定WebEnvironment.RANDOM_PORT以在随机端口上启动应用程序的嵌入式服务器。使用@Autowired注解注入TestRestTemplate来进行HTTP请求的模拟。

步骤3：运行测试
使用常规的JUnit运行器（如JUnit Jupiter或JUnit 4）来运行测试类。测试类中的测试方法将会执行，并且可以通过assertEquals等断言方法进行断言和验证。

小贴士

  1. 可以使用TestRestTemplate来发送HTTP请求并进行断言。这使得可以测试控制器、服务或其他组件的行为和结果。
  2. 示例中使用了Spring Boot 2.x的方式，如果使用的是较早的版本，请相应地调整依赖项和注解的版本。

整合MyBatis

步骤1：添加依赖项
首先，需要在项目的构建文件（例如pom.xml）中添加Spring Boot和MyBatis的依赖项。

<!-- Spring Boot 依赖 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <version>2.5.4</version>
</dependency>

<!-- MyBatis 依赖 -->
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.2.0</version>
</dependency>

<!-- MySQL 驱动依赖 -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.26</version>
</dependency>

步骤2：配置数据源和MyBatis
在application.properties或application.yml中配置数据源和MyBatis。

# application.yml

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydatabase
    username: your_username
    password: your_password
    driver-class-name: com.mysql.cj.jdbc.Driver

mybatis:
  mapper-locations: classpath:mappers/*.xml

在上述配置中，指定了数据库连接的URL、用户名和密码，以及MySQL驱动的类名。还指定了MyBatis Mapper文件的位置，这里假设它们位于src/main/resources/mappers/目录下。

步骤3：创建Mapper接口和XML文件
创建MyBatis的Mapper接口和XML文件，用于定义数据库操作。

// UserMapper.java

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

@Mapper
public interface UserMapper {
    @Select("SELECT id, username, email FROM users WHERE id = #{id}")
    User findById(Long id);
}

<!-- UserMapper.xml -->

<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.mapper.UserMapper">
    <!-- 这里可以定义更多的数据库操作 -->
</mapper>

步骤4：实现Service层和Controller层
创建Service层和Controller层，用于调用MyBatis的Mapper接口进行数据库操作。

// UserService.java

import com.example.mapper.UserMapper;
import com.example.model.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserService {

    private final UserMapper userMapper;

    @Autowired
    public UserService(UserMapper userMapper) {
        this.userMapper = userMapper;
    }

    public User getUserById(Long id) {
        return userMapper.findById(id);
    }
}

// UserController.java

import com.example.model.User;
import com.example.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class UserController {

    private final UserService userService;

    @Autowired
    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/users/{id}")
    public User getUserById(@PathVariable Long id) {
        return userService.getUserById(id);
    }
}

在上面的示例中，创建了UserService和UserController，其中UserService调用MyBatis的UserMapper接口来查询数据库，并返回User对象。UserController暴露了一个REST API来获取用户信息。

步骤5：运行应用程序
现在，可以运行Spring Boot应用程序，并访问UserController暴露的REST API来测试MyBatis集成是否正常工作。

当访问/users/{id}时，UserController将调用UserService，并通过MyBatis查询数据库，并返回相应的用户信息。

赞赏
# Spring # SpringBoot
Maven 进阶 上一篇
Mybatis-Plus 下一篇
已运行:
浏览数: 次 | 访客数: 人
Your time is limited, so don't waste it living someone else's life ... Stay Hungry. Stay Foolish.
0%