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多模块项目）

Maven多模块项目

拆分规矩：

Maven怎么开发springboot多模块项目

Maven开发springboot多模块项目，运用IDEA装备依靠联系的开发过程

为了让子模块能够彼此调用和同享代码，需求在父模块中装备依靠联系

创立Maven多模块项目

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

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

打包办法

子模块（modules）

一致声明版别号（properties）

一致声明依靠（DepencyManagement）

项目办理插件maven-plugins

子模块

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

Maven多模块项意图构建：

聚合功用来一键打包一切的子模块

Maven多模块项目怎么一键打包一切的子模块,对子模块的次序的要求：

多模块项目布置：

多模块Maven工程不同模块的jar包怎么布置到多台机器中

作者信息

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

Maven多模块项目

拆分规矩：

Maven怎么开发springboot多模块项目

Maven开发springboot多模块项目，运用IDEA装备依靠联系的开发过程

为了让子模块能够彼此调用和同享代码，需求在父模块中装备依靠联系

创立Maven多模块项目

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

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

打包办法

子模块（modules）

一致声明版别号（properties）

一致声明依靠（DepencyManagement）

项目办理插件maven-plugins

子模块

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

Maven多模块项意图构建：

聚合功用来一键打包一切的子模块

Maven多模块项目怎么一键打包一切的子模块,对子模块的次序的要求：

多模块项目布置：

多模块Maven工程不同模块的jar包怎么布置到多台机器中

相关文章

在 Kubernetes 中部署并使用 KubeEdge

前后端打包部署，So easy！

ThreadLocal：你不知道的优化技巧，Android开发者都在用

canal同步MySQL的binlog数据时踩了个大坑

作者信息