├── pom.xml
├── maven笔记.txt
└── README.md


/pom.xml:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="UTF-8"?>
  2 | <project xmlns="http://maven.apache.org/POM/4.0.0"
  3 |          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4 |          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5 |     <!--指定了当前pom的版本-->
  6 |     <modelVersion>4.0.0</modelVersion>
  7 | 
  8 |     <groupId>com.tiakon.maven.demo</groupId>
  9 |     <artifactId>maven-learning-notes</artifactId>
 10 |     <version>1.0-SNAPSHOT</version>
 11 |         
 12 |     <!--指定编码格式-->
 13 |     <properties>
 14 |         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
 15 |     </properties>
 16 |          
 17 |     <!--
 18 |         第一个0表示大版本号
 19 |         第二个0表示分支版本号
 20 |         第三个0表示小版本号
 21 |         0.0.1
 22 |         snapshot    快照
 23 |         alpha       内部测试
 24 |         beta        公测
 25 |         Release     稳定
 26 |         GA          正式发布
 27 |     -->
 28 |     <!--
 29 |         打包方式:默认是jar,可选war、zip、pom
 30 |         <packaging></packaging>
 31 |     -->
 32 |     <!--
 33 |         项目名
 34 |         <name></name>
 35 |         项目地址
 36 |         <url></url>
 37 |         项目描述
 38 |         <description></description>
 39 |         开发人员列表
 40 |         <developers></developers>
 41 |         许可证信息
 42 |         <licenses></licenses>
 43 |         组织信息
 44 |         <organization></organization>
 45 |     -->
 46 | 
 47 | 
 48 |     <!--依赖列表-->
 49 |     <dependencies>
 50 |         <!--依赖项-->
 51 |         <dependency>
 52 |             <groupId>junit</groupId>
 53 |             <artifactId>junit</artifactId>
 54 |             <version>RELEASE</version>
 55 |             <!--<type></type>-->
 56 |             <!--依赖范围-->
 57 |             <scope>test</scope>
 58 |             <!--设置依赖是否可选（默认）false-->
 59 |             <!--<optional></optional>-->
 60 |             <!--排斥依赖传递列表-->
 61 |             <!--
 62 |                 <exclusions>
 63 |                     <exclusion>
 64 |                     </exclusion>
 65 |                 </exclusions>
 66 |             -->
 67 |         </dependency>
 68 |     </dependencies>
 69 |     <!--依赖的管理，作用主要定义在父模块中，对子模块进行管理-->
 70 |     <!--
 71 |         <dependencyManagement>
 72 |             <dependencies>
 73 | 
 74 |             </dependencies>
 75 |         </dependencyManagement>
 76 |     -->
 77 |     <!--对构件的行为提供相应的支持-->
 78 |     <build>
 79 |         <!--插件列表-->
 80 |         <plugins>
 81 |             <plugin>
 82 |                 <groupId>org.apache.maven.plugins</groupId>
 83 |                 <artifactId>maven-source-plugin</artifactId>
 84 |                 <version>3.0.1</version>
 85 | 
 86 |                 <executions>
 87 |                     <execution>
 88 |                         <phase>package</phase>
 89 |                         <goals>
 90 |                             <goal>
 91 |                                 jar-no-fork
 92 |                             </goal>
 93 |                         </goals>
 94 |                     </execution>
 95 |                 </executions>
 96 |             </plugin>
 97 |         </plugins>
 98 |     </build>
 99 |     <!--通常用于子模块对父模块pom的继承-->
100 |     <!--<parent></parent>-->
101 |     <!--用来聚合运行Maven项目，指定多个模块一起编译-->
102 |     <!--
103 |         <modules>
104 |             <module></module>
105 |         </modules>
106 |     -->
107 | 
108 | </project>
109 | 


--------------------------------------------------------------------------------
/maven笔记.txt:
--------------------------------------------------------------------------------
  1 | 相关网站
  2 | 
  3 | http://search.maven.org/
  4 | http://www.mvnrepository.com/
  5 | 
  6 | maven介绍及环境搭建
  7 | 介绍：	
  8 | 	基于项目对象模型，可以通过一小段描述信息来管理项目的构建、报告和文档的软件项目管理工具
  9 | 下载 maven.appache.org
 10 | 	download maven 3.3.3 jdk 1.7的支持
 11 | 目录结构：
 12 | 	bin     包含mvn脚本 m2.conf配置文件
 13 | 	boot	类加载器的框架 使用这个jar加载类库
 14 | 	config 	配置文件	settings.xml经常用到
 15 | 	lib		常用的类库除了自己的还有第三方以来的类库
 16 | 配置环境变量：
 17 | 	maven_home	maven目录
 18 | 	path		maven的bin目录
 19 | 	命令行中 mvn -v 能够查看到maven、java、系统版本号就说明安装成功了
 20 | hello maven的小例子
 21 | 	目录介绍
 22 | 		src
 23 | 			-main
 24 | 				-java
 25 | 					-package
 26 | 				-resources
 27 | 			-test
 28 | 				-java
 29 | 					-package
 30 | 	pom.xml配置文件
 31 | 	mvn test	
 32 | 		生成target文件夹
 33 | 			classes文件夹存放字节码文件
 34 | 			reports存放生成的测试报告
 35 | 	mvn package 
 36 | 		target中生成一个jar文件
 37 | 2017年9月24日22点39分
 38 | maven的基础知识
 39 | 	常用的构建命令
 40 | 		mvn -v	查看maven版本
 41 | 			compaile 编译
 42 | 			test 测试
 43 | 			package 打包
 44 | 			clean 删除target中的字节码文件和测试报告
 45 | 			install	安装jar到本地仓库
 46 | 	构建过程：先编译，如果过程中程序有依赖就去pom.xml中查找是否引入坐标,会去本地仓库当中查找
 47 | 		如果有就将jar加入到项目的classpath中如果没有就回去网上的maven中央仓库中下载
 48 | 		放到仓库中供我们的项目使用
 49 | 自动创建目录骨架
 50 | 	archetype插件用于创建符合maven规范的目录骨架
 51 | 		src java中主代码
 52 | 	创建目录的2中方式：
 53 | 	1.	mvn archetype:generate	按照提示进行选择
 54 | 	2.	archetype:generate 	 组织名，公司网址的反写+项目名
 55 | 							-DartifaceId=项目名-模块名
 56 | 							-Dcersion-版本号
 57 | 							-Dpackage=代码所存在的包名
 58 | 	坐标
 59 | 		构建
 60 | 	仓库
 61 | 		本地仓库和远程仓库
 62 | 		lib/maven-model-builder的jar
 63 | 			其中org/apache/maven/model中pom-4.0.0xml
 64 | 			<repository>
 65 | 			<id>central</id>
 66 | 			<name>Central Repository</name>
 67 | 			<url>https://repo.maven.apache.org/maven2</url>默认的中央仓库的地址
 68 | 			<layout>default</layout>默认的布置
 69 | 			<snapshots>
 70 | 			<enabled>false</enabled>禁止下载快照的版本构建
 71 | 			</snapshots>
 72 | 			</repository>
 73 | 		中央仓库地址http://search.maven.org/
 74 | 	镜像仓库
 75 | 		conf	settings
 76 | 		mirror 
 77 | 		<mirror>
 78 | 			<id>maven.net.cn</id>
 79 | 			<mirrorOf>central</mirrorOf> 可以使用* 
 80 | 	对原仓库的访问都指向镜像仓库，原仓库不能直接访问
 81 | 			<name>central mirror in China</name>
 82 | 			<url>http://maven.net.cn/content/groups/public</url>
 83 | 		</mirror>
 84 | 	本地仓库
 85 | 		修改settings
 86 | 		<localRepository>一般不放c盘，防止重装系统丢失
 87 | 		小技巧：将settings复制一份到repo中，可以在maven升级后
 88 | 		不用重新设置maven
 89 | 2017年10月3日15点07分
 90 | 	在eclipse中安装插件以及创建
 91 | 		在eclipse4.0以上不用另外安装maven插件
 92 | 		maven插件将其复制到eclipse/dropins中重启eclipse
 93 | 		1.在eclipse.ini中加入-vm java_home\bin\javaw.exe
 94 | 		2.修改eclipse的jre 在java installed jres 中改成自己的jre
 95 | 		（两者区别？？）
 96 | 		3.更改maven配置 installations改成本机的maven
 97 | 			user settings改成repo中 的settings
 98 | 		选择quick-start
 99 | 		创建了一个maven项目
100 | 			run as mavenbuilder->compile 出现错误
101 | 			在java的jre中添加-Dmaven.multiModuleProjectDirectory=$m2_home(maven的目录)
102 | 			run as mavenbuilder->compile编译成功
103 | 								package打包成功
104 | 2017年10月3日20点30分 
105 | 	完整的项目构建过程包括
106 | 		清理、编译、测试、打包、集成测试、验证、部署
107 | 	maven生命周期
108 | 		clean	清理项目
109 | 		default	构建项目
110 | 		site	生成项目站点
111 | 	clean、compile、test、package、install
112 | 	clean清理项目
113 | 		pre-clean 执行清理前的工作
114 | 		clean清理上一次构建生成的所有文件
115 | 		post-clean 执行清理后的文件
116 | 	default构建项目（最核心）
117 | 		compile test package install
118 | 	site生成项目站点
119 | 		pre-site	在生成项目站点前要完成的工作
120 | 		site		生成项目的站点文件
121 | 		post-site 	在生成项目站点后要完成的工作
122 | 		site-deploy	发布生成的站点到服务器上
123 | 	pom.xml中添加了
124 | 			<build>
125 | 				<plugins>
126 | 					<plugin>
127 | 						<groupId>org.apache.maven.plugins</groupId>
128 | 						<artifactId>maven-source-plugin</artifactId>
129 | 						<version>2.4</version>
130 | 						<executions>
131 | 							<execution>
132 | 								<phase>package</phase>
133 | 								<goals>
134 | 									<goal>jar-no-fork</goal>
135 | 								</goals>
136 | 							</execution>
137 | 						</executions>
138 | 					</plugin>
139 | 				</plugins>
140 | 			</build>
141 | 	然后run as clean package 项目就执行了编译 测试 打包 并且生成了source
142 | 	执行某个阶段时，其前面的阶段会依次执行
143 | pom.xml
144 | 	详解见pom.xml文件
145 | 依赖范围
146 | 	scope	三种classpath 编译测试运行
147 | 		compile 默认的范围，编译测试运行都有效
148 | 		provided 在编译和测试时有效
149 | 		runtime	在测试和运行时有效
150 | 		test 	只在测试时有效
151 | 		system	与本机系统相关联，可移植性差
152 | 		import		导入的范围，它只使用在dependencyManagement中，
153 | 					表示从其他的pom中导入dependecy的配置
154 | 依赖冲突
155 | 	依赖不同版本的相同构建
156 | 	1.短路优先
157 | 		A->B->C->X(jar)
158 | 		A->D->X(jar)
159 | 	2.先声明先优先
160 | 		如果路径长度相同，则谁先声明，先解析谁
161 | 聚合和继承
162 | 	聚合：
163 | 	1.packaging设置为pom
164 | 	2.删除了junit依赖
165 | 	3.modules设置多个模块../模块名
166 | 	4.run as clean install
167 | 	继承：
168 | 	1.创建一个父类，packaging设置为pom，可以删除main和test目录
169 | 	2.	将公共依赖放入<dependencyManagement>中，
170 | 		可以提取版本号到properties中利用${}进行获取
171 | 	3.子类依赖只写groupid和artifactid就可以
172 | 一个完整的web项目：	
173 | 	1.jsp报错 添加servlet api 在www.mvnrepository.com查找servletapi选3.0版本
174 | 	并将junit版本设置为4.10,
175 | 	2.在build中添加插件jetty并将可以写executions	
176 | 			可设置打包成功后	使用jetty run运行jetty服务
177 | 			localhost：8080启动
178 | 	1.添加tomcat服务器在tomcat官网上maven插件
179 | 			localhost:8080/项目名
180 | 	myeclipse中的Deployment Assembly中将test去掉项目发布后不需要测试代码
181 | 	project facts中将dynamic web module勾选上
182 | 	build path中source的各个目录都指向target/class
183 | 	
184 | 	
185 | 
186 | 		
187 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | Maven学习笔记
  2 | =========
  3 | 本笔记配合慕课网上maven视频使用效果最佳，链接如上
  4 | 
  5 | ----------
  6 | 一.介绍
  7 | ----
  8 | **Maven**是基于项目对象模型（POM），可以通过一小段描述信息来管理项目的构建、报告和文档的软件项目管理工具。
  9 | 
 10 | 1. bin目录是包含mvn的运行脚本
 11 | 2. boot目录包含一个类加载器的框架，maven使用它加载自己的类库
 12 | 3. conf配置文件
 13 | 4. lib包含maven运行时的依赖类库
 14 | 
 15 | 二.环境变量的配置
 16 | ---------
 17 | 
 18 | 
 19 | [点击下载](http://maven.apache.org/download.cgi "下载地址")<br>
 20 | **maven**环境配置，增加一个环境变量**MAVEN_HOME**,值是maven的安装路径（`C:\Program Files\apache-maven-3.5.0-bin\apache-maven-3.5.0`）
 21 | 修改path则是在path最后面添加`;%MAVEN_HOME%\bin`。
 22 | 
 23 | 
 24 | 
 25 | ### Maven的项目结构 ###
 26 | 
 27 | ```cmd
 28 | 项目名
 29 | 	-src 
 30 | 	   -main
 31 | 	        -java
 32 | 	             -package
 33 | 	   -test
 34 | 	        -java
 35 | 	             -package
 36 | 	-pom.xml
 37 | ```
 38 | 
 39 | 三.常用命令
 40 | ------
 41 | ```cmd
 42 |     mvn -v 		查看 maven 版本
 43 | 	 compile	编译
 44 | 	 test		测试
 45 | 	 package	打包
 46 | 
 47 | 	 clean		删除 target
 48 | 	 install	安装 jar 包到本地仓库
 49 | ```
 50 | 
 51 | ### maven快速创建项目骨架目录  ###
 52 | **两种方式：**
 53 | 
 54 | ```cmd
 55 | 1.  mvn archetype:generate 按照提示进行选择
 56 | 2.  mvn archetype:generate  -DgroupId=com.imooc.maven   -DartifactId=
 57 |   maven-service   -Dversion=1.0.0SNAPSHOT   -Dpackage=com.imooc.maven.demo
 58 | 	1. -DgroupId=组织名，公司网址反写+项目名
 59 | 	2. -DartifactId=项目名+模块名
 60 | 	3. -Dversion=版本号
 61 | 	4. -Dpackage=代码所存在的包名
 62 | ```
 63 | 四.Maven中的坐标和仓库
 64 | --------------
 65 | 
 66 | **构件坐标:**
 67 | 
 68 | ```cmd
 69 |     	1. groupId:公司名字+项目名
 70 |     	2. artifactId：项目名+模块名
 71 |     	3. varsion:版本号
 72 | ```
 73 | 
 74 | **仓库：**
 75 | 
 76 | ```cmd
 77 | 		1. 本地仓库
 78 | 		2. 远程仓库
 79 | 		3. 镜像仓库
 80 | ```
 81 | 
 82 | 五.更改仓库默认路径
 83 | ------
 84 | 已安装到本地仓库中的jar包位置：
 85 | 
 86 | ```cmd
 87 | C:\Users\用户\.m2\repository\com\tiakon\demo
 88 | ```
 89 | 
 90 | 安装路径conf文件夹下settings.xml文件
 91 | 打开找到这段备注是的代码：
 92 | 
 93 | ```xml
 94 | <!-- localRepository
 95 |      | The path to the local repository maven will use to store artifacts.
 96 |      | Default: ${user.home}/.m2/repository
 97 |     <localRepository>/path/to/local/repo</localRepository>
 98 | -->
 99 | ```
100 | 复制粘贴出来
101 | 
102 | ```xml
103 | <localRepository>/path/to/local/repo</localRepository>
104 | ```
105 | 
106 | **将localRepository便签内的值替换成新路径即可。**
107 | 
108 | 六.maven生命周期
109 | ---------
110 | 
111 | 完整的项目构建过程包括：
112 | **清理、编译、测试、打包、集成测试、验证、部署**
113 | 
114 | **maven三套独立的生命周期**
115 | 
116 | ```cmd
117 | 	clean 	清理项目
118 | 			1.pre-clean	执行清理前的工作
119 | 			2.clean		清理上一次构建生成的所有文件
120 | 			3.post-clean 	执行清理后的文件
121 | 
122 | 	default 构建项目（最核心）
123 | 			compile test package install
124 | 
125 | 	site 	生成项目站点
126 | 			1. pre-site 	在生成项目站点前要完成的工作
127 | 			2. site 	生成项目的站点文档
128 | 			3. post-site	在生成项目站点后要完成的工作
129 | 			4. site-deploy	发布生成的站点到服务器上
130 | ```
131 | 
132 | 七.maven中pom.xml常见元素介绍
133 | ---------------
134 | ```xml
135 | <?xml version="1.0" encoding="UTF-8"?>
136 | <project xmlns="http://maven.apache.org/POM/4.0.0"
137 |          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
138 |          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
139 |     <!--指定了当前pom的版本-->
140 |     <modelVersion>4.0.0</modelVersion>
141 | 
142 |     <groupId>com.tiakon.maven.demo</groupId>
143 |     <artifactId>HoictasStudio-MavenDemo01</artifactId>
144 |     <version>1.0-SNAPSHOT</version>
145 |     <!--
146 |         第一个0表示大版本号
147 |         第二个0表示分支版本号
148 |         第三个0表示小版本号
149 |         0.0.1
150 |         snapshot    快照
151 |         alpha       内部测试
152 |         beta        公测
153 |         Release     稳定
154 |         GA          正式发布
155 |     -->
156 |     <!--
157 |         打包方式:默认是jar,可选war、zip、pom
158 |         <packaging></packaging>
159 |     -->
160 | 
161 |     <!--指定编码格式-->
162 |     <properties>
163 |         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
164 |     </properties>
165 | 
166 |     <!--
167 |         项目名
168 |         <name></name>
169 |         项目地址
170 |         <url></url>
171 |         项目描述
172 |         <description></description>
173 |         开发人员列表
174 |         <developers></developers>
175 |         许可证信息
176 |         <licenses></licenses>
177 |         组织信息
178 |         <organization></organization>
179 |     -->
180 | ```
181 | 
182 | 
183 | ```xml
184 | <!--依赖列表-->
185 | <dependencies>
186 |     <!--依赖项-->
187 |     <dependency>
188 |         <groupId>junit</groupId>
189 |         <artifactId>junit</artifactId>
190 |         <version>RELEASE</version>
191 |         <!--<type></type>-->
192 |         <!--依赖范围-->
193 |         <!--<scope></scope>-->
194 |         <!--设置依赖是否可选（默认）false-->
195 |         <!--<optional></optional>-->
196 |         <!--排斥依赖传递列表-->
197 |         <!--
198 |                 <exclusions>
199 |                     <exclusion>
200 |                     </exclusion>
201 |                 </exclusions>
202 |             -->
203 |     </dependency>
204 | </dependencies>
205 | <!--依赖的管理，作用主要定义在父模块中，对子模块进行管理-->
206 | <!--
207 |         <dependencyManagement>
208 |             <dependencies>
209 | 
210 |             </dependencies>
211 |         </dependencyManagement>
212 |     -->
213 | <!--对构件的行为提供相应的支持-->
214 | <build>
215 |     <!--插件列表-->
216 |     <plugins>
217 |         <plugin>
218 |             <groupId>org.apache.maven.plugins</groupId>
219 |             <artifactId>maven-source-plugin</artifactId>
220 |             <version>3.0.1</version>
221 | 
222 |             <executions>
223 |                 <execution>
224 |                     <phase>package</phase>
225 |                     <goals>
226 |                         <goal>
227 |                             jar-no-fork
228 |                         </goal>
229 |                     </goals>
230 |                 </execution>
231 |             </executions>
232 |         </plugin>
233 |     </plugins>
234 | </build>
235 | <!--通常用于子模块对父模块pom的继承-->
236 | <!--<parent></parent>-->
237 | <!--用来聚合运行Maven项目，指定多个模块一起编译-->
238 | <!--
239 |         <modules>
240 |             <module></module>
241 |         </modules>
242 |     -->
243 | 
244 | </project>
245 | ```
246 | 八.Maven的依赖范围
247 | ----------
248 | 
249 | ```cmd
250 | 三种 classpath
251 | 	1. 编译
252 | 	2. 测试
253 | 	3. 运行
254 | ```
255 | 
256 | **maven提供了6种可选依赖范围:**
257 | 
258 | 
259 | 
260 | ```cmd
261 | 1. compile:	默认范围，编译测试运行都有效。
262 | 2. provided:	在编译和测试时有效。（比如说在做 web 时，你在本地运行的 servlet ，
263 | 是需要调用已添加到项目中的 servlet-api.jar 这个 jar 包的。这个过程就包含了编译【就是
264 | 把 Java 文件编译成 class 文件的过程中也要调用】和测试【测试就是在本地运行】，那么他说
265 | 的运行是指，整个项目已开发完成，编译、测试通过后，将 class 文件或包含有 class 文件的 war 包
266 | 发布到服务器上的 Tomcat 中运行，这时启动项目，就可以直接调 Tomcat 中的 servlet-api.jar ，
267 | 不必再将自己的 jar 包添加到项目中去。也就是说当你选择 provided 时，项目发布时 Maven 不会将
268 | 你添加的 jar 包，加入到项目中。）
269 | 3. runtime:	在测试和运行时有效。(典型例子：JDBC驱动的实现。)
270 | 4. test:	只在测试是有效。
271 | 5. system:	类似 provided，与本机系统相关联，可移植性差。
272 | 6. import:	导入范围，他只是用在 dependencyManagement 中，表示从其他的 pom 中导
273 | 入dependecy的配置。（以下引用官网案例并不难理解。）
274 | ```
275 | 
276 | 
277 | 
278 | 
279 | 
280 | ```xml
281 | Importing Dependencies
282 | 
283 | <project>
284 |     <modelVersion>4.0.0</modelVersion>
285 |     <groupId>maven</groupId>
286 |     <artifactId>B</artifactId>
287 |     <packaging>pom</packaging>
288 |     <name>B</name>
289 |     <version>1.0</version>
290 |     <dependencyManagement>
291 |         <dependencies>
292 |             <dependency>
293 |                 <groupId>maven</groupId>
294 |                 <artifactId>A</artifactId>
295 |                 <version>1.0</version>
296 |                 <type>pom</type>
297 |                 <scope>import</scope>
298 |             </dependency>
299 |             <dependency>
300 |                 <groupId>test</groupId>
301 |                 <artifactId>d</artifactId>
302 |                 <version>1.0</version>
303 |             </dependency>
304 |         </dependencies>
305 |     </dependencyManagement>
306 |     <dependencies>
307 |         <dependency>
308 |             <groupId>test</groupId>
309 |             <artifactId>a</artifactId>
310 |             <version>1.0</version>
311 |             <scope>runtime</scope>
312 |         </dependency>
313 |         <dependency>
314 |             <groupId>test</groupId>
315 |             <artifactId>c</artifactId>
316 |             <scope>runtime</scope>
317 |         </dependency>
318 |     </dependencies>
319 | </project>
320 | ```
321 | 
322 | Assuming A is the pom defined in the preceding example, the end result would be the same. **All of A's managed dependencies would be incorporated into B except for d since it is defined in this pom.**
323 | 
324 | 假设A是前面示例中定义的pom，那么最终结果将是相同的。**所有管理的依赖项都将被合并到B中，除了在这个pom中定义的d之外。**
325 | 
326 | 九.依赖冲突
327 | ------
328 | 
329 | ```cmd
330 | 1.短路优先:
331 | 
332 | 	C->B->A->X1(jar)
333 | 	C->B->X2(jar)
334 | 
335 | 【C依赖B,B依赖A,A和B都包含同一个不同版本的Jar,则取B的依赖版本。（c的pom.xml中不必注明jar坐标）】
336 | 
337 | 2.先声明先优先
338 | 
339 | 	如果路径相同长度相同，则谁先声明，先解析谁。
340 | 
341 | 【C依赖A和B,A和B都包含同一个不同版本的Jar,谁依赖在前取谁的依赖版本。】
342 | ```
343 | 
344 | 十.聚合与继承
345 | -------
346 | ### 聚合 ###
347 | 
348 | ```xml
349 | <packaging>pom</packaging>
350 | <modules>
351 |     <module>../HoictasStudio-MavenDemo01</module>
352 |     <module>../HoictasStudio-MavenDemo02</module>
353 |     <module>../HoictasStudio-MavenDemo03</module>
354 | </modules>
355 | ```
356 | 
357 | 假设在**HoictasStudio-MavenParent**模块中添如以上代码，输入`clean install`命令后，即可同时安装多个jar到本地仓库中
358 | 
359 | ```markdown
360 |     [INFO] HoictasStudio-MavenDemo01 .......................... SUCCESS [  4.618 s]
361 |     [INFO] HoictasStudio-MavenDemo02 .......................... SUCCESS [  0.828 s]
362 |     [INFO] HoictasStudio-MavenDemo03 .......................... SUCCESS [  0.923 s]
363 |     [INFO] HoictasStudio-MavenParent .......................... SUCCESS [  0.021 s]
364 | ```
365 | 
366 | 
367 | ### 继承 ###
368 | 
369 | **根据官方文档说明继承会根据父模块与子模块的包含与否，对pom.xml的写法则有两种。**
370 | 
371 | #### 第一种写法 ####
372 | 
373 | 假设我们有两个模块，前一个叫 `com.mycompany.app:my-app:1`，后一个叫`com.mycompany.app:my-module:1`。
374 | 
375 | my-app的pom文件为：
376 | 
377 | ```xml
378 | <project>
379 |   <modelVersion>4.0.0</modelVersion>
380 |   <groupId>com.mycompany.app</groupId>
381 |   <artifactId>my-app</artifactId>
382 |   <version>1</version>
383 | </project>
384 | ```
385 | 
386 | my-module的pom文件为：
387 | 
388 | ```xml
389 | <project>
390 |   <modelVersion>4.0.0</modelVersion>
391 |   <groupId>com.mycompany.app</groupId>
392 |   <artifactId>my-module</artifactId>
393 |   <version>1</version>
394 | </project>
395 | ```
396 | 
397 | 我们指定如下项目结构：
398 | 
399 | ```xml
400 | 	.
401 | 	 |-- my-module
402 | 	 |   `-- pom.xml
403 | 	 `-- pom.xml
404 | ```
405 | 
406 | 那么，我们需要`my-module`去继承`my-app`，则需要在`my-module`的pom文件中添加以下代码：
407 | 
408 | ```xml
409 | 	<project>
410 | 	  <parent>
411 | 	    <groupId>com.mycompany.app</groupId>
412 | 	    <artifactId>my-app</artifactId>
413 | 	    <version>1</version>
414 | 	  </parent>
415 | 	  <modelVersion>4.0.0</modelVersion>
416 | 	  <groupId>com.mycompany.app</groupId>
417 | 	  <artifactId>my-module</artifactId>
418 | 	  <version>1</version>
419 | 	</project>
420 | ```
421 | 
422 | #### 第二种写法 ####
423 | 
424 | ```cmd
425 | However, that would work if the parent project was already installed inour local repository or was in that specific 
426 | directory structure (parent pom.xml is one directory higher than that of the module's pom.xml). But what if the parent 
427 | is not yet installed and if the directory structure is
428 | .
429 | ```
430 |  	 |-- my-module
431 |  	 |   `-- pom.xml
432 |  	 `-- parent
433 | 	     `-- pom.xml	
434 | 
435 | 上一段话摘自官网对继承的介绍，就是说如果你的父模块已在本地安装或者父模块不包含子模块，目录级别甚至是
436 | 比子模块的还要高，就在第一种写法上添加`<relativePath>`标签。
437 | ​	
438 | 
439 | ```xml
440 | 	<project>
441 | 		  <parent>
442 | 		    <groupId>com.mycompany.app</groupId>
443 | 		    <artifactId>my-app</artifactId>
444 | 		    <version>1</version>
445 | 		    <relativePath>../parent/pom.xml</relativePath>
446 | 		  </parent>
447 | 		  <modelVersion>4.0.0</modelVersion>
448 | 		  <artifactId>my-module</artifactId>
449 | 	</project>
450 | ```
451 | 
452 | 
453 | 
454 | 笔者在看视频时就发现，当父模块与子模块处于同一级别时，在按照视频中的写法（第一种写法）test时就会报错，
455 | 而此时的情况是不包含子模块，所以应该在`<parent>`标签中添加`<relativePath>`标签即可测试通过。
456 | 
457 | 十一.maven配置阿里云镜像
458 | -------
459 | 
460 | 修改`setting.xml`文件，添加镜像地址
461 | 
462 | ```xml
463 |  <mirrors>
464 |       <mirror>
465 | 	<id>nexus-aliyun</id>
466 | 	<mirrorOf>*</mirrorOf>
467 | 	<name>Nexus aliyun</name>
468 | 	<url>http://maven.aliyun.com/nexus/content/groups/public</url>
469 |       </mirror>
470 |   </mirrors>
471 | ```
472 | 
473 | > 这个地址下载 jar 包的速度，谁用谁知道！
474 | 


--------------------------------------------------------------------------------