首页 > 其他分享 >Maven项目构建工具的入门使用

Maven项目构建工具的入门使用

时间：2022-11-28 18:36:01浏览次数：68  
标签：maven 入门 项目 Maven 构建 wm103 maven01 com


目录

  • ​​目录​​
  • ​​前言​​
  • ​​Maven的介绍及环境搭建​​
  • ​​创建Maven项目​​
  • ​​Maven的常用命令​​
  • ​​自动创建目录骨架​​
  • ​Maven中的坐标和仓库​
  • ​​坐标​​
  • ​仓库​
  • ​​关于仓库的介绍​​
  • ​​更改本地仓库的位置​​
  • ​Maven的生命周期和插件​
  • ​​生命周期​​
  • ​​插件​​
  • ​​pom.xml常见元素介绍​​
  • ​Maven的依赖​
  • ​​依赖范围​​
  • ​​依赖传递​​
  • ​​依赖冲突​​
  • ​聚合与继承​
  • ​​聚合​​
  • ​​继承​​


前言

　　尽管本人之前对Maven有所接触，但还是不够系统。那趁这个时候有空闲时间，赶紧重新温习一下，充充电。如下所记录的知识点，可以认为是本人在观看imooc的《项目管理利器——maven》教程（有兴趣的话，可以到imooc网站上进行观看该视频）后所学习到的知识点进行的整理，方便分享以及回顾。那么下面，我们正式开始对maven进行学习。

Maven的介绍及环境搭建

　　Maven是基于项目对象模型（POM），可以通过一小段描述信息来管理项目的构建、报告和文档的软件项目管理工具。
　　maven的bin目录包含了mvn的运行脚本；而boot目录包含了一个类加载器的框架，maven使用它来加载自己的类库；config目录则包含了一些配置文件；lib目录则包含maven进行使用时所使用到的类库。
　　在​​​官网​​​中下载对应的maven文件解压即可。此外，为了在命令行中可以直接运行maven的命令，我们需要配置一下环境变量。在系统变量中，我们新建环境变量“​​MAVEN_HOME​​​”，变量的值为maven的安装目录；然后在path变量的最后加上​​“;%MAVEN_HOME%\bin”​​​。验证是否配置成功：在命令行下，输入“​​mvn -v​​”，查看当前安装的maven版本。

创建Maven项目

　　在创建maven项目之前，我们先来了解一下maven项目应有的目录结构，如下：

- src
  - main
    - java
      - package
  - test
    - java
      - package
  - resources
- pom.xml

　　举例，我们创建一个名为​​maven01​​​的maven项目，如下：
　　首先是​​​main​​​目录下的内容，在如下目录创建​​HelloWorld.java​​文件。

maven01\src\main\java\com\wm103\maven01\model
package com.wm103.maven01.model;

public class HelloWorld {
    public String say() {
        return "Hello World!";
    }
}

　　其次创建​​test​​​目录，在如下目录创建​​HelloWorldTest.java​​文件。

maven01\src\test\java\com\wm103\maven01\model
package com.wm103.maven01.model;

import org.junit.*;
import org.junit.Assert.*;

public class HelloWorldTest {
    @Test
    public void testSay() {
        Assert.assertEquals("Hello World!", new HelloWorld().say());
    }
}

　　最后在项目的根目录中创建​​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/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.wm103.maven01</groupId>
    <artifactId>maven01-model</artifactId>
    <version>0.0.1SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.10</version>
        </dependency>
    </dependencies>
</project>

　　根据以上的步骤，我们就创建好第一个Maven项目了。在这个项目中，​​pom.xml​​文件的groupId的值为项目的包名；artifactId的值是模块名，建议使用项目名-模块名。

Maven的常用命令

mvn -v 查看maven版本
mvn compile 编译mvn项目
mvn test 运行maven项目中创建的测试用例
mvn package 将项目打包为jar包
mvn clean 删除maven项目中的target目录
mvn install 安装jar包到本地仓库中

　　其中​​mvn install​​​命令，我们可以使用该命令将本地项目打包成jar安装到本地仓库。如：我们在新的项目​​maven02​​​中使用到了​​maven01​​​项目中的​​HelloWorld.java​​：

package com.wm103.maven02.util;

import com.wm103.maven01.model.HelloWorld;

public class Speak {
    public String say() {
        return new HelloWorld().say();
    }
}

　　那么我们在​​mvn compile​​​编译​​maven02​​项目的过程中，就会出项如下错误：

[ERROR] Failed to execute goal org.apache.maven.plugins:maven-compiler-plugin:3.1:compile (default-compile) on project maven02-util: Compilation failure: Compilation failure:
[ERROR] /G:/StudyWorld/program/IDEAWorkSpace/Maven/maven02/src/main/java/com/wm103/maven02/util/Speak.java:[3,25] 程序包com.wm103.maven01不存在
[ERROR] /G:/StudyWorld/program/IDEAWorkSpace/Maven/maven02/src/main/java/com/wm103/maven02/util/Speak.java:[7,28] 找不到符号
[ERROR]   符号:   类 HelloWorld
[ERROR]   位置: 类 com.wm103.maven02.util.Speak
[ERROR] -> [Help 1]

　　为解决这样的问题，我们需要对​​maven01​​​项目使用​​mvn install​​​命令，将其打包成jar并安装到本地仓库，其次需要在​​maven02​​​项目中定义对​​maven01​​的依赖，如下：

<?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/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.wm103.maven02</groupId>
    <artifactId>maven02-util</artifactId>
    <version>0.0.1SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.10</version>
        </dependency>
        <dependency>
            <groupId>com.wm103.maven01</groupId>
            <artifactId>maven01-model</artifactId>
            <version>0.0.1SNAPSHOT</version>
        </dependency>
    </dependencies>
</project>

自动创建目录骨架

　　手动创建maven项目的目录结构，实际上是一件很繁琐的事情，为解决这样的问题，在maven中提供了一个​​archetype​​​插件，方便我们创建maven的目录骨架。使用如下：
1. ​​​mvn archetype:generate​​​：按照提示进行选择填写创建；
2. ​​​mvn archetype:generate -DgroupId=组织名，公司网址的反写+项目名 -DartifactId=项目名-模块名 -Dversion=版本号 -Dpackage=代码所存在的包名​​：在命令中先设置好后续需要填写的参数。如：

mvn archetype:generate -DgroupId=com.wm103.maven04 -DartifactId=maven04-demo -Dversion=0.0.1SNAPSHOT -Dpackage=com.wm103.maven04.demo

Maven中的坐标和仓库

坐标

　　在maven中，任一项目的依赖、插件、项目构建的输出都可以被称之为构件，所有构件都可以通过坐标作为其唯一的标识。如：pom.xml中的groupId、artifactId、version三者可以组成一个坐标，标识某一构件。

仓库

关于仓库的介绍

　　构件存储在仓库中。仓库分为本地仓库和远程仓库。如果一个项目在本地仓库中找不到所需的构件，则会到maven的全球中央仓库进行查找，查找到则会将其下载到我们的本地仓库供我们使用。如果在远程的中央仓库也查询不到的话项目就会报错。
　　那么提供的全球仓库的地址是什么呢？我们可以在maven安装目录的​​​lib/maven-model-builder-3.5.3.jar​​​（版本不同，文件名也随之不同）中进行查看。在该jar的​​org/apache/maven/model​​目录中包含一个pom文件。我们所有的maven项目都会继承于该pom文件。在该文件中，我们可以看到：

<repositories>
    <repository>
      <id>central</id>
      <name>Central Repository</name>
      <url>https://repo.maven.apache.org/maven2</url>
      <layout>default</layout>
      <snapshots>
        <enabled>false</enabled>
      </snapshots>
    </repository>
  </repositories>

　　其中url标签中设置的就是远程中央仓库的地址；而snapshots标签中enabled设置为false，也标明了禁止下载为快照版本的构件。
　　远程中央仓库位于国外，我们可以采用配置镜像仓库的方式，将对远程仓库的访问转为对镜像仓库的访问。配置方式如下：

<!-- 修改maven安装目录下的conf目录settings.xml文件中mirrors节点的内容 -->
<mirrors>
  <mirror>
    <id>maven.aliyun.com</id>
    <mirrorOf>central</mirrorOf>
    <name>Aliyun Maven</name>
    <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
  </mirror>
</mirrors>

更改本地仓库的位置

　　对于Windows而言，默认maven的本地仓库位置是当前登录的用户目录中的。如：

C:\Users\DreamBoy\.m2\repository

　　更改本地仓库的位置，同样需要对settings文件进行修改（在文件的55行中进行配置），如下：

<localRepository>H:/MySoftware/maven-repo</localRepository>

Maven的生命周期和插件

生命周期

　　一个完整项目的构建过程包括：清理、编译、测试、打包、集成测试、验证、部署。
　　在Maven中，包括了3套生命周期，即clean（清理项目）、default（构建项目）、site（生成项目站点）。而在这3套生命周期各自包含着一些顺序执行的阶段，即任一阶段被执行，其前面的阶段也会被顺序执行。
clean（清理项目）：

  • ​​pre-clean​​ 执行清理前的工作
  • ​​clean​​ 清理上一次构建生成的所有文件
  • ​​post-clean​​ 执行清理后的文件

default（构建项目-最核心）：

  • ​​compile​​
  • ​​test​​
  • ​​package​​
  • ​​install​​

site（生成项目站点）：

  • ​​pre-site​​ 在生成项目站点前要完成的工作
  • ​​site​​ 生成项目的站点文档
  • ​​post-site​​ 在生成项目站点后要完成的工作
  • ​​site-deploy​​ 发布生成的站点到服务器上

插件

　　在Maven项目中使用插件，可以在项目的pom.xml文件中配置，这里以配置 jetty 为例。如下：

<?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/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.wm103.webdemo</groupId>
    <artifactId>webdemo</artifactId>
    <version>0.0.1SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.10</version>
        </dependency>
    </dependencies>

    <build>
        <finalName>WebDemo</finalName>
        <plugins>
            <plugin>
                <groupId>org.mortbay.jetty</groupId>
                <artifactId>jetty-maven-plugin</artifactId>
                <version>8.1.16.v20140903</version>
                <!-- <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <version>2.2</version> -->
                <executions>
                    <execution>
                        <!-- 在打包成功后使用jetty:run来运行jetty服务 -->
                        <phase>package</phase>
                        <goals>
                            <goal>run</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

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/maven-v4_0_0.xsd">
    <!-- 指定了当前pom的版本 -->
    <modelVersion>4.0.0</modelVersion>

    <!-- 公司网址的反写+项目 -->
    <groupId>com.wm103.maven01</groupId>
    <!-- 项目名+模块名 -->
    <artifactId>maven01-model</artifactId>
    <!-- 版本号，如 0.0.1SNAPSHOT
    第一个0表示大版本号
    第二个0表示分支版本号
    第三个0表示小版本号
    而SNAPSHOT则表示快照，此外还包括有：
    alpha 内部测试； beta 公测； release 稳定； GA 正式发布 -->
    <version>0.0.1SNAPSHOT</version>
    <!-- 打包方式，默认为jar，此外可以设置打包为war、zip、pom等 -->
    <packaging></packaging>
    <!-- 项目描述名 -->
    <name></name>
    <!-- 项目地址 -->
    <url></url>
    <!-- 项目描述 -->
    <description></description>
    <!-- 开发人员列表 -->
    <developers></developers>
    <!-- 许可证信息 -->
    <licenses></licenses>
    <!-- 组织信息 -->
    <organization></organization>

    <!-- 依赖列表 -->
    <dependencies>
        <!-- 依赖项，通过指定坐标标识所需的依赖 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.10</version>
            <type></type>
            <!-- 依赖范围 -->
            <scope>test</scope>
            <!-- 设置依赖是否可选，默认为false。如果为false，子项目默认继承，否则子项目必须显示地引入该依赖 -->
            <optional></optional>
            <!-- 排除依赖传递列表 -->
            <exclusions>
                <exclusion></exclusion>
            </exclusions>
        </dependency>
    </dependencies>

    <!-- 依赖的管理，作用主要定义在父模块中，供子模块继承用的 -->
    <dependencyManagement>
        <dependencies>
            <dependency>

            </dependency>
        </dependencies>
    </dependencyManagement>

    <!-- 为maven项目的构建行为提供相应的支持 -->
    <build>
        <!-- 插件列表 -->
        <plugins>
            <plugin>
                <groupId></groupId>
                <artifactId></artifactId>
                <version></version>
            </plugin>
        </plugins>
    </build>

    <!-- 通常用于子模块对父模块的pom继承 -->
    <parent></parent>
    <!-- 用来聚合运行maven项目，指定多个模块一起编译 -->
    <modules>
        <module></module>
    </modules>
</project>

Maven的依赖

依赖范围

　　在Maven中提供了三种​​classpath​​​，分别为：编译、测试、运行。
　　在​​​dependency​​​标签中​​scope​​​标签指定了当前依赖的范围，即指定了依赖同​​classpath​​​的关系。简单来说就是用​​scope​​​标签下的值说明这个依赖在项目的什么阶段下有效（除特殊值，如​​import​​​外）。
　　在Maven中提供了6种可选的依赖范围：
1. ​​​compile​​​：默认范围，编译测试运行都有效；
2. ​​​provided​​​：在编译和测试时有效；
3. ​​​runtime​​​：在测试和运行时有效；
4. ​​​test​​​：只在测试时有效；
5. ​​​system​​​：类似​​provided​​​，在编译和测试时有效，且与本系统相关联，可移植性差；
6. ​​​import​​​：导入范围，它只能用在​​dependencyManagement​​​的​​dependency​​​的​​scope​​​中，用于将其他项目的依赖导入。
参考：
- ​​Maven POM中的各种scope的行为总结​​
- ​​使用import scope解决maven继承（单）问题​​

依赖传递

　　在Maven中，A项目依赖B项目，而B项目依赖C项目。那么A项目间接地依赖了C项目。这就是所谓的依赖传递。实际的pom.xml配置如下：
　　A项目的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/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.wm103.A</groupId>
    <artifactId>A</artifactId>
    <version>0.0.1SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>com.wm103.B</groupId>
            <artifactId>B</artifactId>
            <version>0.0.1SNAPSHOT</version>
        </dependency>
    </dependencies>
</project>

　　B项目的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/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.wm103.B</groupId>
    <artifactId>B</artifactId>
    <version>0.0.1SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>com.wm103.C</groupId>
            <artifactId>C</artifactId>
            <version>0.0.1SNAPSHOT</version>
        </dependency>
    </dependencies>
</project>

　　C项目的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/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.wm103.C</groupId>
    <artifactId>C</artifactId>
    <version>0.0.1SNAPSHOT</version>
</project>

　　因此在最终编译A项目后，我们会发现A项目引入了打包成jar的C项目。A项目中为排除对C项目的依赖，可以做如下配置：

<?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/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.wm103.A</groupId>
    <artifactId>A</artifactId>
    <version>0.0.1SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>com.wm103.B</groupId>
            <artifactId>B</artifactId>
            <version>0.0.1SNAPSHOT</version>
            <exclusions>
                <exclusion>
                    <groupId>com.wm103.C</groupId>
                    <artifactId>C</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>
</project>

依赖冲突

　　A和B依赖了不同版本的相同构件，而依赖于A和B的C就需要依赖于哪个版本的构件，即发生了依赖冲突的问题。解决这样的问题，Maven遵循如下原则：
- 短路优先
　　如：

A->B->C->X(jar)
A->D->X(jar)

　　这样的情况下，A依赖的是D依赖的X。
- 先声明先优先
　　如果路径长度相同，则谁先声明，先解析谁。

聚合与继承

聚合

　　为同时为多个Maven项目进行install操作（即安装到本地仓库），我们可以使用聚合操作。
　　新建一个新的Maven项目，在其pom.xml中，设置需要聚合的模块，如下：

<packaging>pom</packaging>
<modules>
    <module>../maven01</module>
    <module>../maven02</module>
    <module>../maven03</module>
</modules>

　　在这个项目中聚合了3个项目，分别为maven01、maven02、maven03。对该项目使用​​mvn install​​命令，则会将项目内聚合的项目依次打包安装到本地仓库。

继承

　　参考：​​Maven学习笔记​​


标签：maven,入门,项目,Maven,构建,wm103,maven01,com
From： https://blog.51cto.com/u_15894233/5893363

相关文章

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99