maven学习笔记——尚硅谷

已于 2023-08-21 09:47:09 修改
阅读量1.3k 收藏 19
点赞数 2
分类专栏： # java实用工具 文章标签： maven 学习 spring boot
于 2023-03-20 10:20:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_48092631/article/details/129662079
版权

文章目录

maven学习笔记——尚硅谷

第一章 Maven概述

第一节 为什么要学习Maven

1.Maven 作为依赖管理工具
1.1 jar 包的规模

  • 随着我们使用越来越多的框架，或者框架封装程度越来越高，项目中使用的jar包也越来越多。项目中，一个模块里面用到上百个jar包是非常正常的

  • 比如下面的例子，我们只用到 SpringBoot、SpringCloud 框架中的三个功能:

    • Nacos 服务注册发现
    • Web 框架环境
    • 图模板技术 Thymeleaf

    最终却导入了 106 个 jar 包

    而如果使用 Maven 来引入这些 jar 包只需要配置三个『依赖』:

    <!-- Nacos 服务注册发现启动器 -->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>

<!-- web启动器依赖 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

<!-- 视图模板技术 thymeleaf -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>
1.2 jar 包的来源
  • 这个jar包所属技术的官网。官网通常是英文界面，网站的结构又不尽相同，甚至找到下载链接还发现需要通过特殊的工具下载。
  • 第三方网站提供下载。问题是不规范，在使用过程中会出现各种问题。
    • jar包的名称
    • jar包的版本
    • jar包内的具体细节
  • 而使用 Maven 后，依赖对应的 jar 包能够自动下载，方便、快捷又规范
1.3 jar 包之间的依赖关系

  • 框架中使用的 jar 包，不仅数量庞大，而且彼此之间存在错综复杂的依赖关系。

  • 依赖关系的复杂程度，已经上升到了完全不能靠人力手动解决的程度。

  • 另外，jar 包之间有可能产生冲突。进一步增加了我们在 jar 包使用过程中的难度。

  • 下面是前面例子中 jar 包之间的依赖关系:

    images

    而实际上 jar 包之间的依赖关系是普遍存在的，如果要由程序员手动梳理无疑会增加极高的学习成本，而这些工作又对实现业务功能毫无帮助

  • 使用 Maven 则几乎不需要管理这些关系，极个别的地方调整一下即可，极大的减轻了我们的工作量

2. Maven 作为构建管理工具

  • 你可以不使用 Maven，但是构建必须要做。当我们使用 IDEA 进行开发时，构建是 IDEA 替我们做的

  • 脱离 IDE 环境仍需构建

    images

3.结论
  • 管理规模庞大的 jar 包，需要专门工具。
  • 脱离 IDE 环境执行构建操作，需要专门工具。

第二节 什么是 Maven

Maven 是 Apache 软件基金会组织维护的一款专门为 Java 项目提供构建和依赖管理支持的工具

2.1 构建

  • Java 项目开发过程中，构建指的是使用『原材料生产产品』的过程

    • 原材料

      • Java 源代码
      • 基于 HTML 的 Thymeleaf 文件
      • 图片
      • 配置文件
      • …

    • 产品

      一个可以在服务器上运行的项目

  • 构建过程包含的主要的环节:

    • 清理：删除上一次构建的结果，为下一次构建做好准备
    • 编译：Java 源程序编译成 *.class 字节码文件
    • 测试：运行提前准备好的测试程序
    • 报告：针对刚才测试的结果生成一个全面的信息
    • 打包
      • Java工程：jar包
      • Web工程：war包
    • 安装：把一个 Maven 工程经过打包操作生成的 jar 包或 war 包存入 Maven 仓库
    • 部署
      • 部署 jar 包：把一个 jar 包部署到 Nexus 私服服务器上
      • 部署 war 包：借助相关 Maven 插件（例如 cargo），将 war 包部署到 Tomcat 服务器上
2.2 依赖

  • 如果 A 工程里面用到了 B 工程的类、接口、配置文件等等这样的资源，那么我们就可以说 A 依赖 B。例如

    junit-4.12 依赖 hamcrest-core-1.3
thymeleaf-3.0.12.RELEASE 依赖 ognl-3.1.26
	ognl-3.1.26 依赖 javassist-3.20.0-GA
thymeleaf-3.0.12.RELEASE 依赖 attoparser-2.0.5.RELEASE
thymeleaf-3.0.12.RELEASE 依赖 unbescape-1.1.6.RELEASE
thymeleaf-3.0.12.RELEASE 依赖 slf4j-api-1.7.26

  • 依赖管理中要解决的具体问题：

    • jar 包的下载：使用 Maven 之后，jar 包会从规范的远程仓库下载到本地
    • jar 包之间的依赖：通过依赖的传递性自动完成
    • jar 包之间的冲突：通过对依赖的配置进行调整，让某些jar包不会被导入
2.3 Maven 的工作机制

./images

第二章 Maven 核心程序解压和配置

第一节 Maven核心程序解压与配置

1.Maven 官网地址
2.解压Maven核心程序

核心程序压缩包：apache-maven-3.6.3-bin，解压到非中文、没有空格的目录。例如：

image-20220830091238087

在解压目录中，我们需要着重关注 Maven 的核心配置文件：conf/settings.xml

3.指定本地仓库

  • 本地仓库默认值：用户家目录/.m2/repository。

  • 由于本地仓库的默认位置是在用户的家目录下，而家目录往往是在 C 盘，也就是系统盘。

  • 将来 Maven 仓库中 jar 包越来越多，仓库体积越来越大，可能会拖慢 C 盘运行速度，影响系统性能。所以建议将 Maven 的本地仓库放在其他盘符下。

  • 配置方式如下:

    • 进入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>
  -->
  <localRepository>E:\java_install\maven_repository</localRepository>

    • 创建E:\java_install\maven_repository这个目录

      - 记住：一定要把 localRepository 标签从注释中拿出来。

      - 注意：本地仓库本身也需要使用一个非中文、没有空格的目录

4.配置阿里云提供的镜像仓库

  • Maven 下载 jar 包默认访问境外的中央仓库，而国外网站速度很慢。改成阿里云提供的镜像仓库，访问国内网站，可以让 Maven 下载 jar 包的时候速度更快。

  • 配置的方式是：

    • 将原有的例子配置注释掉

      <!-- <mirror>
  <id>maven-default-http-blocker</id>
  <mirrorOf>external:http:*</mirrorOf>
  <name>Pseudo repository to mirror external repositories initially using HTTP.</name>
  <url>http://0.0.0.0/</url>
  <blocked>true</blocked>
</mirror> -->

    • 加入我们的配置

      <mirror>
    <id>nexus-aliyun</id>
    <mirrorOf>central</mirrorOf>
    <name>Nexus aliyun</name>
    <url>http://maven.aliyun.com/nexus/content/groups/public</url>
</mirror>
5.配置 Maven 工程的基础 JDK 版本

如果按照默认配置运行，Java 工程使用的默认 JDK 版本是 1.5，而我们熟悉和常用的是 JDK 1.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.检查 JAVA_HOME 配置是否正确

Maven 是一个用 Java 语言开发的程序，它必须基于 JDK 来运行，需要通过 JAVA_HOME 来找到 JDK 的安装位置。

image-20220830092739555

可以使用下面的命令验证:

C:\Users\Administrator>echo %JAVA_HOME%
D:\software\Java

C:\Users\Administrator>java -version
java version "1.8.0_141"
Java(TM) SE Runtime Environment (build 1.8.0_141-b15)
Java HotSpot(TM) 64-Bit Server VM (build 25.141-b15, mixed mode)
2.配置 MAVEN_HOME

配置环境变量的规律：

XXX_HOME 通常指向的是 bin 目录的上一级

PATH 指向的是 bin 目录

image-20220830095723588

3.配置PATH

image-20220830095853605

4.验证
C:\Users\Administrator>mvn -v
Apache Maven 3.8.4 (9b656c72d54e5bacbed989b64718c159fe39b537)
Maven home: D:\software\apache-maven-3.8.4
Java version: 1.8.0_141, vendor: Oracle Corporation, runtime: D:\software\Java\jre
Default locale: zh_CN, platform encoding: GBK
OS name: "windows 10", version: "10.0", arch: "amd64", family: "windows"

第三章 使用 Maven：命令行环境

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

1.1 Maven 核心概念：坐标

  1. 数学中的坐标

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-c5ceXMOS-1679278685527)(https://yftypora.oss-cn-shenzhen.aliyuncs.com/img/image-20220830100212874.png)]

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

  2. Maven中的坐标

    • 向量说明

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

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

    • 三个向量的取值方式

      一个项目可能包含多个工程

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

    • 实例

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

  3. 坐标和仓库中 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
1.2 实验操作

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

    E:\java_install\maven_workspace\space20220830

    此时我们已经有了三个目录，分别是：

    • Maven 核心程序：中军大帐
    • Maven 本地仓库：兵营
    • 本地工作空间：战场

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

    image-20220830101255446

  3. 使用命令生成Maven工程

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-osKwhyJd-1679278685528)(https://yftypora.oss-cn-shenzhen.aliyuncs.com/img/img008.be45c9ad.png)]

    运行 mvn archetype:generate 命令

    下面根据提示操作

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

Define value for property 'groupId': com.duanyf.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 再回车。】

    image-20220830102319396

  4. 调整

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

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

        <!-- 依赖的范围 -->
        <scope>test</scope>
    </dependency>
</dependencies>

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

  5. 自动生成的 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 -->
    <modelVersion>4.0.0</modelVersion>

    <!-- 当前Maven工程的坐标信息-->
    <!--groupId标签：坐标向量之一，代表公司或组织开发的某一个项目 -->
    <groupId>com.atguigu.maven</groupId>
    <!--artifactId标签：坐标向量之一，代表项目下的某一个模块 -->
    <artifactId>pro01-maven-java</artifactId>
    <!--version标签：坐标向量之一，代表当前模块的版本 -->
    <version>1.0-SNAPSHOT</version>

    <!-- packaging标签：当前Maven工程的打包方式，可选值有下面三种： -->
    <!-- jar：表示这个工程是一个Java工程  -->
    <!-- war：表示这个工程是一个Web工程 -->
    <!-- pom：表示这个工程是“管理其他工程”的工程 -->
    <packaging>jar</packaging>

    <name>pro01-maven-java</name>
    <url>http://maven.apache.org</url>
    
	<!-- 在Maven中定义属性值 -->
    <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>
1.3 Maven核心概念：POM
  1. 含义
    • POM：Project Object Model，项目对象模型。
    • 和 POM 类似的是：DOM Document Object Model，文档对象模型。
    • 它们都是模型化思想的具体体现
  2. 模型化思想
    • POM 表示将工程抽象为一个模型，再用程序中的对象来描述这个模型。这样我们就可以用程序来管理项目了。
    • 我们在开发过程中，最基本的做法就是将现实生活中的事物抽象为模型，然后封装模型相关的数据作为一个对象，这样就可以在程序中计算与现实事物相关的数据
  3. 对应的配置文件
    • POM 理念集中体现在 Maven 工程根目录下 pom.xml 这个配置文件中。
    • 所以这个 pom.xml 配置文件就是 Maven 工程的核心配置文件。
    • 其实学习 Maven 就是学这个文件怎么配置，各个配置有什么用
1.4 Maven核心概念：约定的目录结构

  1. 各个目录的作用

    ./images

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

  2. 约定目录结构的意义

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

  3. 约定大于配置

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

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

2.1 主体程序

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

下为主体程序

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

./images

2.2 测试程序

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KS8Mrrus-1679278685531)(https://yftypora.oss-cn-shenzhen.aliyuncs.com/img/img013.8b57a581.png)]

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

3.实验三：执行 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

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

2.清理操作
  • 命令：mvn clean
  • 说明：删除 target 目录
3.编译操作
  • 主程序编译：mvn compile
  • 测试程序编译：mvn test-compile
  • 主体程序编译结果存放的目录：target/classes
  • 测试程序编译结果存放的目录：target/test-classes
4.测试操作
  • 命令：mvn test
  • 测试的报告存放的目录：target/surefire-reports
5.打包操作
  • 命令：mvn package
  • 打包的结果：jar 包
  • 存放的目录：target
6.安装操作

  • 命令：mvn install

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qypzKQ5N-1679278685531)(https://yftypora.oss-cn-shenzhen.aliyuncs.com/img/image-20220830140515419.png)]

  • 说明

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

  • 坐标信息如下

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

  • 在 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 文件即可，它们是名字发生了改变，本质上是同一个文件。

4.实验四：创建 Maven 版的 Web 工程

1.说明

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-l8IizyfM-1679278685532)(https://yftypora.oss-cn-shenzhen.aliyuncs.com/img/img014.942770a3.png)]

2.操作

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

  • 命令

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

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

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-v0HeFr8Y-1679278685532)(https://yftypora.oss-cn-shenzhen.aliyuncs.com/img/image-20220830144926128.png)]

3.生成的pom.xml

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

image-20220830145055626

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

image-20220830145320434

5.创建 Servlet

  1. 在 main 目录下创建 java 目录

    image-20220830145409633

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

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-upWeUtRi-1679278685534)(https://yftypora.oss-cn-shenzhen.aliyuncs.com/img/image-20220830145502073.png)]

  3. 在包下创建 Servlet 类

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

  4. 在 web.xml 中注册 Servlet

    <servlet>
    <servlet-name>HelloServlet</servlet-name>
    <servlet-class>com.duanyf.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>
7.编译

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

    image-20220830150210616

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

    ./images

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

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

    image-20220830150550146

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xLenx9VO-1679278685536)(https://yftypora.oss-cn-shenzhen.aliyuncs.com/img/image-20220830150709135.png)]

    image-20220830150829965

  • 比如，我们找到的 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 命令

    image-20220830151007353

9.将 Web 工程打包为 war 包

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

image-20220830151234505

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

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

    image-20220830151506738

  • 启动 Tomcat

    image-20220830151546910

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1n0czJeF-1679278685539)(https://yftypora.oss-cn-shenzhen.aliyuncs.com/img/image-20220830151608143.png)]

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

5.实验五：让 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.duanyf.maven</groupId>
	<artifactId>pro01-maven-java</artifactId>
	<version>1.0-SNAPSHOT</version>
</dependency>
3.在 Web 工程中，编写测试代码

  1. 补充创建目录

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

  2. 确认 Web 工程依赖了 junit

  3. 创建测试类

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

4.执行Maven命令

  1. 测试命令

    mvn test

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

  2. 打包命令

    mvn package

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BgKdYFtP-1679278685540)(https://yftypora.oss-cn-shenzhen.aliyuncs.com/img/img024.91b00e04.png)]

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

    image-20220830181708733

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

    • mvn dependency:list

    image-20220830182958217

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

      javax.servlet:javax.servlet-api:jar:3.1.0:provided
groupId:artifactId:打包方式:version:依赖的范围

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

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

    mvn dependency:tree

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-v2A6YrCY-1679278685542)(https://yftypora.oss-cn-shenzhen.aliyuncs.com/img/image-20220830183405736.png)]

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

6.实验六：测试依赖的范围

  • 标签的位置：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 包产生冲突，同时减轻服务器的负担。说白了就是：“服务器上已经有了，你就别带啦！”

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

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 范围传递

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

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

    <!-- https://mvnrepository.com/artifact/org.springframework/spring-core -->
<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-core</artifactId>
	<version>4.0.0.RELEASE</version>
</dependency>

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

    image-20220830203232671

  • 使用mvn dependency:list 命令查看能使用的jar包

    image-20220830203414699

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

    • 在pro01-maven-java mvn clean install

    • 在pro02-maven-web mvn dependency:tree

      [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-y2WCgViN-1679278685543)(https://yftypora.oss-cn-shenzhen.aliyuncs.com/img/image-20220830204116565.png)]

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

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pijGyfrh-1679278685543)(https://yftypora.oss-cn-shenzhen.aliyuncs.com/img/image-20220830204557248.png)]

8.实验八：测试依赖的排除

1.概念

当 A 依赖 B，A 依赖 C ，B和C依赖依赖了D的不同版本，为了防止冲突，将B依赖度额D排除。而往往这种情况都是为了避免 jar 包之间的冲突

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NDFT3czh-1679278685544)(http://heavy_code_industry.gitee.io/code_heavy_industry/assets/img/img027.2faff879.png)]

所以配置依赖的排除其实就是阻止某些 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>

9.第九节 实验九：继承

1.概念

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

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

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

2.作用

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

    几个工程都依赖同一jar，要想一处修改处处生效就需要继承

  • 它的背景是：

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

  • 它背后的需求是：

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

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

3.举例

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

[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.操作

  1. 创建父工程

    • 工程名称：pro03-maven-parent

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

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

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

  2. 创建模块工程

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

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

      image-20220830213514419

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

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

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

  4. 解读子工程的pom.xml

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

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

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

    即使在父工程配置了对依赖的管理，子工程需要使用具体的哪一个依赖还是要明确配置

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

    关键点：省略版本号

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

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

    <!-- 通过自定义属性，统一指定Spring的版本 -->
<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

    <!-- 自定义标签，维护Spring版本数据 -->
    <duanyf.spring.version>4.3.6.RELEASE</duanyf.spring.version>
</properties>

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

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

    真正实现“一处修改，处处生效”。

  8. 实际意义

img-HEox8nYG-1679278685545

编写一套符合要求、开发各种功能都能正常工作的依赖组合并不容易。

如果公司里已经有人总结了成熟的组合方案，那么再开发新项目时，如果不使用原有的积累，而是重新摸索，会浪费大量的时间。

为了提高效率，我们可以使用工程继承的机制，让成熟的依赖组合方案能够保留下来。

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

10.实验十：聚合

聚合本身的含义:部分组成整体

1.Maven 中的聚合

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

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

概念的对应关系：

从继承关系角度来看：

  • 父工程
  • 子工程

从聚合关系角度来看：

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

在总工程中配置 modules 即可：

<modules>  
    <module>pro04-maven-module</module>
    <module>pro05-maven-module</module>
    <module>pro06-maven-module</module>
</modules>
4.依赖循环问题

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

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传img-Ibq0r3SI-1679278685545

第四章 使用Maven：IDEA环境

第一节 创建父工程

1.创建 Project

img-wVtjQeRa-1679278685546

创建完Maven工程后，IDEA中一只卡在Downloading Maven Plugins

  1. 将默认的maven改成我们下载的maven

img-7ZYiH95p-1679278685546]

  1. 改完后又出现错误可以尝试刷新

img-9q5RQsh1-1679278685547]

2.开启自动导入
2.1 老版本

创建 Project 后，IDEA 会自动弹出下面提示，我们选择『Enable Auto-Import』，意思是启用自动导入。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uBgXfLl7-1679278685547)(https://yftypora.oss-cn-shenzhen.aliyuncs.com/img/image-20220830224524052.png)]

这个自动导入一定要开启，因为 Project、Module 新创建或 pom.xml 每次修改时都应该让 IDEA 重新加载 Maven 信息。这对 Maven 目录结构认定、Java 源程序编译、依赖 jar 包的导入都有非常关键的影响。

另外也可以通过 IDEA 的 Settings 设置来开启：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1xJY0PAK-1679278685548)(https://yftypora.oss-cn-shenzhen.aliyuncs.com/img/image-20220830224545660.png)]

2.2 新版本

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ihAJqbAM-1679278685548)(https://yftypora.oss-cn-shenzhen.aliyuncs.com/img/149742d1771240e1aae1e520ff7d6d59.png)]

勾选上any changes：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mnRCI8nL-1679278685548)(https://yftypora.oss-cn-shenzhen.aliyuncs.com/img/0f1831dd92c24ac081a4c2d4d89f9b29.png)]

第二节 创建 Java 模块工程

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0N0fZ13r-1679278685549)(https://yftypora.oss-cn-shenzhen.aliyuncs.com/img/image-20220830230542698.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pKxrqBnv-1679278685549)(https://yftypora.oss-cn-shenzhen.aliyuncs.com/img/image-20220830230603440.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1TbcZEyp-1679278685549)(https://yftypora.oss-cn-shenzhen.aliyuncs.com/img/image-20220830230709148.png)]

第三节 创建 Web 模块工程

  1. 创建模块

    按照前面的同样操作创建模块，此时这个模块其实还是一个Java模块

  2. 修改打包方式

    <packaging>war</packaging>

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HhuGiigJ-1679278685550)(https://yftypora.oss-cn-shenzhen.aliyuncs.com/img/image-20220830233202352.png)]

  3. Web 设定

    首先打开项目结构菜单：

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rCRnzqXV-1679278685550)(https://yftypora.oss-cn-shenzhen.aliyuncs.com/img/image-20220830233622544.png)]

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

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3nBF9cY0-1679278685551)(https://yftypora.oss-cn-shenzhen.aliyuncs.com/img/image-20220830233655312.png)]

  4. 借助IDEA生成web.xml

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wdMPbX3A-1679278685551)(https://yftypora.oss-cn-shenzhen.aliyuncs.com/img/image-20220830233750887.png)]

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OVAfYIMz-1679278685551)(https://yftypora.oss-cn-shenzhen.aliyuncs.com/img/image-20220830233839556.png)]

  5. 设置 Web 资源的根目录

    结合 Maven 的目录结构，Web 资源的根目录需要设置为 src/main/webapp 目录。

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MATpy5wJ-1679278685552)(https://yftypora.oss-cn-shenzhen.aliyuncs.com/img/image-20220830234141428.png)]

  1. apply—>ok

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ihtyLgd4-1679278685552)(https://yftypora.oss-cn-shenzhen.aliyuncs.com/img/image-20220906215908532.png)]

第四节 其他操作

1.在IDEA中执行Maven命令

  • 方式一：直接执行

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JLvqIoaP-1679278685552)(https://yftypora.oss-cn-shenzhen.aliyuncs.com/img/image-20220830232339763.png)]

  • 方式二：手动输入

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FISsJCP1-1679278685553)(https://yftypora.oss-cn-shenzhen.aliyuncs.com/img/image-20220830232357302.png)]

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-p3ZGpqtZ-1679278685553)(https://yftypora.oss-cn-shenzhen.aliyuncs.com/img/image-20220830232413073.png)]

    如果有需要，还可以给命令后面附加参数：

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-V7wok2vD-1679278685554)(https://yftypora.oss-cn-shenzhen.aliyuncs.com/img/image-20220830232444898.png)]

    # -D 表示后面要附加命令的参数，字母 D 和后面的参数是紧挨着的，中间没有任何其它字符
# maven.test.skip=true 表示在执行命令的过程中跳过测试
mvn clean install -Dmaven.test.skip=true

  • 方式三：idea命令行

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aTwtCcZl-1679278685554)(https://yftypora.oss-cn-shenzhen.aliyuncs.com/img/image-20220830232912270.png)]

2.在IDEA中查看某个模块的依赖信息

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vKOvbeui-1679278685554)(https://yftypora.oss-cn-shenzhen.aliyuncs.com/img/image-20220830232549246.png)]

3.工程导入

Maven工程除了自己创建的，还有很多情况是别人创建的。而为了参与开发或者是参考学习，我们都需要导入到 IDEA 中。下面我们分几种不同情况来说明：

  • 来自版本控制系统

目前我们通常使用的都是 Git（本地库） + 码云（远程库）的版本控制系统，结合 IDEA 的相关操作方式请点这里 (opens new window)查看克隆远程库部分。

  • 来自工程目录

    直接使用 IDEA 打开工程目录即可。下面咱们举个例子：

    1. 工程压缩包

      假设别人发给我们一个 Maven 工程的 zip 压缩包：maven-rest-demo.zip。从码云或GitHub上也可以以 ZIP 压缩格式对项目代码打包下载。

    2. 解压

      如果你的所有 IDEA 工程有一个专门的目录来存放，而不是散落各处，那么首先我们就把 ZIP 包解压到这个指定目录中。

    3. 打开

      只要我们确认在解压目录下可以直接看到 pom.xml，那就能证明这个解压目录就是我们的工程目录。那么接下来让 IDEA 打开这个目录就可以了

      [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Xk7rY200-1679278685555)(https://yftypora.oss-cn-shenzhen.aliyuncs.com/img/image-20220830235031587.png)]

    4. 设置 Maven 核心程序位置

      打开一个新的 Maven 工程，和新创建一个 Maven 工程是一样的，此时 IDEA 的 settings 配置中关于 Maven 仍然是默认值,所以我们还是需要像新建 Maven 工程那样，指定一下 Maven 核心程序位置：

      [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-w7AlPoMq-1679278685555)(https://yftypora.oss-cn-shenzhen.aliyuncs.com/img/image-20220830235130901.png)]

4.模块导入

在实际开发中，通常会忽略模块（也就是module）所在的项目（也就是project）仅仅导入某一个模块本身。这么做很可能是类似这样的情况：比如基于 Maven 学习 SSM 的时候，做练习需要导入老师发给我们的代码参考。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sCQ4sTaY-1679278685555)(https://yftypora.oss-cn-shenzhen.aliyuncs.com/img/image-20220830235450855.png)]

导入 Java 类型模块

  1. 找到老师发的工程目录

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WGwkPwFT-1679278685555)(https://yftypora.oss-cn-shenzhen.aliyuncs.com/img/image-20220830235519807.png)]

  2. 复制我们想要导入的模块目录

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pH939k8f-1679278685556)(https://yftypora.oss-cn-shenzhen.aliyuncs.com/img/image-20220830235531598.png)]

  3. 粘贴到我们自己工程目录下

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3cc776IB-1679278685556)(https://yftypora.oss-cn-shenzhen.aliyuncs.com/img/image-20220830235553999.png)]

  4. 在 IDEA 中执行导入

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CR445vEq-1679278685556)(https://yftypora.oss-cn-shenzhen.aliyuncs.com/img/image-20220830235618546.png)]

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Oca7Qzdk-1679278685557)(https://yftypora.oss-cn-shenzhen.aliyuncs.com/img/image-20220830235633055.png)]

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-02xF3KIB-1679278685557)(https://yftypora.oss-cn-shenzhen.aliyuncs.com/img/image-20220830235640716.png)]

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5N35Wn85-1679278685558)(https://yftypora.oss-cn-shenzhen.aliyuncs.com/img/image-20220830235651100.png)]

  5. 修改 pom.xml

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

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FiwPJMfq-1679278685558)(https://yftypora.oss-cn-shenzhen.aliyuncs.com/img/image-20220830235733807.png)]

  6. 最终效果

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ubO6FqHZ-1679278685559)(https://yftypora.oss-cn-shenzhen.aliyuncs.com/img/image-20220830235800975.png)]

导入 Web 类型模块

其它操作和上面演示的都一样，只是多一步：删除多余的、不正确的 web.xml 设置。如下图所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aEmDKtfB-1679278685559)(https://yftypora.oss-cn-shenzhen.aliyuncs.com/img/image-20220830235849645.png)]

第五章 其他核心概念

1.生命周期

  • 作用

    为了让构建过程自动化完成，Maven 设定了三个生命周期，生命周期中的每一个环节对应构建过程中的一个操作。

  • 三个生命周期

    生命周期名称作用各个环节
    Clean清理操作相关pre-clean clean post-clean
    Site生成站点相关pre-site site post-site deploy-site
    Default主要构建过程validate
    generate-sources
    process-sources
    generate-resources
    process-resources 复制并处理资源文件，至目标目录，准备打包。
    compile 编译项目 main 目录下的源代码。
    process-classes
    generate-test-sources
    process-test-sources
    generate-test-resources
    process-test-resources 复制并处理资源文件，至目标测试目录。
    test-compile 编译测试源代码。
    process-test-classes
    test 使用合适的单元测试框架运行测试。这些测试代码不会被打包或部署。
    prepare-package
    package 接受编译好的代码，打包成可发布的格式，如JAR。
    pre-integration-test
    integration-test
    post-integration-test
    verify
    install将包安装至本地仓库，以让其它项目依赖。
    deploy将最终的包复制到远程的仓库，以让其它开发人员共享；或者部署到服务器上运行（需借助插件，例如：cargo）。

    同一生命周期的，[各个环节]列下面的会执行上面的

  • 特点

    • 前面三个生命周期彼此是独立的。
    • 在任何一个生命周期内部，执行任何一个具体环节的操作，都是从本周期最初的位置开始执行，直到指定的地方。（本节记住这句话就行了，其他的都不需要记）

2.插件和目标

  • 插件

    • Maven 的核心程序仅仅负责宏观调度，不做具体工作。
    • 具体工作都是由 Maven 插件完成的。例如：编译就是由 maven-compiler-plugin-3.1.jar 插件来执行的。

  • 目标

    • 一个插件可以对应多个目标，而每一个目标都和生命周期中的某一个环节对应。

    • Default 生命周期中有 compile 和 test-compile 两个和编译相关的环节，这两个环节对应 compile 和 test-compile 两个目标，而这两个目标都是由 maven-compiler-plugin-3.1.jar 插件来执行的。

3.仓库

  • 本地仓库：在当前电脑上，为电脑上所有 Maven 工程服务

    • 远程仓库：需要联网
    • 局域网：我们自己搭建的 Maven 私服，例如使用 Nexus 技术。
    • Internet
      • 中央仓库
      • 镜像仓库：内容和中央仓库保持一致，但是能够分担中央仓库的负载，同时让用户能够就近访问提高下载速度，例如：Nexus aliyun

  • 建议：不要中央仓库和阿里云镜像混用，否则 jar 包来源不纯，彼此冲突。

  • 专门搜索 Maven 依赖信息的网站：https://mvnrepository.com/

逸凡 D
关注
  • 2
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
尚硅谷Maven学习笔记
青椒盖饭的博客
02-02 1506
生产过程中需要Maven吗? maven真的需要吗？ Maven 是干什么用的？这是很多同学在刚开始接触 Maven 时最大的问题。之所以会提出这个问题， 是因为即使不使用 Maven 我们仍然可以进行 B/S 结构项目的开发。从表述层、业务逻辑层到持久化层 再到数据库都有成熟的解决方案——不使用 Maven 我们一样可以开发项目啊？ Maven 并不是直接用来辅助编码的，它战斗的岗位...
Maven---尚硅谷学习笔记Eclipse版
rzz65452064的博客
09-12 300
自动化构建工具 Maven 哔哩哔哩尚硅谷 Maven-Eclipse版 学习视频网址 文章只为分享学习经验和自己复习用，学习还是去查看正规视频网站和官方文档更有效 解释 归属 备注 pom.xml Maven核心配置文件 文件 resources 资源，存放框架或其他工具 文件 <groupId> 项目组ID pom.mxl 官网倒序 <artifactId> 项目的模块ID pom.mxl <version> 模块版本号 pom
Maven工程自学笔记（学习视频来自于尚硅谷）
最新发布
2301_79583613的博客
05-17 859
自学尚硅谷的SSM框架的学习笔记
Maven 教程：基础篇-尚硅谷学习笔记 2022年
08-09
Maven 教程：基础篇——尚硅谷学习笔记 2022年
maven简单学习笔记（尚硅谷）
qsxfthnkol的博客
11-18 113
MAVP是Groupid（组织 com.{公司/BU }.业务线.[子业务线]）,Artifactid(微服务 项目+模块，其他名字),Version（主 不兼容或改功能，次 向下兼容，修订号 bug）,Packaging（文件类型 默认jar java，war web，pom 父工程）。Maven 为 Java 项目构建管理、依赖管理的工具，使用 Maven 可以自动化构建、测试、打包和发布项目，大大提高了开发效率和质量。父中<moudles><moudle>管理子,可以只继承不聚合,一般同时存在。
[Java]Maven学习笔记(尚硅谷2022)
emmmm.....
01-28 2426
[第一章 Maven概述][第二章 Maven核心程序解压和配置[第三章 使用Maven：命令行] [第四章 使用Maven：IDEA]
（尚硅谷）Maven 新版教程 - 锦囊一
qq_42148002的博客
06-01 1253
跟着视频按照老师的教程来操作的时候，由于 IDEA 、JDK 、Maven 版本不一致，会产生一堆意想不到的错误，本文主要是记录自己遇到的报错以及搜索到的可以解决问题的解决方案，以便今后查阅。 Maven 核心程序：只是负责宏观上的总体调度； Maven 插件：具体负责干活的；总结：参考文献：这里 IDEA 版本需要和 maven 版本进行对应才可以，不然之后用 idea 配置 maven 的时候会报错。这里点击 Help - About 之后看到我的 idea 版本为 2012.3.2那么根据版本对应信息
maven学习笔记
12-16
**Maven学习笔记** 在Java开发领域，Maven是一个不可或缺的构建工具，它极大地简化了项目的构建、管理和依赖管理过程。Maven通过一个统一的项目对象模型（Project Object Model，POM），使得开发者可以轻松地定义...
尚硅谷Maven课程笔记代码资源
11-23
【尚硅谷Maven课程笔记代码资源】是一份全面学习Maven的资料集合，它涵盖了从基础到高级的各种知识点，旨在帮助开发者深入理解并熟练运用Maven进行自动化构建。该资源包含课件、源码和相关的笔记，使得学习过程更加...
尚硅谷 Java 技术之 Maven1
08-03
1.1 添加第三方 jar 包 1.2 jar 包之间的依赖关系 1.3 处理 jar 包之间的冲突 1.4 获取第三方 jar 包 1.5 将项目拆分成多个工
尚硅谷-Maven学习笔记
路遥
03-21 857
1.尚硅谷-Maven学习笔记 尚硅谷-Maven学习笔记已经有热心同学整理好了，这里只做一下链接分享·，点击前往: 尚硅谷-Maven学习笔记
【尚硅谷最新】一篇文章带你搞懂Maven
qq_38196449的博客
04-13 1080
Maven 私服是一种特殊的Maven远程仓库，它是架设在局域网内的仓库服务，用来代理位于外部的远程仓库（中央仓库、其他远程公共仓库）。当然也并不是说私服只能建立在局域网，也有很多公司会直接把私服部署到公网，具体还是得看公司业务的性质是否是保密的等等，因为局域网的话只能在公司用，部署到公网的话员工在家里也可以办公使用。建立了 Maven 私服后，当局域网内的用户需要某个构件时，会按照如下顺序进行请求和下载。请求本地仓库，若本地仓库不存在所需构件，则跳转到第 2 步；
maven笔记（尚硅谷）
qq_26882339的博客
02-02 519
https://www.bilibili.com/video/BV1TW411g7hP?from=search&seid=14158829978266635696 记录下学习笔记。 先是视频中的先修知识总结： 已经掌握的技术： 其中，如果用的struts2，控制器就是Action，如果用的是SpringMVC，控制器就是Handler。 ...
第一章初识Maven与Maven安装配置——尚硅谷
一名在校大三学习JAVA
10-23 421
一个 Maven 工程有约定的目录结构，约定的目录结构对于 Maven 实现自动化构建而言是必不可少的一环，就拿自动编译来说，Maven 必须 能找到 Java 源文件，下一步才能编译，而编译之后也必须有一个准确的位置保持编译得到的字节码文件。修改配置的方式是：将。而实际上 jar 包之间的依赖关系是普遍存在的，如果要由程序员手动梳理无疑会增加极高的学习成本，而这些工作又对实现业务功能毫无帮助。而使用 Maven 则几乎不需要管理这些关系，极个别的地方调整一下即可，极大的减轻了我们的工作量。
Maven基础知识（尚硅谷）
kingdom365的博客
11-18 653
Maven基础知识 项目太大，不适合用package划分，最好是每一个模块对应一个工程，利于分工协作 项目中的jar包必须手动copy到WEB-INF/lib目录下，最好只需要引用而不需要真正复制过来 jar包版本参差不齐，有些jar包只能通过maven或者svn提供下载，我们需要一种规范的方式来下载 jar包之间不是独立存在的，往往一个jar包依赖于另一个jar包，最好是自动引入 … 一、Maven的概念 是一个Java平台的自动化构建工具。 1. 构建 以java源文件、框架配置文件、jsp、htm
尚硅谷-2022新版maven教程笔记
CERTAINTY的博客
03-10 876
尚硅谷-2022新版maven教程笔记
maven狂神笔记md
07-29
"Maven狂神笔记.md"是一本关于Maven的笔记，由狂神团队整理的Markdown格式文件。Maven是一个功能强大的构建工具，用于管理Java项目的构建、依赖管理和项目管理等方面。 这本笔记涵盖了Maven的各个方面，包括Maven的介绍、基本概念、安装和配置、项目结构、POM文件、依赖管理、插件、构建生命周期、打包发布等。通过阅读这本笔记，我们可以系统地学习和了解Maven的使用和原理。 Maven的优势在于它提供了一种规范的项目结构和依赖管理方式，使得开发者可以更加方便地创建、构建和维护Java项目。通过统一的构建生命周期和插件体系，Maven可以帮助我们自动执行各种任务，如编译代码、运行测试、打包发布等，减少了手动操作的繁琐性。 此外，Maven还具有强大的依赖管理功能，可以自动下载和管理项目所需的第三方库和工具。通过在POM文件中定义依赖关系，Maven可以自动解决依赖冲突问题，帮助开发者更好地管理项目的依赖。 总之，"Maven狂神笔记.md"是一本全面介绍和指导Maven使用的笔记，它可以帮助开发者快速上手Maven，并提供了一种规范和高效的项目管理方式。无论是初学者还是有一定经验的开发者，都能从中受益，并提升自己在Java项目开发中的效率和质量。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值