SpringBoot多模块项目开发(Maven多模块项目)
作者:mmseoamin日期:2023-12-19

Maven多模块项目

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

  1. 打开 Spring Boot 官网(spring.io/projects/sp…
  2. 在导航菜单中选择 “Guides” -> “Building a Multi-module Project with Maven”。
  3. 该页面会展示一个针对 Maven 多模块项目的完整示例,其中包含了父模块和多个子模块的代码以及 pom.xml 文件。此外,该页面还提供了一些原则性建议和最佳实践,包括如何定义模块之间的依赖关系、如何配置插件和资源等。
  4. 可以通过下载示例代码并结合官方文档来深入学习 Maven 多模块项目的实现方式和技巧,并根据实际需求进行相应的调整和扩展。 总之,在 Spring Boot 官网中寻找 Maven 多模块项目的最佳实践时,需要注意查看官方文档和示例代码,并结合实际项目需求进行理解和应用。同时,还需要遵循 Maven 的相关约定和规范,以确保项目的可靠性和稳定性。

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

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

  1. Web应用程序或服务端应用程序,特别是对于由多个子系统或模块组成的复杂应用程序。

  2. 基于微服务架构进行开发,其中每个服务都是一个独立的模块。

  3. 企业级应用程序,需要包含多个不同的子系统或模块,并且这些模块需要共享相同的依赖项和配置信息。

  4. 大规模数据处理或分析系统,例如Hadoop等。

  5. 应用商店或插件式系统,其中每个应用程序或插件都可以作为一个单独的模块。

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

拆分规则:

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

  1. 按业务模块划分: 将一个大型系统按照不同的业务模块进行划分,每个模块可以独立开发、测试、部署和维护。比如,对于一个电商系统,可以将商品管理、订单管理、用户管理等业务模块单独拆分成不同的子模块。

  2. 按功能模块划分: 将一个系统按照不同的功能模块进行划分,每个模块负责完成一个特定的功能,比如认证、授权、缓存、搜索等。

  3. 按技术组件划分: 将一个系统按照不同的技术组件进行划分,每个模块可以包含一个或多个技术组件,比如数据库连接、消息队列、缓存框架等。

  4. 按层次划分: 将一个系统按照不同的层次进行划分,每个模块可以包含一个或多个层次,比如数据访问层、服务层、控制层等。

  5. 混合划分: 可以将上述的任意两种或多种方式结合起来使用,以达到更好的代码复用、可维护性和可扩展性。

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

  1. 拆分后的子模块应该具有独立的功能和职责,能够单独进行测试、构建和部署。

  2. 子模块之间应该避免出现循环依赖,否则会导致构建失败和部署异常。

  3. 子模块之间的接口应该设计良好,遵守面向接口编程的原则,以提高代码的复用性和灵活性。

按业务模块拆分

SpringBoot多模块项目开发(Maven多模块项目),image,第1张

按层拆分

SpringBoot多模块项目开发(Maven多模块项目),image,第2张

Maven如何开发springboot多模块项目

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

  1. 创建父模块:在 IDEA 中创建一个 Maven 项目,并在根目录下创建一个父模块。可以通过 “File” -> “New” -> “Module” -> “Maven” 来创建新的 Maven 模块,然后选择 “Empty Project” 选项即可创建空的 Maven 项目结构。在 pom.xml 文件中定义所有子模块的名称。

  2. 创建子模块:在父模块下创建多个子模块,每个子模块对应一个功能或组件。可以通过 “File” -> “New” -> “Module” -> “Maven” 来创建新的 Maven 模块,并选择 “Java” 或者 “Spring Boot” 选项来创建对应类型的子模块。每个子模块都有自己的构建脚本(如 pom.xml 文件)和源代码目录(如 src/main/java 和 src/test/java 目录)。

  3. 配置依赖关系:为了让子模块能够相互调用和共享代码,需要在父模块中配置依赖关系。可以通过右键单击父模块,选择 “Open Module Settings” -> “Dependencies”,然后添加子模块之间的依赖关系。也可以通过 dependencies 标签来定义子模块之间的依赖关系,具体可以参考 Spring Boot 官方文档。

  4. 配置构建任务:在每个子模块的构建脚本中,需要添加适当的任务和插件,以便对应的子模块能够正确编译、测试和打包。可以通过右键单击父模块或子模块,选择 “Open Module Settings” -> “Build, Execution, Deploy” -> “Maven”,然后添加对应的任务和插件,也可以直接编辑 pom.xml 文件进行配置。

  5. 运行测试和打包:在完成各个子模块的开发和配置后,可以使用 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 标签中添加以下代码:

 

xml

复制代码

com.example module-a 1.0-SNAPSHOT com.example module-b 1.0-SNAPSHOT

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

xml

复制代码

com.example module-a 1.0-SNAPSHOT jar module-a Module A

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

xml

复制代码

org.springframework.boot spring-boot-starter-web 2.5.4

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

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

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

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

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

xml

复制代码

com.example module-a 1.0-SNAPSHOT com.example module-b 1.0-SNAPSHOT

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

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

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

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

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

创建Maven多模块项目

第一步:创建Maven父工程(POM)

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

  1. 打包方式(POM)、
  2. 子模块(modules)、
  3. 统一声明版本号(properties)、
  4. 统一声明依赖(DepencyManagement)、
  5. 项目管理插件maven-plugins
  6. 远程仓库

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

  1. 项目的基本信息:如 groupId、artifactId、version 等。

  2. 项目依赖管理:通过 元素来管理子模块中的依赖项。这样,子模块只需要声明依赖项的 groupId 和 artifactId,版本号可以从父模块中继承。

  3. 插件管理:通过元素来管理子模块中的插件。这样,子模块只需要使用插件的 groupId 和 artifactId,版本号和配置信息可以从父模块中继承。

  4. 公共配置信息:例如编译器版本、源代码目录、资源目录等信息。这些配置信息可以在父模块中统一配置,以便子模块直接继承并使用。

  5. 公共构建逻辑:例如测试命令、打包命令、部署命令等。这些构建逻辑可以在父模块中统一配置,以便子模块直接继承并使用。

  6. 公共插件:例如 Maven Surefire 插件、Maven Compiler 插件等。这些插件可以在父模块中配置,并且在子模块中自动继承和使用。

  7. 其他公共资源:例如公共 jar 包、公共配置文件等。这些资源可以在父模块中统一管理和分发,以便子模块直接继承并使用。

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

打包方式

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

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

  1. 项目基本信息:groupId、artifactId、version 等。
  2. 依赖项:包括需要引入的 jar 包或其他 Maven 项目。
  3. 插件:用于扩展 Maven 的功能,例如编译器插件、测试插件等。
  4. 构建选项:定义如何构建项目,包括编译源代码、打包结果输出目录等。
  5. 配置信息:定义一些基本的配置信息,例如编码格式、资源目录、插件版本等。 通过 POM 文件,可以方便地管理和构建 Maven 项目,并且可以实现多模块项目的统一管理。在多模块项目中,子项目可以继承父项目的 POM 文件,从而共享父项目中定义的依赖项、插件、构建选项等信息,避免重复的配置工作。

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

xml

复制代码

com.example my-project 1.0-SNAPSHOT jar ...

元素中指定要使用的打包方式即可。对于不同的打包方式,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中自动出现如下信息:

 

xml

复制代码

chrf-admin chrf-framework chrf-system chrf-quartz chrf-generator chrf-common chrf-bussiness

统一声明版本号(properties)

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

 

xml

复制代码

3.8.0 UTF-8 UTF-8 1.8 3.1.1 1.2.8 1.21 3.0.0 2.3.2 2.2.0 1.4.0 1.2.79 5.8.6 5.10.0 2.11.0 1.4 3.2.2 4.1.2 2.3 0.9.1 3.5.5 1.18.0 5.7.12 2.8.9

统一声明依赖(DepencyManagement)

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

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

 

xml

复制代码

2.27 UTF-8 org.glassfish.jersey jersey-bom ${jersey.version} pom import

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及以后。

 

xml

复制代码

org.springframework.boot spring-boot-maven-plugin true

MAVEN编译插件

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

    xml

    复制代码

    org.apache.maven.plugins maven-compiler-plugin 3.1 ${java.version} ${java.version} ${project.build.sourceEncoding}

    子模块

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

     
    

    xml

    复制代码

    4.0.0 cn.itcast.erp erp_parent 0.0.1-SNAPSHOT erp_domain

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

     
    

    xml

    复制代码

    com.example my-project 1.0-SNAPSHOT

    完整父POM:

     
    

    xml

    复制代码

    4.0.0 com.sf chrf 3.8.0 chrf http://www.chrf.vip 管理系统 3.8.0 UTF-8 UTF-8 1.8 3.1.1 1.2.8 1.21 3.0.0 2.3.2 2.2.0 1.4.0 1.2.79 5.8.6 5.10.0 2.11.0 1.4 3.2.2 4.1.2 2.3 0.9.1 3.5.5 1.18.0 5.7.12 2.8.9 org.springframework.boot spring-boot-dependencies 2.5.8 pom import com.alibaba druid-spring-boot-starter ${druid.version} eu.bitwalker UserAgentUtils ${bitwalker.version} org.mybatis.spring.boot mybatis-spring-boot-starter ${mybatis-spring-boot.version} com.github.pagehelper pagehelper-spring-boot-starter ${pagehelper.boot.version} com.github.oshi oshi-core ${oshi.version} org.redisson redisson ${redission.version} net.java.dev.jna jna ${jna.version} net.java.dev.jna jna-platform ${jna.version} io.springfox springfox-boot-starter ${swagger.version} io.swagger swagger-models commons-io commons-io ${commons.io.version} commons-fileupload commons-fileupload ${commons.fileupload.version} org.apache.poi poi-ooxml ${poi.version} org.apache.velocity velocity-engine-core ${velocity.version} commons-collections commons-collections ${commons.collections.version} com.alibaba fastjson ${fastjson.version} io.jsonwebtoken jjwt ${jwt.version} com.github.penggle kaptcha ${kaptcha.version} com.sf chrf-quartz ${chrf.version} com.sf chrf-generator ${chrf.version} com.sf chrf-framework ${chrf.version} com.sf chrf-system ${chrf.version} com.sf chrf-common ${chrf.version} com.sf chrf-bussiness ${chrf.version} org.projectlombok lombok ${lombok.version} cn.hutool hutool-all ${hutool.version} com.google.code.gson gson ${gson.version} chrf-admin chrf-framework chrf-system chrf-quartz chrf-generator chrf-common chrf-bussiness pom org.apache.maven.plugins maven-compiler-plugin 3.1 ${java.version} ${java.version} ${project.build.sourceEncoding} public aliyun nexus https://maven.aliyun.com/repository/public true public aliyun nexus https://maven.aliyun.com/repository/public true false

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

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

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

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

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

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

    Maven多模块项目的构建:

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

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

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

    1. 配置父模块:在父模块的 POM 文件中,通过 元素来管理子模块的依赖项。这样,子模块只需要声明依赖项的 groupId 和 artifactId,版本号可以从父模块中继承。

    2. 构建子模块:针对每个子模块,使用 mvn clean package 命令进行构建。该命令会自动编译代码、执行测试用例、打包成 jar 或 war 文件,并将结果放在 target 目录下。

    3. 安装到本地仓库:在每个子模块的目录下,使用 mvn install 命令将子模块安装到本地 Maven 仓库中。

    4. 构建父模块:在父模块的目录下,使用 mvn clean package 命令构建父模块。该命令会自动编译代码、执行测试用例、打包成 jar 文件,并将结果放在 target 目录下。

    5. 部署到远程仓库:如果需要,可以使用 mvn deploy 命令将父模块和所有子模块部署到远程 Maven 仓库中。这样其他开发者就可以通过 Maven 依赖机制来使用该多模块项目。

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

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

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

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

     
    

    xml

    复制代码

    ... pom child-module-1 child-module-2 child-module-3 ... ...

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

    接下来,在父模块的目录下,使用以下命令进行构建: 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:

    点击查看代码

     
    

    xml

    复制代码

    ... pom A B C ... org.apache.maven.plugins maven-compiler-plugin 3.8.1 compile-A compile compile ${project.basedir}/A compile-B compile compile ${project.basedir}/B compile-A compile-C compile compile ${project.basedir}/C compile-B org.apache.maven.plugins maven-dependency-plugin 3.1.2 copy-dependencies-A package copy-dependencies ${project.build.directory}/A/lib runtime copy-dependencies-B package copy-dependencies ${project.build.directory}/B/lib runtime copy-dependencies-C package copy-dependencies ${project.build.directory}/C/lib runtime

    在上述示例中,我们使用了 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 等工具来实现。