项目太大?来学习下Maven多模块项目开发(Spring Boot)

项目太大?来学习下Maven多模块项目开发(Spring Boot)

首页枪战射击gz穿越火线2.27更新时间:2024-04-17
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多模块项目的一些场景:

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

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

拆分规则:

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

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

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

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

按业务模块拆分

按层拆分

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复制代码<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 文件中添加以下代码:

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 文件中添加对应的依赖项。例如:

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” 命令来更新项目中的依赖。

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

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

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

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

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工程的父工程主要包含以下内容:
  1. 项目的基本信息:如 groupId、artifactId、version 等。
  2. 项目依赖管理:通过 <dependencyManagement> 元素来管理子模块中的依赖项。这样,子模块只需要声明依赖项的 groupId 和 artifactId,版本号可以从父模块中继承。
  3. 插件管理:通过<pluginManagement>元素来管理子模块中的插件。这样,子模块只需要使用插件的 groupId 和 artifactId,版本号和配置信息可以从父模块中继承。
  4. 公共配置信息:例如编译器版本、源代码目录、资源目录等信息。这些配置信息可以在父模块中统一配置,以便子模块直接继承并使用。
  5. 公共构建逻辑:例如测试命令、打包命令、部署命令等。这些构建逻辑可以在父模块中统一配置,以便子模块直接继承并使用。
  6. 公共插件:例如 Maven Surefire 插件、Maven Compiler 插件等。这些插件可以在父模块中配置,并且在子模块中自动继承和使用。
  7. 其他公共资源:例如公共 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 文件中添加如下元素:

xml复制代码<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中自动出现如下信息:

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)

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

xml复制代码<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中声明一个版本号即可。子类就会使用子类声明的版本号,不继承于父类版本号。

xml复制代码<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及以后。

xml复制代码<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编译插件

xml复制代码 <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内容如下:

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 文件中添加父模块的信息,例如:

xml复制代码<parent> <groupId>com.example</groupId> <artifactId>my-project</artifactId> <version>1.0-SNAPSHOT</version> </parent>

完整父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 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 文件,用于指定子模块的依赖关系、打包方式、构建选项等信息。

  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复制代码<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:

点击查看代码

xml复制代码<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 等工具来实现。

查看全文
大家还看了
也许喜欢
更多游戏

Copyright © 2024 妖气游戏网 www.17u1u.com All Rights Reserved