2022版Maven教程 - 第三章 使用 Maven：命令行环境

最新推荐文章于 2023-11-02 10:43:00 发布
最新推荐文章于 2023-11-02 10:43:00 发布
阅读量452 收藏 1
点赞数 2
分类专栏： Maven 文章标签： maven java jar
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42469070/article/details/125154700
版权

2022版Maven教程 - 第三章 使用 Maven：命令行环境

视频连接
资料连接


实验一：根据坐标创建 Maven 工程

1、Maven 核心概念：坐标

①数学中的坐标

在这里插入图片描述

使用 x、y、z 三个『向量』作为空间的坐标系，可以在『空间』中唯一的定位到一个『点』。

②Maven中的坐标

[1]向量说明

使用三个『向量』在『Maven的仓库』中唯一的定位到一个『jar』包。

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

大到小的范围

[2]三个向量的取值方式
  • groupId：公司或组织域名的倒序，通常也会加上项目名称
    例如：com.atguigu.maven
  • artifactId：模块的名称，将来作为 Maven 工程的工程名
  • version：模块的版本号，根据自己的需要设定
    例如：SNAPSHOT 表示快照版本，正在迭代过程中，不稳定的版本
    例如：RELEASE 表示正式版本

举例：

  • groupId：com.atguigu.maven
  • artifactId：pro01-atguigu-maven
  • version：1.0-SNAPSHOT

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

坐标：

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

上面坐标对应的 jar 包在 Maven 本地仓库中的位置：

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

一定要学会根据坐标到本地仓库中找到对应的 jar 包。


2、实验操作

①创建目录作为后面操作的工作空间

例如：F:\maven-workspace\space2022

WARNING
此时我们已经有了三个目录，分别是：
Maven 核心程序：中军大帐

Maven 本地仓库：兵营

本地工作空间：战场

②在工作空间目录下打开命令行窗口

在这里插入图片描述

③使用命令生成Maven工程

在这里插入图片描述

运行 mvn archetype:generate 命令

下面根据提示操作

TIP
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 再回车。】

mvn archetype:generate
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

④调整

Maven 默认生成的工程，对 junit 依赖的是较低的 3.8.1 版本，我们可以改成较适合的 4.12 版本。

在这里插入图片描述
在这里插入图片描述

自动生成的 App.java 和 AppTest.java 可以删除。

<!-- 依赖信息配置 -->
<!-- dependencies复数标签：里面包含dependency单数标签 -->
<dependencies>
	<!-- dependency单数标签：配置一个具体的依赖 -->
	<dependency>
		<!-- 通过坐标来依赖其他jar包 -->
		<groupId>junit</groupId>
		<artifactId>junit</artifactId>
		<version>4.12</version>
		
		<!-- 依赖的范围 -->
		<scope>test</scope>
	</dependency>
</dependencies>

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

⑤自动生成的 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：生成 war 包，说明这是一个 Web 工程。 -->
  <!-- 取值 pom：说明这个工程用来管理其它工程的工程。 -->
  <packaging>jar</packaging>

  <name>pro01-maven-java</name>
  <url>http://maven.apache.org</url>

  <!-- properties 标签：在 Maven 中定义属性值 -->
  <properties>
  	<!-- 在构建过程中读取源码时使用的字符集 -->
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>

  <!-- dependencies 标签：配置具体依赖信息，可以包含多个 dependency 子标签 -->
  <dependencies>
    <!-- dependency 标签：配置一个具体依赖信息 -->
    <dependency>
      <!-- 坐标信息：导入哪个 jar 包，就配置它的坐标信息即可 -->
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <!-- scope 标签：配置当前的依赖的范围 -->
      <scope>test</scope>
    </dependency>
  </dependencies>
</project>

3、Maven核心概念：POM

①含义

POM：Project Object Model，项目对象模型。和 POM 类似的是: DOM（Document Object Model），文档对象模型。它们都是模型化思想的具体体现。

②模型化思想

POM 表示将工程抽象为一个模型，再用程序中的对象来描述这个模型。这样我们就可以用程序来管理项目了。我们在开发过程中，最基本的做法就是将现实生活中的事物抽象为模型，然后封装模型相关的数据作为一个对象，这样就可以在程序中计算与现实事物相关的数据。

③对应的配置文件

POM 理念集中体现在 Maven 工程根目录下 pom.xml 这个配置文件中。所以这个 pom.xml 配置文件就是 Maven 工程的核心配置文件。其实学习 Maven 就是学这个文件怎么配置，各个配置有什么用。


4、Maven核心概念：约定的目录结构

①各个目录的作用

在这里插入图片描述

另外还有一个 target 目录专门存放构建操作输出的结果。

②约定目录结构的意义

Maven 为了让构建过程能够尽可能自动化完成，所以必须约定目录结构的作用。例如：Maven 执行编译操作，必须先去 Java 源程序目录读取 Java 源代码，然后执行编译，最后把编译结果存放在 target 目录。

③约定大于配置

Maven 对于目录结构这个问题，没有采用配置的方式，而是基于约定。这样会让我们在开发过程中非常方便。如果每次创建 Maven 工程后，还需要针对各个目录的位置进行详细的配置，那肯定非常麻烦。

目前开发领域的技术发展趋势就是：约定大于配置，配置大于编码。



实验二：在 Maven 工程中编写代码

1、主体程序

在这里插入图片描述

主体程序指的是被测试的程序，同时也是将来在项目中真正要使用的程序。

在F:\maven-workspace\space2022\pro01-maven-java\src\main\java\com\atguigu\maven目录下新建Calculator.java类

package com.atguigu.maven;
	
public class Calculator {
	
	public int sum(int i, int j){
		return i + j;
	}
	
}

2、测试程序

在F:\maven-workspace\space2022\pro01-maven-java\src\test\java\com\atguigu\maven目录新建CalculatorTest.java

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);
		
	}
	
}



实验三：执行 Maven 的构建命令

1、要求

运行 Maven 中和构建操作相关的命令时，必须进入到 pom.xml 所在的目录。如果没有在 pom.xml 所在的目录运行 Maven 的构建命令，那么会看到下面的错误信息：

The goal you specified requires a project to execute but there is no POM in this directory
在这里插入图片描述

TIP

mvn -v 命令和构建操作无关，只要正确配置了 PATH，在任何目录下执行都可以。
而构建相关的命令要在 pom.xml 所在目录下运行 – 操作哪个工程，就进入这个
工程的 pom.xml 目录。


2、清理操作

mvn clean
效果：删除 target 目录

在这里插入图片描述


3、编译操作

主程序编译：mvn compile
测试程序编译：mvn test-compile
主体程序编译结果存放的目录：target/classes
测试程序编译结果存放的目录：target/test-classes

mvn compile
在这里插入图片描述
在这里插入图片描述
mvn test-compile
在这里插入图片描述
在这里插入图片描述


4、测试操作

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

在CalculatorTest.java类，添加一句输出

System.out.println("test method hava benn called");

mvn test
在这里插入图片描述
在这里插入图片描述

在F:\maven-workspace\space2022\pro01-maven-java\target\surefire-reports目录下，会生成测试报告
在这里插入图片描述


5、打包操作

mvn package
打包的结果——jar 包，存放的目录：target

mvn package
在这里插入图片描述
在这里插入图片描述


6、安装操作

mvn install

[INFO] Installing F:\maven-workspace\space2022\pro01-maven-java\target\pro01-maven-java-1.0-SNAPSHOT.jar to E:\maven\repo\com\atguigu\maven\pro01-maven-java\1.0-SNAPSHOT\pro01-maven-java-1.0-SNAPSHOT.jar
[INFO] Installing F:\maven-workspace\space2022\pro01-maven-java\pom.xml to E:\maven\repo\com\atguigu\maven\pro01-maven-java\1.0-SNAPSHOT\pro01-maven-java-1.0-SNAPSHOT.pom

mvn clean install
在这里插入图片描述
在这里插入图片描述

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

坐标信息如下：

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

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

E:\maven\repo\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 工程

1、说明

使用 mvn archetype:generate 命令生成 Web 工程时，需要使用一个专门的 archetype。这个专门生成 Web 工程骨架的 archetype 可以参照官网看到它的用法：
在这里插入图片描述

参数 archetypeGroupId、archetypeArtifactId、archetypeVersion 用来指定现在使用的 maven-archetype-webapp 的坐标。


2、操作

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

然后运行生成工程的命令：

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

下面的操作按照提示执行：

TIP

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: :【直接回车，表示确认】

mvn archetype:generate -DarchetypeGroupId=org.apache.maven.archetypes -DarchetypeArtifactId=maven-archetype-webapp -DarchetypeVersion=1.4
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述


3、生成的pom.xml

在F:\maven-workspace\space2022\pro02-maven-web目录下

确认打包的方式是war包形式

在这里插入图片描述

<?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.atguigu.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.12</version>
      <scope>test</scope>
    </dependency>
  </dependencies>

</project>

4、生成的Web工程的目录结构

在这里插入图片描述

webapp 目录下有 index.jsp

WEB-INF 目录下有 web.xml


5、创建 Servlet

①在 main 目录下创建 java 目录

在这里插入图片描述

②在 java 目录下创建 Servlet 类所在的包的目录

在这里插入图片描述

③在包下创建 Servlet 类

HelloServlet.java

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");
		
	}
	
}

在这里插入图片描述

④在 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>

在这里插入图片描述


6、在 index.jsp 页面编写超链接

在这里插入图片描述

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

在这里插入图片描述

TIP

JSP全称是 Java Server Page，和 Thymeleaf 一样，是服务器端页面渲染技术。这里我们不必关心 JSP 语法细节，编写一个超链接标签即可。


7、编译

此时直接执行 mvn compile 命令出错：

mvn compile
在这里插入图片描述
在这里插入图片描述

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

在这里插入图片描述


8、配置对 servlet-api.jar 包的依赖

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

在这里插入图片描述

比如，我们找到的 servlet-api 的依赖信息：

<!-- 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。重新执行 mvn compile 命令。
在这里插入图片描述

mvn compile
在这里插入图片描述
在这里插入图片描述


9、将 Web 工程打包为 war 包

运行 mvn package 命令，生成 war 包的位置如下图所示：

mvn clean package
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述


10、将 war 包部署到 Tomcat 上运行

将 war 包复制到 Tomcat/webapps 目录下

在这里插入图片描述

启动 Tomcat：

在这里插入图片描述

在这里插入图片描述

通过浏览器尝试访问：http://localhost:8080/pro02-maven-web-1.0-SNAPSHOT/index.jsp

在这里插入图片描述

在这里插入图片描述



实验五：让 Web 工程依赖 Java 工程

1、观念

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


2、操作

在 pro02-maven-web 工程的 pom.xml 中，找到 dependencies 标签，在 dependencies 标签中做如下配置：

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

在这里插入图片描述


3、在 Web 工程中，编写测试代码

①补充创建目录

pro02-maven-web\src\test\java\com\atguigu\maven

在这里插入图片描述

②确认 Web 工程依赖了 junit

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

在F:\maven-workspace\space2022\pro02-maven-web目录下 pom.xml文件
在这里插入图片描述

③创建测试类

把 Java 工程的 CalculatorTest.java 类复制到 pro02-maven-wb\src\test\java\com\atguigu\maven 目录下

在这里插入图片描述


4、执行Maven命令

①测试命令

mvn test
说明：测试操作中会提前自动执行编译操作，测试成功就说明编译也是成功的。

mvn test
在这里插入图片描述
在这里插入图片描述

②打包命令

mvn package

在这里插入图片描述

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

在这里插入图片描述

③查看当前 Web 工程所依赖的 jar 包的列表

mvn dependency:list

mvn dependency:list
在这里插入图片描述
在这里插入图片描述

说明：javax.servlet:javax.servlet-api:jar:3.1.0:provided 格式显示的是一个 jar 包的坐标信息。格式是：

TIP
groupId:artifactId:打包方式:version:依赖的范围

这样的格式虽然和我们 XML 配置文件中坐标的格式不同，但是本质上还是坐标信息，大家需要能够认识这样的格式，将来从 Maven 命令的日志或错误信息中看到这样格式的信息，就能够识别出来这是坐标。进而根据坐标到Maven 仓库找到对应的jar包，用这样的方式解决我们遇到的报错的情况。

④以树形结构查看当前 Web 工程的依赖信息

mvn dependency:tree

mvn dependency:tree
在这里插入图片描述

我们在 pom.xml 中并没有依赖 hamcrest-core，但是它却被加入了我们依赖的列表。原因是：junit 依赖了hamcrest-core，然后基于依赖的传递性，hamcrest-core 被传递到我们的工程了。



实验六：测试依赖范围

1、依赖范围

标签的位置：dependencies/dependency/scope

标签的可选值：compile/test/provided/system/runtime/import

①compile 和 test 对比

main目录（空间）test目录（空间）开发过程（时间）部署到服务器（时间）
compile有效有效有效有效
test无效有效有效无效

②compile 和 provided 对比

main目录（空间）test目录（空间）开发过程（时间）部署到服务器（时间）
compile有效有效有效有效
provided有效有效有效无效

③结论

compile：通常使用的第三方框架的 jar 包这样在项目实际运行时真正要用到的 jar 包都是以 compile 范围进行依赖的。比如 SSM 框架所需jar包。

test：测试过程中使用的 jar 包，以 test 范围依赖进来。比如 junit。

provided：在开发过程中需要用到的“服务器上的 jar 包”通常以 provided 范围依赖进来。比如 servlet-api、jsp-api。而这个范围的 jar 包之所以不参与部署、不放进 war 包，就是避免和服务器上已有的同类 jar 包产生冲突，同时减轻服务器的负担。说白了就是：“服务器上已经有了，你就别带啦！”


2、测试

①验证 compile 范围对 main 目录有效

TIP

main目录下的类：HelloServlet 使用compile范围导入的依赖：pro01-atguigu-maven

验证：使用compile范围导入的依赖对main目录下的类来说是有效的

有效：HelloServlet 能够使用 pro01-atguigu-maven 工程中的 Calculator 类
验证方式：在 HelloServlet 类中导入 Calculator 类，然后编译就说明有效

②验证test范围对main目录无效

测试方式：在主体程序中导入org.junit.Test这个注解，然后执行编译。

具体操作：在pro01-maven-java\src\main\java\com\atguigu\maven目录下修改Calculator.java

package com.atguigu.maven;

import org.junit.Test;

public class Calculator {
	
	public int sum(int i, int j){
		return i + j;
	}
	
}

执行Maven编译命令：

[ERROR] /F:/maven-workspace/space2022/pro01-maven-java/src/main/java/com/atguigu/maven/Calculator.java:[3,17] 程序包org.junit不存在

③验证test和provided范围不参与服务器部署

其实就是验证：通过compile范围依赖的jar包会放入war包，通过test范围依赖的jar包不会放入war包。

在这里插入图片描述

④验证provided范围对测试程序有效

测试方式是在pro02-maven-web的测试程序中加入servlet-api.jar包中的类。

修改：pro02-maven-web\src\test\java\com\atguigu\maven\CalculatorTest.java

package com.atguigu.maven;

import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.ServletException;

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);
		
	}
	
}

然后运行Maven的编译命令：mvn compile

然后看到编译成功。



实验七：测试依赖的传递性

1、依赖的传递性

①概念

A 依赖 B，B 依赖 C，那么在 A 没有配置对 C 的依赖的情况下，A 里面能不能直接使用 C？

②传递的原则

在 A 依赖 B，B 依赖 C 的前提下，C 是否能够传递到 A，取决于 B 依赖 C 时使用的依赖范围。

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

2、使用 compile 范围依赖 spring-core

测试方式：让 pro01-maven-java 工程依赖 spring-core

具体操作：编辑 pro01-maven-java 工程根目录下 pom.xml

<!-- https://mvnrepository.com/artifact/org.springframework/spring-core -->
<!-- 以 compile 范围导入 spring-core 依赖，测试依赖的传递性 -->
<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-core</artifactId>
	<version>4.0.0.RELEASE</version>
</dependency>

在这里插入图片描述

使用 mvn dependency:tree 命令查看效果：

mvn dependency:tree
在这里插入图片描述
mvn dependency:list
在这里插入图片描述

还可以在 Web 工程中，使用 mvn dependency:tree 命令查看效果（需要重新将 pro01-maven-java 安装到仓库）：

在这里插入图片描述

因为本地的仓库的pom文件没有更新

pro01-maven-java 重新clean install
在这里插入图片描述
在pro02-maven-web再次查询
在这里插入图片描述


3、验证 test 和 provided 范围不能传递

从上面的例子已经能够看到，pro01-maven-java 依赖了 junit，但是在 pro02-maven-web 工程中查看依赖树的时候并没有看到 junit。

要验证 provided 范围不能传递，可以在 pro01-maven-java 工程中加入 servlet-api 的依赖。

<dependency>
	<groupId>javax.servlet</groupId>
	<artifactId>javax.servlet-api</artifactId>
	<version>3.1.0</version>
	<scope>provided</scope>
</dependency>

在这里插入图片描述

效果还是和之前一样:

mvn clean install
mvn dependency:tree
在这里插入图片描述



实验八：测试依赖的排除

1、概念

当 A 依赖 B，B 依赖 C 而且 C 可以传递到 A 的时候，A 不想要 C，需要在 A 里面把 C 排除掉。而往往这种情况都是为了避免 jar 包之间的冲突。

在这里插入图片描述

所以配置依赖的排除其实就是阻止某些 jar 包的传递。因为这样的 jar 包传递过来会和其他 jar 包冲突。


2、配置方式

<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>

3、测试

测试的方式：在 pro02-maven-web 工程中配置对 commons-logging 的排除

<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>

在这里插入图片描述

运行 mvn dependency:tree 命令查看效果：

在这里插入图片描述

发现在 spring-core 下面就没有 commons-logging 了。



实验九：继承

1、概念

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

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

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


2、作用

在父工程中统一管理项目中的依赖信息，具体来说是管理依赖信息的版本。

它的背景是：

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

它背后的需求是：

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

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


3、举例

在一个工程中依赖多个 Spring 的 jar 包

TIP
[INFO] +- org.springframework:spring-core:jar:4.0.0.RELEASE:compile
[INFO] | \- commons-logging:commons-logging:jar:1.1.1:compile
[INFO] +- org.springframework:spring-beans:jar:4.0.0.RELEASE:compile
[INFO] +- org.springframework:spring-context:jar:4.0.0.RELEASE:compile
[INFO] +- org.springframework:spring-expression:jar:4.0.0.RELEASE:compile
[INFO] +- org.springframework:spring-aop:jar:4.0.0.RELEASE:compile
[INFO] | \- aopalliance:aopalliance:jar:1.0:compile

使用 Spring 时要求所有 Spring 自己的 jar 包版本必须一致。为了能够对这些 jar 包的版本进行统一管理，我们使用继承这个机制，将所有版本信息统一在父工程中进行管理。


4、操作

①创建父工程

创建的过程和前面创建 pro01-maven-java 一样。

工程名称：pro03-maven-parent

工程创建好之后，要修改它的打包方式：

<groupId>com.atguigu.maven</groupId>
<artifactId>pro03-maven-parent</artifactId>
<version>1.0-SNAPSHOT</version>

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

只有打包方式为 pom 的 Maven 工程能够管理其他 Maven 工程。打包方式为 pom 的 Maven 工程中不写业务代码，它是专门管理其他 Maven 工程的工程。

在F:\maven-workspace\space2022目录下
mvn archetype:generate
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

修改pro03-maven-parent目录下的 pom.xml文件

<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.atguigu.maven</groupId>
  <artifactId>pro03-maven-parent</artifactId>
  <version>1.0-SNAPSHOT</version>
  <!-- 当前工程作为父工程，要求管理其它工程，打包方式必须是 pom -->
  <packaging>pom</packaging>

  <name>pro03-maven-parent</name>
  <url>http://maven.apache.org</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>
 
</project>

②创建模块工程

模块工程类似于 IDEA 中的 module，所以需要进入 pro03-maven-parent 工程的根目录，然后运行 mvn archetype:generate 命令来创建模块工程。

假设，我们创建三个模块工程：

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

③查看被添加新内容的父工程 pom.xml

下面 modules 和 module 标签是聚合功能的配置

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

在这里插入图片描述

④解读子工程的pom.xml

<?xml version="1.0"?>
<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <modelVersion>4.0.0</modelVersion>
  
  <!-- parent 标签给当前工程配置父工程 -->
  <parent>
	<!-- 通过指定父工程的坐标找到父工程 -->
    <groupId>com.atguigu.maven</groupId>
    <artifactId>pro03-maven-parent</artifactId>
    <version>1.0-SNAPSHOT</version>
  </parent>
  
  <!-- 子工程的 groupId 如果和父工程的一样，则可以省略 -->
  <!-- <groupId>com.atguigu.maven</groupId> -->
  <!-- 子工程的 version 如果和父工程的一样，则可以省略 -->
  <!-- <version>1.0-SNAPSHOT</version> -->
  
  <!-- 省略 groupId 和 version 后，子工程的坐标可以只保留 artifactId -->
  <artifactId>pro04-maven-module</artifactId>

  <name>pro04-maven-module</name>
  <url>http://maven.apache.org</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>

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

<!-- 在父工程中统一管理依赖信息 -->
<!-- 注意：即使在父工程配置了对依赖的管理，子工程需要使用具体哪一个依赖还是要明确配置。 -->
<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>

⑥子工程中引用那些被父工程管理的依赖

根据自身的业务，引用相关的父pom里的依赖，不同写版本号

	<!-- 注意：即使在父工程配置了对依赖的管理，子工程需要使用具体哪一个依赖还是要明确配置。 -->
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-core</artifactId>
		
		<!-- 对于已经在父工程进行了管理的依赖，子工程中引用时可以不写 version -->
		  
		<!-- <version>4.0.0.RELEASE</version> -->
		<!-- 情况1：确实省略了 version 标签：子工程采纳的就是父工程管理的版本 -->
		<!-- 情况2：没有省略 version 标签：
				A 这里配置了 verison 和父工程管理的版本一致，最终采纳这个版本。
				B 这里配置了 version 但是和父工程管理的版本不一致，那么这里子工程配置的版本会覆盖父工程的版本并最终
				  采纳。绝大部分情况下子工程还是遵从父工程统一管理的依赖。
		-->
	</dependency>

关键点：省略版本号

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

⑦在父工程中升级依赖信息的版本

……
			<dependency>
				<groupId>org.springframework</groupId>
				<artifactId>spring-beans</artifactId>
				<version>4.1.4.RELEASE</version>
			</dependency>
……

⑧在父工程中声明自定义属性

<!-- 通过自定义属性，统一指定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、实际意义

在这里插入图片描述

编写一套符合要求、开发各种功能都能正常工作的依赖组合并不容易。如果公司里已经有人总结了成熟的组合方案，那么再开发新项目时，如果不使用原有的积累，而是重新摸索，会浪费大量的时间。为了提高效率，我们可以使用工程继承的机制，让成熟的依赖组合方案能够保留下来。

如上图所示，公司级的父工程中管理的就是成熟的依赖组合方案，各个新项目、子系统各取所需即可。



实验十：聚合

1、聚合本身的含义

部分组成整体
在这里插入图片描述
动画片《战神金刚》中的经典台词：“我来组成头部！我来组成手臂！”就是聚合关系最生动的体现。


2、Maven 中的聚合

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

  • 项目：整体
  • 模块：部分

TIP

概念的对应关系：

从继承关系角度来看：

  • 父工程
  • 子工程

从聚合关系角度来看：

  • 总工程
  • 模块工程

3、好处

  • 一键执行 Maven 命令：很多构建命令都可以在“总工程”中一键执行。

    以 mvn install 命令为例：Maven 要求有父工程时先安装父工程；有依赖的工程时，先安装被依赖的工程。我们自己考虑这些规则会很麻烦。但是工程聚合之后，在总工程执行 mvn install 可以一键完成安装，而且会自动按照正确的顺序执行。

  • 配置聚合之后，各个模块工程会在总工程中展示一个列表，让项目中的各个模块一目了然。


4、聚合的配置

在总工程中配置 modules 即可：

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

5、依赖循环问题

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

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

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

weixin_42469070
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
idea中pom.xml文件
05-19
idea中pom.xml文件
pom.xml 文件详解
kuirito的博客
05-17 7322
pom.xml 文件详解
pom文件分析（笔记）
myNameGL的博客
08-30 2077
pom文件分析（笔记）
Maven的pom文件
白羊座的橙子
06-08 4323
本文参考于：https://blog.csdn.net/qq_47759220/article/details/119079757pom文件定于了一个maven项目的maven配置，一般pom文件的放在项目或者模块的根目录下。maven的遵循约定大于配置，约定了如下的目录结构： project：整个pom配置文件的根元素，所有的配置都是写在project元素里面的； modelVersion：指定了当前POM模型的版本，对于Maven2及Maven 3来说，它只能是4.0.0； groupId：组织名，
Maven中的pom.xml文件超详细解析
顺其自然~专栏
05-22 8722
POM全程，又称项目对象模型。他是Maven工程的基本工作单元，是一个XML（可扩展标记语言）文件，包含了项目的基本信息，用于描述项目如何构建，声明项目依赖等等。执行任务或目标时，Maven会在当前目录中查找 POM并读取从而获取所需的配置信息执行目标，属于项目级别的配置文件。
spark-hash-SBT-oriented:这是我对mrsqueeze的“火花哈希”版本，但面向SBT，所有代码和逻辑功劳都归功于他。 这使用sbt环境而不是Maven POM环境
05-23
此实现主要基于的第3章中描述的算法，并对火花中使用的内容进行了一些修改。请输入以获取更多信息:)SBT环境将此回购与SBT结合使用的步骤如下： 1.-确保安装了最新的sbt。 对于Ubuntu和其他基于Debian的发行版： ...
java笔试题算法-fcrepo-import-export:fcrepo-进出口
06-03
第一次使用命令行参数运行该实用程序时，包含您提供的参数的配置文件将写入一个文件，该文件的位置将显示在命令行中。 $ java -jar fcrepo-import-export.jar --mode export --resource http://localhost:8080/rest ...
executable-war-example:示例Maven项目显示了如何使用自定义类加载器使Java WAR文件像JAR一样可执行
05-05
当然，您将创建三个模块，并将业务逻辑移至一个模块，并将Web应用程序和CLI移至其他模块，这取决于第一个模块。 它们每个都将分别吐出.war和可执行文件.jar。 但是部署这两个文件可能会有些烦人，因此您可以创建一...
maven window下安装包
11-01
第13章：使用Maven生成项目原型/13.1 Maven项目原型/13.1.3 命令行生成默认的项目原型 第13章：使用Maven生成项目原型/13.1 Maven项目原型/13.1.4 命令行生成的web项目原型 第13章：使用Maven生成项目原型/13.2 编写...
4.Maven核心配置文件（Pom.xml）详细
相互学习 共同进步
04-25 1925
Maven 使用 effective pom（Super pom 加上工程自己的配置）来执行相关的目标，它帮助开发者在 pom.xml 中做尽可能少的配置，这些配置可以被方便的重写。能够在 POM 中设置的一些。如果项目中没有规定某个元素的值，那么父项目中的对应值即为项目的默认值。在创建 POM 之前，我们首先确定工程组（groupId），及其名称（artifactId）和版本，在仓库中这些属性是工程的唯一标识。在你的电脑上的任意目录下创建一个 pom.xml 文件，使用上面提到的示例 pom 中的内容。
maven之pom文件详解
最新发布
大数据知识梳理
11-02 2134
maven的pom文件介绍
maven安装并配置后报错：当前目录下缺少pom.xml
m0_46598144的博客
08-06 4848
问题 默认你已经解压了maven文件且配置好了/etc/profile 输入"mvn -v"准备收获胜利的果实，此时却报错： [ERROR] The goal you specified requires a project to execute but there is no POM in this directory (/usr/local/maven). Please verify you invoked Maven from the correct directory. -> [Help 1]
Maven-详解pom.xml内容及用法
阿东的学习历程
02-10 2970
最近使用SpringBoot，Maven也使用的越来越多，有这个时间刚好研究了下pom.xml文件的东西，真的是又多又杂。综合各位大神的解读，做了一些整理，剔除了一些不常用的，在需要的时候再去设置，尽量去繁就简，配置简单化。模板引入<?xml version="1.0" encoding="UTF-8"?> <!-- pom的模板文件，包含内容节点的定义 --> <project xmlns="ht
IDEA创建maven项目，项目结构无src目录和pom.xml文件?
weixin_43862596的博客
06-06 5919
IDEA中创建maven项目，初建成项目结构无src目录和pom.xml文件。 问题解决： 首先检查Settings中Maven路径及settings配置文件路径是否有问题，我这里一切正常。接着按照步骤File > Settings > Build,Execution,Deployment > Build Tools > Maven > Runnner,界面中VM Options 输入框中填入-DarchetypeCatalog=internal，重启IDEA，打开即会有s
maven项目打包成war包并部署到tomcat上
hzb666666666的博客
05-26 9086
maven项目打包成war包并完成部署
找不到pom.xml文件
choiiie的博客
05-13 8215
找不到pom文件
pom.xml详细说明
m0_62904488的博客
07-14 297
【代码】pom.xml详细说明。
史上最全的maven的pom.xml文件详解
扬帆天涯
02-28 1102
maven详解
cannot resolve plugin org.apache.maven.plugins:maven-deploy-plugin:2.8.2
06-28
2. Maven 配置问题：如果 Maven 配置文件（settings.xml）中没有正确配置 Maven 中央仓库和其他第三方仓库，就可能会导致无法下载插件。在这种情况下，可以检查配置文件是否正确。 3. 插件版本问题：有可能指定的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值