# 创建一个多模块项目
本指南向您展示了如何使用Spring Boot创建一个多模块项目。 该项目将具有一个库jar和使用该库的主应用程序。 您还可以使用它来查看如何自行构建库（即不是应用程序的jar文件）。
## 你会建立什么
您将设置一个库jar，它公开简单的“ Hello，World”消息服务，然后将该服务包含在使用库作为依赖项的Web应用程序中。
## 你需要什么
## 如何完成本指南
像大多数Spring 一样 [入门指南](https://spring.io/guides) ，您可以从头开始并完成每个步骤，也可以绕过您已经熟悉的基本设置步骤。 无论哪种方式，您最终都可以使用代码。
要 **从头开始** ，继续 [创建根项目](https://spring.io/guides/gs/multi-module/#scratch) 。
要 **跳过基础知识** ，请执行以下操作：
* [下载](https://github.com/spring-guides/gs-multi-module/archive/master.zip) 并解压缩本指南的源存储库，或使用 对其进行克隆 [Git](https://spring.io/understanding/Git) ： `git clone [https://github.com/spring-guides/gs-multi-module.git](https://github.com/spring-guides/gs-multi-module.git)`
* 光盘进入 `gs-multi-module/initial`
* 继续 [创建图书馆项目](https://spring.io/guides/gs/multi-module/#initial) 。
**完成后** ，您可以根据中的代码检查结果 `gs-multi-module/complete`.
首先，您设置一个基本的构建脚本。 在使用Spring构建应用程序时，可以使用任何喜欢的构建系统，但是 使用 所需的代码 [Gradle](http://gradle.org) 和 [Maven](https://maven.apache.org) 此处包含 。 如果您都不熟悉，请参阅 [使用Gradle](https://spring.io/guides/gs/gradle) 或 [构建Java项目 使用Maven构建Java项目](https://spring.io/guides/gs/maven) 。
## 创建一个根项目
本指南分步介绍了如何建立两个项目，其中一个是对另一个项目的依赖。 因此，您需要在一个根项目下创建两个子项目。 但首先，在顶层创建构建配置。 对于Maven，您将需要 `pom.xml` 和 `<modules>` 列出子目录：
~~~
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>org.springframework</groupId>
<artifactId>gs-multi-module</artifactId>
<version>0.1.0</version>
<packaging>pom</packaging>
<modules>
<module>library</module>
<module>application</module>
</modules>
</project>
~~~
对于Gradle，您将需要一个 `settings.gradle` 包括相同的目录：
~~~
rootProject.name = 'gs-multi-module'
include 'library'
include 'application'
~~~
并且（可选）您可以添加一个空白 `build.gradle` （以帮助IDE识别根目录）。
### 创建目录结构
在要用作根目录的目录中，创建以下子目录结构（例如，使用 `mkdir library application` 在\* nix系统上）：
~~~
└── library
└── application
~~~
在项目的根目录中，您将需要建立一个构建系统，本指南将向您展示如何使用Maven或Gradle。
## 创建图书馆项目
这两个项目之一用作另一个项目（应用程序）将使用的库。
### 创建目录结构
在 `library` 目录中，创建以下子目录结构（例如，通过使用 `mkdir -p src/main/java/com/example/multimodule/service` 在\* nix系统上）：
~~~
└── src
└── main
└── java
└── com
└── example
└── multimodule
└── service
~~~
现在，您需要配置一个构建工具（Maven或Gradle）。 在这两种情况下，请注意， Spring Boot插件 **没有** 库项目中根本 使用 。 该插件的主要功能是创建一个可执行文件“über-jar”，而我们既不需要库又不需要库。
尽管未使用Spring Boot Maven插件，但您确实想利用Spring Boot依赖项管理，因此可以通过使用 `spring-boot-starter-parent`从Spring Boot作为父项目。 一种替代方法是将依赖项管理作为物料 导入 [清单（BOM）](https://maven.apache.org/guides/introduction/introduction-to-dependency-mechanism.html#Importing_Dependencies) 到 `<dependencyManagement/>`的部分 `pom.xml` 文件。
### 设置图书馆项目
对于Library项目，您无需添加依赖项。 基础的 `spring-boot-starter` 依赖关系提供了您所需的一切。
您可以直接从 获取具有必要依赖项的Maven构建文件 [Spring Initializr](https://start.spring.io/#!type=maven-project&language=java&platformVersion=2.4.3.RELEASE&packaging=jar&jvmVersion=1.8&groupId=com.example&artifactId=multi-module-library&name=multi-module-library&description=Demo%20project%20for%20Spring%20Boot&packageName=com.example.multi-module-library) 。 以下清单显示了 `pom.xml` 选择Maven时创建的文件：
~~~
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.4.3</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>com.example</groupId>
<artifactId>multi-module-library</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>multi-module-library</name>
<description>Demo project for Spring Boot</description>
<properties>
<java.version>1.8</java.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>
~~~
您可以直接从 获取具有必要依赖项的Gradle构建文件 [Spring Initializr](https://start.spring.io/#!type=gradle-project&language=java&platformVersion=2.4.3.RELEASE&packaging=jar&jvmVersion=1.8&groupId=com.example&artifactId=multi-module-library&name=multi-module-library&description=Demo%20project%20for%20Spring%20Boot&packageName=com.example.multi-module-library) 。 以下清单显示了 `build.gradle` 选择Gradle时创建的文件：
~~~
plugins {
id 'org.springframework.boot' version '2.4.3'
id 'io.spring.dependency-management' version '1.0.11.RELEASE'
id 'java'
}
group = 'com.example'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '1.8'
repositories {
mavenCentral()
}
dependencies {
implementation 'org.springframework.boot:spring-boot-starter'
testImplementation 'org.springframework.boot:spring-boot-starter-test'
}
~~~
#### 调整图书馆项目
如果您是从以下位置生成“图书馆”项目的 `start.spring.io` 它将包含构建系统的包装器脚本（ `mvnw` 或者 `gradlew`取决于您所做的选择）。 您可以将该脚本及其关联的配置移至根目录：
~~~
$ mv mvnw* .mvn ..
$ mv gradlew* gradle ..
~~~
Library项目没有使用main方法的类（因为它不是应用程序）。 因此，您必须告诉构建系统不要尝试为Library项目构建可执行的jar。 （默认情况下，Spring Initializr会生成可执行项目。）
要告诉Maven不为Library项目构建可执行的jar，必须从以下位置删除以下代码块： `pom.xml` 由Spring Initializr创建：
~~~
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
~~~
以下清单显示了最终的 `pom.xml` 库项目的文件：
~~~
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.4.3</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>com.example</groupId>
<artifactId>library</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>multi-module-library</name>
<description>Demo project for Spring Boot</description>
<properties>
<java.version>1.8</java.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
</project>
~~~
要告诉Gradle不为Library项目构建可执行的jar，必须将以下代码块添加到 `build.gradle` 由Spring Initializr创建：
~~~
bootJar {
enabled = false
}
jar {
enabled = true
}
~~~
这 `bootJar` 任务尝试创建一个可执行jar，这需要一个 `main()`方法。 因此，您需要禁用 `bootJar` 任务并启用 `jar` 任务（创建普通的jar而不是可执行的jar）。
以下清单显示了最终的 `build.gradle` 库项目的文件：
~~~
plugins {
id 'org.springframework.boot' version '2.4.3'
id 'io.spring.dependency-management' version '1.0.11.RELEASE'
id 'java'
}
group = 'com.example'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '1.8'
repositories {
mavenCentral()
}
bootJar {
enabled = false
}
jar {
enabled = true
}
dependencies {
implementation 'org.springframework.boot:spring-boot-starter'
testImplementation 'org.springframework.boot:spring-boot-starter-test'
}
~~~
## 创建服务组件
图书馆将提供 `MyService`应用程序可以使用的类。 以下清单（来自 `library/src/main/java/com/example/multimodule/service/MyService.java`）显示 `MyService` 班级：
~~~
package com.example.multimodule.service;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.stereotype.Service;
@Service
@EnableConfigurationProperties(ServiceProperties.class)
public class MyService {
private final ServiceProperties serviceProperties;
public MyService(ServiceProperties serviceProperties) {
this.serviceProperties = serviceProperties;
}
public String message() {
return this.serviceProperties.getMessage();
}
}
~~~
要使其在标准Spring Boot习惯用法中具有可配置性（带有 `application.properties`），您还可以添加一个 `@ConfigurationProperties`班级。 这 `ServiceProperties` 类（来自 `library/src/main/java/com/example/multimodule/service/ServiceProperties.java`）满足以下需求：
~~~
package com.example.multimodule.service;
import org.springframework.boot.context.properties.ConfigurationProperties;
@ConfigurationProperties("service")
public class ServiceProperties {
/**
* A message for the service.
*/
private String message;
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
}
~~~
您不必这样做。 一个库可能只提供纯Java API，而没有Spring功能。 在这种情况下，使用该库的应用程序将需要自行提供配置。
## 测试服务组件
您将要为库组件编写单元测试。 如果您将可重用的Spring配置作为库的一部分提供，则可能还需要编写一个集成测试，以确保该配置可以正常工作。 为此，您可以使用JUnit和 `@SpringBootTest`注解。 以下清单（来自 `library/src/test/java/com/example/multimodule/service/MyServiceTest.java`）显示了如何执行此操作：
~~~
package com.example.multimodule.service;
import static org.assertj.core.api.Assertions.assertThat;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest("service.message=Hello")
public class MyServiceTest {
@Autowired
private MyService myService;
@Test
public void contextLoads() {
assertThat(myService.message()).isNotNull();
}
@SpringBootApplication
static class TestConfiguration {
}
}
~~~
在前面的清单中，我们已经配置了 service.message 通过使用的默认属性进行测试 @SpringBootTest注解。 我们 不 建议放置 application.properties 在库中，因为在运行时与使用该库的应用程序可能会发生冲突（只有一个 application.properties从classpath加载）。 你 可以 放 application.properties 在测试类路径中，但不将其包含在jar中（例如，通过将其放置在 src/test/resources).
## 创建应用程序项目
Application项目使用Library项目，该项目提供了其他项目可以使用的服务。
### 创建目录结构
在里面 `application` 目录中，创建以下子目录结构（例如，带有 `mkdir -p src/main/java/com/example/multimodule/application` 在\* nix系统上）：
~~~
└── src
└── main
└── java
└── com
└── example
└── multimodule
└── application
~~~
除非要通过以下方式在库中包含所有Spring组件，否则请不要使用与库相同的包（或库包的父级）。 `@ComponentScan` 在应用程序中。
### 设置应用程序项目
对于Application项目，您需要Spring Web和Spring Boot Actuator依赖项。
您可以直接从 获取具有必要依赖项的Maven构建文件 [Spring Initializr](https://start.spring.io/#!type=maven-project&language=java&platformVersion=2.4.2.RELEASE&packaging=jar&jvmVersion=11&groupId=com.example&artifactId=multi-module-application&name=multi-module-application&description=Demo%20project%20for%20Spring%20Boot&packageName=com.example.multi-module-application&dependencies=web,actuator) 。 以下清单显示了 `pom.xml` 选择Maven时创建的文件：
~~~
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.4.3</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>com.example</groupId>
<artifactId>multi-module-application</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>multi-module-application</name>
<description>Demo project for Spring Boot</description>
<properties>
<java.version>1.8</java.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<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>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>
~~~
您可以直接从 获取具有必要依赖项的Gradle构建文件 [Spring Initializr](https://start.spring.io/#!type=gradle-project&language=java&platformVersion=2.4.2.RELEASE&packaging=jar&jvmVersion=11&groupId=com.example&artifactId=multi-module-application&name=multi-module-application&description=Demo%20project%20for%20Spring%20Boot&packageName=com.example.multi-module-application&dependencies=web,actuator) 。 以下清单显示了 `build.gradle` 选择Gradle时创建的文件：
~~~
plugins {
id 'org.springframework.boot' version '2.4.3'
id 'io.spring.dependency-management' version '1.0.11.RELEASE'
id 'java'
}
group = 'com.example'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '1.8'
repositories {
mavenCentral()
}
dependencies {
implementation 'org.springframework.boot:spring-boot-starter-actuator'
implementation 'org.springframework.boot:spring-boot-starter-web'
testImplementation 'org.springframework.boot:spring-boot-starter-test'
}
~~~
您可以删除 `mvnw` 和/或 `gradlew` 包装器及其关联的配置文件：
~~~
$ rm -rf mvnw* .mvn
$ rm -rf gradlew* gradle
~~~
#### 添加库依赖
Application项目需要依赖Library项目。 您需要相应地修改您的应用程序构建文件。
对于Maven，添加以下依赖项：
~~~
<dependency>
<groupId>com.example</groupId>
<artifactId>library</artifactId>
<version>${project.version}</version>
</dependency>
~~~
以下清单显示了成品 `pom.xml` 文件：
~~~
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.4.3</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>com.example</groupId>
<artifactId>multi-module-application</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>multi-module-application</name>
<description>Demo project for Spring Boot</description>
<properties>
<java.version>1.8</java.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>com.example</groupId>
<artifactId>library</artifactId>
<version>${project.version}</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>
~~~
对于Gradle，添加以下依赖项：
~~~
implementation project(':library')
~~~
以下清单显示了成品 `build.gradle` 文件：
~~~
plugins {
id 'org.springframework.boot' version '2.4.3'
id 'io.spring.dependency-management' version '1.0.11.RELEASE'
id 'java'
}
group = 'com.example'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '1.8'
repositories {
mavenCentral()
}
dependencies {
implementation 'org.springframework.boot:spring-boot-starter-actuator'
implementation 'org.springframework.boot:spring-boot-starter-web'
implementation project(':library')
testImplementation 'org.springframework.boot:spring-boot-starter-test'
}
~~~
## 编写申请
应用程序中的主要类可以是 `@RestController` 使用 `Service`从库中渲染一条消息。 以下清单（来自 `application/src/main/java/com/example/multimodule/application/DemoApplication.java`）显示了这样的类：
~~~
package com.example.multimodule.application;
import com.example.multimodule.service.MyService;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@SpringBootApplication(scanBasePackages = "com.example.multimodule")
@RestController
public class DemoApplication {
private final MyService myService;
public DemoApplication(MyService myService) {
this.myService = myService;
}
@GetMapping("/")
public String home() {
return myService.message();
}
public static void main(String[] args) {
SpringApplication.run(DemoApplication.class, args);
}
}
~~~
`@SpringBootApplication` 是一个方便注释，它添加了以下所有内容：
* `@Configuration`：将类标记为应用程序上下文的Bean定义的源。
* `@EnableAutoConfiguration`：告诉Spring Boot根据类路径设置，其他bean和各种属性设置开始添加bean。 例如，如果 `spring-webmvc` 在类路径上，此注释将应用程序标记为Web应用程序并激活关键行为，例如设置 `DispatcherServlet`.
* `@ComponentScan`：告诉Spring在服务器中寻找其他组件，配置和服务 `com/example` 包，让它找到控制器。
这 `main()` 方法使用Spring Boot的 `SpringApplication.run()`启动应用程序的方法。 您是否注意到没有一行XML？ 没有 `web.xml`文件。 该Web应用程序是100％纯Java，因此您无需处理任何管道或基础结构。
因为 `DemoApplication` 在不同的包装内（ `com.example.multimodule.application`） 比 `MyService` ( `com.example.multimodule.service`), `@SpringBootApplication`无法自动检测到它。 有多种方法可以使MyService生效：
* 直接将其导入 `@Import(MyService.class)`.
* 使用以下命令从包中获取所有内容 `@SpringBootApplication(scanBasePackageClasses={…})`.
* 通过名称指定父包： `com.example.multimodule`。 （本指南使用此方法）
如果您的应用程序还使用JPA或Spring Data，则 @EntityScan 和 @EnableJpaRepositories （和相关）批注仅继承其基本包 @SpringBootApplication未明确指定时。 也就是说，一旦您指定 scanBasePackageClasses 或者 scanBasePackages，您可能还必须明确使用 @EntityScan 和 @EnableJpaRepositories 显式配置其程序包扫描。
## 创建 `application.properties` 文件
您需要在以下位置的库中提供有关该服务的消息 `application.properties`。 在源文件夹中，您需要创建一个名为 `src/main/resources/application.properties`。 以下清单显示了一个可以工作的文件：
~~~
service.message=Hello, World
~~~
## 测试应用
通过启动应用程序来测试端到端结果。 您可以在IDE中启动应用程序，也可以使用命令行。 应用程序运行后，请在浏览器中访问客户端应用程序，网址为： `[http://localhost:8080/](http://localhost:8080/)`。 在那里，你应该看到 `Hello, World` 反映在回应中。
如果您使用Gradle，则以下命令（实际上是依次执行两个命令）将首先构建库，然后运行应用程序：
~~~
$ ./gradlew build && ./gradlew :application:bootRun
~~~
如果使用Maven，则以下命令（实际上是依次执行两个命令）将首先构建库，然后运行应用程序：
~~~
$ ./mvnw install && ./mvnw spring-boot:run -pl application
~~~
## 概括
恭喜你！ 您已经使用Spring Boot创建了可重用的库，然后使用该库来构建应用程序。
- springboot概述
- springboot构建restful服务
- spring构建一个RESTful Web服务
- spring定时任务
- 消费RESTful Web服务
- gradle构建项目
- maven构建项目
- springboot使用jdbc
- springboot应用上传文件
- 使用LDNA验证用户
- 使用 spring data redis
- 使用 spring RabbitTemplate消息队列
- 用no4j访问nosql数据库
- springboot验证web表单
- Spring Boot Actuator构j建服务
- 使用jms传递消息
- springboot创建批处理服务
- spring security保护web 安全
- 在Pivotal GemFire中访问数据
- 使用Spring Integration
- 使用springboot jpa进行数据库操作
- 数据库事务操作
- 操作mongodb
- springmvc+tymleaf创建web应用
- 将Spring Boot JAR应用程序转换为WAR
- 创建异步服务
- spring提交表单
- 使用WebSocket构建交互式Web应用程序
- 使用REST访问Neo4j数据
- jquery消费restful
- springboot跨域请求
- 消费SOAP Web服务
- springboot使用缓存
- 使用Vaadin创建CRUD UI
- 使用REST访问JPA数据
- 使用REST访问Pivotal GemFire中的数据
- 构建soap服务
- 使用rest访问mongodb数据
- 构建springboot应用docker镜像
- 从STS部署到Cloud Foundry
- springboot测试web应用
- springboot访问mysql
- springboot编写自定义模块并使用
- 使用Google Cloud Pub / Sub进行消息传递
- 构建反应式RESTful Web服务
- 使用Redis主动访问数据
- Spring Boot 部署到Kubernetes
- 使用反应式协议R2DBC访问数据
- Spring Security架构
- spring构建Docker镜像详解
- Spring Boot和OAuth2
- springboot应用部署到k8s
- spring构建rest服务详解