易筋SpringBoot 2.1 | 第三十五篇：实战Aparche Maven 的核心概念与理论 Maven仓库管理从入门到精通

最新推荐文章于 2021-11-18 13:19:56 发布

AI架构师易筋

最新推荐文章于 2021-11-18 13:19:56 发布

阅读量416

点赞数

分类专栏：易实战Sprint Boot 2.1 文章标签： Maven 核心概念核心理论 mvn package

本文链接：https://blog.csdn.net/zgpeace/article/details/106039190

版权

易实战Sprint Boot 2.1 专栏收录该内容

40 篇文章 6 订阅

订阅专栏

1. Maven 简介

Apache Maven是一个软件项目管理和理解工具。基于项目对象模型（Project Object Model，POM）的概念，Maven可以从中央信息管理项目的构建，报告和文档。

Maven可以管理项目构建的整个生命周期，包括清理(Clean)、编译(Complie)、打包(Package)、测试(Test)等环节。同事Maven提供了非常丰富的插件，使得构建项目和管理项目变得简单。构建一个项目所需要的流程如下。

生成源码；
从源码中生成文档；
编译源码；
测试；
将源码打包成Jar，运行在服务器、仓库或其它位置。

Apache Maven已经实现了以上的全部功能，并且只需要相关的命令就可以完成相关的功能。

2. Maven的核心概念

Maven的核心是pom文件，pom文件以xml文件的形式来表示资源，包括一些依赖Jar、插件、构建文件等。Maven的工作过程如下：
在这里插入图片描述

首先读取pom文件。pom文件是Maven的核心，所有的项目依赖、插件都在pom文件中统一管理。
下载依赖Jar到本地仓库。Maven命令执行时，首先会检查pom文件的依赖Jar，当检测到本地没有安装依赖Jar时，会默认从Maven的中央仓库下载依赖Jar，中央仓库地址为https://repo1.maven.org/maven2/。依赖Jar下载成功后，会存放在本地仓库中，如果下载不成功，则该命令执行不会通过。
执行构建的生命周期。Mave的构建过程会被分解成构建阶段和构建目标，它们共同构成了Maven的生命周期。
执行构建插件。插件可以更方便地执行构建的各个阶段，也可以用插件实现一些额外的功能。目前Maven有非常丰富的插件，如果需要，你也可以自己实现Maven插件。

3. Maven构建项目的生命周期

在Maven工程中，已经默认定义了构建工程的生命周期，不需要额外引用其它的插件，因为Maven本身已经集成了这些插件。默认的生命周期包括了23个阶段。

阶段	描述
validate	验证工程的完整性
initialize	初始化
generate-sources	生成源码
process-sources	处理源码
generate-resources	生成所有源码
process-resources	处理所有源码
compile	编译
process-classes	处理class文件
generate-test-sources	生成测试源码
process-test-sources	处理测试源码
generate-test-resources	生成所有测试源码
process-test-resources	处理所有测试源码
test-compile	测试编译
process-test-classes	处理测试class文件
test	测试
prepare-package	预打包
package	打包（如Jar、War）
pre-integration-test	预集成测试
integration-test	集成测试
post-integration-test	完成集成测试
verify	验证
install	安装到本地仓库
deploy	提交到远程仓库

4. 常用的Maven命令

mvn clean删除工程的target目录下的所有文件。
mvn package将工程打包（如Jar、War）
mvn package命令执行过程包括以下6个阶段：
2.1 验证
2.2 编译代码
2.3 处理代码
2.4 生成资源文件
2.5 打包（如Jar、War）
2.6 测试
mvn package -Dmaven.test.skip=true 打包时跳过测试。
mvn compile 编译工程代码，不打包。
mvn install 命令包含了 mvn package 的所有过程，并且将生成的包安装到本地仓库。执行mvn install 命令，可以看到终端输出的日志，经过了与mvn package 相同的阶段，最后将Jar包安装到本地仓库。
mvn spring-boot:run 使用spring-boot插件，启动Spring Boot工程。该命令执行时先检查Spring Boot工程源码是否编译，如果工程源码没有编译，则先编译；如果编译了；则启动工程。
mvn test 测试；
mvn idea:idea 生成idea项目
mvn jar:jar 只打Jar包
mvn validate 检验资源是否可用。

5. Maven 安装

Maven可作为zip文件从https://maven.apache.org/download.cgi下载。仅需要二进制文件，因此请查找指向apache-maven- {version} -bin.zip或apache-maven- {version} -bin.tar.gz的链接。

下载zip文件后，将其解压缩到计算机上。然后将bin文件夹添加到您的路径。
笔者是Mac OS, 并且用myzsh
先cd到配置文件

$ vim ~/.zshrc
// 系统默认是 bash
//$ vim ~/.bash_profile

笔者配置信息如下

# JAVA
export JAVA_HOME="$(/usr/libexec/java_home -v 1.8)"
export MAVEN_HOME="/Users/zgpeace/opt/apache-maven-3.5.4"
export SPRING_HOME="/Users/zgpeace/opt/spring-2.1.1.RELEASE"
export PATH=$JAVA_HOME/bin:$MAVEN_HOME/bin:$SPRING_HOME/bin:$PATH

要测试Maven安装，请从命令行运行mvn：

mvn -v

如果一切顺利，应该向您提供有关Maven安装的一些信息。它看起来与以下内容相似（尽管可能略有不同）：

mvn -v
Apache Maven 3.5.4 (1edded0938998edf8bf061f1ceb3cfdeccf443fe; 2018-06-18T02:33:14+08:00)
Maven home: /Users/zgpeace/opt/apache-maven-3.5.4
Java version: 1.8.0_172, vendor: Oracle Corporation, runtime: /Library/Java/JavaVirtualMachines/jdk1.8.0_172.jdk/Contents/Home/jre
Default locale: en_CN, platform encoding: UTF-8
OS name: "mac os x", version: "10.15.2", arch: "x86_64", family: "mac"

恭喜你！您现在已经安装了Maven。

信息：您可能想考虑使用Maven包装器来隔离开发人员，使其避免拥有正确版本的Maven或完全安装它。从Spring Initializr下载的项目都包含包装器。它以脚本的形式显示mvnw在项目的顶层，代替mvn。

6. 创建项目

6.1 创建一个Maven项目

在这里插入图片描述

GroupId: com.zgpeace.maven
ArtificatId: HelloMaven
Version: 0.1.0

在这里插入图片描述

6.2 创建相关类

创建文件目录结构如下

└── src
    └── main
        └── java
            └── hello

创建类src/main/java/hello/Greeter.java

package hello;

public class Greeter {
  public String sayHello() {
    return "Hello world!";
  }
}

创建类src/main/java/hello/HelloWorld.java

package hello;

public class HelloWorld {
  public static void main(String[] args) {
    Greeter greeter = new Greeter();
    System.out.println(greeter.sayHello());
  }
}

6.3 编辑`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.zgpeace.maven</groupId>
    <artifactId>HelloMaven</artifactId>
    <packaging>jar</packaging>
    <version>0.1.0</version>

    <properties>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>
    
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>3.2.1</version>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                        <configuration>
                            <transformers>
                                <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                    <mainClass>hello.HelloWorld</mainClass>
                                </transformer>
                            </transformers>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

    
</project>

除了可选择 <packaging>元素之外，这是构建Java项目所需的最简单的pom.xml文件。它包括以下项目配置的详细信息：

<modelVersion>。POM模型版本（始终为4.0.0）。
<groupId>。项目所属的组或组织。通常表示为反向域名。
<artifactId>。要赋予项目的库工件的名称（例如，其JAR或WAR文件的名称）。
<version>。正在构建的项目的版本。
<packaging>-如何打包项目。对于JAR文件打包，默认为“ jar”。使用“ war”进行WAR文件打包。

在选择版本控制方案时，Spring建议使用语义版本控制方法。
至此，您已定义了一个最小但功能强大的Maven项目。

6.4 构建Java代码

Maven现在准备构建该项目。您现在可以使用Maven执行几个构建生命周期目标，包括编译项目代码，创建库包（例如JAR文件）以及在本地Maven依赖项存储库中安装库的目标。

要尝试构建，请在命令行中发出以下命令：

mvn compile

这将运行Maven，告诉它执行编译目标。完成后，您应该在target / classes目录中找到已编译的.class文件。

由于您不太可能希望直接分发或使用.class文件，因此您可能需要运行程序包目标：

mvn package

该包装目标将编译Java代码，运行任何测试，并通过在内部的JAR文件将代码打包了完成目标目录。JAR文件的名称将基于项目的<artifactId>和<version>。例如，给定以前的最小pom.xml文件，则JAR文件将命名为HelloMaven-0.1.0.jar 。

要执行JAR文件，请运行：

java -jar target/HelloMaven-0.1.0.jar

如果将值<packaging>从“ jar”更改为“ war”，则结果将是目标目录中的WAR文件而不是JAR文件。
Maven还维护本地计算机上的依赖项存储库（通常在主目录中的.m2 / repository目录中），以快速访问项目依赖项。如果要将项目的JAR文件安装到该本地存储库，则应调用install目标：

mvn install

可以切换到本地仓库，看到一件安装该项目：

$ cd $HOME 
$ cd .m2/repository/com/zgpeace/maven
$ ls 
HelloMaven

可以看到本地参考目录结构如下：
在这里插入图片描述

在安装目标将编译，测试和打包项目的代码，然后将其复制到本地依赖性库，准备好另一个项目中引用它作为一个依赖。

说到依赖，现在是时候在Maven构建中声明依赖了。

6.5 声明依赖

简单的Hello World示例是完全独立的，并且不依赖于任何其他库。但是，大多数应用程序都依赖于外部库来处理常见和复杂的功能。

例如，假设除了说“ Hello World！”外，您还希望应用程序打印当前日期和时间。虽然可以使用本机Java库中的日期和时间工具，但可以使用Joda Time库使事情变得更有趣。

首先，将HelloWorld.java更改如下：

package hello;

import org.joda.time.LocalTime;

public class HelloWorld {
  public static void main(String[] args) {
    LocalTime currentTime = new LocalTime();
    System.out.println("The current local time is: " + currentTime);
    Greeter greeter = new Greeter();
    System.out.println(greeter.sayHello());
  }
}

这里HelloWorld使用Joda Time的LocalTime类来获取并打印当前时间。

如果您现在要运行mvn compile以构建项目，则构建将失败，因为您尚未在构建中将Joda Time声明为编译依赖项。您可以通过将以下行添加到pom.xml（在元素内）来解决此问题：

	<dependencies>
        <dependency>
            <groupId>joda-time</groupId>
            <artifactId>joda-time</artifactId>
            <version>2.10.5</version>
        </dependency>
    </dependencies>

XML块声明了项目的依赖项列表。具体来说，它声明了Joda Time库的单个依赖关系。在<dependency>元素内，依赖关系坐标由三个子元素定义：

<groupId> -依赖关系所属的组或组织。
<artifactId> -所需的库。
<version> -所需的特定版本的库。

默认情况下，所有依赖项的作用域都作为compile依赖项。也就是说，它们应该在编译时可用（如果您正在构建WAR文件，包括在WAR的/ WEB-INF / libs文件夹中）。此外，您可以指定一个<scope>元素来指定以下范围之一：

provided -编译项目代码所需的依赖关系，但将在运行时由运行代码的容器（例如Java Servlet API）提供。
test -用于编译和运行测试的依赖性，但对于构建或运行项目的运行时代码不是必需的。

现在，如果您运行mvn compile或mvn package，则Maven应该从Maven Central存储库中解决Joda Time依赖关系，并且构建将成功。

6.6 编写测试

首先在测试范围内将JUnit作为对pom.xml的依赖项添加：

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

然后创建一个如下的测试用例：

src/test/java/hello/GreeterTest.java

package hello;

import static org.hamcrest.CoreMatchers.containsString;
import static org.junit.Assert.*;

import org.junit.Test;

public class GreeterTest {

  private Greeter greeter = new Greeter();

  @Test
  public void greeterSaysHello() {
    assertThat(greeter.sayHello(), containsString("Hello"));
  }

}

Maven使用名为“ surefire”的插件来运行单元测试。此插件的默认配置将编译并运行src/test/java名称匹配的所有类*Test。您可以像这样在命令行上运行测试

MVN测试
或只使用mvn install上面已经显示的步骤（有一个生命周期定义，其中“测试”作为“安装”的一个阶段包含在内）。

这是完成的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.zgpeace.maven</groupId>
    <artifactId>HelloMaven</artifactId>
    <packaging>jar</packaging>
    <version>0.1.0</version>

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

    <dependencies>
        <dependency>
            <groupId>joda-time</groupId>
            <artifactId>joda-time</artifactId>
            <version>2.10.5</version>
        </dependency>

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

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>3.2.1</version>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                        <configuration>
                            <transformers>
                                <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                    <mainClass>hello.HelloWorld</mainClass>
                                </transformer>
                            </transformers>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

    
</project>

7. 总结

恭喜你！您已经创建了一个简单而有效的Maven项目定义来构建Java项目。

也可以看看
使用Gradle构建Java项目

代码下载：
https://github.com/zgpeace/Spring-Boot2.1

参考

https://spring.io/guides/gs/maven/

http://maven.apache.org/

https://www.jianshu.com/p/6bc2c4e9142c

AI架构师易筋

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
易筋SpringBoot 2.1 | 第三十五篇：实战Aparche Maven 的核心概念与理论 Maven仓库管理从入门到精通

1. Maven 简介Apache Maven是一个软件项目管理和理解工具。基于项目对象模型（Project Object Model，POM）的概念，Maven可以从中央信息管理项目的构建，报告和文档。Maven可以管理项目构建的整个生命周期，包括清理(Clean)、编译(Complie)、打包(Package)、测试(Test)等环节。同事Maven提供了非常丰富的插件，使得构建项目和管理项目变得简单。构建一个项目所需要的流程如下。生成源码；从源码中生成文档；编译源码；测试；将源码打包成
复制链接

扫一扫