Maven详细安装使用学习_mvn install

Maven安装配置：

下载Maven核心程序地址：

https://maven.apache.org/
1

解压Maven核心程序：
把下载好的压缩包解压到无中文，无空格的目录中，着重关注解压后的核心配置文件conf/settings.xml

指定本地仓库：
maven的核心配置文件conf/settings.xml会默认本地仓库为电脑用户家目录/.m2/repositor。我们可以在核心配置文件conf/settings.xml中手动修改本地仓库地址如下：

<!-- localRepository
| The path to the local repository maven will use to store artifacts.
|
| Default: ${user.home}/.m2/repository
<localRepository>/path/to/local/repo</localRepository>
-->
<!-- 修改了本地仓库地址为D:\maven-repository，如果电脑没有该目录，maven会自动创建该目录 -->
<localRepository>D:\maven-repository</localRepository>
1
2
3
4
5
6
7
8

配置阿里云提供的镜像仓库：
Maven 下载 jar 包默认访问境外的中央仓库，而国外网站速度很慢。改成阿里云提供的镜像仓库，访问国内网站，可以让 Maven 下载 jar 包的时候速度更快。在maven的核心配置文件conf/settings.xml下的mirrors内的标签注释，改成如下,每次下载jar包就会去阿里云镜像仓库下载了：

<mirrors>
	<mirror>
		<id>nexus-aliyun</id>
		<mirrorOf>central</mirrorOf>
		<name>Nexus aliyun</name>
		<url>http://maven.aliyun.com/nexus/content/groups/public</url>
	</mirror>
</mirrors>
1
2
3
4
5
6
7
8

配置 Maven 工程的基础 JDK 版本：
如果按照默认配置运行，Java 工程使用的默认 JDK 版本是 1.5，而我们熟悉和常用的是 JDK 1.8 版本。修改成为jdk1.8版本方法如下：将 profile 标签整个复制到 settings.xml 文件的 profiles 标签内。

<profile>
	  <id>jdk-1.8</id>
	  <activation>
		<activeByDefault>true</activeByDefault>
		<jdk>1.8</jdk>
	  </activation>
	  <properties>
		<maven.compiler.source>1.8</maven.compiler.source>
		<maven.compiler.target>1.8</maven.compiler.target>
		<maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion>
	  </properties>
	</profile>
1
2
3
4
5
6
7
8
9
10
11
12

因为Maven 是一个用 Java 语言开发的程序，它必须基于 JDK 来运行，需要通过 JAVA_HOME 来找到 JDK 的安装位置。所以也需要下载安装jdk，下载安装方法这里不介绍了。
检查jdk是否安装配置好方法如下：
打开cmd，输入如下三个命令：

查看java版本： java -version
查看环境变量JAVA_HOME： echo %JAVA_HOME%
查看环境变量PATH： echo %PATH%
1
2
3

如上表示以安装jdk。
配置maven_Home:

配置环境变量的规律：
XXX_HOME 通常指向的是 bin 目录的上一级
PATH 指向的是 bin 目录

MAVEN_HOME：maven目录下，bin目录上一级
PATH:maven目录下的bin目录
1
2

检查是否安装配置好maven：

mvn -v
1

使用maven命令创建Java工程：

新建一个目录，作为工作目录；并在工作目录打开cmd：
运行

mvn archetype:generate
1

会出现如下：直接按照下面输入命令即可：

Choose a number or apply filter (format: [groupId:]artifactId, case sensitive contains): 7:【直接回车，使用默认值】

Define value for property ‘groupId’: com.atguigu.maven

Define value for property ‘artifactId’: pro01-maven-java

Define value for property ‘version’ 1.0-SNAPSHOT: :【直接回车，使用默认值】

Define value for property ‘package’ com.atguigu.maven: :【直接回车，使用默认值】

Confirm properties configuration: groupId: com.atguigu.maven artifactId: pro01-maven-java version: 1.0-SNAPSHOT package: com.atguigu.maven Y: :【直接回车，表示确认。如果前面有输入错误，想要重新输入，则输入 N 再回车。】

操作完后，新建的工作目录（路径：D:\java-maven\java）就会生成maven工程，但是Maven 默认生成的工程，对 junit 依赖的是较低的 3.8.1 版本，我们可以在（路径：D:\java-maven\java\pro01-maven-java）pom.xml文件改成较适合的 4.12 版本如下：。自动生成的（路径：D:\java-maven\java\pro01-maven-java\src\main\java\com\atguigu\maven） App.java 和 （路径：D:\java-maven\java\pro01-maven-java\src\test\java\com\atguigu\maven）AppTest.java 也可以删除。

<!-- 依赖信息配置 -->
<!-- dependencies复数标签：里面包含dependency单数标签 -->
<dependencies>
	<!-- dependency单数标签：配置一个具体的依赖 -->
	<dependency>
		<!-- 通过坐标来依赖其他jar包 -->
		<groupId>junit</groupId>
		<artifactId>junit</artifactId>
		<version>4.12</version>
		
		<!-- 依赖的范围 -->
		<scope>test</scope>
	</dependency>
</dependencies>
1
2
3
4
5
6
7
8
9
10
11
12
13
14

对maven工程核心配置文件pom.xml解读：

<!-- project标签：根标签，表示对当前工程进行配置，管理-->
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  
  <!-- modelVersion 标签，从Maven 2 开始就固定是4.0.0 -->
  <!--代表当前pom.xml所采用的标签结构-->
  <modelVersion>4.0.0</modelVersion>

  <!--坐标信息-->
  <!-- groupId 标签： 坐标向量之一，代表公司或组织开发的某个项目-->
  <groupId>com.atguigu.maven</groupId>
  
  <!-- artifactId 标签： 坐标向量之一，代表项目下的某个模块-->
  <artifactId>pro01-maven-java</artifactId>
  
  <!-- version 标签： 坐标向量之一，代表当前模块的版本-->
  <version>1.0-SNAPSHOT</version>
  
  <!-- packaging 标签： 打包方式-->
  <!-- 取值为jar ：生成jar包，说明是一个java工程-->
  <!-- war：表示这个工程是一个Web工程 -->
  <!-- pom：表示这个工程是“管理其他工程”的工程 -->
  <packaging>jar</packaging>

  <!-- 项目名称，地址 -->
  <name>pro01-maven-java</name>
  <url>http://maven.apache.org</url>

  <properties>
  <!-- 工程构建过程中读取源码时使用的字符集 -->
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>
  <!-- 当前工程所依赖的jar包 -->
  <!-- 依赖信息配置 -->
  <!-- dependencies复数标签：里面包含dependency单数标签 -->
<dependencies>
	<!-- dependency单数标签：配置一个具体的依赖 -->
	<!-- 使用dependency配置一个具体的依赖 -->
	<dependency>
		<!-- 通过坐标来依赖其他jar包 -->
		<!-- 在dependency标签内使用具体的坐标依赖我们需要的一个jar包 -->
		<groupId>junit</groupId>
		<artifactId>junit</artifactId>
		<version>4.12</version>
		
		<!-- scope标签配置依赖的范围 -->
		<scope>test</scope>
	</dependency>
</dependencies>
</project>

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
41
42
43
44
45
46
47
48
49
50
51

目前开发领域的技术发展趋势就是：约定大于配置，配置大于编码。Maven核心概念：约定的目录结构如下：

主程序：

package com.atguigu.maven;
	
public class Calculator {
	
	public int sum(int i, int j){
		return i + j;
	}	
}
1
2
3
4
5
6
7
8

测试程序：

package com.atguigu.maven;
	
import org.junit.Test;
import com.atguigu.maven.Calculator;
	
// 静态导入的效果是将Assert类中的静态资源导入当前类
// 这样一来，在当前类中就可以直接使用Assert类中的静态资源，不需要写类名
import static org.junit.Assert.*;
	
public class CalculatorTest{
	
	@Test
	public void testSum(){
		
		// 1.创建Calculator对象
		Calculator calculator = new Calculator();
		
		// 2.调用Calculator对象的方法，获取到程序运行实际的结果
		int actualResult = calculator.sum(5, 3);
		
		// 3.声明一个变量，表示程序运行期待的结果
		int expectedResult = 8;
		
		// 4.使用断言来判断实际结果和期待结果是否一致
		// 如果一致：测试通过，不会抛出异常
		// 如果不一致：抛出异常，测试失败
		assertEquals(expectedResult, actualResult);
	}
}
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

执行 Maven 的构建命令：

执行 Maven 的构建命令时，cmd必须在该工程的pom.xml 文件所在目录下运行，否则会报错如下：

报错或如下：

The goal you specified requires a project to execute but there is no POM in this directory
1

除了mvn -v 命令，它和构建操作无关，只要正确配置了 PATH，在任何目录下执行都可以。

清理操作（删除 target 目录）：

mvn clean
1

主程序编译：

mvn compile
1

测试程序编译：

mvn test-compile
1

测试的报告存放的目录：target/surefire-reports
主体程序编译结果存放的目录：target/classes
测试程序编译结果存放的目录：target/test-classes

测试操作：

mvn test
1

测试的报告存放的目录：target/surefire-reports

打包操作：

mvn package
1

打包的结果—-Java工程：jar 包；web过程：war包，存放的目录：target

安装操作：

mvn install
1

将本地构建过程中生成的 jar 包存入 Maven 本地仓库。这个 jar 包在 Maven 仓库中的路径是根据它的坐标生成的。
坐标如下：

com.atguigu.maven
pro01-maven-java
1.0-SNAPSHOT

在 Maven 本地仓库中生成的路径如下：

D:\maven-rep1026\com\atguigu\maven\pro01-maven-java\1.0-SNAPSHOT\pro01-maven-java-1.0-SNAPSHOT.jar

另外，安装操作还会将 pom.xml 文件转换为 XXX.pom 文件一起存入本地仓库。所以我们在 Maven 的本地仓库中想看一个 jar 包原始的 pom.xml 文件时，查看对应 XXX.pom 文件即可，它们是名字发生了改变，本质上是同一个文件。

创建 Maven 版的 Web 工程：

使用 mvn archetype:generate 命令生成 Web 工程时，需要使用一个专门的 maven-archetype-webapp。
在工作目录下cmd执行该命令，不要在Java工程下执行：

mvn archetype:generate -DarchetypeGroupId=org.apache.maven.archetypes -DarchetypeArtifactId=maven-archetype-webapp -DarchetypeVersion=1.4
1

Define value for property ‘groupId’: com.atguigu.maven

Define value for property ‘artifactId’: pro02-maven-web

Define value for property ‘version’ 1.0-SNAPSHOT: :【直接回车，使用默认值】

Define value for property ‘package’ com.atguigu.maven: :【直接回车，使用默认值】

Confirm properties configuration: groupId: com.atguigu.maven
artifactId: pro02-maven-web version: 1.0-SNAPSHOT package: com.atguigu.maven Y: :【直接回车，表示确认】

生成的pom.xml，打包的方式是war包形式：

 <packaging>war</packaging>
1

目录结构如下：

创建 Servlet：
1.在 main 目录下创建Java目录，在Java目录下创建创建 Servlet 类所在的包的目录与servlet类如下：

package com.atguigu.maven;
	
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.ServletException;
import java.io.IOException;
	
public class HelloServlet extends HttpServlet{
	
	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		
		response.getWriter().write("hello maven web");	
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

2.在 web.xml 中注册 Servlet：

  <servlet>
	<servlet-name>helloServlet</servlet-name>
	<servlet-class>com.atguigu.maven.HelloServlet</servlet-class>
  </servlet>
  <servlet-mapping>
	<servlet-name>helloServlet</servlet-name>
	<url-pattern>/helloServlet</url-pattern>
  </servlet-mapping>
1
2
3
4
5
6
7
8

3.在 index.jsp 页面编写超链接：

<html>
<body>
<h2>Hello World!</h2>
<a href="helloServlet">Access Servlet</a>
</body>
</html>
1
2
3
4
5
6

4.以上操作完成后直接编译

mvn compile
1

会报错如下：

上面的错误信息说明：我们的 Web 工程用到了 HttpServlet 这个类，而 HttpServlet 这个类属于 servlet-api.jar 这个 jar 包。即Web 工程需要依赖 servlet-api.jar 包。

5.配置对 servlet-api.jar 包的依赖,对于不知道详细信息的依赖可以到https://mvnrepository.com/网站查询。使用关键词搜索，然后在搜索结果列表中选择适合的使用。

选择第一个 servlet-api 的依赖信息，把下面的信息加入pom.xml里面：

<!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>3.1.0</version>
    <scope>provided</scope>
</dependency>
1
2
3
4
5
6
7

重新编译执行下面命令就成功了

 mvn compile
1

6.将 Web 工程打包为 war 包 (war包在target目录下），执行命令：

mvn package
1

7.将 war 包部署到 Tomcat 上运行。将 war 包复制到 Tomcat/webapps 目录下，

并打开运行 Tomcat的并目录下的startup.bat，

就可以访问到web项目（通过浏览器尝试访问：http://localhost:8080/pro02-maven-web/index.jsp）

让web工程依赖java工程：

只有 Web 工程依赖 Java 工程，没有反过来 Java 工程依赖 Web 工程。本质上来说，Web 工程依赖的 Java 工程其实就是 Web 工程里导入的 jar 包。最终 Java 工程会变成 jar 包，放在 Web 工程的 WEB-INF/lib 目录下。

让pro02-maven-java 这个web工程依赖pro01-maven-java 这个Java工程，可以在pro01-maven-java 这个Java工程中的pom.xml找到

<groupId>com.atguigu.maven</groupId>
<artifactId>pro01-maven-java</artifactId>
<version>1.0-SNAPSHOT</version>`
1
2
3

这些配置信息，然后放到pro02-maven-java 这个web工程的pim.xml文件上如下：

<!-- 配置对Java工程pro01-maven-java的依赖 -->
<!-- 具体的配置方式：在dependency标签内使用坐标实现依赖 -->
<dependency>
	<groupId>com.atguigu.maven</groupId>
	<artifactId>pro01-maven-java</artifactId>
	<version>1.0-SNAPSHOT</version>
</dependency>
1
2
3
4
5
6
7

在web工程中编写测试代码：
先创建目录pro02-maven-web\src\test\java\com\atguigu\maven，再把 Java 工程的 CalculatorTest.java 类复制到 pro02-maven-java\src\test\java\com\atguigu\maven 目录下

确定web工程依赖了junit

    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <scope>test</scope>
    </dependency>
1
2
3
4
5
6

测试命令：

mvn test
1

打包命令：

mvn package
1

通过查看 war 包内的结构，我们看到被 Web 工程依赖的 Java 工程确实是会变成 Web 工程的 WEB-INF/lib 目录下的 jar 包。

当前 Web 工程所依赖的 jar 包的列表命令：

mvn dependency:list
1

以树形结构查看当前 Web 工程的依赖信息（所依赖的 jar 包的列表）：

mvn dependency:tree
1

测试依赖的范围：

标签的位置：dependencies/dependency/scope
标签的可选值：compile/test/provided/system/runtime/import

compile：通常使用的第三方框架的 jar 包这样在项目实际运行时真正要用到的 jar 包都是以 compile 范围进行依赖的。比如 SSM 框架所需jar包。 test：测试过程中使用的 jar 包，以 test 范围依赖进来。比如 junit。
provided：在开发过程中需要用到的“服务器上的 jar 包”通常以 provided 范围依赖进来。比如
servlet-api、jsp-api。而这个范围的 jar 包之所以不参与部署、不放进 war 包，就是避免和服务器上已有的同类 jar包产生冲突，同时减轻服务器的负担。说白了就是：“服务器上已经有了，你就别带啦！

依赖的传递性：

原则：

在 A 依赖 B，B 依赖 C 的前提下，C 是否能够传递到 A，取决于 B 依赖 C 时使用的依赖范围。
B 依赖 C 时使用 compile 范围：可以传递，即A可以拿到C 。
B 依赖 C 时使用 test 或 provided 范围：不能传递，即A拿不到C。

依赖的排除:

当 A 依赖 B，A 依赖 C ，B和C都依赖D，且B依赖D的1.0版本，C依赖D的2.0版本，为了避免依赖时 jar 包之间的冲突，需要排除A对B工程的D1.0版本的传递依赖，让A依赖B工程时，不依赖D工程的1.0版本。可以在pom.xml配置文件中，A依赖B的配置下增加排除D的配置代码，实现A依赖B，但不给B依赖的D传递给A。
如：

<dependency>
	<groupId>com.atguigu.maven</groupId>
	<artifactId>pro01-maven-java</artifactId>
	<version>1.0-SNAPSHOT</version>
	<scope>compile</scope>
	<!-- 使用excludes标签配置依赖的排除	-->
	<exclusions>
		<!-- 在exclude标签中配置一个具体的排除 -->
		<exclusion>
			<!-- 指定要排除的依赖的坐标（不需要写version） -->
			<groupId>commons-logging</groupId>
			<artifactId>commons-logging</artifactId>
		</exclusion>
	</exclusions>
</dependency>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

以上表示依赖pro01-maven-java，但是不依赖pro01-maven-java下的commons-logging。

继承：

在父工程中为整个项目维护依赖信息的组合既保证了整个项目使用规范、准确的 jar 包；又能够将以往的经验沉淀下来，节约时间和精力。
一个父工程，多个子工程

1.创建父工程：和前面创建 pro01-maven-java一样

工程创建好之后，要修改它的打包方式，因为只有打包方式为 pom 的 Maven 工程能够管理其他 Maven 工程。打包方式为 pom 的 Maven 工程中不写业务代码，它是专门管理其他 Maven 工程的工程。如下：
在pom.xml文件修改打包方式如下

<!-- 当前工程作为父工程，它要去管理子工程，所以打包方式必须是 pom -->
  <packaging>pom</packaging>
1
2

2.创建模块工程：
模块工程类似于 IDEA 中的 module，所以需要进入父工程（即 pro03-maven-parent 工程）的根目录，然后运行

 mvn archetype:generate 
1

命令来创建模块工程。
查看被添加新内容的父工程 pom.xml，下面 modules 和 module 标签是聚合功能的配置

<modules>  
	<module>pro04-maven-module</module>
	<module>pro05-maven-module</module>
	<module>pro06-maven-module</module>
</modules>
1
2
3
4
5

解读子工程的pom.xml：

<!-- 使用parent标签指定当前工程的父工程 -->
<parent>
	<!-- 父工程的坐标 -->
	<groupId>com.atguigu.maven</groupId>
	<artifactId>pro03-maven-parent</artifactId>
	<version>1.0-SNAPSHOT</version>
</parent>

<!-- 子工程的坐标 -->
<!-- 如果子工程坐标中的groupId和version与父工程一致，那么可以省略 -->
<!-- <groupId>com.atguigu.maven</groupId> -->
<artifactId>pro04-maven-module</artifactId>
<!-- <version>1.0-SNAPSHOT</version> -->
1
2
3
4
5
6
7
8
9
10
11
12
13

在父工程中配置依赖的统一管理：

<!-- 使用dependencyManagement标签配置对依赖的管理 -->
<!-- 被管理的依赖并没有真正被引入到工程 -->
<dependencyManagement>
	<dependencies>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
			<version>4.0.0.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-beans</artifactId>
			<version>4.0.0.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>4.0.0.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-expression</artifactId>
			<version>4.0.0.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-aop</artifactId>
			<version>4.0.0.RELEASE</version>
		</dependency>
	</dependencies>
</dependencyManagement>
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

上面的父工程多次写了4.0.0.RELEASE，且版本号都一样，可以用下面的自定义属性写法，实现一处修改，处处生效。

<!-- 通过自定义属性，统一指定Spring的版本 -->
<properties>
	<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
	<!-- 自定义标签，维护Spring版本数据 -->
	<atguigu.spring.version>4.3.6.RELEASE</atguigu.spring.version>
</properties>

<dependencyManagement>
	<dependencies>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
			<!-- 引用上面的 自定义标签-->
			<version>${atguigu.spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-beans</artifactId>
			<version>${atguigu.spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>${atguigu.spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-expression</artifactId>
			<version>${atguigu.spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-aop</artifactId>
			<version>${atguigu.spring.version}</version>
		</dependency>
	</dependencies>
</dependencyManagement>
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

子工程中引用那些被父工程管理的依赖（子工程中可 省略版本号）：

<!-- 子工程引用父工程中的依赖信息时，可以把版本号去掉。	-->
<!-- 把版本号去掉就表示子工程中这个依赖的版本由父工程决定。 -->
<!-- 具体来说是由父工程的dependencyManagement来决定。 -->
<!-- 子工程写版本号，且版本号与父工程不一样时，子工程用自己的版本号覆盖父工程版本号-->

<dependencies>
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-core</artifactId>
	</dependency>
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-beans</artifactId>
	</dependency>
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-context</artifactId>
	</dependency>
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-expression</artifactId>
	</dependency>
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-aop</artifactId>
	</dependency>
</dependencies>
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

聚合：

部分组成整体，使用一个“总工程”将各个“模块工程”汇集起来，作为一个整体对应完整的项目。
项目：整体
模块：部分

从继承关系角度来看：
父工程 子工程

从聚合关系角度来看：
总工程 模块工程

优点：
以 mvn install 命令为例：Maven 要求有父工程时先安装父工程；有依赖的工程时，先安装被依赖的工程。我们自己考虑这些规则会很麻烦。但是工程聚合之后，在总工程执行 mvn install 可以一键完成安装，而且会自动按照正确的顺序执行。
配置聚合之后，各个模块工程会在总工程中展示一个列表，让项目中的各个模块一目了然。

聚合的配置：
在总工程中配置modules即可，在上面继承时已配置好

	<modules>  
		<module>pro04-maven-module</module>
		<module>pro05-maven-module</module>
		<module>pro06-maven-module</module>
	</modules>
1
2
3
4
5

依赖循环问题：
如果 A 工程依赖 B 工程，B 工程依赖 C 工程，C 工程又反过来依赖 A 工程，那么在执行构建操作时会报下面的错误：

DANGER

[ERROR] [ERROR] The projects in the reactor contain a cyclic
reference:

这个错误的含义是：循环引用。

idea 创建maven工程：

自动加载依赖包，并以后不提醒。

配置maven信息：
每次创建 Project 后都需要设置 Maven 家目录位置，否则就会默认使用 IDEA内置的 Maven 核心程序（不稳定）并使用默认的本地仓库位置（在c盘中）。所以要配置成我们自己下载安装的maven核心程序，把默认本地仓库改为我们自己创建的本地仓库。

创建java模块工程：



最后生成如下：

创建web模块工程：
按照上面创建java工程一样先创建一个java模块。
生成如下pro03-maven-web

把pro03-maven-web模块下的pom.xml下的打包方式改成war包，如下：

<packaging>war</packaging>
1

web设定：

然后到 Facets 下查看 IDEA 是否已经帮我们自动生成了 Web 设定。正常来说只要我们确实设置了打包方式为 war，那么 IDEA 2019 版就会自动生成 Web 设定。

没有自动生成web设定，参照下面自己创建：

点ok后如果弹出

是因为本来目src\main\webapp\WEB-INF，点yes创建。

在idea中执行maven命令：

命令执行时，记得右上角选择要操作的项目名称，如下图

也可以项目右键，打开idea终端执行命令操作，如下：

外部模块导入，如需要把外部的pro02-maven-model导入到项目中，在modules中导入需要导入的pro02-maven-model模块如下：


修改 pom.xml：
刚刚导入的 module 的父工程坐标还是以前的，需要改成我们自己的 project。