【Maven】使用Maven构建多模块项目
Maven的聚合工程（多模块工程）
Maven的聚合⼯程（多模块⼯程）在开发2个以上模块的时候，每个模块都是⼀个 Maven Project。
⽐如搜索平台，学习平台，考试平台。
开发的时候可以⾃⼰管⾃⼰独⽴编译，测试，运⾏。
但如果想要将他们整合起来，我们就需要⼀个聚合⼯程。
(1) ⽗模块的创建.⽗模块⼀般承担聚合模块和统⼀管理依赖的作⽤，没有实际代码和资源⽂件.⽗模块就是创建⼀个普通的 Maven Project , 此处省略.(2) ⼦模块的创建①⼦模块需要创建为Maven Module项⽬.②选择该⼦模块所属的⽗模块打包⽅式 : web 项⽬需要打 war 包，其他的⽐如 dao 层, service 层, entity 层都可以打 jar 包.实际的⽬录结构：⼦模块其实是包含在⽗模块⽂件夹⾥⾯的.(4) ⽗模块的 pom ⽂件.<modules><module>PYG-pojo</module><module>PYG-dao</module><module>PYG-Commons</module>...</modules>(5) ⼦模块的 pom ⽂件指明它的⽗模块是谁<modelVersion>4.0.0</modelVersion><!-- 指定它的⽗模块是谁 --><parent><groupId>.pyg</groupId><artifactId>PYG-Parent</artifactId><version>0.0.1-SNAPSHOT</version></parent><!-- 当前⼦模块的名字 --><artifactId>PYG-dao</artifactId>(6) 聚合⼯程的依赖传递⼀般都是在⽗模块的 pom 中定义项⽬⽤到的依赖以及版本,然后在⼦模块的 pom 中, 需要什么依赖就直接引⼊, 不引⼊版本号, 依赖会⾃动从⽗模块中传递到⼦模块中.①⽗模块中定义依赖<!-- 统⼀定义版本号 --><properties><spring.version>4.3.7.RELEASE</spring.version></properties><!-- ⽗模块统⼀管理依赖 --><dependencyManagement><dependencies><dependency><groupId>org.springframework</groupId><artifactId>spring-core</artifactId><version>${spring.version}</version></dependency><dependency><groupId>org.mybatis</groupId><artifactId>mybatis</artifactId><version>${mybatis.version}</version></dependency></dependencies></dependencyManagement>②⼦模块中使⽤依赖⼦模块中使⽤的话, 不需要定义版本号.<dependencies><dependency><groupId>org.springframework</groupId><artifactId>spring-core</artifactId></dependency></dependencies>(7) 聚合⼯程的安装.聚合⼯程不需要每个模块分别安装, 只要对⽗⼯程安装即可.①在打包⽅式为 pom 的模块中, 添加插件.<plugin><groupId>org.apache.tomcat.maven</groupId><artifactId>tomcat7-maven-plugin</artifactId><version>2.2</version><configuration><port>8080</port><path>/</path></configuration></plugin>②在⽗模块上, 右键 -> Run As -> Maven install ③执⾏结果 : ⽗⼯程和⼦模块都Build成功了(7) 多模块的 WEB 项⽬运⾏.在打包⽅式为 pom 的模块上, 右键maven clean tomcat7:run。
Maven的介绍及使用
Maven的介绍及使⽤⼀、Maven简介 Maven 是⼀个项⽬管理⼯具，可以对 Java 项⽬进⾏构建、依赖管理，是⼀个⾃动化构建⼯具。
⾃动化构建⼯具：将原材料（java、js、css、html....）->产品（可发布项⽬） 编译-打包-部署-测试 -> ⾃动构建Maven的作⽤：1、管理jar包1. 增加第三⽅jar包（不需要⾃⼰下载jar包）2. 管理jar包之间的依赖关系（maven⾃动关联下载所有依赖的jar包）2、将项⽬拆分成若⼲个模块：借助于Maven可以将⼀个项⽬拆分成多个⼯程。
（例如爱洋葱）Maven能⼲的事情： 清理：删除编译的结果，为重新编译做准备。
编译：java->class 测试：针对于项⽬中的关键点进⾏测试，也可⽤项⽬中的测试代码去测试开发代码 报告：将测试结果进⾏显⽰ 打包：将项⽬中包含的多个⽂件压缩成⼀个⽂件，⽤于安装或部署（java项⽬打成⼀个jar包，web项⽬打成⼀个war包，⽗⼯程-pom） 安装：将打成的包，放到本地仓库，供其他项⽬使⽤。
部署：将打成的包，放到服务器上，准备运⾏。
Eclipse中的项⽬，要在Tomcat中运⾏，需要部署： a、通过eclipse中add and remove按钮进⾏部署 b、将Web项⽬打成⼀个war包，然后将该war包复制到Tomcat/webapps中即可 通常下载⼀个jar包，先在本地仓库中下载，如果本地仓库中不存在，则再联⽹到中央仓库（镜像）去下载。
约定配置： Maven 提倡使⽤⼀个共同的标准⽬录结构，Maven 使⽤约定优于配置的原则，⼤家尽可能的遵守这样的⽬录结构。
如下所⽰：⼆、Maven POM POM(项⽬对象模型) 是 Maven ⼯程的基本⼯作单元，是⼀个XML⽂件，包含了项⽬的基本信息，⽤于描述项⽬如何构建，声明项⽬依赖，等等。
执⾏任务或⽬标时，Maven 会在当前⽬录中查找 POM。
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的最佳实践需要根据项目的实际情况来进行具体的规划和实施。
使用eclipse搭建maven多module项目（构建父子项目）
3.next
4.next
5.finish–>配置pom.xml (主要把多余部分删除，junit只要在父工程的pom配置就可以了) 创建web module
1. 与创建java module的1、2点一样； 2. next
3.把包名定义下~ 4.右键pdd-shop-appweb项目–>properties–>Project Facets–>Convert to faceted form.. 这里选2.4版本的web工程是因为楼主用的是tomcat 6.0啦，按自己实际情况去修改
网络错误503请刷新页面重试持续报错请尝试更换浏览器或网络环境
使用 eclipse搭建 maven多 module项目（构建父子项目）
创建空 maven项目
1. File–>new–>project…
2.next
3.next
4.finish
5.配置pom.xml
创建 module
创建java module 1. 右键ppd-shop项目–>new–>project…
5.配置pom.xml 配置中有两点说明下：1、把jar包自动拷贝到web-inf目录地下，这个搞web开发都懂是为什么了；2、配置子项目依赖
项目依赖
扩展
JAVA学习之maven的使用
JAVA学习之maven的使⽤场景：最近使⽤springboot写⼀些⼩demo，发现到处都要使⽤maven，更离不开其中的pom.xml⽂件，所以这⾥对maven的常规使⽤作出⼀个整理。
⽂章结构：1. 安装配置maven环境2. maven⽬录结构3. HelloMaven4. 常⽤构建命令5. 使⽤archetype插件⾃动建⽴⽬录6. 坐标&仓库7. ⽣命周期&插件的使⽤8. pom.xml常⽤标签介绍9. maven依赖（范围、传递、冲突）10. 聚合&继承正⽂：1. 安装配置maven环境⾸先，在中下载maven组件。
进⼊官⽹后，在左边菜单找到Download选项，点击进⼊Download页⾯。
当然，我们⾸先要保证JDK安装好。
接下来，要在本地配置好maven的系统环境变量，新建⼀个maven_home的变量，然后在系统变量的path后⾯追加这个maven_home;接着，我们测试下maven安装成功没有（注意，⼀般我们都先安装好JDK，因为maven的命令应该是要借助jdk的）：如图所⽰，显⽰了maven的版本信息跟jdk的版本信息，当然，我们也可以使⽤echo 查看下系统环境变量：到这⾥，我们对maven的环境配置就完成了。
其实这是第⼀种，我们下载jar包的形式，不过本⼈是使⽤第⼆种，直接安装eclipse（包含maven）的版本即可，⽐如我安装的版本即是⾃带的maven；接下来只需要配置好本地的系统变量即可。
诶，如果我们想要改变maven的版本呢，我们可以在eclipse当中的preferences当中改变：2. maven项⽬的⽬录结构先在这⾥插⼊⼀点个⼈对maven的理解，我们之前每个项⽬都需要有⾃⼰的jar包，但是这么多jar包很多有相同的，⽽这些jar包⼜是基于项⽬存放的，如果我们跨越项⽬这⼀层，统⼀管理jar包呢，这样不就可以节约很多空间和时间。
idea maven多模块项目搭建 简书
idea maven多模块项目搭建简书Idea是一款非常流行的Java集成开发环境（IDE），而Maven是一款强大的项目管理工具。
结合使用Idea和Maven可以快速、高效地搭建多模块项目。
在本文中，我们将介绍如何使用Idea Maven搭建多模块项目，并给出一些实际的示例。
1.创建一个Maven父工程首先，在Idea中创建一个新项目，选择Maven项目模板。
然后，填写项目信息，包括GroupId、ArtifactId和Version等。
2.创建子模块在父工程中右键单击，选择新建Maven模块。
在弹出的对话框中，选择创建一个新的子模块。
3.配置子模块的pom.xml文件在子模块的pom.xml文件中，配置依赖项、插件和其他一些项目相关的配置。
根据项目需求，选择合适的依赖项，并确保版本兼容性。
4.添加依赖关系在父工程的pom.xml文件中，添加子模块的依赖关系。
根据项目需求，选择合适的依赖项，并确保版本兼容性。
示例如下：```xml<modules><module>子模块1</module><module>子模块2</module></modules>```5.构建和运行项目在Idea中，点击项目右上角的绿色运行按钮，即可构建和运行多模块项目。
6.文件结构一个典型的多模块项目的文件结构如下：```- Parent Project（父工程）- pom.xml（父工程的配置文件）- Submodule 1（子模块1）- pom.xml（子模块1的配置文件）- src/main/java- src/main/resources- ...- Submodule 2（子模块2）- pom.xml（子模块2的配置文件）- src/main/java- src/main/resources- ...- ...```7.实际示例下面以一个简单的Web应用为例，来演示如何使用Idea Maven搭建多模块项目。
SpringBoot+maven聚合项目创建与打包部署的完整流程
SpringBoot+maven聚合项⽬创建与打包部署的完整流程开发环境：IDEA，SprngBoot 2.0.4，Maven 2.19.1⼯程结构：⽗⼯程father⼦模块 dao （⽤于持久化数据跟数据库交互）⼦模块 entity （实体类）⼦模块 service （处理业务逻辑）⼦模块 web （页⾯交互接收、传递数据，唯⼀有启动类的模块）关系： web依赖 service、dao、entityservice依赖 dao、entitydao依赖 entityentity谁都不依赖，独⽴的这⾥我⽤⽐较常见的⼯程结构举例说明，有些公司的项⽬可能会把模块分的很细，或者会有两个程序⼊⼝，也就是两个可以启动的模块！这个我在⽂章最后会做说明！缕清了思路其实没那么复杂！⼀，创建Maven多模块项⽬先建⽴外层⽗⼯程 File →new →project 选择Spring Initializr Next下⼀步到以下页⾯⼯程结构如下接下来，把src整个删掉，⽗⼯程不需要，因为⽗⼯程你就当它只有⼀个外壳就完了接下来创建⼦模块⼯程上右键→ new → Module 选择Spring Initaializr 下⼀步重复以上动作，创建dao模块，service模块，web模块service模块和entity模块⼀样什么都不需要引⼊dao模块和web模块可以根据实际需求选择引⼊mysql，mybatis，redis，web这些，我把我的贴出来删除每个⼦模块中没⽤的⽂件，.mvn、.gitignore、daoiml、mvnw、mvnw.cmd⽂件只留下pom.xml删除除了web模块以外其它模块中的Applicatin启动项，和resources⽬录下的application.properties配置⽂件以上动作操作完成以后如果你发现你的⼦模块变成了⽂件夹，没关系，找到Maven Projects刷新⼀下就好了整理过后的项⽬结构是这样的以上项⽬的基本结构就完成了，接下来建⽴各⾃依赖⼆、依赖关系打开⽗pom.xml修改打包⽅式jar为pom，注意：build内容也需要做替换，因为默认的spring-boot-maven-plugin这种⽅式，等到后期打包的时候他会⼀直提⽰你，你引⼊的依赖不存在！代码如下4.0.0com.miufather0.0.1-SNAPSHOTpom<name>father</name><description>Demo project for Spring Boot</description><parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>2.0.4.RELEASE</version><relativePath/> <!-- lookup parent from repository --></parent><properties><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding><project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding><java.version>1.8</java.version></properties><!--声明你有四个⼉⼦ --><modules><module>entity</module><module>dao</module><module>service</module><module>web</module></modules><dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId><scope>test</scope></dependency></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></configuration></plugin><plugin><groupId>org.apache.maven.plugins</groupId><artifactId>maven-surefire-plugin</artifactId><version>2.19.1</version><configuration><skipTests>true</skipTests> <!--默认关掉单元测试 --></configuration></plugin></plugins></build>这⾥有个坑需要注意，dao、service、entity这三个模块的pom.xml⽂件中不需要build 内容，直接⼲掉entity 的 pom.xml 内容4.0.0com.miuentity0.0.1-SNAPSHOTjarentityDemo project for Spring Bootcom.miufather0.0.1-SNAPSHOT../pom.xml<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding><project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding><java.version>1.8</java.version>org.springframework.bootspring-boot-starterorg.springframework.bootspring-boot-starter-testtestdao 的 pom.xml 内容4.0.0com.miudao0.0.1-SNAPSHOTjardaoDemo project for Spring Bootcom.miufather0.0.1-SNAPSHOT../pom.xml<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding><project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding> <java.version>1.8</java.version>org.springframework.bootspring-boot-starter-data-redisorg.mybatis.spring.bootmybatis-spring-boot-starter1.3.2mysqlmysql-connector-javaruntimeorg.springframework.bootspring-boot-starter-testtestcom.miuentity0.0.1-SNAPSHOTservice 模块的 pom.xml 内容4.0.0<groupId>com.miu</groupId><artifactId>service</artifactId><version>0.0.1-SNAPSHOT</version><packaging>jar</packaging><name>service</name><description>Demo project for Spring Boot</description><!--声明⽗模块--><parent><groupId>com.miu</groupId><artifactId>father</artifactId><version>0.0.1-SNAPSHOT</version><relativePath>../pom.xml</relativePath></parent><properties><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding><project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding><java.version>1.8</java.version></properties><dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId><scope>test</scope></dependency><!--service模块引⼊entity模块--><dependency><groupId>com.miu</groupId><artifactId>entity</artifactId><version>0.0.1-SNAPSHOT</version></dependency><!--service模块引⼊dao模块--><dependency><groupId>com.miu</groupId><artifactId>dao</artifactId><version>0.0.1-SNAPSHOT</version></dependency></dependencies>web模块的 pom.xml 内容注意build部分，因为web模块作为程序的⼊⼝启动，所以它需要打包，并且要指定Main Class 4.0.0com.miuweb0.0.1-SNAPSHOTjarwebDemo project for Spring Bootcom.miufather0.0.1-SNAPSHOT../pom.xml<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding><project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding><java.version>1.8</java.version>org.springframework.bootspring-boot-starter-data-redisorg.springframework.bootspring-boot-starter-weborg.mybatis.spring.bootmybatis-spring-boot-starter1.3.2mysqlmysql-connector-javaruntimeorg.springframework.bootspring-boot-starter-testtestcom.miuentity0.0.1-SNAPSHOTcom.miuservice0.0.1-SNAPSHOTcom.miudao0.0.1-SNAPSHOTorg.springframework.bootspring-boot-maven-plugincom.miu.web.WebApplicationZIPrepackage到此为⽌所有的依赖全部完成！接下来就是测试！这⾥只⽤简单的测试来实验！三、代码测试entity模块中创建 EntiyTest类dao模块中创建 DaoTest类service模块中创建ServiceTest类Web模块中创建WebTest类最后把web模块中的application.properties⽂件补充⼀下就OK了，因为引⼊了mysql，redis等配置，所以数据源是要配的，不然运⾏起来会报错找不到数据源！server.port=8080-----------------------------------数据库配置----------------------------------------spring.datasource.driver-class-name=com.mysql.jdbc.Driverspring.datasource.url=jdbc:mysql://127.0.0.1:3306/test?characterEncoding=utf8ername=rootspring.datasource.password=123------------------------------------redis配置---------------------------------------spring.redis.database=0spring.redis.host=127.0.0.1spring.redis.port=6379spring.redis.password=spring.redis.jedis.pool.max-active=8spring.redis.jedis.pool.max-idle=8spring.redis.jedis.pool.max-wait=-1msspring.redis.jedis.pool.min-idle=0spring.redis.timeout=10000ms⼀切准备就绪，开始运⾏web模块下的启动类进⾏测试四、打包可执⾏jar看到上⾯的页⾯就证明模块之间的依赖没有问题，调⽤正常，我这⾥是⽤简单的创建对象的这种⽅式来操作的，实际开发并不是这种操作，⼤部分都是通过 @Autowired 注解来实现的注⼊，这⾥我就不做演⽰了，只要模块之间调⽤没问题，剩下的就是铺代码的事了，接下来还有最后⼀个打包问题，为什么要啰嗦那么多还要说打包问题呢，因为我建议在项⽬架构之初，除了搭框架以外，最好是在最开始的时候就测试⼀下打包，尤其是这种多模块项⽬之间各种依赖的这种⼯程的打包，如果等你代码写的铺天盖地的时候你在去想怎么打包，到时候有你头疼的！如果你是按照我本章的流程⼀步步下来的话，那么你完全不⽤担⼼打包问题，因为所有的pom.xml有已经配置好了，只需要动⼿运⾏package打包动作就⾏了，第⼀次打包不需要clean，记住以后每次打包之前clean⼀下，关于为什么打jar包，不打war包这个问题，还有其它会遇到的问题，在⽂章最后会做说明！双击运⾏package，看到BUILD SUCCESS 就证明打包成功了，如此简单？告诉你就是这么简单，前提是你的每⼀个模块下的pom.xml要配置好，谁需要打包，谁不需要打包，谁依赖谁，⽗⼯程是否声明了⼦模块，⼦模块是否声明了⽗⼯程是谁，这些是重点！接下来去找你⼯程⽬录，web⽂件夹下的target⽂件夹，刚才打包好的jar⽂件，就放在这⾥了然后我把这个jar⽂件上传到我的测试服务器，使⽤ java -jar web-0.0.1-SNAPSHOT.jar 命令来测试运⾏打包的可执⾏jar⽂件到底⾏不⾏！运⾏成功，输⼊我测试服务器地址测试也没问题，到此为⽌全部搞定聚合⼯程举⼀个简单的例⼦，整个⼯程你就当作⼀个公司，⽗⼯程（退休了什么也不⼲）只需要声明有⼏个⼉⼦（⼦模块）就完事了，⼦模块web声明⽗⼯程是谁，就当他是⼤⼉⼦，公司他管事，pom.xml⽂件需要打包，需要build配置，需要其它三个兄弟帮助其它⼦模块声明⽗⼯程是谁，之间关系都是兄弟，不需要打包，哪⾥需要去哪⾥！在此我说⼀下重点和需要注意的地⽅！1.⽗pom.xml 打包⽅式，jar要更改为pom，build 需要更改2.不需要打包的模块pom.xml⽂件中不要写，全删掉，例如有些⼯程中的common模块，utils模块，entity模块，service模块都不需要打包3.声明⽗⼯程时，填写⽗⼯程位置../pom.xml4.关于applicatin.properties配置⽂件，只需要在启动的模块中配置就可以了，5.关于打包为什么打包jar包，不打war包，打war包⽬的是war包可以运⾏在tomcat下，但是SpringBoot是内置tomcat，如果你打war包，前提是⼲掉内置的tomcat，然后才能打包，各种⿇烦，直接打包可执⾏jar包，使⽤java -jar 命令就可以完美的运⾏起来很⽅便！6.真实开发中使⽤@Autowired 注解来实现注⼊，⽽不是new对象这种⽅式，所以可能会产⽣注⼊以后报错，是因为你的启动类上没有配置扫描，使⽤@ComponentScan(basePackages = "你的路径")注解来解决，如果你使⽤的持久层是Mybatis，那么你的mapper也需要扫描，在启动类上使⽤@MapperScan("你的mapper⽂件地址")注解来解决，算了还是贴个图⽚吧不罗嗦了，就到这⾥吧，⼀个⽂章写了两个⼩时可见我的良苦⽤⼼，（关键是我被这个多模块打包问题困扰了好长时间，⽹上各种找解决办法，说的天花乱坠，狗屁不通，服的五体投地）。
maven 模板
maven 模板Maven 模板。
Maven 是一个强大的项目管理工具，它可以帮助开发人员更轻松地构建、发布和管理项目。
Maven 使用项目对象模型（POM）来描述项目，通过插件和目标来执行各种构建任务。
在实际项目中，我们经常需要创建一些通用的 Maven 模板来加快项目的开发和部署过程。
本文将介绍如何创建和使用 Maven 模板，以及一些常见的 Maven 模板示例。
一、创建 Maven 模板。
1. 创建 Maven 项目。
首先，我们需要创建一个 Maven 项目作为模板。
可以使用 Maven 的 archetype插件来创建一个基本的 Maven 项目，然后将其作为模板进行定制化。
在命令行中执行以下命令来创建一个 Maven 项目：```bash。
mvn archetype:generate -DgroupId=com.example -DartifactId=my-project -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false。
```。
这将创建一个名为 `my-project` 的 Maven 项目，可以作为我们的模板项目。
2. 定制化模板。
一旦有了基本的Maven 项目，我们可以根据实际需求对其进行定制化。
比如，可以添加一些常用的依赖、配置文件、插件等，以及定义一些常用的构建目标。
定制化完成后，我们就可以将这个项目作为 Maven 模板来使用了。
3. 安装模板到本地仓库。
为了方便后续的使用，我们需要将定制化后的模板安装到本地Maven 仓库中。
在模板项目的根目录下执行以下命令：```bash。
mvn install。
```。
这将把模板项目安装到本地 Maven 仓库中，以便后续可以通过 Maven 的archetype 插件来生成基于这个模板的新项目。
二、使用 Maven 模板。
1. 生成新项目。
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 的确保依赖也是进⾏编译部署的。
maven配置多模块项目pommodules
maven配置多模块项⽬pommodules所有⽤Maven管理的真实的项⽬都应该是分模块的，每个模块都对应着⼀个pom.xml。
它们之间通过继承和聚合（也称作多模块，multi-module）相互关联。
那么，为什么要这么做呢？我们明明在开发⼀个项⽬，划分模块后，导⼊Eclipse变成了N个项⽬，这会带来复杂度，给开发带来不便。
为了解释原因，假设有这样⼀个项⽬，很常见的Web应⽤。
在这个应⽤中，我们分了⼏层：Dao层负责数据库交互，封装了Hibernate交互的类。
Service层处理业务逻辑，放⼀些Service接⼝和实现相关的Bean。
Web层负责与客户端交互，主要有⼀些Structs的Action类。
对应的，在⼀个项⽬中，我们会看到⼀些包名：org.myorg.app.daoorg.myorg.app.serviceorg.myorg.app.weborg.myorg.app.util这样整个项⽬的框架就清晰了，但随着项⽬的进⾏，你可能会遇到如下问题：1. 这个应⽤可能需要有⼀个前台和⼀个后台管理端（web或者swing），你发现⼤部分dao，⼀些service，和⼤部分util是在两个应⽤中可。
这样的问题，你⼀周内遇到了好⼏次。
2. pom.xml中的依赖列表越来越长以重⽤的，但是，由于⽬前只有⼀个项⽬（WAR），你不得不新建⼀个项⽬依赖这个WAR，这变得⾮常的恶⼼，因为在Maven中配置对WAR的依赖远不如依赖JAR那样简单明了，⽽且你根本不需要org.myorg.app.web。
有⼈修改了dao，提交到svn并且不⼩⼼导致build失败了，你在编写service的代码，发现编译不过，只能等那⼈把dao修复了，你才能继续进⾏，很多⼈都在修改，到后来你根本就不清楚哪个依赖是谁需要的，渐渐的，很多不必要的依赖被引⼊。
甚⾄出现了⼀个依赖有多个版本存在。
3. build整个项⽬的时间越来越长，尽管你只是⼀直在web层⼯作，但你不得不build整个项⽬。
Jenkins自动触发构建maven多模块项目
Jenkins⾃动触发构建maven多模块项⽬⼀、要求
在⼀个Spring boot项⽬中，通过Jenkins来触发构建某单⼀模块时，其他模块和其余分⽀不受影响
⼆、Jenkins配置
1. 安装插件
插件：Generic Webhook Trigger Plugin
2. 配置⽤户
设置⽤户token，不然会报403错误
jenkins---> ⽤户列表----> 具体⽤户------> 设置
（记住token，保存下来）
三、构建项⽬
1.选择插件
2. 在Post content parameters中新增参数
3. 第⼆个参数
4. 第三个参数
5. Optional filter
^(refs/heads/dev)\s(ssh://git@xxxx.git)\s([\s\S]*xxxx[\s\S]*)$ $ref $git_ssh_url $commits
# 这边匹配的dev分⽀
# (ssh://git@xxx.git) ： gitlab上git_ssh_url地址
# *xxx : 匹配的模块名称
四、配置GitLab
1. 配置wenhook
2.添加jenkins信息
http://user:user_token@jenkin_server/generic-webhook-trigger/invoke # user: jenkins⽤户设置添加token的⽤户
# user_token: 第⼆步设置的⽤户 token
# jenkins_server: jinkins的地址
此时点击test测试，如果有相关分⽀的推送，就会⾃动构建发布。
idea maven多模块项目搭建 简书
idea maven多模块项目搭建简书Idea Maven多模块项目搭建简书在本文中，将详细介绍如何使用Idea和Maven搭建一个多模块项目，并将其发布到简书。
Idea是一款强大的Java开发工具，而Maven是一个用于构建和管理Java项目的工具。
通过结合使用这两个工具，可以高效地搭建和管理一个复杂的多模块项目。
以下是搭建一个Idea Maven多模块项目的步骤：第一步：安装Idea和Maven首先，确保已经安装了Idea和Maven。
可以从官方网站下载并安装最新版本的Idea和Maven。
安装完成后，打开Idea。
第二步：创建一个Maven项目在Idea的欢迎界面中，选择“Create New Project”，然后选择“Maven”作为项目类型。
在下一步中，可以选择使用Maven的一个快速启动模板或者自定义项目设置。
第三步：配置项目结构在创建项目后，可以在Idea的工具栏中找到“Project Structure”选项。
点击这个选项，可以配置项目的结构和模块。
第四步：创建模块在“Project Structure”中的模块选项卡中，点击“+”按钮添加一个新模块。
可以选择一个Maven模板或者自定义模块设置。
第五步：配置模块依赖在模块创建后，可以在“Dependencies”选项卡中配置模块的依赖关系。
点击“+”按钮添加依赖项，并选择所需的依赖库。
第六步：编写代码在完成上述步骤后，可以开始编写代码了。
每个模块都有自己的源代码目录，可以按照需要在相应的目录下创建Java类。
第七步：构建和测试项目在Idea中，可以使用Maven进行项目构建和测试。
可以在Idea的右侧窗口中找到“Maven Projects”选项卡，并选择“Lifecycle”下的“clean”和“install”来构建和测试项目。
第八步：发布到简书完成项目的开发和测试后，可以将其发布到简书。
首先，需要在简书上创建一个账号，并登录到该账号。
解决idea使用maven多模块install报依赖模块的包找不到的问题
解决idea使⽤maven多模块install报依赖模块的包找不到的问题
解决⽅法：
如果被依赖项⽬是springboot项⽬，那么可以把相关的springboot的东西移除掉，改造成普通项⽬。
如果不想改造项⽬，那就添加
<configuration>部分的配置，因为springboot项⽬打包的时候会⽣成两个jar包（如下图所⽰)：⼀个是普通可被引⽤的jar包，另⼀个是springboot的可执⾏jar包。
后者会将前者覆盖，但后者却不可以被别的模块引⽤。
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<!--命名可执⾏jar名字，默认可执⾏Jar包与普通jar命名相同，前者会将后者覆盖，可执⾏Jar不能够被其他模块引⽤-->
<configuration>
<classifier>exec</classifier>
</configuration>
</plugin>
</plugins>
</build>
欢迎访问个⼈博客，共同学习，共同进步！。
Maven多模块项目，统一使用父pom的依赖
Maven多模块项⽬，统⼀使⽤⽗pom的依赖当前项⽬是⼀个平台，为了好管理，需要区分多个⼦系统，所以需要创建⼀个Maven多模块项⽬。
框架使⽤的是SpringBoot，其中⽤到的starter包有：1. lombok2. validation3. mybatis-plus4. mysql驱动5. devtools为了好管理，所以将⽗pom进⾏改造：⼀共有这么⼏步：⾸先引⼊parent，为的是统⼀starter的版本：<parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>2.2.6.RELEASE</version><relativePath/> <!-- lookup parent from repository --></parent><groupId>com.example.child.demo</groupId><artifactId>business-child-demo</artifactId><version>0.0.1-SNAPSHOT</version>然后需要将packaging修改为pom<packaging>pom</packaging>指定编译插件和release插件<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></configuration></plugin><plugin><groupId>org.apache.maven.plugins</groupId><artifactId>maven-release-plugin</artifactId><version>2.4.1</version><configuration><autoVersionSubmodules>true</autoVersionSubmodules></configuration></plugin></plugins></build>然后引⼊需要的依赖：<dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-validation</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-devtools</artifactId><scope>runtime</scope><optional>true</optional></dependency><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><scope>runtime</scope></dependency><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId><optional>true</optional></dependency><dependency><groupId>com.baomidou</groupId><artifactId>mybatis-plus-boot-starter</artifactId><version>${mybatis-plus.version}</version></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId><scope>test</scope><exclusions><exclusion><groupId>org.junit.vintage</groupId><artifactId>junit-vintage-engine</artifactId></exclusion></exclusions></dependency></dependencies>然后在⼦项⽬的pom.xml中通过parent引⼊⽗pom.xml<?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><groupId>com.example.child.demo</groupId><artifactId>business-child-demo</artifactId><version>0.0.1-SNAPSHOT</version><name>business-child-demo</name><description>Spring Boot Demo</description><parent><groupId>org.example.parent</groupId><artifactId>example-parent</artifactId><version>1.0-SNAPSHOT</version></parent><build><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId></plugin></plugins></build></project>这样就可以了，然后就可以通过package命令打成jar包运⾏了。
Maven学习基础
最新课件
12
maven作为一个高度自动化构建工具，本身提供了构建 项目的功能，下面就来体验一下使用maven构建项目的 过程。
一、构建Jave项目
1、使用mvn archetype:generate命令：
mvn archetype:generate -DgroupId=com.mycompany.app -DartifactId=myapp DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false
最新课件 </properties>
8
使用Maven编译、清理、测试、打包项目
1、使用Maven编译项目，编译项目的命令是："mvn compile“ 2、使用Maven清理项目，清理项目的命令是："mvn clean“ 3、使用Maven测试项目，测试项目的命令是："mvn test“ 4、使用Maven打包项目，打包项目的命令是："mvn package“ 5、使用Maven部署项目，部署项目的命令是："mvn install"
使用"mvn install"命令，就把maven构建项目的【清理】→【编译】→ 【测试】→【打包】的这几个过程都做了，同时将打包好的jar包发布到 本地的Maven仓库中，所以maven最常用的命令还是"mvn install"，这个 命令能够做的事情最多。
最新课件
9
maven的编译，清理，测试，打包，部署命令是可以 几个命令同时组合起来使用的，常用的命令组合如下：
Maven使用基础
最新课件
1
一、Maven的基本概念
maven 命令行用法
maven 命令行用法
Maven是一个构建工具和项目管理工具，可以帮助开发人员自动化构建、部署和管理Java项目。
以下是一些常用的Maven 命令行用法：
1. 清理项目：mvn clean
- 清理项目生成的目录和文件，如target目录。
2. 编译项目：mvn compile
- 编译项目的源代码，生成编译后的class文件。
3. 打包项目：mvn package
- 在项目的目录下生成可部署的jar、war或其他类型的程序包。
4. 运行单元测试：mvn test
- 执行项目中的单元测试。
5. 安装项目：mvn install
- 将项目的构件安装到本地仓库，可以在其他项目使用该构件。
6. 部署项目：mvn deploy
- 将项目的构件上传到远程仓库，以供其他开发人员使用。
7. 生成项目报告：mvn site
- 生成项目的文档报告，包括项目的各种统计信息和代码覆
盖率等。
8. 清理本地仓库：mvn dependency:purge-local-repository
- 清理本地仓库中的所有已下载的构件。
9. 查看项目依赖：mvn dependency:tree
- 查看项目的依赖树结构。
10. 运行插件：mvn <plugin>:<goal>
- 运行指定的插件和目标，可以根据项目的需要来运行Maven插件。
这些只是Maven命令行的部分用法，Maven还有很多其他功能和命令可以用来管理和构建Java项目。
请参考Maven官方文档以获取更详细的信息。
解决maven多模块之间的相互依赖的方案
解决maven多模块之间的相互依赖的⽅案近期在做⼀个普通javaweb项⽬转转换成maven项⽬的任务。
原项⽬类型:javaWeb项⽬两个源码包⼀个产品基础包，⼀个基于产品基础包的开发包，两个都是普通javaWeb项⽬。
本来应该是开发包可以单边引⽤产品基础包的，由于开发不规范最终导致产品基础包和开发包存在了相互引⽤。
针对当时我们的项⽬我考虑了两种⽅案：⽅案⼀、将产品基础包和开发包整合成⼀个源码包，再重构为Maven项⽬。
产品基础包编译成jar包，jsp页⾯整合到开发包中。
后续产品基础包如果升级，重新编译成jar包更换现有jar即可，涉及⽤到的jsp需要项⽬组开发团队整合到正在使⽤的开发包中按正常版本发布流程提交源码即可。
（这种⽅案需⼈⼯整合为⼀个源码包，相互间的引⽤⾃然就不存在了）⽅案⼆、使⽤Maven聚合⼯程使⽤Maven聚合⼯程，将产品基础包和开发包分别构建成两个Maven模块，然后将开发包⽬前最新版本打成jar包放⼊Maven仓库由产品基础包引⽤从⽽断掉产品基础包对开发包之前的引⽤，之后开发时务必做到开发包单边引⽤产品基础包，便不会再出现产品基础包对开发包的引⽤。
剩下的就由开发包单边依赖产品基础包即可，从⽽可以避免循环依赖。
后续产品基础包如果升级，按正常版本发布流程提交源码即可，⽆需⼈⼯整合，各⾃提交到各⾃的Maven模块，⽆影响。
(这种⽅案后期要确保：开发⼈员严格遵守开发规范开发包单边引⽤产品基础包)考虑到⼀下两种原因，最终采⽤了第⼆种⽅案：1、整合两个源码包需要花费很长时间影响进度，且整合过程中也存在⼀定的风险。
2、后续产品基础包可能存在升级3、还有其他模块功能待整合上线，需要考虑到可扩展性。
后⾯再⽹上查问题时碰到更好的⽅案，以下内容转⾃：很多时候随着项⽬的膨胀，模块会越来越多，如果设计上稍有不慎就会出现模块之间相互依赖的情况。
这对于使⽤M aven的⽤户是⽐较痛苦的，因为出现模块之间相互依赖的话在构建的时候就会失败，Maven通常要先编译被依赖的模块，如果出现相互依赖M aven就不知道该怎么办了。
maven executions 用法
Maven是一款广泛使用的项目管理工具，它可以帮助开发人员自动化项目构建过程，简化项目管理和依赖库管理。
在Maven中，executions是一个重要的概念，它可以让开发人员在构建过程中执行特定的插件和目标。
本文将介绍Maven executions的用法，并指导开发人员如何利用executions实现项目构建和部署的自动化。
一、什么是Maven executions1.1 Maven executions的概念在Maven中，executions是指在项目构建过程中执行插件和目标的配置。
每个插件都可以包含一个或多个executions，用于在特定阶段执行插件的功能。
通过配置executions，开发人员可以在构建过程中实现各种自定义的操作，如编译、测试、打包、部署等。
1.2 executions的配置方式在Maven的pom.xml文件中，开发人员可以通过<executions>标签来配置插件的executions。
通常，一个插件的executions配置包括插件的目标、阶段和操作等信息。
通过配置executions，开发人员可以灵活地控制项目构建过程中插件的执行顺序和行为。
二、Maven executions的用法2.1 在项目中使用executions对于有些需要在构建过程中执行的操作，如代码生成、资源处理、测试覆盖率检查等，可以通过配置executions来实现。
通过在pom.xml中添加插件的executions配置，可以在构建过程中自动执行相应的操作，提高项目的构建效率和质量。
2.2 自定义构建流程通过合理配置executions，开发人员可以将构建过程中的各个步骤组织起来，形成一个完整的自定义构建流程。
可以在构建过程中依次执行代码编译、单元测试、打包、部署等步骤，从而实现项目构建和部署的自动化。
2.3 控制插件的执行顺序在Maven中，插件的执行顺序对项目的构建过程至关重要。
java基础知识-Maven-maven多模块工程打包部署
java基础知识-Maven-maven多模块⼯程打包部署⼀般maven多模块⼯程结构如下图，图中分为dao数据层和上层web层(当然还可以有service层),在进⾏多模块划分的时候，⼀般将dao层采⽤jar进⾏打包，web层进⾏war打包。
在进⾏war包部署时，发现dao是以jar包形式存在于lib包⽬录下，dao⾥引⽤的配置⽂件也都在⾃⼰的jar⽂件⾥，如果部署服务器时，web层会引⽤不到dao⾥的配置⽂件。
因此研究了下⽤maven进⾏合并打包的⽅法：project|--business (核⼼业务)|--business-api|--business-service|--business-message|--business-dao|--business-web|--common (公共组件、服务、常量)|--common-component|--common-component-...|--common-service|--common-constants|--common-...|--management (管理台)|--management-...|--taskserver (定时任务、批处理)|--msgserver (消息队列)1.确保dao pom.xml中有以下配置<!--配置打包时不过滤⾮java⽂件开始 --><!--说明，在进⾏模块化开发打jar包时，maven会将⾮java⽂件过滤掉，xml,properties配置⽂件等，但是这些⽂件⼜是必需的，使⽤此配置可以在打包时将不会过滤这些必需的配置⽂件。
--><resources><resource><directory>src/main/java</directory><includes><include>**/*.js</include><include>**/*.json</include><include>**/*.properties</include><include>**/*.xml</include></includes><!-- resource的filtering属性⽤来表⽰资源⽂件中的占位符是否需要被替换，true为需要替换。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
一、Maven多模块项目Maven多模块项目,适用于一些比较大的项目，通过合理的模块拆分，实现代码的复用，便于维护和管理。
尤其是一些开源框架，也是采用多模块的方式，提供插件集成，用户可以根据需要配置指定的模块。
项目结构如下：test-hd-parent (父级)---pom.xml---test-hd-api (第三方接口层)----pom.xml---test-hd-foundation (基础工具层)----pom.xml---test-hd-resource(资源层)----pom.xml---test-hd-service (逻辑业务层)----pom.xml---test-hd-modules (web层)----pom.xml---test-hd-www (web模块1)----pom.xml---test-hd-admin (web模块2)----pom.xml二、创建一个父maven工程新建一个maven项目，选择存储位置，并选择创建一个简单的maven工程●输入Group Id、Artifact Id、Packaging，packaging选择pom包●生成父工程，pom.xml如下●删除工程中的src 目录三、创建子模块右击父工程名---》New---》Project，然后选择新建一个maven module工程设置子工程名以及父工程，再设置快速创建模式得到子工程（test-hd-api，第三方接口层），设置编译的jdk∙同理设置，子模块：test-hd-foundation(基础工具层)、test-hd-resource(资源层) 、test-hd-service(逻辑业务层)∙新建test-hd-modules (web层)，选择创建一个a simple project，输入Group Id、Artifact Id、Packaging，packaging选择pom包四、创建web子模块∙web子模块在建在test-hd-modules (web层)里面，右击test-hd-modules 工程名---》New---》Project，然后选择新建一个maven module工程，设置子工程名以及父工程，选择新建web项目∙配置maven web项目，参照：【Maven】Eclipse 使用Maven创建Java Web项目∙同理可以配置其他的web子模块test-hd-admin(web模块2)五、配置个模块的依赖在parent项目pom.xml中建立依赖管理（dependencyManagement）<project xmlns="/POM/4.0.0" xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/POM/4.0.0/xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><groupId>com.hd</groupId><artifactId>test-hd-parent</artifactId><version>0.0.1-SNAPSHOT</version><packaging>pom</packaging><modules><module>test-hd-api</module><module>test-hd-service</module><module>test-hd-resource</module><module>test-hd-foundation</module><module>test-hd-modules</module></modules><!-- maven依赖--><dependencyManagement><dependencies><!-- hd --><dependency><groupId>com.hd</groupId><artifactId>test-hd-api</artifactId><version>0.0.1-SNAPSHOT</version></dependency><dependency><groupId>com.hd</groupId><artifactId>test-hd-service</artifactId><version>0.0.1-SNAPSHOT</version></dependency><dependency><groupId>com.hd</groupId><artifactId>test-hd-resource</artifactId><version>0.0.1-SNAPSHOT</version></dependency><dependency><groupId>com.hd</groupId><artifactId>test-hd-foundation</artifactId><version>0.0.1-SNAPSHOT</version></dependency><!-- Servlet --><dependency><groupId>javax.servlet</groupId><artifactId>javax.servlet-api</artifactId><version>3.0.1</version><scope>provided</scope></dependency><dependency><groupId>javax.servlet.jsp</groupId><artifactId>jsp-api</artifactId><version>2.2</version><scope>provided</scope></dependency><!-- jstl --><dependency><groupId>javax.servlet</groupId><artifactId>jstl</artifactId><version>1.2</version></dependency><dependency><groupId>taglibs</groupId><artifactId>standard</artifactId><version>1.1.2</version></dependency><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>3.8.1</version><scope>test</scope></dependency></dependencies></dependencyManagement></project>test-hd-foundation中的依赖<?xml version="1.0"?><projectxsi:schemaLocation="/POM/4.0.0 /xsd/maven-4.0.0.xsd"xmlns="/POM/4.0.0"xmlns:xsi="/2001/XMLSchema-instance"> <modelVersion>4.0.0</modelVersion><parent><groupId>com.hd</groupId><artifactId>test-hd-parent</artifactId><version>0.0.1-SNAPSHOT</version></parent><artifactId>test-hd-foundation</artifactId><dependencies><!-- servlet --><dependency><groupId>javax.servlet</groupId><artifactId>jstl</artifactId></dependency><dependency><groupId>taglibs</groupId><artifactId>standard</artifactId></dependency><dependency><groupId>junit</groupId><artifactId>junit</artifactId></dependency></dependencies><build><plugins><!-- define the project compile level --><plugin><groupId>org.apache.maven.plugins</groupId><artifactId>maven-compiler-plugin</artifactId><version>2.3.2</version><configuration><source>1.7</source><target>1.7</target></configuration></plugin></plugins></build></project>test-hd-api中的依赖关系<?xml version="1.0"?><projectxsi:schemaLocation="/POM/4.0.0 /xsd/maven-4.0.0.xsd"xmlns="/POM/4.0.0"xmlns:xsi="/2001/XMLSchema-instance"> <modelVersion>4.0.0</modelVersion><parent><groupId>com.hd</groupId><artifactId>test-hd-parent</artifactId><version>0.0.1-SNAPSHOT</version></parent><artifactId>test-hd-api</artifactId><dependencies><dependency><groupId>com.hd</groupId><artifactId>test-hd-foundation</artifactId> </dependency><!-- servlet --><dependency><groupId>javax.servlet</groupId><artifactId>jstl</artifactId></dependency><dependency><groupId>taglibs</groupId><artifactId>standard</artifactId></dependency><dependency><groupId>junit</groupId><artifactId>junit</artifactId></dependency></dependencies><build><plugins><!-- define the project compile level --><plugin><groupId>org.apache.maven.plugins</groupId><artifactId>maven-compiler-plugin</artifactId><version>2.3.2</version><configuration><source>1.7</source><target>1.7</target></configuration></plugin></plugins><finalName>test-hd-api</finalName></build></project>test-hd-resource中的依赖关系<?xml version="1.0"?><projectxsi:schemaLocation="/POM/4.0.0 /xsd/maven-4.0.0.xsd"xmlns="/POM/4.0.0"xmlns:xsi="/2001/XMLSchema-instance"> <modelVersion>4.0.0</modelVersion><parent><groupId>com.hd</groupId><artifactId>test-hd-parent</artifactId><version>0.0.1-SNAPSHOT</version></parent><artifactId>test-hd-resource</artifactId><dependencies><dependency><groupId>junit</groupId><artifactId>junit</artifactId></dependency></dependencies><build><plugins><!-- define the project compile level --><plugin><groupId>org.apache.maven.plugins</groupId><artifactId>maven-compiler-plugin</artifactId><version>2.3.2</version><configuration><source>1.7</source><target>1.7</target></configuration></plugin></plugins></build></project>test-hd-service中的依赖关系<?xml version="1.0"?><projectxsi:schemaLocation="/POM/4.0.0 /xsd/maven-4.0.0.xsd"xmlns="/POM/4.0.0"xmlns:xsi="/2001/XMLSchema-instance"> <modelVersion>4.0.0</modelVersion><parent><groupId>com.hd</groupId><artifactId>test-hd-parent</artifactId><version>0.0.1-SNAPSHOT</version></parent><artifactId>test-hd-service</artifactId><dependencies><dependency><groupId>com.hd</groupId><artifactId>test-hd-foundation</artifactId></dependency><dependency><groupId>com.hd</groupId><artifactId>test-hd-api</artifactId></dependency><!-- servlet --><dependency><groupId>javax.servlet</groupId><artifactId>jstl</artifactId></dependency><dependency><groupId>taglibs</groupId><artifactId>standard</artifactId></dependency><dependency><groupId>junit</groupId><artifactId>junit</artifactId></dependency></dependencies><build><plugins><!-- define the project compile level --><plugin><groupId>org.apache.maven.plugins</groupId><artifactId>maven-compiler-plugin</artifactId><version>2.3.2</version><configuration><source>1.7</source><target>1.7</target></configuration></plugin></plugins><finalName>test-hd-service</finalName></build></project>test-hd-module中的依赖关系<?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"><modelVersion>4.0.0</modelVersion><parent><groupId>com.hd</groupId><artifactId>test-hd-parent</artifactId><version>0.0.1-SNAPSHOT</version></parent><artifactId>test-hd-modules</artifactId><packaging>pom</packaging><modules><module>test-hd-www</module><module>test-hd-admin</module></modules><dependencies><dependency><groupId>com.hd</groupId><artifactId>test-hd-foundation</artifactId> </dependency><dependency><groupId>com.hd</groupId><artifactId>test-hd-service</artifactId> </dependency><dependency><groupId>com.hd</groupId><artifactId>test-hd-api</artifactId></dependency><dependency><groupId>com.hd</groupId><artifactId>test-hd-resource</artifactId> </dependency><!-- servlet --><dependency><groupId>javax.servlet</groupId><artifactId>jstl</artifactId></dependency><dependency><groupId>taglibs</groupId><artifactId>standard</artifactId></dependency><dependency><groupId>junit</groupId><artifactId>junit</artifactId></dependency></dependencies></project>∙test-hd-www中的依赖关系<?xml version="1.0"?><projectxsi:schemaLocation="/POM/4.0.0/xsd/maven-4.0.0.xsd"xmlns="/POM/4.0.0"xmlns:xsi="/2001/XMLSchema-instance"><modelVersion>4.0.0</modelVersion><parent><groupId>com.hd</groupId><artifactId>test-hd-modules</artifactId><version>0.0.1-SNAPSHOT</version></parent><artifactId>test-hd-www</artifactId><packaging>war</packaging><build><plugins><!-- define the project compile level --><plugin><groupId>org.apache.maven.plugins</groupId><artifactId>maven-compiler-plugin</artifactId><version>2.3.2</version><configuration><source>1.7</source><target>1.7</target></configuration></plugin></plugins><finalName>test-hd-www</finalName></build></project>∙最后使用maven-update整个工程，右击父工程名--》Maven--》Update Project六、打包和发布∙打包，右击父工程名test-hd-parent---->Run As--->Maven Install∙打包web子工程，右击工程名test-hd-www--->Run As ---> Maven Build...---> Goals: clean package--->Run∙右击工程名test-hd-www，进行刷新，找到war包，放到tomcat的webapps 中，启动tomcat，即可访问工程http://localhost:8080/test-hd-www∙可以去tomcat下面webapps》test-hd-www》WEB-INF》lib中，看到引用的jar包。