springboot第3集：springboot中创建多个模块创建，关联，后续如何打包呢
springboot第3集：springboot中创建多个模块创建，关联，后续如何打包呢
在Spring Boot中，创建多个模块并关联它们的最佳实践是使用Maven或Gradle进行构建。以下是使用Maven先创建父pom.xml：
<groupId>com.example</groupId>
<artifactId>multi-module-project</artifactId>
<version>0.0.1</version>
<packaging>pom</packaging>
<modules>
<module>module-one</module>
<module>module-two</module>
</modules>下面是module-one的pom.xml文件示例：
<parent>
<groupId>com.example</groupId>
<artifactId>multi-module-project</artifactId>
<version>0.0.1</version>
</parent>
<artifactId>module-one</artifactId>
<version>0.0.1</version>在上述示例中，module-one将其父项目定义为com.example：multi-module-project。
在创建完您的多个模块并将它们关联起来之后，您可以使用以下Maven命令打包所有模块：
mvn clean package此命令将在每个模块中生成一个单独的JAR文件，您可以将其分发或部署到服务器上。如果您不希望在每个模块中生成单独的JAR文件，则可以在父pom.xml文件中更改打包类型：
<packaging>pom</packaging>这样，只会生成一个JAR文件，其中包含所有模块。
最后，您可以使用以下命令来安装依赖项并导出JAR文件：
mvn install此命令将安装所有依赖项，并将最终的JAR文件放在/target目录下。
在Spring Boot中使用多个Maven模块的最佳实践是使用一个父模块来管理它们。父模块是一个Maven项目，它包含多个子模块，并通过声明它们的依赖关系来管理它们。
Spring Boot多模块开发的主要优势是将大型应用程序拆分为相互依赖的小模块，从而简化代码库的管理和维护。然而，多模块的开发方式可能会带来一些挑战和错误，下面是一些Spring Boot多模块开发的排坑指南:
- 在父模块中定义通用依赖库
如果多个子模块需要使用同样的依赖库，可以将它们定义在父模块的pom.xml文件中。这样做可以避免重复性的工作，同时简化整个项目结构，提高代码库的易读性和可维护性。
- 避免不必要的依赖
在多模块开发中，有时会因为过多的依赖而导致误解和错误。因此，应该仔细规划项目结构，避免依赖交叉，并且应该只引入必要的库，而不是引入每个库。
- 确定模块之间的依赖关系
模块之间的依赖关系应该是有意义的。如果子模块之间的依赖关系过于复杂，将会导致代码难以维护，同时也会增加测试和代码重构的难度。因此，应该仔细规划模块之间的依赖关系，确保它们符合逻辑。
- 避免模块之间的冲突
当不同的子模块中包含同样的类或库时，可能会发生冲突。这时需要使用类加载器来避免冲突。如果使用Spring Boot的默认配置，多个Spring Boot模块将会共享同一个类加载器，这有可能导致冲突。为了避免这种情况，应该使用独立的类加载器，以避免子模块之间的冲突。
- 使用maven profiles来管理不同的环境
多模块Spring Boot应用程序通常在不同的环境中运行，如开发环境、测试环境和生产环境。为了管理不同的环境，可以使用maven profiles管理不同的配置文件。例如，在开发环境下，我们可能需要启用H2数据库，而在生产环境下，我们可能需要使用MySQL数据库。
总之，多模块开发可以显著简化代码库的管理和维护，从而提高应用程序的可读性和可维护性。然而，由于复杂性和错误的潜在风险，多模块开发需要更严格的规划和管理，以确保代码库的整洁和正确性。
- 使用Spring Boot插件统一管理多个子模块
使用Spring Boot插件可以使多个子模块统一管理，确保应用程序以相同的方式构建和部署。使用Spring Boot插件也可以轻松部署新子模块，而无需手动更新构建脚本。
- 配置文件和环境变量的使用
Spring Boot内置了多种配置文件幸而支持，如通过配置文件application.properties和application.yml等，还支持使用环境变量对应用程序进行配置。在多模块开发中，可以将这些配置信息放在父模块中，子模块可以继承这些配置信息。同时，子模块也可以在自己的配置文件中进行覆盖。
- 统一日志框架
在多模块开发中，子模块使用的可能不同的日志框架（如Log4j、Log4j2、slf4j、logback等），使用不同的日志框架可能导致日志记录混乱。因此，最好使用统一的日志框架进行日志记录。在Spring Boot中，使用Slf4j与Logback的组合可以进行统一的日志记录。
- 编写单元测试
在多模块的开发过程中，编写单元测试是非常重要的，可以对子模块的正常运行及时进行检测，发现和解决问题。开发者可以在每个子模块中进行单元测试编写。
- 模块命名规范
在多模块开发中子模块的命名应该遵守一定的规范和标准。通常，可以在模块名中包含两个部分，分别用“-”分隔。第一部分为业务功能相关的名称，第二部分为模块的类型，例如order-service, user-service等。
首先，Spring Boot多模块开发将应用程序分为多个松散耦合的模块，每个模块具有自己的特定功能和职责，可以分别实现测试、部署和版本控制。
下面是一个简单示例，展示如何用Gradle构建多模块Spring Boot应用程序，包括4个模块：
- api：包含REST API的接口和实现类。
- Service：包含业务逻辑和数据存储的实现类。
- Dao：持久化层接口。
- Model：实体类
- 创建 Gradle项目 使用 Gradle 初始化一个新的项目
- 创建模块 创建模块的方法有很多，可以手动创建，也可以使用 Gradle 或者 Maven 等构建工具来自动创建。
在 Intellij IDEA 中，右击项目名称，选择 New -> Module，创建各个模块。
- 配置 Gradle 编写 build.gradle 文件，添加所需的依赖项。
buildscript {
ext {
springBootVersion = '2.3.0.RELEASE'
}
repositories {
mavenCentral()
}
dependencies {
classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
}
}
// 引入所有的 jar 包
apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'
apply plugin: 'io.spring.dependency-management'
group = 'com.example'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '1.8'
repositories {
mavenCentral()
}
dependencies {
implementation 'org.springframework.boot:spring-boot-starter-web'
testImplementation('org.springframework.boot:spring-boot-starter-test') {
exclude group: 'org.junit.vintage', module: 'junit-vintage-engine'
}
}
bootJar {
archiveFileName = "app.jar"
}- Api模块配置
dependencies {
implementation project(":model")
implementation project(":service")
implementation 'org.springframework.boot:spring-boot-starter-web'
}- Service模块配置
dependencies {
implementation project(":model")
implementation project(":dao")
}- Dao模块配置
dependencies {
implementation project(":model")
}- Model模块配置
dependencies {
implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
implementation 'com.h2database:h2'
}至此，Spring Boot多模块的基本开发已经完成。
如何创建聚合父工程，如何编写子模块代码，如何运行项目，如何运维部署，如何启动项目呢？
- 创建聚合父工程
首先需要创建一个聚合父工程，用于管理多个子模块。聚合父工程的结构类似于下面这样：
my-project/
├── my-project-api
├── my-project-service
└── my-project-dao
└── my-project-web
├── pom.xml其中，my-project/目录为聚合父工程，my-project-api、my-project-service、my-project-dao、my-project-web为子模块。
在聚合父工程的pom.xml中，需要添加如下内容：
<modules>
<module>my-project-api</module>
<module>my-project-service</module>
<module>my-project-dao</module>
<module>my-project-web</module>
</modules>这样就创建了一个聚合父工程，并添加了4个子模块。
- 编写子模块代码
以my-project-api为例，其代码结构如下：
my-project-api/
├── src/
│ ├── main/
│ │ ├── java/
│ │ │ └── com/
│ │ │ └── example/
│ │ │ └── apimodule/
│ │ │ └── controller/
│ │ │ └── UserController.java
│ │ └── resources/
│ │ └── application.properties
│ └── test/
│ └── java/
│ └── com/
│ └── example/
│ └── apimodule/
│ └── controller/
│ └── UserControllerTest.java
└── pom.xml其中，UserController为API模块的控制层代码，application.properties为API模块的配置文件，UserControllerTest.java为API模块的测试代码。
- 运行项目
在聚合父工程中，可以使用mvn clean install命令打包并运行项目。
- 运维部署
多模块打包的操作，需要在聚合父工程的pom.xml中添加如下配置：
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-assembly-plugin</artifactId>
<version>3.3.0</version>
<configuration>
<descriptorRefs>
<descriptorRef>jar-with-dependencies</descriptorRef>
</descriptorRefs>
<archive>
<manifest>
<mainClass>com.example.Application</mainClass>
</manifest>
</archive>
<finalName>${project.artifactId}-${project.version}</finalName>
<appendAssemblyId>false</appendAssemblyId>
</configuration>
<executions>
<execution>
<id>make-assembly</id>
<phase>package</phase>
<goals>
<goal>single</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>这样，在项目根目录下执行mvn clean package命令时，会自动将所有子模块打包成一个可执行的jar包。
- 启动项目
在项目根目录下，使用命令java -jar my-project-web/target/my-project-web-1.0.0-SNAPSHOT.jar启动项目，其中my-project-web/target/my-project-web-1.0.0-SNAPSHOT.jar为打包后的可执行jar包路径。
将一个Spring Boot单模块项目改造成多模块项目的过程，大致可以分为以下几个步骤：
- 分析项目结构和依赖关系
首先，需要分析单模块项目中的代码和依赖关系，将其拆分成若干个模块。可以根据功能模块或层次模块进行拆分，每个模块需要有自己的职责和功能，并且它们之间需要松耦合，可以单独构建和部署。
- 创建聚合父项目
在单模块项目的根目录下创建一个聚合父项目，用于管理所有的子项目。可以使用Maven或Gradle构建工具来创建父项目，这里以Maven为例：
<project>
<groupId>com.example</groupId>
<artifactId>my-parent-project</artifactId>
<version>1.0.0-SNAPSHOT</version>
<packaging>pom</packaging>
...
</project>在聚合父项目的pom.xml文件中，需要声明所有的子项目，例如：
<modules>
<module>my-web-project</module>
<module>my-service-project</module>
<module>my-dao-project</module>
</modules>- 创建子项目
在聚合父项目下，使用Maven或Gradle创建所有的子项目。每个子项目有自己的独立目录和pom.xml文件，例如：
<project>
<parent>
<groupId>com.example</groupId>
<artifactId>my-parent-project</artifactId>
<version>1.0.0-SNAPSHOT</version>
<relativePath>../pom.xml</relativePath>
</parent>
<groupId>com.example</groupId>
<artifactId>my-web-project</artifactId>
<version>1.0.0-SNAPSHOT</version>
<packaging>jar</packaging>
...
</project>四个模块的示例结构如下：
my-parent-project/
├── my-web-project/
│ ├── src/main/java/com/example/web/...
│ ├── src/main/resources/...
│ ├── src/test/java/com/example/web/...
│ └── pom.xml
├── my-service-project/
│ ├── src/main/java/com/example/service/...
│ ├── src/main/resources/...
│ ├── src/test/java/com/example/service/...
│ └── pom.xml
├── my-dao-project/
│ ├── src/main/java/com/example/dao/...
│ ├── src/main/resources/...
│ ├── src/test/java/com/example/dao/...
│ └── pom.xml
└── pom.xml- 将代码和资源文件拆分到子项目
根据分析结果，将代码和资源文件拆分到相应的子项目中。例如，将控制器，服务，DAO接口和实现类等拆分到相应的模块中。
- 配置各个子项目的依赖关系
根据聚合父项目和子项目之间的依赖关系，打开各个子项目的pom.xml文件，并添加相应的依赖关系，例如：
<dependency>
<groupId>com.example</groupId>
<artifactId>my-service-project</artifactId>
<version>1.0.0-SNAPSHOT</version>
</dependency>- 运行和测试
在所有子项目的pom.xml文件中添加必要的插件（例如，Maven的spring-boot-maven-plugin），并使用构建工具编译、打包和运行子项目。可以使用聚合父项目来一次性编译、打包和运行所有子项目。
- 部署
在所有子项目成功运行和测试后，使用构建工具将各个子项目打成可执行的jar或war包或者直接部署在应用服务器上。
SpringBoot多模块开发是将整个项目按照功能模块划分为多个模块，每个模块可以独立开发，独立测试，独立部署，模块之间可以随时拼接成一个完整的应用。
下面是一个SpringBoot多模块开发的示例：
我们的项目中有两个功能模块，一个是用户模块，一个是订单模块，那么我们可以将项目划分为如下的两个子模块：
- user-module：该模块中包含用户的增删改查功能
- order-module：该模块中包含订单的增删改查功能
同时，我们还可以创建一个父模块，用来对子模块进行统一管理：
- parent-module：该模块是父模块，主要作用是管理所有子模块的依赖和配置
我们可以将项目的整体结构划分为如下所示的目录结构：
├── parent-module 父模块
├── user-module 用户管理模块
├── order-module 订单管理模块在父模块中，我们可以统一管理所有子模块的依赖和配置信息，子模块之间可以通过在父模块中引入彼此的依赖，来实现模块之间的交互。
同时，在子模块中，我们可以独立开发、独立测试、独立部署，这样可以提高我们的开发效率和项目的可维护性。
总之，采用SpringBoot多模块开发，可以有效地解耦各功能模块，提供更高效的协作和更方便的项目管理。