Maven多模块项目

不论是maven还是Gradle，参考优秀的开源项目和boot官网的最佳实践使用构建工具组织代码来构建自己的项目，比如nacos、springboot，ruoyi等等；要找到 Spring Boot 官网上关于 Maven 多模块项目的最佳实践，可以按照以下步骤进行：

打开 Spring Boot 官网（spring.io/projects/sp…

在导航菜单中选择 “Guides” -> “Building a Multi-module Project with Maven”。

该页面会展示一个针对 Maven 多模块项目的完整示例，其中包含了父模块和多个子模块的代码以及 pom.xml 文件。此外，该页面还提供了一些原则性建议和最佳实践，包括如何定义模块之间的依赖关系、如何配置插件和资源等。

可以通过下载示例代码并结合官方文档来深入学习 Maven 多模块项目的实现方式和技巧，并根据实际需求进行相应的调整和扩展。总之，在 Spring Boot 官网中寻找 Maven 多模块项目的最佳实践时，需要注意查看官方文档和示例代码，并结合实际项目需求进行理解和应用。同时，还需要遵循 Maven 的相关约定和规范，以确保项目的可靠性和稳定性。

Maven多模块项目,适用于一些比较大的项目，通过合理的模块拆分，实现代码的复用，便于维护和管理。尤其是一些开源框架，也是采用多模块的方式，提供插件集成，用户可以根据需要配置指定的模块。微服务项目是以多模块的方式开发，分包部署； springboot多模块项目使用maven打包部署时需要从子模块到父模块依次进行打包，并且每个pom.xml文件的配置都要正确

Maven多模块项目适用于大型的、复杂的，需要分层设计和模块化开发的项目。以下是适合采用Maven多模块项目的一些场景：

Web应用程序或服务端应用程序，特别是对于由多个子系统或模块组成的复杂应用程序。
基于微服务架构进行开发，其中每个服务都是一个独立的模块。
企业级应用程序，需要包含多个不同的子系统或模块，并且这些模块需要共享相同的依赖项和配置信息。
大规模数据处理或分析系统，例如Hadoop等。
应用商店或插件式系统，其中每个应用程序或插件都可以作为一个单独的模块。

总之，如果要开发大型、复杂的应用程序，使用Maven多模块项目可以提高代码的可读性、可维护性和可扩展性，同时还可以更好地利用现有的开源库和工具来加速开发过程。

拆分规则：

对于多模块Maven工程，其拆分规则应根据具体情况和项目需求来确定。以下是一些常用的拆分规则：

按业务模块划分： 将一个大型系统按照不同的业务模块进行划分，每个模块可以独立开发、测试、部署和维护。比如，对于一个电商系统，可以将商品管理、订单管理、用户管理等业务模块单独拆分成不同的子模块。
按功能模块划分： 将一个系统按照不同的功能模块进行划分，每个模块负责完成一个特定的功能，比如认证、授权、缓存、搜索等。
按技术组件划分： 将一个系统按照不同的技术组件进行划分，每个模块可以包含一个或多个技术组件，比如数据库连接、消息队列、缓存框架等。
按层次划分： 将一个系统按照不同的层次进行划分，每个模块可以包含一个或多个层次，比如数据访问层、服务层、控制层等。
混合划分： 可以将上述的任意两种或多种方式结合起来使用，以达到更好的代码复用、可维护性和可扩展性。

无论采用何种拆分规则，都需要注意以下几点：

拆分后的子模块应该具有独立的功能和职责，能够单独进行测试、构建和部署。
子模块之间应该避免出现循环依赖，否则会导致构建失败和部署异常。
子模块之间的接口应该设计良好，遵守面向接口编程的原则，以提高代码的复用性和灵活性。

按业务模块拆分按层拆分

Maven如何开发springboot多模块项目

使用 IntelliJ IDEA 开发 Spring Boot 多模块项目并使用 Maven 进行构建，一般需要遵循以下步骤：

创建父模块：在 IDEA 中创建一个 Maven 项目，并在根目录下创建一个父模块。可以通过 “File” -> “New” -> “Module” -> “Maven” 来创建新的 Maven 模块，然后选择 “Empty Project” 选项即可创建空的 Maven 项目结构。在 pom.xml 文件中定义所有子模块的名称。
创建子模块：在父模块下创建多个子模块，每个子模块对应一个功能或组件。可以通过 “File” -> “New” -> “Module” -> “Maven” 来创建新的 Maven 模块，并选择 “Java” 或者 “Spring Boot” 选项来创建对应类型的子模块。每个子模块都有自己的构建脚本（如 pom.xml 文件）和源代码目录（如 src/main/java 和 src/test/java 目录）。
配置依赖关系：为了让子模块能够相互调用和共享代码，需要在父模块中配置依赖关系。可以通过右键单击父模块，选择 “Open Module Settings” -> “Dependencies”，然后添加子模块之间的依赖关系。也可以通过 dependencies 标签来定义子模块之间的依赖关系，具体可以参考 Spring Boot 官方文档。
配置构建任务：在每个子模块的构建脚本中，需要添加适当的任务和插件，以便对应的子模块能够正确编译、测试和打包。可以通过右键单击父模块或子模块，选择 “Open Module Settings” -> “Build, Execution, Deploy” -> “Maven”，然后添加对应的任务和插件，也可以直接编辑 pom.xml 文件进行配置。
运行测试和打包：在完成各个子模块的开发和配置后，可以使用 Maven 命令来运行测试和打包应用程序。在 IDEA 中，可以通过右键单击父模块或子模块，选择 “Run” 或者 “Debug”，然后选择相应的 Maven 任务即可。

总之，在使用 IntelliJ IDEA 开发 Spring Boot 多模块项目时，需要注意 Maven 的相关配置和使用方式，以及 IDEA 对 Maven 的集成和支持。同时，还需要熟悉 Spring Boot 和 Maven 的相关文档和最佳实践，并根据实际项目需求进行合理配置和扩展。

Maven开发springboot多模块项目，使用IDEA配置依赖关系的开发步骤

在使用 IntelliJ IDEA 开发 Spring Boot 多模块项目时，可以通过以下步骤来配置子模块之间的依赖关系：

打开 IDEA 中的 Maven 项目，进入父模块的 pom.xml 文件。

在 pom.xml 文件中添加要依赖的子模块。例如，如果要在父模块中依赖子模块 A 和 B，则需要在 dependencies 标签中添加以下代码：

<dependencies>
   <dependency>
      <groupId>com.example</groupId>
      <artifactId>module-a</artifactId>
      <version>1.0-SNAPSHOT</version>
   </dependency>
   <dependency>
      <groupId>com.example</groupId>
      <artifactId>module-b</artifactId>
      <version>1.0-SNAPSHOT</version>
   </dependency>
</dependencies>

在每个子模块中，需要将该子模块声明为一个 Maven 模块。为此，在子模块的 pom.xml 文件中添加以下代码：

<groupId>com.example</groupId>
<artifactId>module-a</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>
<name>module-a</name>
<description>Module A</description>

如果依赖的子模块还依赖其他的库，也需要在其 pom.xml 文件中添加对应的依赖项。例如：

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

在 IDEA 中，使用 Maven Tool Window 来刷新依赖关系。依赖更新后，可以通过右键单击子模块或父模块并选择 “Reimport” 命令来更新项目中的依赖。

为了让子模块能够相互调用和共享代码，需要在父模块中配置依赖关系

在 Maven 或 Gradle 中，多模块项目中的子模块通常是相互独立的，如果需要在一个子模块中调用另一个子模块中的类或方法，则需要在父模块中配置依赖关系。

具体来说，在父模块的 pom.xml 或 build.gradle 文件中，可以使用对应的语法来声明子模块之间的依赖关系。例如，Maven 的 pom.xml 文件中可以添加以下代码：

<dependencies>
   <dependency>
      <groupId>com.example</groupId>
      <artifactId>module-a</artifactId>
      <version>1.0-SNAPSHOT</version>
   </dependency>
   <dependency>
      <groupId>com.example</groupId>
      <artifactId>module-b</artifactId>
      <version>1.0-SNAPSHOT</version>
   </dependency>
</dependencies>

这样，在其他子模块的 pom.xml 或 build.gradle 文件中，就可以使用 import 或 include 语句来引用所需的类或库，而不需要在每个子模块中重复编写同样的代码。

通过在父模块中配置依赖关系，可以有效地实现代码的共享和重用，减少代码冗余和维护成本，同时也方便了项目的管理和部署。但需要注意的是，在配置依赖关系时，需要遵循一定的约定和规范，以保证依赖的正确性和可靠性，避免出现不必要的错误和问题。

在 Maven 或 Gradle 中，当父模块中配置了子模块之间的依赖关系后，在构建项目时并不会直接将依赖关系打包进去。相反，每个子模块都会单独生成一个 jar 或者 war 包，并将其发布到本地 Maven 仓库或者远程仓库中。

当另一个模块需要使用某个依赖项时，Maven 或者 Gradle 会从仓库中下载对应的依赖项，然后在编译和打包时引用这些依赖。这种方式可以避免重复打包和部署相同的依赖项，同时也方便了版本控制和依赖管理。

需要注意的是，如果在子模块中有多个版本的同一依赖项，则可能会出现依赖冲突的问题，需要通过合理配置依赖关系来解决。同时，还需要定期清理本地 Maven 或 Gradle 缓存，以确保依赖项的正确性和稳定性。

创建Maven多模块项目

第一步：创建Maven父工程（POM）

创建一个MAVEN项目，生成一个空的 pom.xml 文件，不包含任何代码或资源文件，仅作为父工程或聚合工程的管理文件。只留下一个POM文件，pom文件包含以下内容 父POM构成：声明

打包方式（POM）、

子模块（modules）、

统一声明版本号（properties）、

统一声明依赖（DepencyManagement）、

项目管理插件maven-plugins

远程仓库

多模块Maven工程的父工程主要包含以下内容：

项目的基本信息：如 groupId、artifactId、version 等。
项目依赖管理：通过 <dependencyManagement> 元素来管理子模块中的依赖项。这样，子模块只需要声明依赖项的 groupId 和 artifactId，版本号可以从父模块中继承。
插件管理：通过<pluginManagement>元素来管理子模块中的插件。这样，子模块只需要使用插件的 groupId 和 artifactId，版本号和配置信息可以从父模块中继承。
公共配置信息：例如编译器版本、源代码目录、资源目录等信息。这些配置信息可以在父模块中统一配置，以便子模块直接继承并使用。
公共构建逻辑：例如测试命令、打包命令、部署命令等。这些构建逻辑可以在父模块中统一配置，以便子模块直接继承并使用。
公共插件：例如 Maven Surefire 插件、Maven Compiler 插件等。这些插件可以在父模块中配置，并且在子模块中自动继承和使用。
其他公共资源：例如公共 jar 包、公共配置文件等。这些资源可以在父模块中统一管理和分发，以便子模块直接继承并使用。

总之，父工程主要包含了所有子模块所需要的公共配置信息、构建逻辑和插件等内容，以提高整个项目的代码复用性和可维护性。

打包方式

<packaging>pom</packaging>pom的打包方式：生成一个空的 pom.xml 文件，不包含任何代码或资源文件，仅作为父工程或聚合工程的管理文件。 一般来说所有的父级项目的packaging都为pom，packaging默认类型jar类型，如果不做配置，maven会将该项目打成jar包。

在Maven中，POM是指项目对象模型（Project Object Model），它是用来描述 Maven 项目的 XML 文件。POM 文件包含了一个 Maven 项目所需的所有信息，例如项目基本信息、依赖项、插件、构建选项、配置信息等。可以将 POM 文件看作是 Maven 项目的配置文件，用于管理和构建整个项目。 具体来说，POM 文件包括以下内容：

项目基本信息：groupId、artifactId、version 等。

依赖项：包括需要引入的 jar 包或其他 Maven 项目。

插件：用于扩展 Maven 的功能，例如编译器插件、测试插件等。

构建选项：定义如何构建项目，包括编译源代码、打包结果输出目录等。

配置信息：定义一些基本的配置信息，例如编码格式、资源目录、插件版本等。通过 POM 文件，可以方便地管理和构建 Maven 项目，并且可以实现多模块项目的统一管理。在多模块项目中，子项目可以继承父项目的 POM 文件，从而共享父项目中定义的依赖项、插件、构建选项等信息，避免重复的配置工作。

为了指定打包方式，需要在 POM 文件中添加如下元素：

<project>
  <groupId>com.example</groupId>
  <artifactId>my-project</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>jar</packaging> <!-- 指定打包方式为 jar -->
  ...
</project>

在<packaging>元素中指定要使用的打包方式即可。对于不同的打包方式，Maven 会自动调用相应的插件进行构建、打包和发布。

Maven项目的打包方式主要有以下几种： 常用的几种是：pom、jar、war、tar.gz

jar： 将项目打包成一个可执行的 jar 包，其中包含了所有的代码和依赖项。可以使用如下 Maven 命令进行打包： mvn clean package 打包结果会保存在 target 目录中，通常是一个以 artifactId 和 version 命名的 jar 文件。

war： 将项目打包成一个 Web 应用程序，适用于 Java Web 项目。与 jar 类似，war 包也包含了所有的代码和依赖项，并且还包括了 Web 应用程序所需的配置文件、Web 资源等。可以使用如下 Maven 命令进行打包：(用于web项目) mvn clean package 打包结果会保存在 target 目录中，通常是一个以 artifactId 和 version 命名的 war 文件。

pom： 生成一个空的 pom.xml 文件，不包含任何代码或资源文件，仅作为父工程或聚合工程的管理文件。可以使用如下 Maven 命令进行打包： mvn clean package 打包结果会保存在 target 目录中，通常是一个以 artifactId 和 version 命名的 pom 文件。

ear： 将多个 jar 或 war 包打包成一个企业级应用程序（EAR）文件，包含了所有的代码和依赖项，并且可以包含 EJB 模块、Web 模块等。可以使用如下 Maven 命令进行打包： mvn clean package 打包结果会保存在 target 目录中，通常是一个以 artifactId 和 version 命名的 ear 文件。

tar.gz： 将项目打包成一个 gzip 格式的压缩文件，适用于需要将整个项目发送给他人或备份项目的场景。可以使用如下 Maven 命令进行打包： mvn clean package assembly:single 打包结果会保存在 target 目录中，通常是一个以 artifactId 和 version 命名的 tar.gz 文件。

以上是 Maven 项目的主要打包方式，开发者可以根据实际需求选择合适的打包方式。同时，Maven 还支持其他的打包方式，例如 zip、rpm、deb 等。

子模块（modules）

在父工程下通过new --> module 创建子模块项目，会发现父工程的pom.xml中自动出现如下信息：

<modules>
        <module>chrf-admin</module>
        <module>chrf-framework</module>
        <module>chrf-system</module>
        <module>chrf-quartz</module>
        <module>chrf-generator</module>
        <module>chrf-common</module>
        <module>chrf-bussiness</module>
		<!--  <module>chrf-process</module>-->
    </modules>

统一声明版本号（properties）

作用：自定义标签统一声明版本号 在需要统一版本的位置,使用 ${自定义标签名} 引用声明的版本号。另外，自定义标签声明数据的配置并不是只能用于声明依赖的版本号,凡是需要统一声明后再引用的场合都可以使用,例如:统一配置项目构建的源码的字符集格式。

<properties>
        <chrf.version>3.8.0</chrf.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <maven-jar-plugin.version>3.1.1</maven-jar-plugin.version>
        <druid.version>1.2.8</druid.version>
        <bitwalker.version>1.21</bitwalker.version>
        <swagger.version>3.0.0</swagger.version>
        <kaptcha.version>2.3.2</kaptcha.version>
        <mybatis-spring-boot.version>2.2.0</mybatis-spring-boot.version>
        <pagehelper.boot.version>1.4.0</pagehelper.boot.version>
        <fastjson.version>1.2.79</fastjson.version>
        <oshi.version>5.8.6</oshi.version>
        <jna.version>5.10.0</jna.version>
        <commons.io.version>2.11.0</commons.io.version>
        <commons.fileupload.version>1.4</commons.fileupload.version>
        <commons.collections.version>3.2.2</commons.collections.version>
        <poi.version>4.1.2</poi.version>
        <velocity.version>2.3</velocity.version>
        <jwt.version>0.9.1</jwt.version>
        <redission.version>3.5.5</redission.version>
        <lombok.version>1.18.0</lombok.version>
        <hutool.version>5.7.12</hutool.version>
        <gson.version>2.8.9</gson.version>
    </properties>

统一声明依赖（DepencyManagement）

dependencyManagement的其实相当于一个对所依赖jar包进行版本管理的管理器。

作用：统一管理项目的版本号，确保应用的各个项目的依赖和版本一致，因此，在顶层pom（父类）中定义共同的依赖关系。同时可以避免在每个使用的子项目中都声明一个版本号，这样想升级或者切换到另一个版本时，只需要在父类容器里更新，不需要任何一个子项目的修改；如果某个子项目需要另外一个版本号时，只需要在dependencies中声明一个版本号即可。子类就会使用子类声明的版本号，不继承于父类版本号。

<properties>
    <jersey.version>2.27</jersey.version>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.glassfish.jersey</groupId>
            <artifactId>jersey-bom</artifactId>
            <version>${jersey.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

dependencyManagement和dependencies区别 dependencies即使在子项目中不写该依赖项，那么子项目仍然会从父项目中继承该依赖项（全部继承）。 dependencyManagement里只是声明依赖，并不实现引入，因此子项目需要显示的声明需要用的依赖。如果不在子项目中声明依赖，是不会从父项目中继承下来的；只有在子项目中写了该依赖项，并且没有指定具体版本，才会从父项目中继承该项，并且version和scope都读取自父pom;另外如果子项目中指定了版本号，那么会使用子项目中指定的jar版本。

项目管理插件maven-plugins

blog.csdn.net/u013412066/… Spring Boot的Maven插件（Spring Boot Maven plugin）能够以Maven的方式为应用提供Spring Boot的支持，即为Spring Boot应用提供了执行Maven操作的可能。 Spring Boot Maven plugin能够将Spring Boot应用打包为可执行的jar或war文件，然后以通常的方式运行Spring Boot应用。 Spring Boot Maven plugin的最新版本为2017.6.8发布的1.5.4.RELEASE，要求Java 8, Maven 3.2及以后。

<build>
		<plugins>
			<!--可执行的JAR/WAR -->
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
				<configuration>
					<executable>true</executable>
				</configuration>
			</plugin>
		</plugins>
	</build>

MAVEN编译插件

source: 源代码编译JDK版本
target:目标平台编译版本
encoding:字符集编码

 <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.1</version>
                <configuration>
                    <source>${java.version}</source>
                    <target>${java.version}</target>
                    <encoding>${project.build.sourceEncoding}</encoding>
                </configuration>
            </plugin>
        </plugins>
    </build>

子模块

聚合工程：需要什么依赖需要引入，在父工程统一管理版本号，父工程以POM方式打包，子模块不写默认打jar包这部分的配置信息是父工程聚合子模块的信息而子模块的pom.xml内容如下：

<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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <parent>
    <groupId>cn.itcast.erp</groupId>
    <artifactId>erp_parent</artifactId>
    <version>0.0.1-SNAPSHOT</version>
  </parent>
  <artifactId>erp_domain</artifactId>
</project>

配置父子关系在每个子模块的 pom.xml 文件中添加父模块的信息，例如：

<parent>
  <groupId>com.example</groupId>
  <artifactId>my-project</artifactId>
  <version>1.0-SNAPSHOT</version>
</parent>

完整父POM：

<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>

    <groupId>com.sf</groupId>
    <artifactId>chrf</artifactId>
    <version>3.8.0</version>

    <name>chrf</name>
    <url>http://www.chrf.vip</url>
    <description>管理系统</description>

    <properties>
        <chrf.version>3.8.0</chrf.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <maven-jar-plugin.version>3.1.1</maven-jar-plugin.version>
        <druid.version>1.2.8</druid.version>
        <bitwalker.version>1.21</bitwalker.version>
        <swagger.version>3.0.0</swagger.version>
        <kaptcha.version>2.3.2</kaptcha.version>
        <mybatis-spring-boot.version>2.2.0</mybatis-spring-boot.version>
        <pagehelper.boot.version>1.4.0</pagehelper.boot.version>
        <fastjson.version>1.2.79</fastjson.version>
        <oshi.version>5.8.6</oshi.version>
        <jna.version>5.10.0</jna.version>
        <commons.io.version>2.11.0</commons.io.version>
        <commons.fileupload.version>1.4</commons.fileupload.version>
        <commons.collections.version>3.2.2</commons.collections.version>
        <poi.version>4.1.2</poi.version>
        <velocity.version>2.3</velocity.version>
        <jwt.version>0.9.1</jwt.version>
        <redission.version>3.5.5</redission.version>
        <lombok.version>1.18.0</lombok.version>
        <hutool.version>5.7.12</hutool.version>
        <gson.version>2.8.9</gson.version>
    </properties>

    <!-- 依赖声明 -->
    <dependencyManagement>
        <dependencies>

            <!-- SpringBoot的依赖配置-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>2.5.8</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>

            <!-- 阿里数据库连接池 -->
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid-spring-boot-starter</artifactId>
                <version>${druid.version}</version>
            </dependency>

            <!-- 解析客户端操作系统、浏览器等 -->
            <dependency>
                <groupId>eu.bitwalker</groupId>
                <artifactId>UserAgentUtils</artifactId>
                <version>${bitwalker.version}</version>
            </dependency>

            <!-- SpringBoot集成mybatis框架 -->
            <dependency>
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter</artifactId>
                <version>${mybatis-spring-boot.version}</version>
            </dependency>

            <!-- pagehelper 分页插件 -->
            <dependency>
                <groupId>com.github.pagehelper</groupId>
                <artifactId>pagehelper-spring-boot-starter</artifactId>
                <version>${pagehelper.boot.version}</version>
            </dependency>

            <!-- 获取系统信息 -->
            <dependency>
                <groupId>com.github.oshi</groupId>
                <artifactId>oshi-core</artifactId>
                <version>${oshi.version}</version>
            </dependency>

            <dependency>
                <groupId>org.redisson</groupId>
                <artifactId>redisson</artifactId>
                <version>${redission.version}</version>
            </dependency>

            <dependency>
                <groupId>net.java.dev.jna</groupId>
                <artifactId>jna</artifactId>
                <version>${jna.version}</version>
            </dependency>

            <dependency>
                <groupId>net.java.dev.jna</groupId>
                <artifactId>jna-platform</artifactId>
                <version>${jna.version}</version>
            </dependency>

            <!-- Swagger3依赖 -->
            <dependency>
                <groupId>io.springfox</groupId>
                <artifactId>springfox-boot-starter</artifactId>
                <version>${swagger.version}</version>
                <exclusions>
                    <exclusion>
                        <groupId>io.swagger</groupId>
                        <artifactId>swagger-models</artifactId>
                    </exclusion>
                </exclusions>
            </dependency>

            <!-- io常用工具类 -->
            <dependency>
                <groupId>commons-io</groupId>
                <artifactId>commons-io</artifactId>
                <version>${commons.io.version}</version>
            </dependency>

            <!-- 文件上传工具类 -->
            <dependency>
                <groupId>commons-fileupload</groupId>
                <artifactId>commons-fileupload</artifactId>
                <version>${commons.fileupload.version}</version>
            </dependency>

            <!-- excel工具 -->
            <dependency>
                <groupId>org.apache.poi</groupId>
                <artifactId>poi-ooxml</artifactId>
                <version>${poi.version}</version>
            </dependency>

            <!-- velocity代码生成使用模板 -->
            <dependency>
                <groupId>org.apache.velocity</groupId>
                <artifactId>velocity-engine-core</artifactId>
                <version>${velocity.version}</version>
            </dependency>

            <!-- collections工具类 -->
            <dependency>
                <groupId>commons-collections</groupId>
                <artifactId>commons-collections</artifactId>
                <version>${commons.collections.version}</version>
            </dependency>

            <!-- 阿里JSON解析器 -->
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>fastjson</artifactId>
                <version>${fastjson.version}</version>
            </dependency>

            <!-- Token生成与解析-->
            <dependency>
                <groupId>io.jsonwebtoken</groupId>
                <artifactId>jjwt</artifactId>
                <version>${jwt.version}</version>
            </dependency>

            <!-- 验证码 -->
            <dependency>
                <groupId>com.github.penggle</groupId>
                <artifactId>kaptcha</artifactId>
                <version>${kaptcha.version}</version>
            </dependency>

            <!-- 定时任务-->
            <dependency>
                <groupId>com.sf</groupId>
                <artifactId>chrf-quartz</artifactId>
                <version>${chrf.version}</version>
            </dependency>

            <!-- 代码生成-->
            <dependency>
                <groupId>com.sf</groupId>
                <artifactId>chrf-generator</artifactId>
                <version>${chrf.version}</version>
            </dependency>

            <!-- 核心模块-->
            <dependency>
                <groupId>com.sf</groupId>
                <artifactId>chrf-framework</artifactId>
                <version>${chrf.version}</version>
            </dependency>

            <!-- 系统模块-->
            <dependency>
                <groupId>com.sf</groupId>
                <artifactId>chrf-system</artifactId>
                <version>${chrf.version}</version>
            </dependency>

            <!-- 通用工具-->
            <dependency>
                <groupId>com.sf</groupId>
                <artifactId>chrf-common</artifactId>
                <version>${chrf.version}</version>
            </dependency>

            <!-- 业务模块-->
            <dependency>
                <groupId>com.sf</groupId>
                <artifactId>chrf-bussiness</artifactId>
                <version>${chrf.version}</version>
            </dependency>

            <!--第三方工具类-->
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>${lombok.version}</version>
            </dependency>

            <dependency>
                <groupId>cn.hutool</groupId>
                <artifactId>hutool-all</artifactId>
                <version>${hutool.version}</version>
            </dependency>
            <!-- gson -->
            <dependency>
                <groupId>com.google.code.gson</groupId>
                <artifactId>gson</artifactId>
                <version>${gson.version}</version>
            </dependency>

        </dependencies>
    </dependencyManagement>

    <modules>
        <module>chrf-admin</module>
        <module>chrf-framework</module>
        <module>chrf-system</module>
        <module>chrf-quartz</module>
        <module>chrf-generator</module>
        <module>chrf-common</module>
        <module>chrf-bussiness</module>
		<!--  <module>chrf-process</module>-->
    </modules>
    <packaging>pom</packaging>


    <dependencies>

    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.1</version>
                <configuration>
                    <source>${java.version}</source>
                    <target>${java.version}</target>
                    <encoding>${project.build.sourceEncoding}</encoding>
                </configuration>
            </plugin>
        </plugins>
    </build>

    <repositories>
        <repository>
            <id>public</id>
            <name>aliyun nexus</name>
            <url>https://maven.aliyun.com/repository/public</url>
            <releases>
                <enabled>true</enabled>
            </releases>
        </repository>
    </repositories>

    <pluginRepositories>
        <pluginRepository>
            <id>public</id>
            <name>aliyun nexus</name>
            <url>https://maven.aliyun.com/repository/public</url>
            <releases>
                <enabled>true</enabled>
            </releases>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </pluginRepository>
    </pluginRepositories>

</project>

Maven多模块项目哪些需要构建jar，哪些不需要构建jar

在Maven多模块项目中，通常只需要为子模块打包成 jar 文件，父模块不需要打包成 jar 文件。

子模块是实际的代码模块，需要被编译、打包和部署，因此需要将其打包成 jar 文件。而父模块仅仅是用来管理子模块的，本身并不包含任何可执行代码，所以不需要打包成 jar 文件。

具体来说，如果一个子模块需要作为一个库被其他模块引用，那么就需要将其打包成 jar 文件，并将其发布到 Maven 中央仓库或私有仓库中。这样其他模块就可以通过 Maven 依赖机制来使用该库。

另外，在多模块项目中，通常还会有聚合模块和父模块。聚合模块用于将多个子模块组织在一起，方便进行统一的构建和测试；而父模块用于管理所有子模块的依赖关系、插件配置等信息。这两个模块都不需要打包成 jar 文件，它们只是用于组织并管理子模块的结构和配置信息。

总之，对于一个多模块项目，只有子模块需要打包成 jar 文件并发布到 Maven 仓库中，而聚合模块和父模块则不需要打包成 jar 文件。

Maven多模块项目的构建：

Maven多模块项目的构建一般分为以下几个步骤：

创建父模块：首先创建一个 Maven 项目，作为父模块。在父模块的 POM 文件中，通过元素来列出所有子模块的目录或相对路径。

创建子模块：在父模块的目录下创建子模块。每个子模块都有自己的 POM 文件，用于指定子模块的依赖关系、打包方式、构建选项等信息。

配置父模块：在父模块的 POM 文件中，通过元素来管理子模块的依赖项。这样，子模块只需要声明依赖项的 groupId 和 artifactId，版本号可以从父模块中继承。
构建子模块：针对每个子模块，使用 mvn clean package 命令进行构建。该命令会自动编译代码、执行测试用例、打包成 jar 或 war 文件，并将结果放在 target 目录下。
安装到本地仓库：在每个子模块的目录下，使用 mvn install 命令将子模块安装到本地 Maven 仓库中。
构建父模块：在父模块的目录下，使用 mvn clean package 命令构建父模块。该命令会自动编译代码、执行测试用例、打包成 jar 文件，并将结果放在 target 目录下。
部署到远程仓库：如果需要，可以使用 mvn deploy 命令将父模块和所有子模块部署到远程 Maven 仓库中。这样其他开发者就可以通过 Maven 依赖机制来使用该多模块项目。

总之，Maven多模块项目的构建遵循了一定的规范和流程，包括创建父模块、创建子模块、配置父模块、构建子模块、安装到本地仓库、构建父模块和部署到远程仓库等步骤。通过这些步骤，可以实现对多模块项目的统一管理和构建。

聚合功能来一键打包所有的子模块

在Maven多模块项目中，可以使用 Maven 的聚合功能来一键打包所有的子模块。聚合功能允许我们在父模块上执行命令，然后自动构建所有的子模块，并将结果汇总到父模块中。

要一键打包所有的子模块，需要在父模块的 POM 文件中添加如下代码：

<project>
  ...
  <packaging>pom</packaging> <!-- 父模块的打包方式为 pom -->
  <modules>
    <module>child-module-1</module>
    <module>child-module-2</module>
    <module>child-module-3</module>
    ...
  </modules>
  ...
</project>

其中 <modules> 元素列出了所有的子模块。如果有新的子模块加入，只需要在该元素中添加相应的 <module> 元素即可。

接下来，在父模块的目录下，使用以下命令进行构建： mvn clean package 该命令会依次遍历所有的子模块，并递归地执行 clean 和 package 目标。最终，所有子模块的打包结果会被复制到父模块的 target 目录中，并生成一个汇总的 jar 文件。该 jar 文件包含了所有子模块的打包结果和配置信息。

通过这种方式，我们可以方便地一键打包所有的子模块，避免手动逐个构建子模块的麻烦。

Maven多模块项目如何一键打包所有的子模块,对子模块的顺序的要求：

在Maven多模块项目中，要一键打包所有子模块并且保证子模块的顺序是正确的，可以使用 Maven 的聚合功能结合插件来实现。

具体地，在父模块的 POM 文件中，配置元素列出所有的子模块，并且使用元素中的 plugins 子元素来配置 Maven 插件。不同的插件有不同的聚合目标，比如 maven-dependency-plugin 插件的 copy-dependencies 目标用于将依赖项复制到指定目录。

下面是一个示例：假设一个多模块项目由三个子模块 A、B 和 C 组成，并且它们的编译顺序应该是 A -> B -> C：

点击查看代码

<project>
  ...
  <packaging>pom</packaging> <!-- 父模块的打包方式为 pom -->
  <modules>
    <module>A</module>
    <module>B</module>
    <module>C</module>
  </modules>
  ...
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.8.1</version>
        <executions>
          <execution>
            <id>compile-A</id>
            <phase>compile</phase>
            <goals>
              <goal>compile</goal>
            </goals>
            <configuration>
              <basedir>${project.basedir}/A</basedir>
            </configuration>
          </execution>
          <execution>
            <id>compile-B</id>
            <phase>compile</phase>
            <goals>
              <goal>compile</goal>
            </goals>
            <configuration>
              <basedir>${project.basedir}/B</basedir>
            </configuration>
            <dependsOn>compile-A</dependsOn>
          </execution>
          <execution>
            <id>compile-C</id>
            <phase>compile</phase>
            <goals>
              <goal>compile</goal>
            </goals>
            <configuration>
              <basedir>${project.basedir}/C</basedir>
            </configuration>
            <dependsOn>compile-B</dependsOn>
          </execution>
        </executions>
      </plugin>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-dependency-plugin</artifactId>
        <version>3.1.2</version>
        <executions>
          <execution>
            <id>copy-dependencies-A</id>
            <phase>package</phase>
            <goals>
              <goal>copy-dependencies</goal>
            </goals>
            <configuration>
              <outputDirectory>${project.build.directory}/A/lib</outputDirectory>
              <includeScope>runtime</includeScope>
            </configuration>
          </execution>
          <execution>
            <id>copy-dependencies-B</id>
            <phase>package</phase>
            <goals>
              <goal>copy-dependencies</goal>
            </goals>
            <configuration>
              <outputDirectory>${project.build.directory}/B/lib</outputDirectory>
              <includeScope>runtime</includeScope>
            </configuration>
          </execution>
          <execution>
            <id>copy-dependencies-C</id>
            <phase>package</phase>
            <goals>
              <goal>copy-dependencies</goal>
            </goals>
            <configuration>
              <outputDirectory>${project.build.directory}/C/lib</outputDirectory>
              <includeScope>runtime</includeScope>
            </configuration>
          </execution>
        </executions>
      </plugin>
    </plugins>
  </build>
</project>

在上述示例中，我们使用了 maven-compiler-plugin 插件和 maven-dependency-plugin 插件。maven-compiler-plugin 插件用于编译子模块的源代码，并且通过 dependsOn 元素来声明依赖关系；maven-dependency-plugin 插件用于将子模块的依赖项复制到指定目录中。

通过这种方式，我们可以保证按照正确的顺序依次编译子模块，并且完成所有的构建、测试。

多模块项目部署：

多模块Maven工程不同模块的jar包如何部署到多台机器中

jar包方式： 对于多模块Maven工程中的不同模块需要部署到多台机器的情况，如果只是需要将 jar 包部署到多台机器上，可以采用以下步骤：

在每台机器上安装相应的运行环境和依赖（如 JDK、数据库等），确保这些机器可以互相访问。

对于每个模块，打包生成 jar 包，并在项目根目录下执行 Maven 命令：mvn clean package。在 target 目录中可以找到生成的 jar 包。

将每个模块的 jar 包复制到需要部署的机器上，可以通过 scp 命令实现跨机器拷贝文件： scp your-module-name/target/your-module-name.jar user@server:/path/to/jar/

其中，your-module-name 表示模块名称，user@server 表示远程服务器的用户名和 IP 地址，/path/to/jar/ 表示 jar 包所在路径。

在每台机器上启动应用程序，可以使用 Java 命令来执行 jar 包，例如： java -jar your-module-name.jar 如果需要更高级的部署方案，例如负载均衡、高可用等，可以使用 Docker、Kubernetes 等工具来实现。

war包方式： 针对多模块Maven工程的不同模块需要部署到多台机器的情况，可以使用分布式部署的方式来实现。具体步骤如下：

确定不同模块需要部署到哪些机器上，并在每台机器上安装相应的运行环境和依赖（如 JDK、Tomcat、数据库等），确保这些机器可以互相访问。

对于每个模块，打包生成 war 包，并在项目根目录下执行 Maven 命令：mvn clean package。在 target 目录中可以找到生成的 war 包。

将每个模块的 war 包复制到需要部署的机器上，可以通过 scp 命令实现跨机器拷贝文件：

scp your-module-name/target/your-module-name.war user@server:/path/to/tomcat/webapps/ 其中，your-module-name 表示模块名称，user@server 表示远程服务器的用户名和 IP 地址，/path/to/tomcat/webapps/ 表示 Tomcat 的 webapps 目录所在路径。

启动 Tomcat 服务器，在浏览器中输入 http://ip:port/your-module-name 访问应用程序。其中，ip 和 port 分别表示服务器的 IP 地址和端口号，your-module-name 表示模块名称。

如果需要更高级的部署方案，例如负载均衡、高可用等，可以使用 Nginx、Kubernetes 等工具来实现。

SpringBoot多模块项目开发（Maven多模块项目）