maven创建多模块web项目
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多模块项目，多web合并项目使用心得
maven多模块项⽬，多web合并项⽬使⽤⼼得Fixflow,做中国最好的开源流程引擎！项⽬地址此⽂章适合maven初学者或想接触maven的⽤户，讲的只是⽪⽑，⾼⼿请⾃觉略过。
最近⼀直在搞fixflow5.2的升级⼯作，以前只知道maven好⽤，但是⼀直没机会接触，这次由于⼯作需要，终于有空看下maven了。
由于以前项⽬使⽤linksource来管理项⽬结构，⽤tomcat来调试，习惯了，所以虽然决定⽤maven，但是还是习惯⽤tomcat来调试。
所以就⼀直在⽹上搜maven tomcat 多web，发现都是⼀些转载的⽂章，⽽且都需要这插件，那插件的，感觉新⼿⽆从下⼿，不过⼏天研究下来，觉得其实⽹上的⽅案都不是我想要的，其实有更简单的，下⾯我就来简单说下fixflow⽤maven来构建多web的过程。
关于fixflow的maven结构介绍，可以参考我的另⼀篇博客，这也是我们这篇⽂章的⽬标。
这篇⽂章，我准备分3个部分来介绍：1. maven多模块项⽬。
2. maven多web合并项⽬。
3. maven多web合并项⽬在eclipse+tomcat环境下部署和调试。
maven多模块项⽬maven多模块项⽬需要⼀个⽗⼯程来聚合各个⼦模块，不过其实就是需要⼀个⽗pom.xml，主要作⽤是声明⼦模块，代码如下：Xml代码1. <modules>2. <module>modules/fixflow-core</module>3. <module>modules/fixflow-expand</module>4. <module>modules/fixflow-common-api</module>5. <module>modules/fixflow-common-servlet</module>6. <module>modules/fixflow-manage-servlet</module>7. <module>modules/fixflow-webapp-common</module>8. <module>modules/fixflow-webapp-taskcenter</module>9. <module>modules/fixflow-webapp-managecenter</module>10. <module>modules/fixflow-webapp-explorer</module>11. <module>modules/fixflow-converter</module>12. <module>modules/fixflow-webapp-editor</module>13. </modules>然后在⼦模块中，声明⽗⼯程，⼦模块中代码如下：Xml代码1. <parent>2. <groupId>com.founder.fix.fixflow</groupId>3. <artifactId>fixflow-root</artifactId>4. <version>5.0</version>5. <relativePath>../..</relativePath>6. </parent>关于多模块的⽂章，⽹上有很多，也都很详细，这⾥不再多说。
使用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、配置子项目依赖
项目依赖
扩展
SpringBootMaven多模块项目搭建
SpringBootMaven多模块项目搭建展开全文Spring Boot（2.0） Maven多模块项目搭建简介版本号说明创建时间创建人1.0 创建2018-05-15 吴桂镇一、搭建环境-编译器：Eclipse Oxygen.1a (4.7.1a)-jdk：1.8-Maven : 3.0-操作系统：win10二、项目创建1.parent新建一个maven project 如下图点击next填写相关信息，点击finish。
注意Packaging 应选择pom创建之后效果如下图删除 src文件夹，并修改pom.xml。
修改后修过如下图，其中<parent></parent>中是对spring boot的集成<modules></modules>是对maven子模块项目的引用，正常情况下创建子模块后才在parent的pom.xml中添加一条对应的module,此处预先添加好。
2.core创建maven项目点击finish 创建完毕。
修改pom.xml添加<parent>对父模块的依赖，修改后如下图3.api创建过程类似于core 但是在pom.xml中添加对core的依赖4.serviceService 为springboot项目，使用eclipse创建时应先添加spring sts插件，或者去下载完成后导入进来，下面介绍使用sts插件创建的。
创建完毕之后修pom.xml,修改<parent>里的引用，从spring-boot-starter-parent 到 demo-parent,再引用api和core。
因为service不是一个web应用，可以不依赖spring-boot-starter-web5.webWeb也是一个springboot的项目，创建过程与service类似，只是在pom.xml中增加了下面的依赖。
三、集成dubbo1.在api中添加接口和对应的实体类demo以themis数据库intf_fee表为例实体类：@SuppressWarnings("serial")public** class IntfFee implements** Serializable{**private** String intfId;**private** String plateCde;**private** String intfName;**private** BigDecimal intfCost;**private** BigDecimal intfPrice;**private** String classType;**private** String intfStatus;**private** String remark;**private** BigDecimal feeRowBegin;**private** BigDecimal feeRowEnd;**public** String getIntfId() {**return** intfId;}**public**** void** setIntfId(String intfId) { **this**.intfId = intfId;}**public** String getPlateCde() {**return** plateCde;}**public**** void** setPlateCde(String plateCde) {**this**.plateCde = plateCde;}**public** String getIntfName() {**return** intfName;}**public**** void** setIntfName(String intfName) { **this**.intfName = intfName;}**public** BigDecimal getIntfCost() {**return** intfCost;}**public**** void** setIntfCost(BigDecimal intfCost) { **this**.intfCost = intfCost;}**public** BigDecimal getIntfPrice() {**return** intfPrice;}**public**** void** setIntfPrice(BigDecimal intfPrice) { **this**.intfPrice = intfPrice;}**public** String getClassType() {**return** classType;}**public**** void** setClassType(String classType) { **this**.classType = classType;}**public** String getIntfStatus() {**return** classType;}**public**** void** setIntfStatus(String intfStatus) {**this**.intfStatus = intfStatus;}**public** String getRemark() {**return** remark;}**public**** void** setRemark(String remark) {**this**.remark = remark;}**public** BigDecimal getFeeRowBegin() {**return** feeRowBegin;}**public**** void** setFeeRowBegin(BigDecimal feeRowBegin) {**this**.feeRowBegin = feeRowBegin;}**public** BigDecimal getFeeRowEnd() {**return** feeRowEnd;}**public**** void** setFeeRowEnd(BigDecimal feeRowEnd) { **this**.feeRowEnd = feeRowEnd;}•1•2•3•4•5•6•7•8•9•10•11•12•13•14•15•17 •18 •19 •20 •21 •22 •23 •24 •25 •26 •27 •28 •29 •30 •31 •32 •33 •34 •35 •36 •37 •38 •39 •40 •41 •42 •43 •44 •45•47 •48 •49 •50 •51 •52 •53 •54 •55 •56 •57 •58 •59 •60 •61 •62 •63 •64 •65 •66 •67 •68 •69 •70 •71 •72 •73 •74 •75•77 •78 •79 •80 •81 •82 •83 •84 •85 •86 •87 •88 •89 •90 •91 •92 •93 •94 •95 •96 •97 •98 •99 •100 •101 •102 •103 •104 •105•107 •108 •109 •110 •111 •112 •113 •114 •115 •116 •117 •118 •119 •120 •121 •122 •123 •124 •125 •126 •127 •128 •129 •130 •131 •132 •133 •134 •135•137•138•139•140接口public** interface** IDemoService {String sayHello(String message);•1•2}2.配置服务端在demo-service pom.xml中增加dubbo的依赖，如下<!–dubbo-springBoot依赖–><dependency><groupId>com.alibaba.spring.boot</groupId><artifactId>dubbo-spring-boot-starter</artifactId><version>2.0.0</version></dependency><dependency><groupId>com.101tec</groupId><artifactId>zkclient</artifactId><version>0.2</version></dependency>•1•2•3•4•5•6•7•8•9•10•11•12•13•14•15•16•17•18•19•20在application.properties中添加dubbo的相关配置,如下dubbospringboot 配置spring.dubbo.application.id=provider=providerspring.dubbo.registry.address=zookeeper://127.0.0.1:2181 spring.dubbo.server=true=dubbospring.dubbo.protocol.port=20880在启动类中添加@EnableDubboConfiguration注解编写service3.配置消费端在demo-web的pom.xml添加依赖<!--dubbo-springBoot依赖--><dependency><groupId>com.alibaba.spring.boot</groupId><artifactId>dubbo-spring-boot-starter</artifactId><version>${dubbo-spring-boot.version}</version></dependency><dependency><groupId>com.101tec</groupId><artifactId>zkclient</artifactId><version>${zk-client.version}</version></dependency>•1•2•3•4•5•6•7•8•9•10•11•12•13•14•15•16•17•18•19•20•21•22在application.properties中添加dubbo的配置Dubbo 服务消费者配置=consumerspring.dubbo.application.id=consumerspring.dubbo.protocol.port=20800=dubbospring.dubbo.registry.address=zookeeper://127.0.0.1:2181 注册中心请求超时时间设置操作设置消费者超时时间（通过DubboConfig去读取，配置）,默认使用服务端的超时时间，客户端配置时间则需要读取配置然后新增dubboContext.xml 其中配置<dubbo:consumer timeout="${spring.dubbo.consumer.timeout}" cluster="failfast"/>此项目使用服务端配置超时时间，故没有新增dubboContext.xml文件spring.dubbo.consumer.timeout=300006包路径也可以单独配置出dubbo包，将与dubbo交互的内容都存放在此处，分层明确spring.dubbo.scan=com.caxs在启动类中添加 @EnableDubboConfiguration 注解编写测试controller@RestControllerpublic** class** TestController {@Reference**private** IDemoService demoService;@RequestMapping("/")**public** String sayHello(String msg) {**return** demoService.sayHello(msg);}•1•2•3•4•5•6•7•8•9•10•11•12}注：使用@Reference来引用服务端提供的服务四、集成mybatis使用mysql 数据库在demo-service中添加相应的依赖（mybatis,mysql，连接池）<dependency><groupId>com.alibaba</groupId><artifactId>druid</artifactId><version>${druid.version}</version></dependency><dependency><groupId>org.mybatis.spring.boot</groupId><artifactId>mybatis-spring-boot-starter</artifactId><version>1.3.2</version></dependency><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId> <scope>runtime</scope></dependency><dependency><groupId>org.mybatis</groupId><artifactId>mybatis</artifactId><version>${mybatis.version}</version></dependency>•1•2•3•4•5•6•7•8•9•10•11•12•13•14•15•16•17•18•19•20•21•22•23•24•25•26•27•28•29•30•31•32•33•34•35•36•37•38•39•40在配置文件中添加配置，采用yml格式的如下spring:application:name: demo-service#DATABASE CONFIG•1•2•3•4datasource:driver-class-name: com.mysql.jdbc.Driverurl: your urlusername: your usernamepassword: your passwordtype: com.alibaba.druid.pool.DruidDataSource #这里是配置druid连接池，以下都是druid的配置信息filters: stat,wall,log4jmaxActive: 20initialSize: 1maxWait: 60000minIdle: 1timeBetweenEvictionRunsMillis: 60000minEvictableIdleTimeMillis: 300000validationQuery: select 'x'testWhileIdle: **true**testOnBorrow: **false**testOnReturn: **false**poolPreparedStatements: **true**maxOpenPreparedStatements: 20connection-properties:druid.stat.merggSql=ture;druid.stat.slowSqlMillis=5000 •1•2•3•4•5•6•7•8•9•10•11•12•13•14•15•16•17•18•19•20•21•22•23•24•25•26•27•28•29•30•31•32•33•34•35•36•37•38mybatismybatis:mapper-locations: classpath*:/daos/**Dao.xml #把xml文件放在com.XX.mapper.*中可能会出现找到的问题，这里把他放在resource下的mapper中#实体扫描，多个package用逗号或者分号分隔#typeAliasesPackage: com.tdx.account_service.entity #这里是实体类的位置configuration:map-underscore-to-camel-case: **true**cache-enabled: **false**•1•2•3•4logging 不同的目录不同的日志输出级别logging:level:root: info•1•2com.wugz.demo: debug添加dao层的接口和xml文件（此处示例使用注解的方式代替xml）接口：@Mapperpublic interface IntfFeeDao {/\*\*\* 方式1：使用注解编写SQL。
用Maven建立web项目
⽤Maven建⽴web项⽬近来⽆事，复习复习Spring相关知识，从《Spring企业应⽤开发实战》这本书开始。
本⽂为学习《Spring企业应⽤开发实战》总结，著作权归原作者。
⼀、⽤Maven建⽴web项⽬1.点击“File”->“New”->"Other"->输⼊“Maven”，新建⼀个“Maven Project”，如下图所⽰：2.请勾选“Create a simple project”，创建⼀个简单的项⽬，不使⽤模板。
也可以使⽤模板，选择WebApp，不过这⾥就不应该勾选。
如下图所⽰：3.填写好包名、项⽬名，选择打包类型为：war，如下图所⽰：4.项⽬创建好后可能会发现有错误，选择项⽬，右键“属性properties”->"层⾯Project Facets"->"Java"修改版本号为1.8，默认为1.5；点击“Ok”保存后关闭。
如下图所⽰：5.重复上⼀个步骤，反勾Dynamic Web Module，将项⽬暂时变成⾮Web项⽬。
点击“Ok”保存后关闭。
6.重复上⼀步骤，再进层⾯属性，勾选“Dynamic Web Module”选择Version为3.0。
点击左下⾓的超链接“Further Configuration available...“。
7.勾选“Generate web.xml deployment descriptor”⽣成web.xml部署描述⽂件。
点击“Ok”保存后关闭。
8.将⽣成的WebContent⽬录下的两个⽂件夹“META-INF”与“WEB-INF”复制到src/main/webapp⽬录下。
9.删除WebContent⽬录。
10.删除后会发现项⽬的pom.xml⽂件报错，是因为找不到指定位置的web.xml⽂件引起的。
再进⼊项⽬的属性，选择“Deployment Assembly”项⽬部署项，删除“src/test/java”、“src/test/resources”与“WebContent”⽬录，因为这三项不需要部署出去。
IntelliJIDEA创建maven多模块项目（图文教程）
IntelliJIDEA创建maven多模块项⽬（图⽂教程）项⽬主要分成3个模块，wms-root为⽗模块，wms-core和wms-app(webapp类型的模块)为⼦模块。
⼀、Parent Project,创建wms-root⽗模块。
1、依次点击：File->New->Project2、左侧⾯板选择maven（不要选择Create from archetype选项），如下图，点击Next即可。
3、依次补全如下信息，点击Next4、输⼊项⽬名字。
如ModuleProject，我们主要是在这个项⽬下创建我们的⼦模块。
5、这样我们就创建好了⼀个普通项⽬，因为该项⽬是作为⼀个Parent project存在的，可以直接删除src⽂件夹。
⼆、创建⼦模块，wms-core1、在⽗模块上右键如下图操作，创建⼀个模块，该模块即为⼦模块。
2、同样不选择Create from archetype选项，因为是普通模块，Next。
、3、groupId和version继承⾃Parent project，这⾥只⽤ArtifactId，Next。
4、填写模块名称，模块名称和ArtifactId相同即可。
5、创建完成后结构如下图。
三、创建⼦模块，wms-app1、同创建wms-core的第⼀步相同。
2、在有⽹络的情况下可直接下载maven提供给我们的模块。
如下勾选Create from archetype，并选中webapp模块。
Next3、groupId和version继承⾃Parent project，这⾥只⽤填写ArtifactId。
Next4、可以使⽤默认的maven配置，本⼈使⽤的是⾃⼰下载的maven和settings.xml⽂件。
如图5、填写模块名称，Next之后等待从⽹路上下载相关组件即可。
6、最终项⽬结构如下图只要熟悉web项⽬结构的，不⼀定要使⽤该⽅法。
按照web项⽬的结构⼿动构建⼀个即可。
idea maven多模块项目搭建 简书
idea maven多模块项目搭建简书在IDEA中使用Maven进行多模块项目搭建的步骤在软件开发过程中，使用多模块项目可以更好地管理和组织代码。
IDEA是一个功能强大的集成开发环境，而Maven是一个优秀的项目构建工具。
本文将介绍如何使用IDEA和Maven来搭建多模块项目。
1. 创建一个Maven项目打开IDEA，选择"File" -> "New" -> "Project"，在弹出窗口中选择"Maven"，点击"Next"。
在"GroupId"和"ArtifactId"字段中输入项目的唯一标识符，然后点击"Next"。
在"Project location"字段中选择项目保存的路径，点击"Next"。
在"Project SDK"字段中选择项目所使用的Java开发环境，点击"Next"。
在最后一个窗口中，选择项目的类型，点击"Finish"。
2. 添加模块在项目创建完成后，我们需要添加模块。
右键点击项目名称，选择"New" -> "Module"，在弹出窗口中选择"Maven"，然后点击"Next"。
在"GroupId"和"ArtifactId"字段中输入新模块的唯一标识符，然后点击"Next"。
在"Content root"字段中选择新模块的路径，点击"Next"。
在"Project SDK"字段中选择模块所使用的Java开发环境，点击"Next"。
eclipse中创建多模块mavenweb项目
eclipse中创建多模块mavenweb项⽬本⽂讲述在eclipse中创建分模块maven web项⽬。
暂时将⼀个项⽬分为controller；service；dao以及⽗类模块四部分。
1.创建⽗类模块。
创建⼀个简单的maven project打包类型设置为pom。
创建⼀个web模块。
选中six-roo项⽬右键new maven module将maven web 项⽬转成eclipse ⽀持的web 项⽬具体步骤见下⾯⽂章/HanShisi/p/5523998.html按照上述⽅法创建service 模块，six-service这⾥的打包类型默认选择jar就可以。
此时的⽬录结构如下图同理建出six-dao此处不再赘述。
在此讲下现在项⽬的结构。
six-root作为项⽬的⽗级项⽬，⽽six-web，six-service，six-dao作为其下的⼦模块，也可称之为⼦项⽬。
在⽗级项⽬的pom⽂件中引⼊项⽬需要的依赖。
各级⼦项⽬，引⼊其需要的⼦项⽬的依赖。
如：six-web需要依赖six-service所以在six-web项⽬的pom⽂件中有如下依赖配置。
同时 six-service需要依赖six-dao所以在six-service的pom配置⽂件中应添加对six-dao的依赖。
在此不再赘述。
此处需要注意，如果需要项⽬其它普通web项⽬⼀样在本地tomcat下部署、运⾏、测试，则还需要做如下操作。
选中需要的⼦项⽬，加⼊进来。
如此部署运⾏则和其它web项⽬⼀样了。
这⾥多提⼀点，如果是导⼊已存在的maven项⽬特别是web项⽬，⽽且也是eclipse识别的web项⽬的情况下，需注意导⼊后是否加⼊了maven的依赖。
如图。
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搭建多模块项目。
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整个项⽬。
Maven创建多模块项目（包括依赖版本号的统一更新）
Maven创建多模块项⽬（包括依赖版本号的统⼀更新）0、多项⽬⼯程的⽂件夹及依赖关系bus-core-api为公共项⽬，app-web-ui依赖bus-core-api，app-desktop-ui依赖bus-core-api1、创建⼀个⽗Maven⼯程mvn archetype:generate -DgroupId=com.jsoft.test -DartifactId=testproject -Dversion=1.0-SNAPSHOT -DarchetypeGroupId=org.codehaus.mojo.archetypes -DarchetypeArtifactId=pom-root -DinteractiveMode=false -DarchetypeVersion=RELEAS 注意：此项⽬为pom类型的⼯程，创建好之后只有⼀个pom.xml⽂件，<packaging>类型为pom。
创建好后的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 /xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><groupId>com.jsoft.test</groupId><artifactId>testproject</artifactId><version>1.0-SNAPSHOT</version><packaging>pom</packaging><name>testproject</name></project>2、创建三个⼦Maven⼯程注意：此时创建的⼯程的⽬录是进去⽗Maven⼯程的⽬录进⾏创建①创建bus-core-api项⽬mvn archetype:generate -DgroupId=com.jsoft.test -DartifactId=bus-core-api -Dversion=1.0-SNAPSHOT -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false -DarchetypeVersion=RELEASE②创建app-desktop-ui项⽬mvn archetype:generate -DgroupId=com.jsoft.test -DartifactId=app-desktop-ui -Dversion=1.0-SNAPSHOT -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false -DarchetypeVersion=RELEASE③创建app-web-ui项⽬mvn archetype:generate -DgroupId=com.jsoft.test -DartifactId=app-web-ui -Dversion=1.0-SNAPSHOT -DarchetypeArtifactId=maven-archetype-webapp -DinteractiveMode=false -DarchetypeVersion=RELEASE此时创建好项⽬之后，⽗Maven⼯程pom.xml也会跟着改变，⾃动加⼊<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><groupId>com.jsoft.test</groupId><artifactId>testproject</artifactId><version>1.0-SNAPSHOT</version><packaging>pom</packaging><name>testproject</name><modules><module>bus-core-api</module><module>app-desktop-ui</module><module>app-web-ui</module></modules></project>⽽通过进⼊到⽗Maven⼯程的⽬录创建的⼦Maven⼯程，pom.xml也会做相应的变化，增加了<parent>节点，内容如下：bus-core-api：<?xml version="1.0"?><project xsi: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.jsoft.test</groupId><artifactId>testproject</artifactId><version>1.0-SNAPSHOT</version></parent><groupId>com.jsoft.test</groupId><artifactId>bus-core-api</artifactId><version>1.0-SNAPSHOT</version><name>bus-core-api</name><url></url><properties><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding></properties><dependencies><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>3.8.1</version><scope>test</scope></dependency></dependencies></project>app-desktop-ui：<?xml version="1.0"?><project xsi: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.jsoft.test</groupId><artifactId>testproject</artifactId><version>1.0-SNAPSHOT</version></parent><groupId>com.jsoft.test</groupId><artifactId>app-desktop-ui</artifactId><version>1.0-SNAPSHOT</version><name>app-desktop-ui</name><url></url><properties><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding></properties><dependencies><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>3.8.1</version><scope>test</scope></dependency></dependencies></project>app-web-ui：<?xml version="1.0"?><project xsi: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.jsoft.test</groupId><artifactId>testproject</artifactId><version>1.0-SNAPSHOT</version></parent><groupId>com.jsoft.test</groupId><artifactId>app-web-ui</artifactId><version>1.0-SNAPSHOT</version><packaging>war</packaging><name>app-web-ui Maven Webapp</name><url></url><dependencies><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>3.8.1</version><scope>test</scope></dependency></dependencies><build><finalName>app-web-ui</finalName></build></project>⽽此时项⽬还没有完⼯，因为bus-core-api为公共项⽬，app-web-ui依赖bus-core-api，app-desktop-ui依赖bus-core-api，所以必须在app-web-ui和app-desktop-ui增加对bus-core-api的依赖引⽤。
springboot基于maven多模块项目搭建（直接启动webApplication）
springboot基于maven多模块项⽬搭建（直接启动webApplication）1. 新建maven项⽬springboot-module2.把src删掉，新建module项⽬springboot-module-apispringboot-module-modelspringboot-module-servicespringboot-module-utilspringboot-module-web3. 添加模块之间的依赖3.1 springboot-module.pom1<?xml version="1.0" encoding="UTF-8"?>2<project xmlns="/POM/4.0.0"3 xmlns:xsi="/2001/XMLSchema-instance"4 xsi:schemaLocation="/POM/4.0.0 /xsd/maven-4.0.0.xsd">5<modelVersion>4.0.0</modelVersion>67<groupId>com.springboot.module</groupId>8<artifactId>springboot-module</artifactId>9<packaging>pom</packaging>10<version>1.0-SNAPSHOT</version>11<modules>12<module>springboot-module-api</module>13<module>springboot-module-model</module>14<module>springboot-module-service</module>15<module>springboot-module-util</module>16<module>springboot-module-web</module>17</modules>1819<!-- Spring boot ⽗引⽤-->20<parent>21<groupId>org.springframework.boot</groupId>22<artifactId>spring-boot-starter-parent</artifactId>23<version>1.4.1.RELEASE</version>24</parent>25<dependencies>26<!-- Spring boot 核⼼web-->27<dependency>28<groupId>org.springframework.boot</groupId>29<artifactId>spring-boot-starter-web</artifactId>30</dependency>31<dependency>32<groupId>org.projectlombok</groupId>33<artifactId>lombok</artifactId>34<version>1.16.18</version>35</dependency>36<dependency>37<groupId>org.springframework.boot</groupId>38<artifactId>spring-boot-starter-logging</artifactId>39</dependency>40<dependency>41<groupId>org.springframework.boot</groupId>42<artifactId>spring-boot-starter-test</artifactId>43</dependency>44</dependencies>4546<build>47<plugins>48<plugin>49<groupId>org.springframework.boot</groupId>50<artifactId>spring-boot-maven-plugin</artifactId>51<executions>52<execution>53<goals>54<goal>repackage</goal>55</goals>56</execution>57</executions>58<configuration>59<executable>true</executable>60</configuration>61</plugin>62</plugins>63</build>64</project>3.2 springboot-module-api.pom1<?xml version="1.0" encoding="UTF-8"?>2<project xmlns="/POM/4.0.0"3 xmlns:xsi="/2001/XMLSchema-instance"4 xsi:schemaLocation="/POM/4.0.0 /xsd/maven-4.0.0.xsd"> 5<parent>6<artifactId>springboot-module</artifactId>7<groupId>com.springboot.module</groupId>8<version>1.0-SNAPSHOT</version>9</parent>10<modelVersion>4.0.0</modelVersion>11<artifactId>springboot-module-api</artifactId>1213<dependencies>14<dependency>15<groupId>com.springboot.module</groupId>16<artifactId>springboot-module-util</artifactId>17<version>1.0-SNAPSHOT</version>18<scope>compile</scope>19</dependency>20</dependencies>21</project>3.3 springboot-module-model.pom1<?xml version="1.0" encoding="UTF-8"?>2<project xmlns="/POM/4.0.0"3 xmlns:xsi="/2001/XMLSchema-instance"4 xsi:schemaLocation="/POM/4.0.0 /xsd/maven-4.0.0.xsd"> 5<parent>6<artifactId>springboot-module</artifactId>7<groupId>com.springboot.module</groupId>8<version>1.0-SNAPSHOT</version>9</parent>10<modelVersion>4.0.0</modelVersion>11<artifactId>springboot-module-model</artifactId>1213<dependencies>14<dependency>15<groupId>org.springframework.boot</groupId>16<artifactId>spring-boot-starter-data-jpa</artifactId>17</dependency>18<dependency>19<groupId>mysql</groupId>20<artifactId>mysql-connector-java</artifactId>21</dependency>22<dependency>23<groupId>com.springboot.module</groupId>24<artifactId>springboot-module-util</artifactId>25<version>1.0-SNAPSHOT</version>26<scope>compile</scope>27</dependency>28</dependencies>2930</project>3.4 springboot-module-service.pom1<?xml version="1.0" encoding="UTF-8"?>2<project xmlns="/POM/4.0.0"3 xmlns:xsi="/2001/XMLSchema-instance"4 xsi:schemaLocation="/POM/4.0.0 /xsd/maven-4.0.0.xsd"> 5<parent>6<artifactId>springboot-module</artifactId>7<groupId>com.springboot.module</groupId>8<version>1.0-SNAPSHOT</version>9</parent>10<modelVersion>4.0.0</modelVersion>11<artifactId>springboot-module-service</artifactId>1213<dependencies>14<dependency>15<groupId>com.springboot.module</groupId>16<artifactId>springboot-module-model</artifactId>17<version>1.0-SNAPSHOT</version>18</dependency>19<dependency>20<groupId>com.springboot.module</groupId>21<artifactId>springboot-module-api</artifactId>22<version>1.0-SNAPSHOT</version>23</dependency>24<dependency>25<groupId>ma.glasnost.orika</groupId>26<artifactId>orika-core</artifactId>27<version>1.5.1</version>28</dependency>29<dependency>30<groupId>mons</groupId>31<artifactId>commons-lang3</artifactId>32<version>3.5</version>33</dependency>34</dependencies>35</project>3.5 springboot-module-util.pom1<?xml version="1.0" encoding="UTF-8"?>2<project xmlns="/POM/4.0.0"3 xmlns:xsi="/2001/XMLSchema-instance"4 xsi:schemaLocation="/POM/4.0.0 /xsd/maven-4.0.0.xsd"> 5<parent>6<artifactId>springboot-module</artifactId>7<groupId>com.springboot.module</groupId>8<version>1.0-SNAPSHOT</version>9</parent>10<modelVersion>4.0.0</modelVersion>11<artifactId>springboot-module-util</artifactId>1213<dependencies>14<dependency>15<groupId>org.springframework.boot</groupId>16<artifactId>spring-boot-starter-data-jpa</artifactId>17</dependency>18</dependencies>19</project>3.6 springboot-module-web.pom1<?xml version="1.0" encoding="UTF-8"?>2<project xmlns="/POM/4.0.0"3 xmlns:xsi="/2001/XMLSchema-instance"4 xsi:schemaLocation="/POM/4.0.0 /xsd/maven-4.0.0.xsd"> 5<parent>6<artifactId>springboot-module</artifactId>7<groupId>com.springboot.module</groupId>8<version>1.0-SNAPSHOT</version>9</parent>10<modelVersion>4.0.0</modelVersion>11<artifactId>springboot-module-web</artifactId>1213<dependencies>14<dependency>15<groupId>com.springboot.module</groupId>16<artifactId>springboot-module-service</artifactId>17<version>1.0-SNAPSHOT</version>18</dependency>19</dependencies>20</project>4. 模块依赖关系图5. 层说明springboot-module-api ——业务逻辑接⼝springboot-module-model ——实体类springboot-module-service ——数据访问层，业务逻辑层的实现springboot-module-util ——⼯具模块springboot-module-web ——表现层6. 包名设计包名推荐以groupId为开头定义，所有模块的包名结构统⼀规范，⽐如groupId是com.springboot.module,⽽所有模块包名都以com.springboot.module开头，其中web层的WebApplication需要放在com.springboot.module下，不能放在com.springboot.module.web或者com.springboot.module.controller下。
Maven学习总结（八）——使用Maven构建多模块项目
Maven学习总结（⼋）——使⽤Maven构建多模块项⽬ 在平时的Javaweb项⽬开发中为了便于后期的维护，我们⼀般会进⾏分层开发，最常见的就是分为domain（域模型层）、dao（数据库访问层）、service（业务逻辑层）、web（表现层），这样分层之后，各个层之间的职责会⽐较明确，后期维护起来也相对⽐较容易，今天我们就是使⽤Maven来构建以上的各个层。
项⽬结构如下： system-parent |----pom.xml |----system-domain |----pom.xml |----system-dao |----pom.xml |----system-service |----pom.xml |----system-web |----pom.xml⼀、创建system-parent项⽬ 创建system-parent，⽤来给各个⼦模块继承。
进⼊命令⾏，输⼊以下命令：mvn archetype:create -DgroupId=me.gacl -DartifactId=system-parent -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false 如下图所⽰： 命令执⾏完成之后可以看到在当前⽬录(C:\Documents and Settings\Administrator)⽣成了system-parent⽬录，⾥⾯有⼀个src⽬录和⼀个pom.xml⽂件，如下图所⽰： 将src⽂件夹删除，然后修改pom.xml⽂件，将<packaging>jar</packaging>修改为<packaging>pom</packaging>，pom表⽰它是⼀个被继承的模块，修改后的内容如下：1<project xmlns="/POM/4.0.0" xmlns:xsi="/2001/XMLSchema-instance"2 xsi:schemaLocation="/POM/4.0.0 /xsd/maven-4.0.0.xsd">3<modelVersion>4.0.0</modelVersion>45<groupId>me.gacl</groupId>6<artifactId>system-parent</artifactId>7<version>1.0-SNAPSHOT</version>8<packaging>pom</packaging>910<name>system-parent</name>11<url></url>1213<properties>14<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>15</properties>1617<dependencies>18<dependency>19<groupId>junit</groupId>20<artifactId>junit</artifactId>21<version>3.8.1</version>22<scope>test</scope>23</dependency>24</dependencies>25</project>⼆、创建sytem-domain模块 在命令⾏进⼊创建好的system-parent⽬录，然后执⾏下列命令：mvn archetype:create -DgroupId=me.gacl -DartifactId=system-domain -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false 如下图所⽰： 命令执⾏完成之后可以看到在system-parent⽬录中⽣成了system-domain，⾥⾯包含src⽬录和pom.xml⽂件。
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”来构建和测试项目。
第八步：发布到简书完成项目的开发和测试后，可以将其发布到简书。
首先，需要在简书上创建一个账号，并登录到该账号。
利用intellijidea创建maven多模块项目
利⽤intellijidea创建maven多模块项⽬本⽂通过⼀个例⼦来介绍利⽤maven来构建⼀个多模块的jave项⽬。
开发⼯具：intellij idea。
⼀、项⽬结构multi-module-oject是主⼯程，⾥⾯包含两个模块（Module）：1. web-app是应⽤层，⽤于界⾯展⽰，依赖于web-service参的服务。
2. web-service层是服务层，⽤于给app层提供服务。
⼆、构建项⽬2.1 Parent Project新建⼀个空⽩标准maven project（不要选择Create from archetype选项）填写项⽬坐标得到⼀个标准的maven项⽬，因为该项⽬是作为⼀个Parent project存在的，可以直接删除src⽂件夹。
2.2 增加web-app模块（Module）选择从archetype创建（选择webapp选项）groupId和version继承⾃Parent project，这⾥只需要填写artifactId即可。
2.3增加web-service模块⽤同样的⽅法创建web-service模块（不过该模块是⼀个空⽩maven标准项⽬，不要从archetype创建）2.4 得最终项⽬结构2.5 关键⼏点1. Parent project和各个Module拥有独⽴pom⽂件，他们之间的关系后续会专门写⽂章介绍。
2. Parent project⽤于组织不同的Module，不实现逻辑3. Module集成Parent project的groupId和version，Module只需要指定⾃⼰的artifactId即可。
三、添加项⽬依赖上⾯的操作是添加web-app对web-service模块的依赖，完成上述操作后web-Service中public的类已经在web-app模块中可见了。
但是这个时候在app模块使⽤了service模块中的类，通过maven进⾏编译（compile）的时候还是会报错XX找不到（XX为service模块的类），要解决这个问题需要在app的pom中增加对service的依赖：<dependency><groupId>blogs.kmpp</groupId><artifactId>web-service</artifactId><version>1.0-SNAPSHOT</version></dependency>以上，项⽬依赖的添加已经完成四、开始编程4.1 web-service模块编程在web-service模块中增加⼀个Service类（SimpleService.)4.2 web-app模块编程在web-app模块增加⼀个Servlet，并且调⽤web-service模块的SimpleService类的getServiceDescrtion⽅法。
idea maven多模块项目搭建 简书
idea maven多模块项目搭建简书【实用版】目录1.idea maven 多模块项目的概念2.搭建步骤3.常见问题与解决方法正文一、idea maven 多模块项目的概念在实际软件开发过程中，一个项目可能需要包含多个模块，而每个模块又需要独立编译、测试和部署。
在这种情况下，我们可以采用 maven 多模块项目来管理。
maven 多模块项目是指一个项目组（groupId）下包含多个子项目（artifactId），每个子项目可以拥有自己的代码库、编译配置和依赖关系等。
而 IDEA（IntelliJ IDEA）是一款广泛使用的 Java 开发工具，它提供了对 maven 多模块项目的良好支持。
二、搭建步骤1.创建父项目首先，我们需要创建一个 maven 父项目。
打开 IDEA，点击“Create New Project”，选择“Maven Project”，然后点击“Next”。
在左侧的“Project”标签下，我们可以看到一个名为“groupId”的输入框，输入父项目的组名。
接着在右侧的“Project”标签下，点击“Browse”，选择一个存放父项目的目录。
最后，点击“Finish”，创建父项目。
2.创建子项目接下来，我们需要创建一个或多个子项目。
在 IDEA 中，右键点击父项目，选择“Add Module”，然后在弹出的对话框中选择“Maven Project”。
输入子项目的名称（artifactId）和描述（pom.xml 中的<packaging>），点击“Finish”。
此时，子项目已创建成功。
3.配置子项目在创建子项目后，我们需要编辑子项目的 pom.xml 文件，添加相关依赖和配置。
例如，我们可以在 pom.xml 的<dependencies>标签内添加子项目所需的 jar 包依赖。
同时，我们还可以在<build><plugins>标签内添加一些构建插件，如 maven-compiler-plugin 等。
构建Maven多模块项目的方法
构建Maven多模块项⽬的⽅法⽬录构建Maven多模块项⽬创建⽗模块创建⼦模块:model层创建⼦模块：dao模块创建⼦模块：service层创建⼦模块：web层编译运⾏项⽬Maven相关特性⽗模块的配置⽗模块聚合⼦模块⽗模块统⼀管理依赖包⼦模块在pom.xml中声明⽗模块参考⽂章构建Maven多模块项⽬JavaWeb开发⼀般都会进⾏分层开发，通常分为model，模型层dao，数据访问层service，业务逻辑层web，表现层分层后，各层职责明确，后期维护起来也会容易⼀些。
接下来我们就是使⽤Maven来构建以上各层，即构建⼀个Maven多模块项⽬，项⽬⽬录结构如下所⽰。
创建⽗模块执⾏命令：mvn -B archetype:generate -DgroupId=com.jepcc.app -DartifactId=demo -DarchetypeArtifactId=maven-archetype-quickstart -DarchetypeVersion=1.4，得到⼀个新项⽬。
接下来作如下处理：删除src⽂件夹修改demo/pom.xml⽂件<packaging>标签在没有指明的情况下默认是jar，这⾥将其修改为pom，表⽰模块是⼀个可以被继承的模块。
创建⼦模块:model层进⼊demo⽬录，执⾏命令：mvn -B archetype:generate -DgroupId=com.jepcc.app -DartifactId=model -DarchetypeArtifactId=maven-archetype-quickstart -DarchetypeVersion=1.4，在demo⽬录下⽣成了model ⽬录，model⽬录⾥包含了src⽬录和pom.xml⽂件。
且demo/pom.xml⾥⾃动新增了以下内容，<modules><module>model</module></modules>接下来做如下处理：修改model/pom.xml⽂件删除<groupId>com.jepcc.app</groupId>和<version>1.0-SNAPSHOT</version>因为groupId和version会继承⾃⽗模块的groupId和version。
命令行创建多模块的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类型。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实现步骤
创建项目目录
进入“工作空间”目录，创建名为tradework的文件夹，切换至控制台，进入该文件夹。
配置模块
生成各个模块
该步骤会依次生成项目的各个模块，但是生成的模块并没有创建依赖，只是最简单的并且符合maven要求的项目结构的模块，关于什么是maven的标准项目结构，可以参考maven 官方文档，或者《maven权威指南》。
#core 模块创建
mvn archetype:create -DgroupId=com.taobao.trade -DartifactId=trade-core
#client 模块创建
mvn archetype:create -DgroupId=com.taobao.trade -DartifactId=trade-client
#server 模块创建
mvn archetype:create -DgroupId=com.taobao.trade -DartifactId=trade-server -DpackageName=com. taobao.trade -DarchetypeArtifactId=maven-archetype-webapp
配置项目模块
关系。
生成好各个模块之后在tradework根目录下会生成三个目录，每个目录下都会有一个
配置依赖
进入tradework根目录，在pom.xml文件中加入dependencies节点，加入如下内容：
内容如下：
生成Eclipse 项目文件及包引用定义，注意，需确保定义Classpath Variables: M2_REPO，指向本地maven类库目录。
打开Eclipse ，导入工程即可。