zoukankan      html  css  js  c++  java

  • Maven 环境搭建及使用（win10）

    最近由于公司项目需要，学习了一下Maven 环境的配置。这里把配置步骤和简单的操作做一个汇总。

    一、Maven环境的搭建

    1、配置java环境（这里不详述过程，可参考：http://www.cnblogs.com/Belieflee/p/4778315.html）

         java 环境配置好后，在命令行中输入java -version ,配置成功如下图所示：

           

    2、下载Maven安装包

         下载地址：http://maven.apache.org/download.cgi

    3、Maven安装配置

         a、安装Maven

         将下载好的Maven安装包解压。解压的路径为E:javaapache-maven-3.5.0

         b、配置环境变量

         右键计算机-属性-高级系统设置-系统环境变量

         新建 MAVEN_HOME : E:javaapache-maven-3.5.0，在PATH后添加 %MAVEN_HOME%in。

         还有一个可选的环境变量MAVEN_OPTS，该环境变量主要是配置Maven在使用jdk的时候指定JVM属性的。如指定其值为“-Xms256m -Xmx512m”

        

        在命令窗口使用mvn -v来验证一下Maven是否安装成功在命令窗口使用mvn -v来验证一下Maven是否安装成功

       

    4、首次运行完mvn -version后，会在用户目录下创建一个.m2的目录(比如：C:Users当前用户名.m2)，这个目录是maven的“本地仓库”，仓库是maven中一个很重要的概念。

    试想一下，我们会在工作中同时创建很多项目，每个项目可能都会引用一些公用的jar包(.NET中是dll文件)，一种作法是每个项目里，都复制一份这些依赖的jar包(或dll文件)，这样显然不好，相同的文件在硬盘上保存了多份，太占用空间，而且这些依赖的jar包(或dll文件)的版本也不太好管理(比如某个公用的jar包，从1.0升级到2.0，如果所有引用这个jar包的项目都需要更新，必须一个个项目的修改)。

      maven的仓库则很好的解决了这些问题，它在每台机器上创建一个本机仓库，把本机上所有maven项目依赖的jar包统一管理起来，而且这些jar包用“坐标”来唯一标识(注：坐标是另一个重要的概念，后面还会讲到，这里只要简单理解成“唯一识别某个jar包文件名、版本号”的标识即可)，这样所有maven项目就不需要再象以前那样把jar包复制到lib目录中，整个maven项目看起来十分清爽。

    5、配置Maven环境

    在Maven中提供了一个settings.xml文件来定义Maven的全局环境信息。这个文件会存在于Maven的安装目录的conf子目录下面，或者是用户家目录的.m2子目录下面。我们可以通过这个文件来定义本地仓库、远程仓库和联网使用的代理信息等。

      其实相对于多用户的PC机而言，在Maven安装目录的conf子目录下面的settings.xml才是真正的全局的配置。而用户家目录的.m2子目录下面的settings.xml的配置只是针对当前用户的。当这两个文件同时存在的时候，那么对于相同的配置信息用户家目录下面的settings.xml中定义的会覆盖Maven安装目录下面的settings.xml中的定义。用户家目录下的settings.xml文件一般是不存在的，但是Maven允许我们在这里定义我们自己的settings.xml，如果需要在这里定义我们自己的settings.xml的时候就可以把Maven安装目录下面的settings.xml文件拷贝到用户家目录的.m2目录下，然后改成自己想要的样子。

      先来看一个基本的settings.xml的样子：

     
    1. <?xml version="1.0" encoding="UTF-8"?>  
    2. <settings xmlns="http://maven.apache.org/SETTINGS/1.0.0"  
    3.           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
    4.           xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0 http://maven.apache.org/xsd/settings-1.0.0.xsd">  
    5. <localRepository>/path/to/local/repo</localRepository>  
    6. <interactiveMode>true</interactiveMode>  
    7. <offline>false</offline>  
    8.   <pluginGroups>  
    9.   </pluginGroups>  
    10.   <proxies>  
    11.     <proxy>  
    12.       <id>optional</id>  
    13.       <active>true</active>  
    14.       <protocol>http</protocol>  
    15.       <username>proxyuser</username>  
    16.       <password>proxypass</password>  
    17.       <host>proxy.host.net</host>  
    18.       <port>80</port>  
    19.       <nonProxyHosts>local.net|some.host.com</nonProxyHosts>  
    20.     </proxy>  
    21.   </proxies>  
    22.   <servers>  
    23.     <server>  
    24.       <id>deploymentRepo</id>  
    25.       <username>repouser</username>  
    26.       <password>repopwd</password>  
    27.     </server>  
    28.   </server>  
    29.   <mirrors>  
    30.     <mirror>  
    31.       <id>mirrorId</id>  
    32.       <mirrorOf>repositoryId</mirrorOf>  
    33.       <name>Human Readable Name for this Mirror.</name>  
    34.       <url>http://my.repository.com/repo/path</url>  
    35.     </mirror>  
    36.   </mirrors>  
    37.   <profiles>  
    38.     <profile>  
    39.       <id>jdk-1.4</id>  
    40.       <activation>  
    41.         <jdk>1.4</jdk>  
    42.       </activation>  
    43.       <repositories>  
    44.         <repository>  
    45.           <id>jdk14</id>  
    46.           <name>Repository for JDK 1.4 builds</name>  
    47.           <url>http://www.myhost.com/maven/jdk14</url>  
    48.           <layout>default</layout>  
    49.           <snapshotPolicy>always</snapshotPolicy>  
    50.         </repository>  
    51.       </repositories>  
    52. </profile>  
    53.   </profiles>  
    54.   <activeProfiles>  
    55.     <activeProfile>alwaysActiveProfile</activeProfile>  
    56.     <activeProfile>anotherAlwaysActiveProfile</activeProfile>  
    57.   </activeProfiles>  
    58. </settings>   

    settings.xml中主要包括以下元素：

    localRepository：表示Maven用来在本地储存信息的本地仓库的目录。默认是用户家目录下面的.m2/repository目录。

    1. <localRepository>/path/to/local/repo</localRepository>  

    interactiveMode：表示是否使用交互模式，默认是true；如果设为false，那么当Maven需要用户进行输入的时候，它会使用一个默认值。

    1. <interactiveMode>true</interactiveMode>  

    offline：表示是否离线，默认是false。这个属性表示在Maven进行项目编译和部署等操作时是否允许Maven进行联网来下载所需要的信息。

     
    1. <offline>false</offline>  

    pluginGroups：在pluginGroups元素下面可以定义一系列的pluginGroup元素。表示当通过plugin的前缀来解析plugin的时候到哪里寻找。pluginGroup元素指定的是plugin的groupId。默认情况下，Maven会自动把org.apache.maven.plugins和org.codehaus.mojo添加到pluginGroups下。

     
    1. <pluginGroups> </pluginGroups>  

    proxies：其下面可以定义一系列的proxy子元素，表示Maven在进行联网时需要使用到的代理。当设置了多个代理的时候第一个标记active为true的代理将会被使用。

     
    1. <proxies>  
    2.     <proxy>  
    3.       <id>optional</id>  
    4.       <active>true</active>  
    5.       <protocol>http</protocol>  
    6.       <username>proxyuser</username>  
    7.       <password>proxypass</password>  
    8.       <host>proxy.host.net</host>  
    9.       <port>80</port>  
    10.       <nonProxyHosts>local.net|some.host.com</nonProxyHosts>  
    11.     </proxy>  
    12.   </proxies>  

    servers：其下面可以定义一系列的server子元素，表示当需要连接到一个远程服务器的时候需要使用到的验证方式。这主要有username/password和privateKey/passphrase这两种方式。

     
    1.  <servers>  
    2.   <server>  
    3.     <id>deploymentRepo</id>  
    4.     <username>repouser</username>  
    5.     <password>repopwd</password>  
    6.   </server>  
    7. </server>  

    mirrors：用于定义一系列的远程仓库的镜像。我们可以在pom中定义一个下载工件的时候所使用的远程仓库。但是有时候这个远程仓库会比较忙，所以这个时候人们就想着给它创建镜像以缓解远程仓库的压力，也就是说会把对远程仓库的请求转换到对其镜像地址的请求。每个远程仓库都会有一个id，这样我们就可以创建自己的mirror来关联到该仓库，那么以后需要从远程仓库下载工件的时候Maven就可以从我们定义好的mirror站点来下载，这可以很好的缓解我们远程仓库的压力。在我们定义的mirror中每个远程仓库都只能有一个mirror与它关联，也就是说你不能同时配置多个mirror的mirrorOf指向同一个repositoryId。

    1. <mirrors>  
    2.   <mirror>  
    3.     <id>mirrorId</id>  
    4.     <mirrorOf>repositoryId</mirrorOf>  
    5.     <name>Human Readable Name for this Mirror.</name>  
    6.     <url>http://my.repository.com/repo/path</url>  
    7.   </mirror>  
    8. </mirrors>  

    l  id：是用来区别mirror的，所有的mirror不能有相同的id

    l  mirrorOf：用来表示该mirror是关联的哪一个仓库，其值为其关联仓库的id。当要同时关联多个仓库时，这多个仓库之间可以用逗号隔开；当要关联所有的仓库时，可以使用“*”表示；当要关联除某一个仓库以外的其他所有仓库时，可以表示为“*,!repositoryId”；当要关联不是localhost或用file请求的仓库时，可以表示为“external:*”。

    l  url：表示该镜像的url。当Maven在建立系统的时候就会使用这个url来连接到我们的远程仓库。

    profiles：用于指定一系列的profile。profile元素由activation、repositories、pluginRepositories和properties四个元素组成。当一个profile在settings.xml中是处于活动状态并且在pom.xml中定义了一个相同id的profile时，settings.xml中的profile会覆盖pom.xml中的profile。

     
    1. <profiles>  
    2.   <profile>  
    3.     <id>jdk-1.4</id>  
    4.     <activation>  
    5.       <jdk>1.4</jdk>  
    6.     </activation>  
    7.     <repositories>  
    8.       <repository>  
    9.         <id>jdk14</id>  
    10.         <name>Repository for JDK 1.4 builds</name>  
    11.         <url>http://www.myhost.com/maven/jdk14</url>  
    12.         <layout>default</layout>  
    13.         <snapshotPolicy>always</snapshotPolicy>  
    14.       </repository>  
    15.     </repositories>  
    16. t;/profile>  
    17. </profiles>  

    activation：这是profile中最重要的元素。跟pom.xml中的profile一样，settings.xml中的profile也可以在特定环境下改变一些值，而这些环境是通过activation元素来指定的。

    在上面这段代码中，当所有的约束条件都满足的时候就会激活这个profile。

    jdk：表示当jdk的版本满足条件的时候激活，在这里是1.4。这里的版本还可以用一个范围来表示，如

    <jdk>[1.4,1.7]</jdk>表示1.4、1.5、1.6和1.7满足；

    activeProfiles：底包含一系列的activeProfile元素，表示对于所有的pom都处于活跃状态的profile。

      1. <activeProfiles>  
      2.   <activeProfile>alwaysActiveProfile</activeProfile>  
      3.   <activeProfile>anotherAlwaysActiveProfile</activeProfile>  
      4. </activeProfiles>  

    二、Maven使用入门

    到目前为止，已经大概安装好了Maven，现在开始创建一个最简单的Hello World项目。

    1.创建项目

    在命令行输入：

    mvn archetype:generate -DgroupId=com.mycompany.app -DartifactId=my-app -Dversion=1.0

    回车，如图：

    执行Maven命令（goal）archetype:generate，并且设置了一些参数

    ( -DgroupId=com.mycompany.app -DartifactId=my-app -Dversion=1.0) 
    【mvn archetype:generate 创建maven项目；

    -DgroupId=com.mycompany.app组ID；

    -DartifactId=my-app项目名称

    -Dversion=1.0版本】 

    如果你是首次运行该命令(goal)，maven将要花一些时间从maven库去把最新的工具包(Maven把它叫作artifacts)下载到你的本地仓库(local repository)中，所以这个时候需要Internet连接。Maven默认的本地库是%USER_HOME%.m2 epository，比如我的本地库路径为：C:Userfulei.m2 epository。

    命令执行完后你将看到maven生成了一个名为my-app的目录，这个名字就是你在命令中指定的artifactId，进入该目录，你将发现以下标准的项目结构：

    其中:src/main/java 目录包含了项目的源代码，src/test/java 目录包含了项目的测试代码，pom.xml是项目的项目对象模型（Project Object Model or POM）。

     

    2.POM代码介绍

    就像Make的Makefile、Ant的build.xml一样，Maven项目的核心是pom.xml。POM（Project Object Model，项目对象模型）定义了项目的基本信息，用于描述项目如何构建，声明项目依赖等。下面列出这个POM的内容：

     
    1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
    2.   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">  
    3.   <modelVersion>4.0.0</modelVersion>  
    4.   
    5.   <groupId>com.mycompany.app</groupId>  
    6.   <artifactId>my-app</artifactId>  
    7.   <version>1.0</version>  
    8.   <packaging>jar</packaging>  
    9.   
    10.   <name>my-app</name>  
    11.   <url>http://maven.apache.org</url>  
    12.   
    13.   <properties>  
    14.     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>  
    15.   </properties>  
    16.   
    17.   <dependencies>  
    18.     <dependency>  
    19.       <groupId>junit</groupId>  
    20.       <artifactId>junit</artifactId>  
    21.       <version>3.8.1</version>  
    22.       <scope>test</scope>  
    23.     </dependency>  
    24.   </dependencies>  
    25. </project>  

    代码第一行是XML头，指定了该xml文档的版本和编码方式。紧接着是project元素，project是所有pom.xml的根元素，它还声明了一些POM相关的命名空间及xsd元素，虽然这些属性不是必须的，但是用这些属性能够让第三方工具能够快速编辑POM。

    根元素的第一个元素modelVersion指定了当前POM模型的版本，对于Maven2及Maven3来说，它只能是4.0.0。

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

    groupID定义了项目属于哪个组，这个组往往和项目所在的组织或公司存在关联。比如在googlecode上建立了一个myapp的项目，那么groupID就是com.googlecode.myapp。

    · 简而言之：

    · modelVersion： 这个XML文件所使用的POM格式的版本

    · groupId： 相当于这个project的所有者或者机构的一个标识，一般是com.company.xxx这种格式

    · artifactId： 这个project最后所生成的文档(jar、war)的名字，比如对于junit这个开源的project，它的artifactId就是junit

    · packaging： 这个project的打包的类型，一般是war、jar等值

    · version： project的版本

    · name： project的名字，生成文档等内容的时候会用的这个名字

     

    3.主代码

    项目主代码和测试代码不同，项目的主代码会被打包到最终的构件中（如jar），而测试代码只在运行测试时用到，不会被打包。默认情况下，Maven项目主代码位于src/main/java目录，所以在该目录下创建文件com/mycompany/app/App.java，其代码内容如下：

     
    1. package com.mycompany.app;  
    2. /** 
    3.  * Hello world! 
    4.  */  
    5. public class App   
    6. {  
    7.     public static void main( String[] args )  
    8.     {  
    9.         System.out.println( "Hello World!" );  
    10.     }  
    11. }  

    关于Java代码有两点需要注意。首先，在绝大多数情况下，应该把项目主代码放到src/main/java目录下（遵循Maven的约定），而无须额外的配置，Maven会自动搜寻该目录找到项目主代码，其次，该Java类的包命是com.mycompany.app

    这与POM中定义的groupID和artifactID相吻合，项目中Java类的包都应该基于项目的groupID和artifactID，这样更加清晰，更加符合逻辑，也可以方便搜索构件或Java类。

     

    4.编译 

    使用Maven进行编译，在项目根目录下运行命令mvn clean compile，会得到如下输出：

    clean告诉Maven清理输出目录target/,compile告诉Maven编译项目主代码，从输出中看到Maven实现执行了clean:clean任务，删除target/目录。默认情况下，Maven构建的所有输出都在target/目录中；接着执行resources：resources任务（未定义项目资源，暂时略过）；之后执行compile：compile任务，将项目主代码编译至target/classes目录（编译好的类为com/mycompany/app/App.class）

     

    5.测试 

    主代码与测试代码分别位于独立的目录中，Maven项目中的默认的测试代码了目录为src/test/java。

    在Java世界中，JUnit是事实上的单元测试标准，要使用JUnit，要为项目添加JUnit依赖，项目POM代码中：

     
    1. <dependencies>  
    2.   <dependency>  
    3.     <groupId>junit</groupId>  
    4.     <artifactId>junit</artifactId>  
    5.     <version>3.8.1</version>  
    6.     <scope>test</scope>  
    7.   </dependency>  
    8. </dependencies>  

    代码中有dependencies元素，该元素下可以包含多个dependency元素以声明项目的依赖，这里添加了一个依赖--groupID是junit,artifactID是junit,version是3.8.1,有了这段声明，Maven就能够自动下载junit-3.8.1.jar。有了Maven，它会自动访问中央仓库，下载需要的文件。也可以自己访问该仓库，打卡路径junit/junit/3.8.1/,就能看到junit-3.8.1pom和junit-3.8.1.jar。

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

    打开测试用例代码，在src/test/java目录下的AppTest.java,代码如下：

     
    1. package com.mycompany.app;  
    2. import junit.framework.Test;  
    3. import junit.framework.TestCase;  
    4. import junit.framework.TestSuite;  
    5. /** 
    6.  * Unit test for simple App. 
    7.  */  
    8. public class AppTest   
    9.     extends TestCase  
    10. {  
    11.     /** 
    12.      * Create the test case 
    13.      * 
    14.      * @param testName name of the test case 
    15.      */  
    16.     public AppTest( String testName )  
    17.     {  
    18.         super( testName );  
    19.     }  
    20.     /** 
    21.      * @return the suite of tests being tested 
    22.      */  
    23.     public static Test suite()  
    24.     {  
    25.         return new TestSuite( AppTest.class );  
    26.     }  
    27.     /** 
    28.       Rigourous Test :-) 
    29.      */  
    30.     public void testApp()  
    31.     {  
    32.         assertTrue( true );  
    33.     }  
    34. }  

    调用Maven执行测试，运行mvn clean test,如图：

     

    测试代码通过编译后在target/test-classes下生成了二进制文件，紧接着surefire:test任务运行测试，surefire是Maven中负责执行测试的插件，这里它运行测试用例AppTest，并输出测试报告，显示一共运行了多少测试，失败了多少，出错了多少，跳过了多少。显然，测试通过了。

     

    6.打包

    在命令行上输入：cd my-app回车，进入到项目路径下，再输入mvn package回车这时命令行将会打印出各种动作，并且以下面一段信息结束，如图：

    此时，maven在my-app下面建立了一个新的目录target/，构建打包后的jar文件my-app-1.0.jar就存放在这个目录下。编译后的class文件放在target/classes/目录下面，测试class文件放在target/test-classes/目录下面。

    7.运行

    执行下面的命令：

    java -cp target/my-app-1.0.jar com.mycompany.app.App，结果如图：


    至此，我们得到了项目的输出。

     

    8.安装JAR包

    如果需要的话，可以复制这个jar文件到其他项目的Classpath中从而使用my-app类。还需要一个安装的步骤，执行mvn clean install:

    在打包之后，有执行了安装任务install:install。从输出可以看到该任务将项目输出的jar安装到了Maven本地仓库中，可以打开相应的文件夹看到my-app项目的pom和jar。我们说只有将构件下载到本地仓库中，才能由所有Maven项目使用。

    到这里就说完了创建，编译，测试，打包以及安装，大部分的项目也就是做这些事情。

    Maven最主要的命令：mvn clean compile、mvn clean test、mvn clean package、mvn clean install。

     

    Maven有一套build的生命周期，是按照一套顺序走下来的，这一套顺序就叫一个生命周期(lifecycle)。一个生命周期分为多个阶段(build phase)，每一个build phase是由目标(goal)组成的，一个goal其实就是一个任务，目标可以绑定到生命周期阶段上。一个生命周期阶段可以绑定多个插件目标。当maven在构建过程中逐步的通过每个阶段时，会执行该阶段所有的插件目标。比如执行打包命令：

    mvn package时，会先执行compile，再执行test，最后才是package打包。

     

    参考：http://blog.csdn.net/xuexiaoxu1990/article/details/52882664
  • 相关阅读:
    浙大数据结构课后习题 练习二 7-2 Reversing Linked List (25 分)
    浙大数据结构课后习题 练习二 7-2 一元多项式的乘法与加法运算 (20 分)
    浙大数据结构课后习题 练习一 7-1 Maximum Subsequence Sum (25 分)
    浙大数据结构课后习题 练习一 7-1 最大子列和问题 (20 分)
    PAT Basic 1019 数字黑洞 (20 分)
    PAT Basic 1017 A除以B (20 分)
    PAT Basic 1013 数素数 (20 分)
    PAT Basic 1007 素数对猜想 (20 分)
    PAT Basic 1003 我要通过！ (20 分)
    自动化运维——HelloWorld（一）
  • 原文地址：https://www.cnblogs.com/yaohuimo/p/6831062.html
Copyright © 2011-2022 走看看