Maven学习第4期---Maven简单使用

时间  2019-11-12
标签 maven 学习 简单 使用 栏目 Maven 繁體版
原文   原文链接

1、Maven经常使用命令

在学习使用Maven构建项目以前，先来了解一下Maven一些实用的命令。mvn的命令有不少，在项目开发中，理解了下面的几个经常使用命令后，运用maven就基本没有问题了。Maven经常使用的命令以下：java

1.1 经常使用的mvn命令

mvn archetype:create 建立 Maven 项目
mvn compile 编译主程序源代码，不会编译test目录的源代码。第一次运行时，会下载相关的依赖包，可能会比较费时
mvn test-compile 编译测试代码，compile以后会生成target文件夹，主程序编译在classes下面，测试程序放在test-classes下
mvn test 运行应用程序中的单元测试
mvn site 生成项目相关信息的网站
mvn clean 清除目标目录中的生成结果
mvn package 依据项目生成 jar 文件，打包以前会进行编译，测试
mvn install在本地 Repository 中安装 jar。
mvn eclipse:eclipse 生成 Eclipse 项目文件及包引用定义
mvn deploy 在整合或者发布环境下执行，将最终版本的包拷贝到远程 的repository，使得其余的开发者或者工程能够共享。web

1.2 一些高级功能命令

跳过测试类 ： -Dmaven.test.skip=true apache

下载jar包源码： -DdownloadSource=true 安全

下载javadocs： -DdownloadJavadocs=true app

例如： 框架

mvn package -Dmaven.test.skip=true ：表示打包时忽略掉test目录，不编译。
mvn install -DdownloadSource=true ：本地安装jar包时，下载jar的源文件包。 dom

2、Maven简单使用

到目前为止，咱们已经大概了解并安装好了Maven。为了进一步学习Maven，咱们和其余项目一样以一个最简单的HelloWorld项目开始，探究Maven的核心概念。经过对该项目的学习，来让咱们对构建生命周期 (Build Life Cycle)，Maven仓库 (Repositories)，依赖管理 (Dependency Management)和项目对象模型 (Project Object Model)有一个基本的理解。 eclipse

2.1 编写POM

就像Make的Makefile、Ant的build.xml同样，Maven项目的核心是pom.xml。POM(Project Object Model)，项目对象模型定义了项目的基本信息，用于描述项目如何构建，声明项目依赖，等等。如今先为HelloWorld项目编写一个最简单的pom. xml， maven

首先建立一个名为helloworld的文件夹，打开该文件夹，新建一个名为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>org.hebut.test</groupId>

    <artifactId>helloworld</artifactId>

    <version>0.0.1-SNAPSHOT</version>

    <name>Maven Hello World Project</name>

</project>

XML头

代码的第一行是XML头，指定了该xml文档的版本和编码方式。

project元素

XML头以后紧接着就是project元素，project是全部pom.xml的根元素，它还声明了一些POM相关的命名空间及xsd元素，虽然这些属性不是必须的，但使用这些属性可以让第三方工具（如IDE中的XMl编辑器）帮助咱们快速编辑POM 。

modelVersion元素

根元素下的第一个子元素modelVersion，它指定了当前POM模型的版本，对于Maven 3以及Maven 3来讲，它只能是4.0.0。

坐标

这段代码中最重要的是：包含groupId、artifactId和version的三行。这三个元素定义了一个项目基本的坐标，在Maven的世界，任何的jar、pom或者war都是以基于这些基本的坐标进行区分的。

groupId元素

groupId定义了项目属于哪一个组，这个组每每和项目所在的组织或公司存在关联。譬如在googlecode上创建了一个名为myapp的项目，那么groupId就应该是com.googlecod.myapp，若是你的公司是mycom，有一个项目为myapp。耶么groupId就应该是com.mycom.myapp。

artifactId元素

artifactId定义了当前Maven项目在组中惟一的ID，咱们为这个HelloWord项目定义artifactId为hello-world。在前面的groupld为

com.googlecode.myapp的例子中，你可能会为不一样的子项目（模块）分配artifactId，如myapp-util、myapp-domain、myapp-web等。

version元素

顾名思义，version指定了Hello World项目当前的版本0.0.1。SNAPSHOT意为快照，说明该项目还处于开发中，是不稳定的版本。随着项目的展，version会不断更新，如升级为0.0.二、0.0.三、1.0.0等。

name元素

最后一个name元素，声明了一个对于用户更为友好的项目名称，虽然这不是必须的，但仍是推荐为每一个POM声明name。以方便信息交流。

没有任何实际的Java代码，咱们就可以定义一个Maven项目的POM，这体现了Maven的一大优势，它能让项目对象模型最大程度地与实际代码相独立，咱们能够称之为解耦，或者正交性。这在很大程度上避免了Java代码和POM代码的相互影响：好比当项目须要升级版本时，只须要修改POM。而不须要更改Java代码；而在POM稳定以后，平常的Java代码开发工做基本不涉及POM的修改。

2.2 编写主代码

项目主代码和测试代码不一样，项目的主代码会被打包到最终的构件中如：jar。而测试代码只在运行测试时用到，不会被打包。默认状况下，Maven假设项目主代码位于src/main/java目录，咱们遵循Maven的约定，建立该目录，而后在该目录下建立文件org/hebut/test/helloworld/HelloWorld. java，其内容如代码以下所示：

package org.hebut.test.helloworld

public class HelloWorld{

    public String sayHello(){

        return "Hello Maven";

    }

    public static void main(String[] args){

        System.out.println(new HelloWorld());

    }

}

这是一个简单的Java类，它有一个sayHello()方法，返回一个String同时这个类还带有一个main方法，建立一个HelloWorld实例，调用sayHello()方法，并将结果输出到控制台。

关于该Java代码有两点须要注意：首先，在绝大多数状况下，应该把项目主代码放到src/main/java/目录下，而无须额外的配置，Maven会自动搜寻该目录找到项目主代码。其次，该Java类的包名是org.hebut.test.helloworld，这与以前在POM中定义的groupId和artifactld相吻合。通常来讲，项目中Java类的包都应该基于项目的groupld和anifactId。这样更加清晰，更加符合逻辑，也方便搜索构件或者Java类。

代码编写完毕后，使用Maven进行编译，在项目的根目录下运行命令mvn clean compile会获得以下输出：

执行完毕，发现项目根目录多了一个target目录：

上面使用的clean命令告诉Maven清理输出目录target/，compile告诉Maven编译项目主代码，从输出中看到Maven首先执行了clean：clean任务，删除target/目录。默认状况下，Maven构建的全部输出都在target/目录中；接着执行resources：resources任务，未定义项目资源，暂且略过；

最后执行compiler：compile任务，将项目主代码编译至target/classes目录，编译好的类为：

org/hebut/test/helloworld/HelloWorld.Class

上文提到的clean:clean、resources:resources和compiler:compile对应了一些Maven插件及插件目标，好比clean:clean是clean插件的clean目标，compiler:compile是compiler插件的compile目。

至此，Maven在没有任何额外的配置的状况下就执行了项目的清理和编译任务。接下来，编写一些单元测试代码并让Maven执行自动化测试。

2.3 编写测试代码

为了使项目结构保持清晰，主代码与测试代码应陔分别位于独立的目录中。正如上面所述，Maven项目中默认的主代码目录是src/main/java。对应地，Maven项目中默认的测试代码目录是src/test/java。所以，在编写测试用例以前，应当先建立该目录。

2.3.1 设置依赖

在Java世界中，由Kent Beck和Erich Gamma创建的JUnit是事实上的单元测试标准。要使用JUnit，首先须要为HelloWorld项目添加一个JUnit依赖，修改项目的POM代码以下：

<?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>org.hebut.test</groupId>

    <artifactId>helloworld</artifactId>

    <version>0.0.1-SNAPSHOT</version>

<name>Maven Hello World Project</name>

<dependencies>

<dependency>

<groupId>junit</groupId>

<artifactId>junit</artifactId>

<version>4.7</version>

<scope>test</scope>

</dependency>

    </dependencies>

</project>

dependencies元素

代码中添加了dependencies元素，该元素下能够包含多个dependency元素以声明项目的依赖。

dependency元素

dependency元素用以声明项目的依赖，这里添加了一个依赖groupId是junit，artifactld是junit，version是4.7。前面提到groupId、artifactId和versIon是任何一个Maven项目最基本的坐标。JUnit也不例外，有了这段声明Maven就可以自动下载junit-4.7.jar。那么，Maven从哪里下载这个jar 呢?

在使用Maven以前，能够去JUnit的官方网站下载分发包。有了Maven以后，它会自动访问中央仓库：

http://repo1.maven.org/maven2/,下载须要的文件。

固然与能够本身访问该仓库，打开路径junit/junit/4. 7/，就能看到junit-4.7.pom和junit-4.7.jar。

scope元素

上述POM代码中还有一个值为test的元素scope，scope为依赖范围，若依赖范围为test则表示该依赖只对测试有效。换句话说，测试代码中的import JUnit代码是没有问题的，可是若是在主代码中用import Junit代码，就会形成编译错误。若是不声明依赖范围，那么默认值就是compile，表示该依赖对主代码和测试代码都有效。

2.3.2 编写测试代码

配置了测试依赖，接着就能够编写测试类。回顾一下前面的HelloWorld类，如今要测试该类的sayHello()方法，检查其返同值是否为"Hello Maven"。在src/test/java目录下建立文件，其内容代码以下所示：

package org.hebut.test.helloworld;

import org.junit.Test;

import static org.junit.Assert.assertEquals;

public class HelloWorldTest{

    @Test

    public void testSayHello(){

        HelloWorld helloworld=new HelloWorld();

        String result=helloworld.sayHello();

        assertEquals("Hello Maven",result);

    }

}

一个典型的单元测试包含三个步骤：

① 准备测试类及数据；

②执行要测试的行为；

③ 检查结果。

上述样例，首先初始化了一个要测试的HelloWorld实例，接着执行该实例的sayHello()方法并保存结果到result变量中，最后使用JUnit框架的Assert类检查结果是否为咱们指望的"Hello Maven"。在JUnit 3中，约定全部须要执行测试的方法都以test开头，这里使用了JUnit 4，但仍然遵循这一约定。在JUnit 4中，须要执行的测试方法都应该以@Test进行标注。

测试用例编写完毕以后就能够调用Maven执行测试。运行mvn clean test：

咱们看到compiler: testCompile任务执行成功了，测试代码经过编译以后在target/test-classes下生成了二进制文件:

紧接着surefire：test任务运行测试，surefire是Maven中负责执行测试的插件，这里它运行测试用例HelloWorldTest，而且输出测试报告，显示一共运行了多少测试，失败了多少，出错了多少，跳过了多少二硅然，咱们的测试经过了。

2.4 打包安装

将项目进行编译、测试以后，下一个重要步骤就是打包:package。 Hello WorldPOM中没有指定打包类型，使用默认打包类型jar。简单地执行命令：

mvn clean package进行打包，能够看到以下输出：

相似地，Maven会在打包以前执行编译、测试等操做，这里看到jar: jar任务负责打包，实际上就是jar插件的jar目标将项目主代码打包成一个名为helloworld-0.0.1-SNAPSHOT.jar的文件。该文件也位于target/输出目录中，它是根据artifact-version. jar规则进行命名的，若有须要，还可使用finalName来自定义该文件的名称。

至此，咱们获得了项目的输出，若是有须要的话，就能够复制这个jar文件到其余项目的Classpath中从而使用HelloVV orld类。可是，如何才能让其余的Maven项目直接引用这个jar呢？还须要一个安装的步骤，执行mvn clean install:

在打包以后，又执行了安装任务install:install。从输出能够看到该任务将项目输出的jar安装到了Maven本地仓库中，能够打开相应的文件夹看到HelloWorld项目的pom和jar:

以前讲述，JUnit的POM及jar的下载的时候，咱们说只有构件被下载到本地仓库后，才能由全部Maven项目使用，这里是一样的道理，只有将HelloWorld的构件安装到本地仓库以后，其余Maven项目才能使用它。

咱们已经体验了Maven最主要的命令：mvn clean compile、mvn clean test、mvn clean package、mvn clean install。执行test以前是会先执行Compile的，执行package以前是会先执行test的。而相似地，install以前会执行package。能够在任何一个Maven项目中执行这些命令，并且咱们已经清楚它们是用来作什么的。

2.4 运行

到目前为止，尚未运行Hello World项目，不要忘了HelloWorld类但是有一个main方法的。默认打包生成的jar是不可以直接运行的，由于带有main方法的类信息不会添加到manifest中，即打开jar文件中的META-INF/MANIFEST. MF文件，将没法看到Main-Class一行。默认Maven生成的JAR包只包含了编译生成的.class文件和项目资源文件，而要获得一个能够直接在命令行经过java命令运行的JAR文件，还要知足两个条件

■ JAR包中的/META-INF/MANIFEST.MF元数据文件必须包含Main-Class信息。

■ 项目全部的依赖都必须在Classpath中。

Maven有好几个插件能帮助用户完成上述任务，不过用起来最方便的仍是maven-shade-plugin， 它可让用户配置Main-Class的值，而后在打包的时候将值填入/META-INF/MANIFEST.MF文件。关于项目的依赖，它很聪明地将依赖JAR文件所有解压后，再将获得的.class文件连同当前项目的.class文件一块儿合并到最终的CLI包中，这样，在执行CLI JAR文件的时候，全部须要的类就都在Classpath中了。下面是一个配置样例：

  1. <build>
  2.     <plugins>
  3.        <plugin>
  4.            <groupId>org.apache.maven.plugins</groupId>
  5.            <artifactId>maven-shade-plugin</artifactId>
  6.            <version>1.4</version>
  7.            <executions>
  8.              <execution>
  9.                <phase>package</phase>
  10.                <goals>
  11.                  <goal>shade</goal>
  12.                </goals>
  13.                <configuration>
  14.                  <transformers>
  15.                    <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
  16.                      <mainClass>org.hebut.test.helloworld.HelloWorld</mainClass>
  17.                    </transformer>
  18.                  </transformers>
  19.                </configuration>
  20.              </execution>
  21.            </executions>
  22.        </plugin>
  23.     </plugins>
  24.    </build>

plugin元素在POM中的相对位置应该在<project><build><plugins>下面。咱们配置了mainClass为org.hebut.helloworld.HelloWorld，项目在打包时会将该信息放到MANIFEST中。如今执行mvn clean install。待构建完成以后打开target/目录，能够看到helloworld-0.0.1-SNAPSHOT.jar和original-helloworld-0.0.1-SNAPSHOT.jar。前者是带有Main-Class信息的可运行jar，后者是原始的jar，打开helloworld-0.0.1-SNAPSHOT.jar的META-INF/MANIFEST. MF。能够看到它包含以下信息：

Manifest-Version: 1.0

Build-Jdk: 1.6.0_24

Built-By: hadoop

Created-By: Apache Maven 3.2.5

Main-Class: org.hebut.test.helloworld.HelloWorld

Archiver-Version: Plexus Archiver

如今，在项目根目录中执行该jar文件：

E:\Test\helloworld>java -jar target\helloworld-0.0.1-SNAPSHOT.jar

Hello Maven

控制台输出为Hello Maven，这正是咱们所指望的。

3、使用Archetype生成项目骨架

3.1 Maven 项目约定

HelloWorld项目中有一些Maven的约定：在项目的根目录中放置pom.xml，在src/main/java目录中放置项目的主代码，在src/test/java中放置项目的测试代码。咱们称这些基本的目录结构和pom. xml文件内容称为项目的骨架。Maven项目的骨架以下：

|---MavenProject

|---pom.xml

|---src

|---main              

|---java

|---test

|---java

3.2 Maven Archetype

当第一次建立项目骨架的时候，你还会饶有兴趣地去体会这些默认约定背后的思想，第二次，第三次，你也许还会满意本身的熟练程度，但第4、第五次作一样的事情，你可能就会恼火了。为此Maven提供了Archetype以帮助咱们快速勾勒出项目骨架。仍是以Hello World为例，咱们使用maven archetype来建立该项目的骨架，离开当前的Maven项目目录。

若是是Maven 3简单地运行：

mvn archetype:generate

若是是Maven 2最好运行以下命令：

mvn org.apache.maven.plugins:maven-archetype-plugin:2.0-alpha-5:generate

不少资料会让你直接使用更为简单的mvn archetype:generate命令，但在Maven 2中这是不安全的，由于该命令没有指定Archetype插件的版本，因而Maven会自动去下载最新的版本，进而可能获得不稳定的SNAPSHOT版本，致使运行失败。然而在Maven 3中，即便用户没有指定版本，Maven也只会解析最新的稳定版本，所以这是安全的。

咱们其实是在运行插件maven-archetype-plugin，注意冒号的分隔，其格式为groupld:artifactid:version:goal，org.apache.maven.plugins是maven官方插件的groupld，maven-archetype-plugin是Archetype插件的artifactId，2.0-alpha-5是日前该插件最新的稳定版，generate是要使用的插件目标。

3.3 Maven Archetype 生成HelloWorld

执行mvn archetype:generate后，紧接着会看到一段长长的输出，有不少可用的Archetype供选择，包括著名的Appfuse项目的Archetype、JPA项目的Archetype等。每个Archetype前面都会对应有一个编号，同时命令行会提示一个默认的编号，其对应的Archetype为maven-archetype-quickstart，直接回车以选择该Archetype：

，紧接着Maven会提示输入要建立项目的groupId、artifactId、version以及包名package。以下输入并确认：

Archetype插件将根据咱们提供的信息建立项目骨架。在当前目录下，Archetype插件会建立一个名为HelloWorld，即咱们定义的artifactId。从中能够看到项目的基本结构：

|---HelloWorld

|---pom.xml

|---src

     |---main

     |---java

         |---org.hebut.maven.helloworld

    |---test

     |---java

基本的pom.xml已经被建立，里面包含了必要的信息以及一个junit依赖；主代码目录src/main/java已经被建立，在该目录下还有一个Java类org.hebut.maven.helloworld.App，注意这里使用到了刚才定义的包名，而这个类也仅仅只有一个简单的输出"Hello World!"的main方法；测试代码目录src/test/java也被建立好了，而且包含了一个测试用例org.hebut.maven.helloworld.AppTest。

Archetype能够帮助咱们迅速地构建起项目的骨架，在前面的例子中，咱们彻底能够在Archetype生成的骨架的基础上开发Hello World项目以节省大量时间。此外，这里仅仅是看到了一个最简单的Archetype，若是有不少项目拥有相似的自定义项目结构以及配置文件，则彻底能够一劳永逸地开发本身的Archetype。而后在这些项目中使用自定义的Archetype来快速生成项目骨架。

4、m2eclipse简单使用

前面介绍HelloWorld项目的时候，并无涉及IDE，如此简单的一个项目，使用最简单的编辑器也能很快完成。但对于稍微大一些的项目来讲，没有IDE就是不可想象的。那么，下面将介绍一个目前比较经常使用的一款Maven IDE插件：m2eclipse。m2eclipse是Eclipse中的一款Maven插件，功能比较强大，下面将介绍一下m2eclispe的基本使用。

4.1 导入Maven项目

在上期，介绍了如何安装m2eclipse。如今，使用m2ecilpse导人HelloWorld项目：

步骤一：选择菜单项File，而后选择Import，咱们会看到一个Import对话框。在该对话框中选择Mavenl目录下的Maven Projects：

步骤二：而后单击Next按钮，就会出现Import Projects对话框：

步骤三：在该对话框中，单击Browse按钮选择HelloWorld的根目录，即包含pom. xml文件的那个目录

这时对话框中的Projects：部分就会显示该目录包含的Maven项目，如上图所示。

步骤四：单击Finish按钮以后，m2ecilpse就会将该项目导人到当前的workspace中

导人完成以后，就能够在Package Explorer视图中看上图所示的项目结构。

从上图，咱们看到主代码目录src/main/java和测试代码目录src/test/java成了Eclipse中的资源目录，包和类的结构也十分清晰。固然pom.xml永远在项目的根目录下，而从这个视图中甚至还能看到项目的依赖junit-3.8.1.jar，其实际的位置指向了Maven本地仓库。这里自定义了Maven本地仓库地址为F:\Tools\DevelopTool\MavenSource。

4.2 建立Maven项目

建立一个Maven项目也十分简单，下面简单介绍一下Maven项目建立方式。

步骤一：选择菜单项File→New→Other，在弹出的对话框中选择Maven下的Maven Project：

步骤二：而后单击Next按钮，在弹出的New Maven Project对话框中，使用默认的选项，不要选择Create a simple project选项，那样咱们就能使用Maven Arche-

type

步骤三：单击Next按钮，此时m2eclipse会提示咱们选择一个Archetype。这里选择maven-ar-chetype-quickstart

步骤四：再单击Next按钮，因为m2eclipse其实是在使用maven-archetype-plugin插件建立项目，所以这个步骤与上一节使用archetype建立项目骨架相似，输入groupld、artifactld、version、package（暂时不考虑Properties）。以下图所示：

单击Finish按钮，Maven项目就建立完成了了，其结构与前一个已导入的HelloWorld项目结构基本一致。

4.3 运行mvn命令

以前，咱们须要在命令行输入如mvn clean install之类的命令来执行maven构建，m2eclipse中也有对应的功能。在Maven项目或者pom. xml上右击，再在弹出的快捷菜单中选择Run As，就能看到常见的Maven命令，以下图所示：

选择想要执行的Maven命令就能执行相应的构建，同时也能在Eclipse的console中看到构建输出。这里常见的一个问题是，默认选项中没有咱们想要执行的Maven命令怎么办？好比，默认带有mvn test，但咱们想执行mvn clean test。很简单，选择Maven build以自定义Maven运行命令，在弹出话框的Goals一项中输入咱们想要执行的命令，如clean test，设置一下Name，单击Run便可。而且，下一次咱们选择Maven build或者使用快捷键"Alt+Shift+X，M"快速执行Maven构建的时候，上次的配置直接就能在历史记录中找到。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程