Maven基础_mvn archetype:generate the goal you specified requ-CSDN博客

本文链接：https://blog.csdn.net/Siebert_Angers/article/details/127586012

文章目录

一. 前言
二. 命令行构建Maven默认工程
三. Maven生命周期
四. 命令行构建web工程
五. 依赖范围
六. 继承
七. 聚合
八. IDEA整合Maven

一. 前言

1. Maven是什么?

在开篇之前，小编觉得有必要简单的介绍一下Maven是什么。Maven翻译为“专家“， ”内行”的意思，是著名Apache公司下基于Java开发的开源项目，是一个项目管理工具软件可以对项目进行构建、依赖的管理。

2. 构建?

Java 项目开发过程中“构建”就好比原材料生产产品的过程,而原材料就是:Java 源代码、基于HTML的Thymeleaf文件、图片、配置文件等等…
而产品就是一个可以在服务器上运行的项目
PS:Gradle被称之为下一代项目构建管理工具,有取代Mavem的趋势。

3. 构建的主要过程

构建项目的主要过程也对应了后文中提到的“Maven声明周期”
构建过程包含的主要的环节：
清理:删除上一次构建的结果，为下一次构建做好准备。
编译:Java 源程序编译成后缀为 .class 的字节码文件
测试: 运行提前准备好的测试程序
报告:针对刚才测试的结果生成一个全面的信息
打包:Java工程–>jar包 | Web工程–>war包
安装:把一个 Maven 工程经过打包操作生成的 jar 包或 war 包存入 Maven 仓库
部署:部署 jar 包–>把一个 jar 包部署到 Nexus 私服服务器上;部署 war 包–>借助相关 Maven 插件（例如 cargo），将 war 包部署到 Tomcat 服务器上。

二. 命令行构建Maven默认工程

想要构建Maven工程需要本地安装配置好Maven，如果有没有在本地安装配置Maven的小伙伴可以参考小编的这篇文章 Windows安装配置Maven，后续我们可以使用IDEA基于图形化界面构建，但是小编还是觉得有必要知道maven基于命令行的项目构建方式。
在构建Maven的工程之前我们还需要了解一下Maven的核心概念:Maven坐标
注:工程和项目的区别，一个工程中可能包含多个项目，这一点在后续的分布式与微服务中表现的极为明显。

1. Maven 核心概念:坐标

在数学中我们使用x、y、z 三个『向量』作为空间的坐标系，可以在『空间』中唯一的定位到一个『点』。
而在Maven中我们也使用三个坐标定位到仓库中唯一一个jar包，它们分别是groupId，artifactId，version。

groupId : 公司或者组织的ID
artifactId : 一个项目或者是项目中的一个模块的 id
version : 版本号

groupId：公司或组织域名的倒序，通常也会加上项目名称列如: com.yunchuang.maven
artifactId : 模块的名称，将来作为 Maven 工程的工程名
version : 模块的版本号，根据自己的需要设定，一般SNAPSHOT 表示快照版本，正在迭代过程中，不稳定的版本，RELEASE 表示正式版本。
举个栗子:

<groupId>com.yunchuang.maven</groupId>
<artifactId>por01-maven</artifactId>
<version>1.0-SNAPSHOT</version>

2. 坐标和仓库中 jar 包的存储路径之间的对应关系

例如:

<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
<version>2.5</version>

则对应本地仓库路径如下:

Maven本地仓库根目录\javax\servlet\servlet-api\2.5\servlet-api-2.5.jar

3. 构建Maven默认工程

Maven命令结构如下:
在这里插入图片描述
进入工作目录打开CMD，使用以下命令可以构建一个Maven的默认项目，前提是当前系统环境已经配置好了Maven。

mvn archetype:generate

回车运行后会出现以下一些提示

Choose a number or apply filter (format: [groupId:]artifactId, case sensitive contains): 7: 【直接回车使用默认值】
Define value for property ‘groupId’:【输入groupId再回车】
Define value for property ‘artifactId’: 【输入artifactId再回车】
Define value for property ‘version’ 1.0-SNAPSHOT: :【输入版本，直接回车使用默认值】
Define value for property ‘package’ com.yuanchuang.maven: : 【直接回车使用默认值】
Confirm properties configuration: groupId: com.atguigu.maven artifactId: pro01-maven-java version: 1.0-SNAPSHOT package: com.atguigu.maven Y:【直接回车，表示确认。如果前面有输入错误，想要重新输入，则输入 N 再回车。】

看到BUILD SUCCESS就是创建成功了，第一次创建可能比较久。
在这里插入图片描述
可以看到创建的工程是以artifactId为项目名称的

打开这个生成好的项目可以看到以下项目结构，这个.idea是IDEA工具自动生成的我们忽略不计。

提到这个目录结构的话那就不得不聊一聊我们下一个Maven核心概念:POM

4. Maven核心概念:POM

POM:Project Object Model，项目对象模型。和 POM 类似的是：DOM（Document Object Model），文档对象模型。它们都是模型化思想的具体体现。
模型化思想:POM 表示将工程抽象为一个模型，再用程序中的对象来描述这个模型。这样我们就可以用程序来管理项目了。我们在开发过程中，最基本的做法就是将现实生活中的事物抽象为模型，然后封装模型相关的数据作为一个对象，这样就可以在程序中计算与现实事物相关的数据。
对应的配置文件:POM 理念集中体现在 Maven 工程根目录下 pom.xml 这个配置文件中。所以这个 pom.xml 配置文件就是 Maven 工程的核心配置文件。其实学习 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从Maven2开始就固定是4.0.0 代表当前pom.xml采用的标签结构 -->
  <modelVersion>4.0.0</modelVersion>
<!-- 当前Maven工程的坐标 -->
	<!--groupId:代表公司或组织开发的一个项目 -->
  <groupId>com.yunchuang.maven</groupId>
  	<!-- 代表当前项目下的模块名 -->
  <artifactId>pro01-maven</artifactId>
  	<!-- 模块版本 -->
  <version>1.0-SNAPSHOT</version>
  
  <!-- 当前Maven工程的打包方式，可选值有下面三种： -->
  <!-- jar：表示这个工程是一个Java工程 默认值  -->
  <!-- war：表示这个工程是一个Web工程 -->
  <!-- pom：表示这个工程是“管理其他工程”的工程 -->
  <packaging>jar</packaging>

  <name>pro01-maven-java</name>
  <url>http://maven.apache.org</url>
	
	<!--properties定义属性值 -->
  <properties>
	<!-- 工程构建过程中读取源码时使用的字符集 -->
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>

  <!-- 当前工程所依赖的jar包 -->
  <dependencies>
	<!-- 使用dependency配置一个具体的依赖 -->
    <dependency>
	
	  <!-- 在dependency标签内使用具体的坐标依赖我们需要的一个jar包 -->
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
	  
	  <!-- scope标签配置依赖的范围 -->
      <scope>test</scope>
    </dependency>
  </dependencies>
</project>

5. Maven核心概念:约定的目录结构

各个目录的意义:
在这里插入图片描述
运行项目的话还会有一个 target 目录专门存放构建操作输出的结果。
约定目录结构的意义:Maven 为了让构建过程能够尽可能自动化完成，所以必须约定目录结构的作用。例如：Maven 执行编译操作，必须先去 Java 源程序目录读取 Java 源代码，然后执行编译，最后把编译结果存放在 target 目录
约定大于配置:Maven 对于目录结构这个问题，没有采用配置的方式，而是基于约定。这样会让我们在开发过程中非常方便。如果每次创建 Maven 工程后，还需要针对各个目录的位置进行详细的配置，那肯定非常麻烦。
目前开发领域的技术发展趋势就是：约定大于配置，配置大于编码。

三. Maven生命周期

上文中提到的构建的主要过程其实就对应了Maven项目的声明周期，它们包括、清理操作、编译操作
、测试操作、打包操作、安装操作。
这些操作也对应着对Maven构建的项目的一些指令。值得注意的是在命令行环境执行这些指令必须进入到 pom.xml 所在的目录(想操作哪个工程就进入哪个工程的pom.xml所在目录)。如果没有在 pom.xml 所在的目录运行 Maven 的构建命令，那么会看到下面的错误信息：

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

而在图形化的操作界面比如IDEA就为我们提供快捷操作直接通过点击就可以快速对项目执行这些指令，如下图:
在这里插入图片描述

1. 编译操作

主程序编译:在命令行环境执行以下指令，可以对当前的主程序进行编译，编译完成后会在src同级目录下出现一个target目录存放程序编译完成后的结果。
主体程序编译结果存放的目录：target/classes

mvn compile

测试程序编译:执行以下的命令可以对测试程序目录中的代码进行编译
测试程序编译结果存放的目录：target/test-classes

mvn test-compile

2. 清零操作

执行以下命令可以清理上一次编译完成的结果，无论是主程序的编译结果还是测试程序的编译结果都会被清理掉，target目录会被直接删除。
通常用来配合上一条命令使用可以解决一些特殊的bug

mvn clean

3. 测试操作

执行以下命令会对主程序中存放在测试目录的代码进行执行，执行这条命令时会自动执行清理、编译操作因为这个操作是在它们的生命周期之后之后的命令也是同理。
测试的报告存放的目录：target/surefire-reports

mvn test

4. 打包操作

执行以下命令会对当前主程序进行打包操作，根据配置文件的内容决定打成什么包,同理也会将上面的生命周期命令都执行一遍。
打包后的存放目录: target/

mvn package

5. 安装操作

执行以下命令会对当前主项目进行安装，安装的效果是将本地构建过程中生成的 jar 包存入 Maven 本地仓库。这个 jar 包在 Maven 仓库中的路径是根据它的坐标生成的。

mvn install

如果要导入安装好的jar包，假如我们上面构建的项目被打包则引入依赖则用下面的配置方式。

<groupId>com.yunchuang.maven</groupId>
<artifactId>pro01-maven</artifactId>
<version>1.0-SNAPSHOT</version>

在本地仓库中的路径则是

本地仓库路径\com\yunchuang\maven\pro01-maven\1.0-SNAPSHOT\pro01-maven-1.0-SNAPSHOT.jar

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

四. 命令行构建web工程

使用 mvn archetype:generate 命令生成 Web 工程时，需要使用一个专门的 archetype。这个专门生成 Web 工程骨架的 archetype 可以参照官网看到它的用法：
在这里插入图片描述
参数 archetypeGroupId、archetypeArtifactId、archetypeVersion 用来指定现在使用的 maven-archetype-webapp 的坐标。

1. 创建web工程

注意：如果在上一个工程的目录下执行 mvn archetype:generate 命令，那么 Maven 会报错：不能在一个非 pom 的工程下再创建其他工程。所以不要再刚才创建的工程里再创建新的工程，请回到工作空间根目录来操作。
然后运行以下命令构建web工程

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

回车后会遇到以下几个提示:

Define value for property ‘groupId’: 【输入groupId再回车】
Define value for property ‘artifactId’: 【输入artifactId再回车】
Define value for property ‘version’ 1.0-SNAPSHOT: :【输入版本，直接回车使用默认值】
Define value for property ‘package’ com.yunchuang.maven: :【直接回车使用默认值】
Confirm properties configuration: groupId: com.atguigu.maven artifactId: pro01-maven-java version: 1.0-SNAPSHOT package: com.atguigu.maven Y:【直接回车，表示确认。如果前面有输入错误，想要重新输入，则输入 N 再回车。】

然后就可看到构建成功
在这里插入图片描述
其目录结构如下:

我们查看其 pom.xml 依赖管理文件，其中内容如下:

<?xml version="1.0" encoding="UTF-8"?>

<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>4.0.0</modelVersion>

  <groupId>com.yunchuang.maven</groupId>
  <artifactId>pro02-maven-web</artifactId>
  <version>1.0-SNAPSHOT</version>
  <!-- web工程打包方式为war -->
  <packaging>war</packaging>

  <name>pro02-maven-web Maven Webapp</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>
	
	<!-- 源码字符集 -->
  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
  </properties>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
  </dependencies>

  <!-- <build>标签的内容都可以去掉都是声明周期插件 -->
  
</project>

创建完成后我们就可以在其中编写java代码然后部署到Tomcat上了，然后我们就可以通过浏览器去访问就可以在浏览器看到我们编写的页面内容了。

2. javaweb hello world

接下来我们将演示基于上一小节我们创建好的javaweb工程编写一个hello代码，然后进行打包，再部署到tomcat服务器上，然后我们将在浏览器上访问我们编写的内容。
创建目录:首先我们在创建好的工程目录的main目录下创建一个java目录然后再创建com/yunchuang/maven目录结构。
创建类:在工程的src/main/java/com/yunchuang/maven目录下创建一个HelloServlet类
将以下代码添加进HelloServlet类

package com.yunchuang.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");
		
	}
	
}

在 web.xml 中注册 Servlet

<servlet>
	<servlet-name>helloServlet</servlet-name>
	<servlet-class>com.yunchuang.maven.HelloServlet</servlet-class>
 </servlet>
  <servlet-mapping>
	<servlet-name>helloServlet</servlet-name>
	<url-pattern>/helloServlet</url-pattern>
  </servlet-mapping>

在 index.jsp 页面编写超链接

<html>
<body>
<h2>Hello World!</h2>
<a href="helloServlet">Access Servlet</a>
</body>
</html>

将以下依赖信息添加到 pmo.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>

再重新进入pom.xml所在目录打开cmd执行以下指令:

mvn compile

可以看到编译成功
在这里插入图片描述
这时再执行以下命令打包

mvn package

在这里插入图片描述
打包成功后就可以在项目的taeget目录下看到打包好的war包

接下来只要将这个声场的war包放在Tomcat的Tomcat/webapps目录下面再执行Tomcat安装目录下的bin目录中的启动脚本即可，war包会自动解压，这时用浏览器访问http://localhost:8080/pro02-maven-web/index.jsp就可以访问到我们编写的内容了

3. web工程依赖java工程

明确一个意识：从来只有 Web 工程依赖 Java 工程，没有反过来 Java 工程依赖 Web 工程。本质上来说，Web 工程依赖的 Java 工程其实就是 Web 工程里导入的 jar 包。最终 Java 工程会变成 jar 包，放在 Web 工程的 WEB-INF/lib 目录下。
在配置依赖之前要先对我们上面创建好的pro01的java工程执行install命令。将其安装到本地仓库，然后再打开pro02的web工程呢在其中的pom.xml依赖管理文件中加入以下的依赖信息。

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

这样pro02工程中就可以访问pro01中的类
可以使用以下指令在命令行中查看当前工程的依赖信息

mvn dependency:list  // 列表形式查看
mvn dependency:tree // 树形方式查看

五. 依赖范围

    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <scope>test</scope>
    </dependency>

1. compile和test对t比

在这里插入图片描述

2. compile和provided对L比

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

3. 依赖的传递性

A 依赖 B，B 依赖 C，那么在 A 没有配置对 C 的依赖的情况下，A 里面能不能直接使用 C？这就是依赖传递性的概念。
传递的原则:在 A 依赖 B，B 依赖 C 的前提下，C 是否能够传递到 A，取决于 B 依赖 C 时使用的依赖范围

B 依赖 C 时使用 compile 范围：可以传递
B 依赖 C 时使用 test 或 provided 范围：不能传递，所以需要这样的 jar 包时，就必须在需要的地方明确配置依赖才可以。

其实使用下面的命令，可以在命令行中能够列出来的依赖就可以在当前的项目中使用，这样就可以检测当前项目的可用依赖。

mvn dependency:list  // 列表形式查看
mvn dependency:tree // 树形方式查看

4. 依赖的排除

当 A 依赖 B，B 依赖 C 而且 C 可以传递到 A 的时候，A 不想要 C，需要在 A 里面把 C 排除掉。而往往这种情况都是为了避免 jar 包之间的冲突。
在这里插入图片描述
所以配置依赖的排除其实就是阻止某些 jar 包的传递。因为这样的 jar 包传递过来会和其他 jar 包冲突。
配置示例:

<dependency>
	<groupId>com.yunchuang.maven</groupId>
	<artifactId>pro01-maven</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. 概念

Maven工程之间，A 工程继承 B 工程

B 工程：父工程
A 工程：子工程

本质上是 A 工程的 pom.xml 中的配置继承了 B 工程中 pom.xml 的配置。

2. 作用

在父工程中统一管理项目中的依赖信息，具体来说是管理依赖信息的版本。
一般来说子工程中继承父工程的依赖是不需要指定版本号的。
背景:

对一个比较大型的项目进行了模块拆分
一个 project 下面，创建了很多个 module。
每一个 module 都需要配置自己的依赖信息。

它背后的需求是：

在每一个 module 中各自维护各自的依赖信息很容易发生出入，不易统一管理。
使用同一个框架内的不同 jar 包，它们应该是同一个版本，所以整个项目中使用的框架版本需要统一。
使用框架时所需要的 jar 包组合（或者说依赖信息组合）需要经过长期摸索和反复调试，最终确定一个可用组合。这个耗费很大精力总结出来的方案不应该在新的项目中重新摸索。

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

3. 案例演示

创建的过程和前面创建 pro01-maven 一样。工程名称：pro03-maven-parent 为父工程。
注意:工程创建好之后，要修改它的打包方式

 <groupId>com.yunchuang.maven</groupId>
  <artifactId>pro03-maven-parent</artifactId>
  <version>1.0-SNAPSHOT</version>
  <!-- 当前工程作为父工程，它要去管理子工程，所以打包方式必须是 pom -->
  <packaging>pom</packaging>

只有打包方式为 pom 的 Maven 工程能够管理其他 Maven 工程。打包方式为 pom 的 Maven 工程中不写业务代码，它是专门管理其他 Maven 工程的工程。
这样父工程就被创建好了，接下来就可以在父工程的工程的根目录，然后运行指令来创建工程模块。

mvn archetype:generate

我们创建三个模块工程，结构如下：
在这里插入图片描述
再查看pro03-maven-parent 父工程中的依赖文件，发现其中多了以下几条内容：

<!-- 聚合配置 -->
<modules>  
	<module>pro04-maven-module</module>
	<module>pro05-maven-module</module>
	<module>pro06-maven-module</module>
</modules>

查看子工程的pom.xml，会发现：

<!-- 使用parent标签指定当前工程的父工程 -->
<parent>
	<!-- 父工程的坐标 -->
	<groupId>com.yunchuang.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> -->

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

<!-- 使用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>

子工程中引用那些被父工程管理的依赖：关键点：省略版本号

<!-- 子工程引用父工程中的依赖信息时，可以把版本号去掉。	-->
<!-- 把版本号去掉就表示子工程中这个依赖的版本由父工程决定。 -->
<!-- 具体来说是由父工程的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>

4. 父工程中声明自定义属性

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

在需要的地方使用${}的形式来引用自定义的属性名：

<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-core</artifactId>
		<version>${atguigu.spring.version}</version>
</dependency>

5. 总结

编写一套符合要求、开发各种功能都能正常工作的依赖组合并不容易。如果公司里已经有人总结了成熟的组合方案，那么再开发新项目时，如果不使用原有的积累，而是重新摸索，会浪费大量的时间。为了提高效率，我们可以使用工程继承的机制，让成熟的依赖组合方案能够保留下来。
如下图所示，公司级的父工程中管理的就是成熟的依赖组合方案，各个新项目、子系统各取所需即可。
在这里插入图片描述

七. 聚合

聚合本身的含义就是部分组成整体，使用一个“总工程”将各个“模块工程”汇集起来，作为一个整体对应完整的项目。这就是我们maven中的聚合

项目：整体
模块：部分

概念的对应关系：
从继承关系角度来看：

父工程对应整体
子工程对应部分

从聚合关系角度来看：

总工程
模块工程

1. 好处

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

2. 聚合的配置

就以我们上个项目的创建为例，创建多个子项目后，父工程的依赖配置文件中自动帮我们配置好了聚合，如果是别的情况在在总工程中配置 modules 即可：

<modules>  
		<module>pro04-maven-module</module>
		<module>pro05-maven-module</module>
		<module>pro06-maven-module</module>
</modules>

3. 依赖循环问题

如果 A 工程依赖 B 工程，B 工程依赖 C 工程，C 工程又反过来依赖 A 工程，那么在执行构建操作时会报下面的错误：[ERROR] [ERROR] The projects in the reactor contain a cyclic reference: 这个错误的含义是：循环引用。
这是一个值得注意的点。

八. IDEA整合Maven

本次演示采用的IDEA的版本是，IntelliJ IDEA 2021.3.2，其他版本可能有所不同，但是大致都是一样的。

1. 创建父工程

打开IDEA 点击【新建项目】选择【Maven】模板创建
在这里插入图片描述
填写好相关信息就可以点击【完成】了

然后基础的Maven工程就创建完毕了

2.配置Maven

创建好项目后首先要检查或者配置Maven的相关信息，点击左上角的【文件】然后点击【设置】在搜索里面搜索 Maven 就可以看到Maven的相关信息配置，IDEA里面有一个默认的Maven，但是一般我们并不使用它
在这里插入图片描述
分别配置好我们本地的Maven路径 还有本地的Maven配置文件 和本地仓库路径 最后点击【确定】即可

3.创建子工程

创建完上面的父工程后，我们可以在父工程下创建多个依赖父工程的子工程。
选择要创建子工程的模块【右击】点击【新建】选择【模块】点击
在这里插入图片描述
点击后选择【Maven】模板创建然后填写模块名 IDEA 会自动帮我们填写好一些信息也帮我们选择好了要依赖的父工程，填写完后点击【完成】即可

创建完成后父工程的打包方式IDEA也自动修改为 pom了聚合也帮我们配置好了
在这里插入图片描述

4. 在IDEA中执行Maven命令

创建好Maven工程后IDEA给我们提供了快速的Maven执行方式，点击要执行的命令即可对模块执行Maven命令
在这里插入图片描述
执行下面的命令在执行命令的上方的生命周期都会执行一遍，但是如果想要跳过一些生命周期命令的执行，比如像执行完clean 后直接执行insatll 则可以点击【M】输入clean 和 install 然后回车就执行了
也可以选择要执行的模块。
在这里插入图片描述
如果想要跳过测试(test)生命周期命令的话可以点击这个蓝色小按钮

或者

5. IDEA创建web工程

创建web工程在IDEA中可以使用骨架创建，也可以使用骨架创建，这里主要演示的还是使用骨架创建Web工程
新建一个模块在基于Maven创建模块时可以选择使用模板创建只需要勾选然后选择项目模板即可
在这里插入图片描述
按照正常流程创建模块后会出现Maven配置信息选择，注意选择好Maven的项目信息

也可以不使用web骨架创建一个普通的Maven模块将其改造为Web工程,这个感兴趣的小伙伴可以去搜索一下相关文章，最后值得注意的是web工程的打包方式是war