MAVEN父子工程

合集下载

maven submodule 最佳实践

Maven是一个强大的项目管理工具，它可以帮助开发人员管理项目的依赖关系、构建和部署项目。

在实际的项目开发过程中，经常会遇到需要将一个大型项目拆分成多个子模块来进行管理的情况。

Maven提供了submodule的功能，可以很好地满足这个需求。

下面将介绍一些关于Maven submodule的最佳实践，希望能帮助大家更好地使用Maven来管理子模块项目。

1. 确定子模块的结构在使用Maven submodule的时候，首先需要确定子模块的结构。

一般来说，子模块应该具有清晰的功能划分，可以根据业务功能、技术模块等来进行划分。

子模块之间的依赖关系也需要明确定义，确保每个子模块可以独立运行和测试。

2. 使用父子模块关系Maven submodule支持父子模块的关系，可以通过父pom.xml来统一管理子模块的依赖和配置。

这样可以避免重复配置，提高项目的可维护性。

在子模块中也可以引用父模块中定义的依赖和插件，减少重复的配置工作。

3. 统一版本管理在多个子模块的项目中，往往会遇到版本管理的问题。

Maven提供了dependencyManagement来统一管理依赖的版本，可以在父模块的pom.xml中进行统一配置。

这样可以避免不同子模块使用不同版本的依赖导致的冲突和问题。

4. 合理使用聚合和继承Maven提供了聚合和继承的功能，可以帮助开发人员更好地管理子模块项目。

聚合可以将多个子模块项目聚合在一起进行构建、测试和部署，方便统一管理。

继承则可以提取公共的配置和依赖，避免重复配置，提高项目的可维护性和扩展性。

5. 使用模块化的构建工具除了Maven之外，还有一些其他的构建工具也支持submodule的功能，比如Gradle等。

可以根据项目的实际情况选择合适的构建工具来管理子模块项目。

也可以考虑使用一些模块化的构建工具来简化子模块项目的管理和维护。

Maven submodule的最佳实践需要根据项目的实际情况来进行具体的规划和实施。

idea 父子工程的编译

idea 父子工程的编译
在IntelliJ IDEA 中，父子工程（Parent-Child Project）是指一个工程（父工程）中包含一个或多个子工程。

父工程可能是一个更大项目的一部分，而子工程则是父工程中的具体模块或组件。

要编译父子工程，可以按照以下步骤进行操作：
1.打开IntelliJ IDEA，并加载需要编译的父子工程。

2.在主菜单中，选择"Build"（构建）> "Rebuild Project"
（重新构建项目），或者使用快捷键"Ctrl+F9"（Windows/Linux）或"Command+F9"（Mac）。

3.IDEA 将自动编译整个父子工程，包括父工程和所有子
工程。

4.如果在编译过程中遇到任何错误或警告，IDEA 将在
"Problems"（问题）窗口中显示相关信息。

可以根据这些信息修改代码或配置文件，然后再次执行编译操作。

5.如果需要单独编译某个子工程，可以在项目视图中选择
该子工程，然后右键单击并选择"Build Project"（构建项目）。

6.编译完成后，可以在"Build"（构建）工具窗口中查看
编译结果和输出文件。

需要注意的是，在编译父子工程时，可能需要配置构建工具（如Maven 或Gradle）和构建配置文件，以确保编译的正确性和一致性。

具体的配置步骤和要求可能会因项目类型和开发环境而有所不同。

mvn父子项目如何写单元测试案例

mvn父子项目如何写单元测试案例
在 Maven 父子项目中，通常建议将单元测试放在子项目中，因为子项目是实际实现功能的地方。

父项目通常只包含一些通用的配置和依赖管理。

以下是在 Maven 父子项目中编写单元测试案例的一般步骤：
1. 在子项目的源码目录中创建一个单元测试类。

通常情况下，单元测试类应该与被测试的类位于同一目录下，并且以 Test 作为后缀。

例如，如果有一个名为 MyService 的服务类，那么对应的单元测试类应该命名为MyServiceTest。

2. 在单元测试类中编写测试方法。

每个测试方法应该针对被测试类的一个具体功能或方法进行测试。

测试方法应该使用JUnit或其他类似的测试框架来编写。

3. 在测试方法中编写具体的测试逻辑。

可以使用模拟对象（Mock）来模拟被测试类所依赖的其他对象，以便在测试中控制被测试类的行为。

4. 在子项目的文件中添加 JUnit 依赖。

可以在父项目的文件中添加 JUnit 依赖，然后在子项目的文件中继承父项目的配置。

5. 在子项目的文件中配置 Maven Surefire 插件。

该插件用于运行单元测试。

可以在父项目的文件中配置 Maven Surefire 插件，然后在子项目的文件中继承父项目的配置。

6. 运行单元测试。

可以使用 Maven 命令行工具运行单元测试，例如 `mvn test`。

Maven 将自动扫描并运行所有符合条件的测试类和方法。

总之，在 Maven 父子项目中编写单元测试案例时，需要将测试代码放在子项目中，并使用合适的测试框架和依赖管理工具来编写和运行测试。

maven中groupid的作用

maven中groupid的作用Maven中groupId的作用在使用Maven进行项目管理时，groupId是一个非常重要的配置项，它用来唯一标识一个项目或者模块。

groupId的作用主要体现在以下几个方面：1. 命名空间的划分在Maven中，groupId是一个项目或者模块的命名空间，它的作用是将不同的项目或者模块进行分类和划分。

通过groupId，可以清晰地区分出不同的项目，避免命名冲突和混淆。

在实际开发中，通常会根据项目的业务逻辑、功能模块或者团队划分来设置不同的groupId，以便于管理和维护。

2. 依赖管理和版本控制在Maven中，依赖管理是非常重要的一项功能。

通过配置项目的pom.xml文件，可以定义项目的依赖关系，并且可以指定依赖的具体版本。

而groupId则是一个依赖项的唯一标识符，在引入依赖时必须指定正确的groupId才能找到对应的依赖项。

通过groupId，可以方便地管理项目的依赖关系，并且可以确保依赖项的唯一性。

3. 项目结构的组织在Maven中，groupId也可以用来组织项目的目录结构。

通常情况下，Maven会根据groupId来生成项目的目录结构，将不同的项目模块分别放置在对应的目录下。

这样可以使项目的结构更加清晰和有序，便于管理和维护。

同时，还可以通过groupId来指定项目的父子关系，使得项目之间的依赖关系更加清晰和可控。

4. 统一管理和发布通过统一的groupId，可以方便地管理和发布项目。

在一个公司或者团队内部，可以约定一套统一的groupId规范，使得所有的项目都遵循相同的命名规则。

这样可以方便团队成员之间的交流和协作，同时也方便其他开发者在使用项目时能够快速了解项目的结构和依赖关系。

总结来说，Maven中的groupId是用来唯一标识一个项目或者模块的，它在依赖管理、项目结构组织、命名空间划分和统一管理等方面都起到了重要作用。

通过合理设置和使用groupId，可以使项目的管理更加规范和清晰，提高开发效率和代码质量。

使用IDEA创建maven父子工程项目

使⽤IDEA创建maven⽗⼦⼯程项⽬第⼀步：打开IDEA，点击create new project，如果没有弹出如下界⾯，就先将打开的项⽬关闭，然后重新打开IDEA即可⼀开始创建⽗⼯程，所以不⽤选中create from archetype，点击next，如下图：第⼆步：GroupId（⼀般填反转后公司域名）和ArtifactId（项⽬名）还有Version，这三个属性⽬的是标识你的项⽬的唯⼀性，点击next，如下图：第三步：以上配置按需修改，⼀般保持默认，很简单就是保存项⽬的路径，点击，如下图：第四步：⽗⼯程创建后，由于是⽗⼯程，所以建议删除其中的src⽂件，接下来创建⼦项⽬，⿏标移到项⽬上右键，依次new→点击module，如下图：第五步：⼦⼯程需要按下图标识1/2/3操作，如下图：第六步：输⼊ArtifactId（项⽬名），点击next，如下图：第七步：可以保持默认，直接点击next，如下图：第⼋步：点击finish完成，如下图：注意：sontest是my_test的⼦项⽬，所以⽬录是\my_test\sontest，要看仔细，不然会创建失败创建成功，如下图：第九步：⼦⼯程也可以是java项⽬，在new→module时不要选中Create from archetype，点击next，然后填⼀个ArtifactId（项⽬名），然后⼀直next就⾏了注意：pom⽂件中要添加<packaging>jar</packaging>第⼗步：maven⼦⼯程创建完毕后，会发现main⽂件夹⾥⾯没有java⽂件夹，没关系，⾃⼰创建就⾏了，如下图（图中不明⽩的配置可以IDEA相关⽂档查阅清楚，这⾥不多叙述）：选中main⽂件夹，右键，点击New Folder...创建java⽂件夹后，继续操作就OK，如下图（创建resources⽂件夹同理）：直接点击Apply即可，如果弹出报错提⽰那就是因为⽗⼯程中有错误的⽂件⽬录，如下图（现在⽆错误，我当初遇到过这个问题是这样解决的，如果不⾏请⾃⾏百度）：先选中⽗⼯程，然后看右边Add Content Root中是否除了Excluded Folders还有其他红⾊的⽂件⽬录，如果有删除就⾏了。

Maven多模块父子工程（含SpringBoot示例）

Maven多模块⽗⼦⼯程（含SpringBoot⽰例）⼀、为什么要⽤Maven多模块假设有这样⼀个项⽬，很常见的Java Web应⽤。

在这个应⽤中，我们分了⼏层：DaoServiceWeb对应的，在⼀个项⽬中，我们会看到⼀些包名：org.xx.app.daoorg.xx.app.serviceorg.xx.app.weborg.xx.app.util但随着项⽬的进⾏，你可能会遇到如下问题：1. 这个应⽤可能需要有⼀个前台和⼀个后台管理端，你发现⼤部分dao，⼀些service，和⼤部分util是在两个应⽤中可。

2. pom.xml中的依赖列表越来越长以重⽤的，但是，由于⽬前只有⼀个项⽬，你不得不新建⼀个项⽬依赖这个WAR.3. build整个项⽬的时间越来越长，尽管你只是⼀直在web层⼯作，但你不得不build整个项⽬。

4. 某个模块，⽐如util，你只想让⼀些经验丰富的⼈来维护，可是，现在这种情况，每个开发者都能修改，这导致关键模块的代码质量不能达到你的要求。

我们会发现，其实这⾥实际上没有遵守⼀个设计模式原则：“⾼内聚，低耦合”。

虽然我们通过包名划分了层次，并且你还会说，这些包的依赖都是单向的，没有包的环依赖。

这很好，但还不够，因为就构建层次来说，所有东西都被耦合在⼀起了。

因此我们需要使⽤Maven划分模块。

⼀个简单的Maven模块结构是这样的：---- app-xxx|-- pom.xml (pom)||-- app-util| |-- pom.xml (jar)||-- app-dao| |-- pom.xml (jar)||-- app-service| |-- pom.xml (jar)||-- app-web|-- pom.xml (war)⼆、 Maven创建多模块聚合项⽬1.1 创建⽗⼯程1.以IDEA为⽰例 (Eclipse⼤同⼩异) 选择New--Project2.在弹出界⾯选择Maven, 选择JDK，-->next3.输⼊GroupId 和ArtifactId , -->next4.输⼊完整项⽬名，和项⽬保存在本地的路径 ->finish5.完成之后我们得到⼀个新建的maven⼯程作为我们的⽗⼯程，然后删掉⽬录下的整个src,得到如下⽬录1.2 Spring Boot⽗⼯程1. Spring boot在创建单应⽤项⽬的时候，有默认的<parent>依赖；我们在⾃定义⽗⼯程项⽬时，如果直接以Spring boot的parent作为项⽬的<parent>⽗依赖管理的话，⼦项⽬会由于存在两个parent⽽报错，⽆法导⼊依赖。

maven引用子项目的版本号

maven引用子项目的版本号Maven是一个流行的Java项目管理工具，它可以自动化构建、测试和部署Java应用程序。

在Maven中，我们可以使用父项目和子项目的概念来组织我们的代码库。

父项目是一个包含多个子项目的项目，而子项目是父项目的一部分。

在Maven中，我们可以使用父项目的pom.xml文件来引用子项目的版本号。

在Maven中，我们可以使用dependencyManagement元素来管理依赖项的版本号。

在父项目的pom.xml文件中，我们可以使用dependencyManagement元素来列出所有子项目的依赖项，并指定它们的版本号。

这样，当子项目引用这些依赖项时，它们将自动使用父项目中指定的版本号。

以下是一个示例父项目的pom.xml文件，其中包含两个子项目：```<project><modelVersion>4.0.0</modelVersion><groupId>com.example</groupId><artifactId>parent-project</artifactId><version>1.0.0</version><packaging>pom</packaging><modules><module>child-project-1</module><module>child-project-2</module></modules><dependencyManagement><dependencies><dependency><groupId>com.example</groupId> <artifactId>dependency-1</artifactId> <version>1.0.0</version></dependency><dependency><groupId>com.example</groupId> <artifactId>dependency-2</artifactId> <version>2.0.0</version></dependency></dependencies></dependencyManagement></project>```在这个示例中，我们定义了两个子项目：child-project-1和child-project-2。

maven多模块父模块问题deploy问题

maven多模块⽗模块问题deploy问题很多时候我们只需要发布⽗pom，对于⼦模块需要独⽴处理（发布特定的⼦模块）解决⽅法忽略递归⼦模块mvn clean package deploy -N // 在⽗pom⽬录指定deploy 项⽬mvn clean package deploy -pl . // 在⽗pom⽬录参考maven 命令usage: mvn [options] [<goal(s)>] [<phase(s)>]Options:-am,--also-make If project list is specified, alsobuild projects required by thelist-amd,--also-make-dependents If project list is specified, alsobuild projects that depend onprojects on the list-B,--batch-mode Run in non-interactive (batch)mode (disables output color)-b,--builder <arg> The id of the build strategy touse-C,--strict-checksums Fail the build if checksums don'tmatch-c,--lax-checksums Warn if checksums don't match-cpu,--check-plugin-updates Ineffective, only kept forbackward compatibility-D,--define <arg> Define a system property-e,--errors Produce execution error messages-emp,--encrypt-master-password <arg> Encrypt master security password-ep,--encrypt-password <arg> Encrypt server password-f,--file <arg> Force the use of an alternate POMfile (or directory with pom.xml)-fae,--fail-at-end Only fail the build afterwards;allow all non-impacted builds tocontinue-ff,--fail-fast Stop at first failure inreactorized builds-fn,--fail-never NEVER fail the build, regardlessof project result-gs,--global-settings <arg> Alternate path for the globalsettings file-gt,--global-toolchains <arg> Alternate path for the globaltoolchains file-h,--help Display help information-l,--log-file <arg> Log file where all build outputwill go (disables output color)-llr,--legacy-local-repository Use Maven 2 Legacy LocalRepository behaviour, ie no use of_remote.repositories. Can also beactivated by using-Dmaven.legacyLocalRepo=true-N,--non-recursive Do not recurse into sub-projects-npr,--no-plugin-registry Ineffective, only kept forbackward compatibility-npu,--no-plugin-updates Ineffective, only kept forbackward compatibility-nsu,--no-snapshot-updates Suppress SNAPSHOT updates-ntp,--no-transfer-progress Do not display transfer progresswhen downloading or uploading-o,--offline Work offline-P,--activate-profiles <arg> Comma-delimited list of profilesto activate-pl,--projects <arg> Comma-delimited list of specifiedreactor projects to build insteadof all projects. A project can bespecified by [groupId]:artifactIdor by its relative path-q,--quiet Quiet output - only show errors-rf,--resume-from <arg> Resume reactor from specifiedproject-s,--settings <arg> Alternate path for the usersettings file-t,--toolchains <arg> Alternate path for the usertoolchains file-T,--threads <arg> Thread count, for instance 2.0Cwhere C is core multiplied-U,--update-snapshots Forces a check for missingreleases and updated snapshots onremote repositories-up,--update-plugins Ineffective, only kept forbackward compatibility-v,--version Display version information-V,--show-version Display version informationWITHOUT stopping build-X,--debug Produce execution debug output说明多看看maven 的help 还是⽐较重要的，⼀切都在命令⾏中，⽽且有时我们还是需要添加-amd 或者-am 的确保依赖也是进⾏编译部署的。

mvn parent中的依赖

mvn parent中的依赖
在Maven的项目中，通常会使用父子项目的方式来管理依赖关系。

在父项目的pom.xml文件中，可以定义一些通用的依赖，供子
项目继承和使用。

这样可以避免在每个子项目中都重复定义相同的
依赖，提高了项目的管理效率。

在Maven的父项目中定义依赖可以通过在pom.xml文件中的
<dependencies>标签中添加<dependency>子标签来实现。

这些依赖
通常是项目中多个子模块都需要使用的依赖，例如常用的日志库、
数据库连接池等。

定义依赖时需要指定依赖的坐标，包括groupId、artifactId和version。

父项目中定义的依赖会被所有的子项目继承和使用，子项目可
以直接引用父项目中定义的依赖，而无需再次在子项目中声明这些
依赖。

这样可以简化子项目的pom.xml文件，减少重复的配置，提
高了项目的可维护性。

需要注意的是，父项目中定义的依赖并不会自动引入到子项目
的classpath中，子项目在使用父项目定义的依赖时，仍然需要在
自己的pom.xml文件中显式声明这些依赖。

父项目中的依赖只是提
供了一个依赖管理的范围，使得子项目可以更加方便地引用这些依赖。

总之，Maven父项目中的依赖定义可以帮助我们更好地管理项目中的依赖关系，提高项目的可维护性和开发效率。

通过合理地使用父项目中的依赖定义，可以使得项目结构更加清晰，依赖关系更加合理，从而更好地管理和维护我们的项目。

maven多个子项目、父项目之间的引用问题

maven多个⼦项⽬、⽗项⽬之间的引⽤问题在项⽬时⽤到maven管理项⽬，在⼀个就项⽬的基础上开发新的项⽬；关于⼦项⽬和⽗项⽬，⼦项⽬与⼦项⽬之间的调⽤问题，发现⾃⼰存在不⾜，以下是⾃⼰查询的问题，解决了⾃⼰的疑惑。

问题下⾯是⼀个简略的项⽬结构图Parent`------ childA(BusinessLayer)`--- pom.xml`------ childB(WebLayer)`--- pom.xml`------ pom.xml1、Parent怎么能找到childA和childB呢？在maven中，parent模块组织好childA和childB，叫做"聚合"，多个模块联合编译。

实现起来很简单，只需要在parent的pom⽂件⾥加⼊以下内容。

<modules><module>childA</module><module>childB</module></modules>2、是不是这样写就完全ok了？这样只是告诉maven编译器，在读取parent的pom⽂件时去找到childA和childB，但还是会分别去编译他们引⼊的依赖。

这样就会导致pom ⽂件引⼊的包重复！！于是我们引⼊了"继承"的概念，也就是形成"⽗⼦"关系，⼦pom可以引⽤到⽗pom中引⼊的依赖。

具体做法如下：在parent中，写⼊以下内容，其中"*"标识的⾏可以组成⼀个路径，通过这个路径可以在maven仓库中找到这个pom⽂件！本例中，path为M2_Path/com/sang/main/Parent-Moduel/1.0.2/xxxx-1.0.2.pom。

所以这三个标签是必须的<modelVersion>4.0.0</modelVersion><groupId>com.sang.main</groupId> *<artifactId>Parent-Moduel</artifactId> *<version>1.0.2</version> *<packaging>pom</packaging><name>Simple-main</name>⽗pom写好了，⼦pom就通过<parent>标签继承⽗pom的依赖，如下：<parent><groupId>com.sang.main</groupId><artifactId>Parent-Moduel</artifactId><version>1.0.2</version><relativePath>../pom.xml</relativePath> </parent>值得注意的是<relativePath>标签，如果pom的层次关系就像本例中的那样只隔⼀层，则可以省略这个。

maven父子工程应用场景

Maven父子工程是指通过一个主工程（父工程）来管理多个相关的子工程。

下面是几个使用Maven父子工程的应用场景：
1. 多模块项目管理：当一个大型项目需要分解为多个模块进行开发时，可以使用Maven父子工程来管理不同模块的依赖关系和构建过程。

父工程可以定义公共的依赖和插件，并通过继承来管理子模块之间的依赖关系，可以方便地进行模块的编译、测试和部署。

2. 统一版本管理：如果多个项目或模块共享相同的依赖，使用Maven父子工程可以避免手动管理每个项目的依赖版本。

通过在父工程中定义依赖的版本号，子工程可以继承父工程的版本配置，确保所有项目使用统一的依赖版本，降低版本冲突和管理成本。

3. 模块化开发与复用：通过Maven父子工程可以将一个整体项目划分为多个独立的模块，每个模块都有自己的功能和职责。

这样，可以实现模块化开发和复用，提高代码的可维护性和可扩展性。

不同的开发团队可以专注于不同的模块，便于并行开发和团队协作。

4. 分布式构建和部署：当一个项目需要在不同环境（如测试环境、生产环境）进行构建和部署时，可以使用Maven父子工程来管理不同环境的配置和部署脚本。

通过在父工程中定义不同环境的配置文件和插件，可以实现一次编译打包，多次部署，提高构建和部署的效率。

总之，Maven父子工程在大型项目的组织和管理中起到了重要的作用，可以实现模块化开发、依赖管理、版本控制和分布式构建部署等功能，提高开发效率和项目的可维护性。

狂神说Java个人笔记-JavaWeb

狂神说Java个⼈笔记-JavaWeb 3.Tomcat3.1安装Tomcat3.2Tomcat启动和配置3.3配置⾼难度⾯试题：请你谈谈⽹站是如何进⾏访问的！1.输⼊⼀个域名：回车2.检查本机的C:\Windows\System32\drivers\etc\hosts配置⽂件下有没有这个域名映射；1.有：直接返回对应的ip地址，这个地址中，有我们需要访问的web程序，可以直接访问127.0.0.12.没有：去DNS服务器找找到的话就返回，找不到就返回找不到3。

可以配置⼀下环境变量3.4发布⼀个web⽹站不会就先模仿，将⾃⼰写的⽹站，放到服务器Tomcat中指定的web应⽤⽂件夹webapps下，就可以访问了⽹站应该有的结构-- webapps: Tomcat服务器的web⽬录-ROOT-kuangstudy：⽹站的⽬录名-Web-INF-classes：java程序-lib：web应⽤所依赖的jar包-web.xml：⽹站配置⽂件-index.html 默认的⾸页4.HTTP4.1什么是HTTPHTTP（超⽂本传输协议）是⼀个简单的请求-响应协议，它通常运⾏在TCP之上。

⽂本：html，字符串超⽂本：图⽚，⾳乐，视频定位，地图。

80HTTPS：安全的4434.2两个时代HTTP/1.0:客户端可以与web服务器连接后，只能获得⼀个web资源，断开连接HTTP/1.1：客户端可以与web服务器连接后，可以获得多个web资源。

4.3HTTP请求客户端----发请求----服务器百度：Request URL:https:/// 请求地址Request Method:GET get⽅法/post⽅法Status Code:200 OK 状态码：200Remote Address:182.61.200.7:4431.请求⾏请求⾏终的请求⽅式：GET请求⽅式：Get，Post ，HEAD，DELETE，PUT，TRACT...get:请求能够携带的参数⽐较少，⼤⼩有限制，会在浏览器的URL地址栏显⽰数据内容，不安全，但⾼效post：请求能够携带的参数没有限制，⼤⼩没有限制，不会在浏览器的URL地址栏显⽰数据内容，安全，但不⾼效。

命令行创建多模块的Maven项目（父模块，子模块）

命令行创建多模块的Maven项目（父模块，子模块）我们都知道，我们常常将一个复杂的java应用拆分成多个java子应用。

由于maven的出现，这种拆分就更加容易了，因为我们通过maven可以创建多个关联模块的项目（Multiple Module Projects）。

由一个总的模块，下面包含多个子模块（子模块还可以包含子模块）。

一、通过在Maven命令行创建。

1. 创建父模块（总的POM） - cms-validator使用命令mvn archetype:generate -DgroupId=com.ebay.tools.cms.validator -DartifactId=cms-validator创建一个maven项目，然后修改该项目的pom.xml文件，将package类型改为pom<packaging>pom</packaging>并删除其中的src目录。

2. 创建提供rest service的子模块：validator-rest在父模块的目录下，使用命令mvn archetype:generate -DgroupId=com.ebay.tools.cms.validator.rest -DartifactId=validator-rest创建一个maven（子）项目。

3. 创建一个web子模块： validator-web在父模块的目录下，mvn archetype:generate -DgroupId=com.ebay.tools.cms.validator.web -DartifactId=validator-web -DarchetypeArtifactId=maven-archetype-webapp完成以上3步以后，会在总的pom.xml中已经自动加入：<modules><module>validator-rest</module> <module>validator-web</module> </modules>在各个子模块中也自动的加入了：<parent><artifactId>cms-validator</artifactId><groupId>com.ebay.tools.cms.validator</groupId><version>1.0-SNAPSHOT</version></parent>由于默认情况下子模块继承了总POM的package(pom),这里需要修改子模块的pom的package类型。

maven父子工程编译顺序

maven父子工程编译顺序一、什么是Maven父子工程Maven父子工程是一种将多个项目组织在一起的方式，其中一个项目作为父项目，其他项目作为子项目。

父项目定义了一些共享的配置和依赖项，子项目可以继承这些配置和依赖项，并可以定义自己的独立配置和依赖项。

通过使用父子工程，可以实现多个项目之间的代码复用和统一管理，提高开发效率。

二、使用Maven父子工程的方法1. 创建父项目：首先需要创建一个普通的Maven项目，并将其作为父项目。

在父项目的pom.xml文件中，可以定义一些共享的配置和依赖项，例如编译版本、插件版本、资源目录等。

子项目可以继承这些配置和依赖项。

2. 创建子项目：在父项目下创建子项目，每个子项目都是一个独立的Maven项目。

子项目的pom.xml文件中可以定义自己的独立配置和依赖项，例如项目名称、打包方式、依赖库等。

3. 定义模块关系：在父项目的pom.xml文件中，使用<modules>标签来定义所有的子项目。

每个子项目都需要在<modules>标签中添加一个<module>标签，指定子项目的相对路径。

这样，Maven就能够识别父子项目之间的关系。

4. 编译顺序：在进行编译时，Maven会按照父子项目的定义顺序进行编译。

首先会编译父项目，然后按照<modules>标签中定义的顺序编译子项目。

这样可以保证子项目在编译时能够正确地解析父项目的依赖和配置。

三、Maven父子工程编译顺序的原理Maven父子工程的编译顺序是由Maven的生命周期和构建顺序决定的。

Maven定义了一系列的生命周期，包括clean、validate、compile、test、package、install、deploy等。

每个生命周期又包含了一系列的构建阶段，例如在compile生命周期中，包含了process-sources、compile、process-resources、resources等阶段。

在idea中创建maven父子工程，子工程无法导入父工程依赖的问题

在idea中创建maven⽗⼦⼯程，⼦⼯程⽆法导⼊⽗⼯程依赖的问题创建maven⽗⼦⼯程时遇到⼀个问题，当⼦⼯程的名称前缀和⽗⼯程的名称⼀样时，⼦⼯程会出现⼀系列的问题。

⽐如我的⽗⼯程名称是microservicecloud，⼦⼯程名称是microservicecloud-api。

那么⼦⼯程就会存在如下问题。

1.⽬录类型需要⼿动设置
2.pom⽂件没有被加载，在maven管理界⾯是灰⾊的
⼦⼯程引⼊的依赖
导⼊依赖包是却找不到
安装lombok插件
File->Settings->plugins 搜索lombok,并安装lombok plugins。

然后软件重启。

重启之后，将原来的⼦⼯程删掉重新创建⼀遍就可以了
但是当⼦⼯程名字的前缀和⽗⼯程名称不⼀样时，⽐如⼦⼯程名称叫micro-api，这时即使不安装lombok插件，也是可以正常使⽤的，不知道是什么原因。

maven的lifecycle的用法(一)

maven的lifecycle的用法(一)Maven的lifecycleMaven是一款强大的项目管理工具，它通过定义一套标准的生命周期来管理项目的构建、测试、打包和部署等整个过程。

在使用Maven 时，你可以通过运行不同的lifecycle来执行特定的操作。

什么是Maven的lifecycle？Maven的lifecycle是指一系列的构建步骤，按照特定的顺序执行，包括clean、validate、compile、test、package、verify、install和deploy等阶段。

每个阶段都有一个或多个与之关联的插件目标。

通过执行不同的lifecycle，你可以完成各种构建和部署的操作。

Maven的lifecycle的用法使用Maven的lifecycle非常简单，只需要在命令行中运行指定的命令即可。

下面列举了几个常用的lifecycle及其对应的命令：•clean：清理项目的目标文件和构建结果。

命令为mvn clean。

•validate：验证项目的基本信息是否正确。

命令为mvn validate。

•compile：编译项目的源代码。

命令为mvn compile。

•test：运行项目的单元测试。

命令为mvn test。

•package：将项目打包成可发布的格式，如JAR或WAR。

命令为mvn package。

•verify：对打包结果进行验证。

命令为mvn verify。

•install：将项目的构件安装到本地仓库中。

命令为mvn install。

•deploy：将项目的构件部署到远程仓库中。

命令为mvn deploy。

Maven的lifecycle的执行顺序Maven的lifecycle的执行顺序是固定的，按照clean、validate、compile、test、package、verify、install和deploy的顺序依次执行。

如果在执行过程中出现错误，Maven会立即停止执行并报告错误信息。

（03）maven项目分模块开发，子项目继承自父项目，打包运行方法

（03）maven项⽬分模块开发，⼦项⽬继承⾃⽗项⽬，打包运⾏⽅法现在有⼀个项⽬结构如下：⽗项⽬project<modelVersion>4.0.0</modelVersion><groupId>com.xxx.xxx</groupId><artifactId>project</artifactId><version>1.0.0-SNAPSHOT</version><packaging>pom</packaging><dependencyManagement><dependencies><dependency><groupId>io.spring.platform</groupId><artifactId>platform-bom</artifactId><version>Brussels-SR4</version><type>pom</type><scope>import</scope></dependency></dependencies></dependencyManagement><modules><module>../projectA</module><module>../projectB</module><module>../projectC</module></modules> ⼦项⽬projectA继承⾃⽗项⽬project<modelVersion>4.0.0</modelVersion><artifactId>projectA</artifactId><parent><groupId>com.xxx.xxx</groupId><artifactId>project</artifactId><version>1.0.0-SNAPSHOT</version><relativePath>../project</relativePath></parent><dependencies>... ...</dependencies> ⼦项⽬projectB继承⾃⽗项⽬project，同时引⼊了projectA做为依赖<modelVersion>4.0.0</modelVersion><artifactId>projectB</artifactId><parent><groupId>com.xxx.xxx</groupId><artifactId>project</artifactId><version>1.0.0-SNAPSHOT</version><relativePath>../project</relativePath></parent><dependencies><dependency><groupId>com.xxx.xxx</groupId><artifactId>projectA</artifactId><version>1.0.0-SNAPSHOT</version></dependency>... ...</dependencies> ⼦项⽬projectC继承⾃⽗项⽬project，同时引⼊了projectB做为依赖<modelVersion>4.0.0</modelVersion><artifactId>projectC</artifactId><parent><groupId>com.xxx.xxx</groupId><artifactId>project</artifactId><version>1.0.0-SNAPSHOT</version><relativePath>../project</relativePath></parent><dependencies><dependency><groupId>com.xxx.xxx</groupId><artifactId>projectB</artifactId><version>1.0.0-SNAPSHOT</version></dependency>... ...</dependencies> 现在要打包，直接在project上执⾏clean compile package打出的包⽆法运⾏，需要修改projectC（客户写的源码）的pom.xml⽂件... ...</dependencies><build><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId><version>1.3.3.RELEASE</version><executions><execution><goals><goal>repackage</goal></goals></execution></executions></plugin></plugins><finalName>demo</finalName></build> 然后在project上执⾏上述命令，打出的jar名字是demo.jar，运⾏：java -jar demo.jar即可。

构建标准maven项目（父子项目）

构建标准maven项⽬（⽗⼦项⽬）
1.创建⼀个项⽬选择maven⽅式构建
点击“next”
2.选择构建项⽬所在位置，图中没有路径，默认是在当前⼯作区下构建，如果之前构建过，那么会有路径，你直接下⼀步，不修改的话，显⽰的⽬录下构建
点击next
3选择⽣成⽅式
点击next
4.填写项⽬命名
完成
5.修改，因为作为⽗项⽬，把项⽬下⾯内容全部删除，只保留pom⽂件
1）删除src/main/java和/src/test/java
2)右键buildpath-》buildconfig到如下界⾯
，source，和libraries下的⽂件选择全部将其删除，记得点apply或者ok才会⽣效
6刷新项⽬
然后修改pom⽂件
将jar修改成pom，作为⽗项⽬需要这样设置，还可以添加⼀些属性，⼦项⽬可以⽤，全局设置，避免冲突，然后保存
7.选中项⽬右键new-->project.
注意，这选择和刚才的不⼀样
8.填写⼦项⽬名称下⼀步
，接下来点击finished完成最后⼀步，不贴图了
9.修改dubbo-api的pom
如图两⾏删掉
保存，⽗类中的pom⽂件多了
完成（不错如果pom⽂件⾥⾯有保存或者警告，有可能是⽣成项⽬时候，项⽬的命名或者版本不对导致，改对应就ok了）。

SpringgBoot父子工程的创建

SpringgBoot⽗⼦⼯程的创建知识：SpringBoot⽗⼦⼯程创建花开堪折直需折，莫待⽆花空折枝开始之前，⾮常⾮常有必要了解⼀下关于以及的区别，这样才可以在进⾏创建maven⽗⼦⼯程种避免⼀些不必要的意外错误。

dependencyManagement与dependencies的区别：dependencyManagement：在项⽬的⽗⼯程中pom⽂件使⽤，⽤于管理jar包的版本，并不会去下载jar包⼦项⽬在引⼊dependencyManagement中定于了的jar包时，只需要定义相应的groupId和artifactId，可以不⽤定义jar包的version（当然有特殊需求，定义了也是没有问题的）,因为⼦module会沿着继承关系⼀级⼀级向上找对应的jar包版本，如果在最顶层的⽗pom中的dependencyManagement任然没有找到，就会报错；dependencies：⽤于管理jar包，此时在这⾥引⼊了的jar包，会去下载；如果是⽗⼦⼯程，并且⽗⼯程有定义dependencyManagement进⾏jar版本的管理，⼦⼯程只需要定义相应的groupId和artifactId(具体解析看上上⾯第三条说明)⽗⼯程中定义了代表⼦⼯程将会继承在中定义的ja包这⾥在插⼊⼀下⼤佬对pom的意思说明：使⽤maven分模块管理，都会有⼀个⽗级项⽬，pom⽂件⼀个重要的属性就是packaging（打包类型），⼀般来说所有的⽗级项⽬的packaging都为pom，packaging默认类型jar类型，如果不做配置，maven会将该项⽬打成jar包。

⼤佬连接：⽗⼦⼯程创建简单总结：有了以上知识的介绍，对于搭建⽗⼦⼯程就相对很轻松了，总结⼀下就是：⽗⼯程:必须要有pom⽤于管理全局的jar版本，可避免jar版本混乱或不⼀致导致不兼容等的问题在⽗⼯程中是⽤于定义公共的jar包，所有的⼦⼯程都将继承⼦⼯程⼦⼯程定义中的jar包，如果没有指定版本将会去⽗⼯程中查找对应的version,⼀直向上直到顶层⽗⼯程，如果仍然没有将会报错⼦⼯程定义也可以⾃⼰定义jar包版本案列演⽰：⽗⼯程pom:<?xml version="1.0" encoding="UTF-8"?><project xmlns="/POM/4.0.0" xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/POM/4.0.0 https:///xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>2.4.0</version><relativePath/> </parent><groupId>com.ld</groupId><artifactId>mybatis</artifactId><version>0.0.1-SNAPSHOT</version><name>mybatis</name><description>Demo project for Spring Boot</description><packaging>pom</packaging><modules><module>DynamicSQL</module></modules><properties><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding><java.version>1.8</java.version><mysql.version>8.0.18</mysql.version><mybatis.spring.boot.version>2.1.3</mybatis.spring.boot.version></properties><dependencyManagement><dependencies><dependency><groupId>org.mybatis.spring.boot</groupId><artifactId>mybatis-spring-boot-starter</artifactId><version>${mybatis.spring.boot.version}</version></dependency><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>${mysql.version}</version></dependency></dependencies></dependencyManagement><dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId></dependency></dependencies><build><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId></plugin></plugins></build></project>⼦⼯程pom:<?xml version="1.0" encoding="UTF-8"?><project xmlns="/POM/4.0.0"xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/POM/4.0.0 /xsd/maven-4.0.0.xsd"> <parent><artifactId>mybatis</artifactId><groupId>com.ld</groupId><version>0.0.1-SNAPSHOT</version></parent><modelVersion>4.0.0</modelVersion><artifactId>DynamicSQL</artifactId><dependencies><dependency><groupId>org.mybatis.spring.boot</groupId><artifactId>mybatis-spring-boot-starter</artifactId></dependency><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId></dependency></dependencies></project>最后：创建Module这些应该都是⼩问题了，如果⼈然不是很熟悉，推荐创建⼦⼯程时，使⽤maven的⽅式创建，这样可指定继承的⽗⼯程pom⽂件。

mvn parent 变量

mvn parent 变量
Maven中的parent标签有一个非常实用的变量，可以在子模块中引用父模块的依赖版本号或其他属性值。

该变量的名称为${project.version}，在pom.xml文件中可以通过
${project.version}来引用父模块的版本号。

例如，在父模块的pom.xml文件中定义了一个版本号为1.0的属性：
<properties>
<project.version>1.0</project.version>
</properties>
在子模块的pom.xml文件中可以通过${project.version}来引用该属性：
<dependencies>
<dependency>
<groupId>com.example</groupId>
<artifactId>example</artifactId>
<version>${project.version}</version>
</dependency>
</dependencies>
这样子模块就可以直接使用父模块定义的版本号，而不需要再重复定义一遍。

使用parent变量可以使Maven构建更加简洁和易于维护。