【Maven】Maven

发表于2021-08-28更新于2022-02-04字数统计3.5k阅读时长25分阅读次数

image-20210913132641433

Maven 简介

软件开发中的阶段

  • 需要分析： 分析项目具体完成的功能，有什么要求，具体怎么实现
  • 设计阶段：根据分析的结果，设计项目的使用什么技术，解决难点
  • 开发阶段：编码实现功能，编译代码，自我测试
  • 测试阶段：专业的测试人员，测整个项目的功能十分符合设计要求。出一个测试报告
  • 发布阶段： 项目的打包，给用户安装项目

什么是 Maven

maven是apache基金会的开源项目，使用java语法开发。Maven这个单词的本意是：专家，内行。maven是项目的自动化构建工具，用于管理项目的依赖。下载地址： http://maven.apache.org/

Maven 能做什么

  • 项目的自动构建，帮助开发人员做项目代码的编译，测试，打包，安装，部署等工作
  • 管理依赖（管理项目中使用的各种jar包）

依赖：项目中需要使用的其他资源，常见的是jar。比如项目要使用mysql驱动。我们就说项目依赖mysql驱动。

Maven 中的概念

  • POM
  • 约定的目录结构
  • 坐标
  • 依赖管理
  • 仓库管理
  • 生命周期
  • 插件和目标
  • 继承
  • 聚合

Maven 的核心概念

约定的目录结构

maven项目使用的大多人遵循的目录结构，叫做约定的目录结构。

一个maven项目是一个文件夹，例如：

image-20210828195930150

POM

POM： Project Object Model 项目对象模型，maven把项目当做模型处理，操作这个模型就是操作项目。

maven通过pom.xml文件实现项目的构建和依赖的管理：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
<?xml version="1.0" encoding="UTF-8"?>

<!-- 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">
    
    <!-- pom模型的版本，就是4.0.0 -->  
    <modelVersion>4.0.0</modelVersion>

    <!-- 坐标 -->  
    <artifactId>cloud2021</artifactId>
    <groupId>com.zhao.springcloud</groupId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <java.version>1.8</java.version>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>

</project>

坐标 gav

坐标概念来自数学，坐标组成是 groupid, artifiactId, version。

坐标作用：确定资源的，是资源的唯一标识。在maven中，每个资源都是坐标。坐标值是唯一的，简称叫gav：

1
2
3
4
<groupId>com.bjpowernode</groupId>
<artifactId>ch01-maven</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>
  • groupId：组织名称，代码，公司，团体或者单位的标识。这个值常使用的公司域名的倒写
  • artifactId：项目名称，如果groupId中有项目，此时当前的值就是子项目名。项目名称是唯一的
  • version：版本，项目的版本号，使用的数字。三位组成。例如：5.2.5（主版本号.次版本号.小版本号） 注意：版本号中有-SNAPSHOT，表示快照，不是稳定的版本。

packaging为项目打包的类型，有jar ，war，ear，pom等等。默认是jar。区别：

  • jar：将项目打成jar包，可以使用java命令直接执行
  • war：将项目打成war包，需要放到Tomcat中执行
  • pom：常用于Maven父工程，用于让子模块继承该父工程的pom文件。代表当前工程是纯pom工程，没有业务代码，只用于管理依赖，让子模块继承，从而做到依赖版本统一

搜索坐标的地址： https://mvnrepository.com/

依赖 dependency

依赖：项目中要使用的其他资源（jar）。 需要使用maven表示依赖，管理依赖。通过使用dependency和gav一起完成依赖的使用

需要在pom.xml文件中，使用dependencies和dependency，还有gav完成依赖的说明。格式：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<dependencies>
    <!-- 日志 -->
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.17</version>
    </dependency>

    <!-- mysql驱动 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.16</version>
    </dependency>

</dependencies>

仓库

仓库是存东西的，maven的仓库存放的是：

  1. maven工具自己的jar包
  2. 第三方的其他jar，比如项目中要使用mysql驱动
  3. 自己写的程序，可以打包为jar，存放到仓库。

仓库的分类：

本地仓库（本机仓库）： 位于你自己的计算机，它是磁盘中的某个目录。修改本地仓库的位置：修改maven工具的配置文件（maven的安装路径/conf/setting.xml）

远程仓库： 需要通过联网访问的

  • 中央仓库： 一个ftp服务器，存放了所有的资源。
  • 中央仓库的镜像： 就是中央仓库的拷贝。在各大主要城市都有镜像。
  • 私服：在局域网中使用的。私服就是自己的仓库服务器，在公司内部使用的。

maven使用仓库： maven自动使用仓库，当项目启动后，执行了maven的命令，maven首先访问的是本地仓库，从仓库中获取所需的jar，如果本地仓库没有 ，需要访问私服或者中央仓库或者镜像。

image-20201016114322189

Maven 的生命周期，插件和命令

maven的生命周期： 项目构建的各个阶段。包括清理，编译，测试，报告，打包，安装，部署

  • 插件：要完成构建项目的各个阶段，要使用maven的命令，执行命令的功能是通过插件完成的。插件就是jar，一些类。
  • 命令： 执行maven功能是由命令发出的。比如 mvn compile

常用命令：

  • mvn clean：清理命令，作用是删除以前生成的数据，即删除target目录
  • mvn compile：编译命令，执行的代码编译，把src/main/java目录中的java代码编译为.class文件。同时把.class文件拷贝到target/classes目录。这个目录classes是存放类文件的根目录（也叫做类路径，classpath）
  • mvn test-compile：编译命令，编译src/test/java目录中的源文件，把生成的.class拷贝到target/test-classes目录。同时把src/test/resources目录中的文件拷贝到 test-clasess目录
  • mvn test：测试命令，作用执行 test-classes目录的程序，测试src/main/java目录中的主程序代码是否符合要求。
  • mvn package：打包，作用是把项目中的资源.class文件和配置文件都放到一个压缩文件中，默认压缩文件是jar类型的。web应用是war类型，扩展是jar，war的。
  • mvn install：把生成的打包的文件 ，安装到maven仓库。

自定义配置插件

在pom.xml文件中，<build>标签里设置插件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<!-- 设置构建项目相关的内容 -->
<build>
    <plugins>
        <!-- 设置插件 -->
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.8.1</version>
            <configuration>
                <source>1.8</source> <!-- 指定编译代码的jdk版本 -->
                <target>1.8</target> <!-- 运行java程序使用的jdk版本-->
            </configuration>
        </plugin>
    </plugins>
</build>

Maven 和 IDEA 的集成

IDEA中有一个自带的maven，我们要让idea使用自己本地安装的maven。

  1. 选择 File- Settings

image-20201016151034872

image-20201016151528678

​ 设置项： -DarchetypeCatalog=internal

  1. File - Other Settings

image-20201016151823967

同上的设置

依赖管理

依赖范围：使用scope表示依赖的范围。依赖范围表示： 这个依赖（jar和里面类）在项目构建的那个阶段起作用。

依赖范围scope 类型：

  • compile：默认，参与构建项目的所有阶段
  • test：测试，在测试阶段使用，比如执行mvn test会使用junit 。
  • provided：提供，项目在部署到服务器时，不需要提供这个依赖的jar ，而是由服务器这个依赖的jar包。例如servlet和jsp依赖需要使用provided范围，让部署的Tomcat提供其依赖。
  • import：必须用在<dependencyManagement>标签内，与scope中的pom类型配合使用，用于将目标工程的pom文件中的依赖内容直接复制到当前项目中，从而做到分类管理，即将不同类型的依赖放在不同的pom文件中，使用这些大量的依赖只需要import少量的pom文件即可，例如：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
<!-- spring boot 2.2.2 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-dependencies</artifactId>
    <version>2.2.2.RELEASE</version>
    <type>pom</type>
    <scope>import</scope>
</dependency>
<!-- spring cloud Hoxton.SR1 -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-dependencies</artifactId>
    <version>Hoxton.SR1</version>
    <type>pom</type>
    <scope>import</scope>
</dependency>
<!-- spring cloud 阿里巴巴 -->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-alibaba-dependencies</artifactId>
    <version>2.1.0.RELEASE</version>
    <type>pom</type>
    <scope>import</scope>
</dependency>

只需要import三个pom文件即可导入大量的依赖，从而做到依赖的分类管理。其中导入的spring-boot-dependencies的scope类型为pom：

1
2
3
4
5
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-dependencies</artifactId>
<version>2.2.2.RELEASE</version>
<packaging>pom</packaging>
<name>Spring Boot Dependencies</name>

<dependencyManagement>标签常用于父工程中，用于管理子模块的依赖。在其下创建的子模块不再需要填写依赖的版本号（版本号都在父工程中指定了），若需要自定义版本号，只需要在子模块的pom文件里自定义修改即可，其会遵循就近原则。

父工程使用如下两种标签管理依赖时的区别：

  • <dependencies>：其内的所有依赖都会被子模块直接继承，坏处是引入了大量的冗余依赖
  • <dependencyManagement>：其内的依赖子模块不会直接拥有，需要子模块自己按需添加<dependency>标签引入，好处是不需要全部引入父工程的所有依赖

Maven父工程里只能有pom文件，不需要有src目录和target目录，其作用仅仅是用于定义子模块需要用到的依赖版本，不需要有业务代码。

常用设置

properties里面的配置：

1
2
3
4
5
6
7
<properties>
    <maven.compiler.source>1.8</maven.compiler.source> 源码编译 jdk 版本
    <maven.compiler.target>1.8</maven.compiler.target> 运行代码的 jdk 版本
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> 项目
    构建使用的编码，避免中文乱码
    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding> 生成报告的编码
</properties>

全局变量

在properties定义标签，这个标签就是一个变量，标签的文本就是变量的值。使用全局变量表示多个依赖使用的版本号。

使用步骤：

  1. 在properties标签中，定义一个标签，指定版本的值
1
2
3
4
5
6
7
8
<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
    <!--自定义变量-->
    <spring.version>5.2.5.RELEASE</spring.version>
    <junit.version>4.11</junit.version>
</properties>
  1. 使用全局变量，语法 ${变量名}
1
2
3
4
5
6
7
8
9
10
11
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-core</artifactId>
    <version>${spring.version}</version>
</dependency>

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-web</artifactId>
    <version>${spring.version}</version>
</dependency>
  1. 使用资源插件，处理配置文件的信息
  • maven会把src/main/resources目录中的文件，拷贝到target/classes目录下
  • maven只处理src/main/java目录中的 .java文件，把这些.java文件编译为.class，拷贝到 target/classes目录中。不处理其他文件。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<build>
    <!--资源插件：告诉maven把src/main/java目录中的指定扩展名的文件拷贝到 target/classes目录中。
  -->
    <resources>
        <resource>
            <directory>src/main/java</directory> <!--所在的目录-->
            <includes>
                <!--包括目录下的 .properties,.xml 文件都会扫描到-->
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <!--  filtering 选项 false 不启用过滤器，*.property 已经起到过滤的作用了 -->
            <filtering>false</filtering>
        </resource>
    </resources>
</build>

以上配置可用于解决MyBatis的mapper文件导出问题。

Maven 打包跳过测试

https://www.cnblogs.com/three-fighter/p/13996864.html

使用Maven打包的时候，可能会因为单元测试打包失败，这时候就需要跳过单元测试。

一、命令行方式跳过测试

我们可以用两种命令来跳过测试

  • mvn clean install -DskipTests：不执行测试用例，但编译测试用例类生成相应的class文件至target/test-classes下。跳过单元测试，但是会继续编译。
  • mvn clean install -Dmaven.test.skip=true：不执行测试用例，也不编译测试用例类。不但跳过单元测试的运行，也跳过测试代码的编译

二、pom.xml中配置跳过测试

可以在 pom.xml 中添加如下配置来跳过测试：

1
2
3
4
5
6
7
8
9
10
11
12
<build>
    <plugins>
        <!-- maven 打包时跳过测试 -->
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-surefire-plugin</artifactId>
            <configuration>
                <skip>true</skip>
            </configuration>
        </plugin>
    </plugins>
</build>

三、Idea中配置跳过测试

  1. 直接配置：Maven命令栏的工具栏有下图中的图标，这个图标就是 Skip Tests。点击选中，再用LifeStyle 中的打包就会跳过测试：

在这里插入图片描述

  1. 更改 Maven 配置
  • 方式 1：打开配置，找到 Maven–>Runner，在 VM option 中添加 -Dmaven.test.skip=true

在这里插入图片描述

  • 方式2：Runner–> Propertis 中选中 Skip tests

在这里插入图片描述