常用构建命令

常用命令

         mvn –v

         compile

         test

          package

          clean 删除Maven生成的项目目标文件target

          install ：安装jar包到本地仓库中

创建目录的两种方式：

1.      archetype:generate按照提示进行选择

2.      archetype:generate–DgroupId=组织名.公司网址的反写.项目名

                                     -DartifactId=项目名-模块名

                                     -Dversion=版本号

                                     -Dpackage=代码所在的包名

install详解

         当Maven包下管理多个项目的时候，一个项目maven02中使用到了另外一个项目maven01当中的类，需要import引入该包的地址

                                                                          import com.terence.maven01.model.HelloWorld;

         但是测试的时候仍然编译不通过，这是因为，两个项目之间没有什么关系，此时需要将包含maven01中的那个类的jar包引入过来才可以编译成功，此时需要进入maven01目录下，使用install命令，将包含这个类的项目jar包发布到本地仓库中，方便其他项目使用。

        此时，项目mavne02仍旧不能编译成功，还需要在配置文件中引入依赖的jar包，即maven01项目的坐标。

对Maven02项目的配置文件pom.xml添加依赖如下：

#####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.terence.maven02</groupId>
  <artifactId>maven02-model</artifactId>
 <version>0.0.1-SNAPSHOT</version>
 
 <dependencies>
    <dependency>
       <groupId>junit</groupId>
       <artifactId>junit</artifactId>
       <version>4.10</version>
    </dependency>
    <dependency>
        <groupId>com.terence.maven01</groupId>
        <artifactId>maven01-model</artifactId>
         <version>0.0.1-SNAPSHOT</version>
    </dependency>
  </dependencies>
</project>

         此时如果需要用到配置文件的jar包，maven会自动根据配置文件将对应的jar包添加到ClassPath当中，项目便可以通过路径变量到本地仓库中寻找对应的jar包，如果这个jar包不存在，会从网络上下载对应的jar包到中央仓库中。

         到这个地方，Maven项目管理的优势已经体现了出来，项目编译运行会根据项目配置文件pom.xml的描述内容通过变量路径到本地仓库寻找对应的依赖jar包，如果这个包不存在，会自动到网路上下载相应的包，不会像手动添加jar包一样添加了一些不必要的jar包而且还要手动添加到ClassPath路径当中。

 

archetype详解（自动创建目录）

Archetype插件的引入，用于创建复合Maven规定的目录骨架，提高开发效率。

》在MavenCode目录下创建一个文件夹maven03

》Dos界面进入maven03目录

》创建项目目录结构，输入命令：mvn archetype:generate，此时，如果是第一次自动创建目录，则需要从网络上下载一些依赖文件，时间会久一点，等待一下就好。

直到出现以上界面，遇到上述第三行906提示直接回车，第一个红线处提示让选择快速创建的archetype插件版本，输入:6，即上图第一个红线的位置，然后输入项目的坐标groupId、artifactId、version等信息，最后输入package包名，回车即可，出现下图的配置确认、配置成功等信息。

另一种快速创建Maven目录的方式就是一次性闯将命令

mvn archetype:generate-DgroupId=com.imooc.maven04     -DartifactId=maven04-demo    -Dversion=1.0.0-SNAPSHOT -Dpackage=com.imooc.maven04-demo

然后一步到位的自动执行，过程中直接回车、输入版本号6、输入y，最后闯将成功。

 

核心概念

坐标

插件、依赖都是构件，要找到一个构件，就需要一个准确的坐标，而Maven项目的坐标则是：（groupId、artifactId、version）

           groupId=com.imooc.maven04      组织名.公司网址的反写.项目名

           artifactId=maven04-demo    项目名-模块名

           version=1.0.0-SNAPSHOT  版本号

所有这些构件都存在于仓库当中。

仓库

      仓库分为两种：本地仓库和远程仓库，如果本地仓库找不到这个构件就会到远程仓库中寻找，将找到的构建下载到本地仓库，如果远程仓库也找不到，就会报错。

     Maven提供的一个默认的仓库地址：

    在本机Maven解压包：C:\Program Files\Apache SoftwareFoundation\apache-maven-3.1.1\lib

    寻找到maven-model-builder-3.3.1.jar

    对其解压，找到maven-model-builder-3.1.1.jar\org\apache\maven\model下的pom.4.0.0.xml，它提供了比价全的依赖。

###pom.4.0.0.xml文件

<project>
  <modelVersion>4.0.0</modelVersion>
 
  <repositories>
    <repository>
      <id>central</id>
      <name>Central Repository</name>
      <url>http://repo.maven.apache.org/maven2</url>
      <layout>default</layout>
      <snapshots>
        <enabled>false</enabled>
      </snapshots>
    </repository>
  </repositories>
……

上述<url>元素内容http://repo.maven.apache.org/maven2是中央仓库的地址（可以输入浏览器查看中央仓库内容资源），远程中央仓库包含了java开发将近全部的依赖文件、框架资源等信息；<enabled>元素是false,表示禁止下载快照版本；

 

镜像仓库

镜像仓库是国内的仓库，使用该仓库更快更稳定，访问陈功率更高。

在maven解压包C:\Program Files\Apache SoftwareFoundation\apache-maven-3.1.1\conf 找到setting.xml文件，在该文件的镜像描述中，有这样一段：

<mirrors>

    <!-- mirror

     | Specifies a repository mirrorsite to use instead of a given repository. The repository that

     | this mirror serves has an IDthat matches the mirrorOf element of this mirror. IDs are used

     | for inheritance and directlookup purposes, and must be unique across the set of mirrors.

     | -->

    <mirror>

      <id>maven.net.cn</id>        <!—国内镜像仓库标识-->

      <mirrorOf>central</mirrorOf> <!—中央仓库映射-->

      <name>central mirror in china</name><!—国内仓库名-->

      <url>http://maven.net.cn/content/groups/pulibc</url>

                                  <!—国内镜像仓库url地址-->

    </mirror>

  </mirrors>

上述<mirror>元素中的内容是特意设置的，亦可不设置，如果不设置，则使用默认设置。

更改仓库位置

       通常本地仓库存放位置都是在用户目录下的.m文件夹下的repository文件中，此时在setting.xml文件中的设置不需要更改，则默认在此仓库。

如果需要更改仓库地址，在需要在setting.xml文件中更改<localRepository>元素的仓库路径。

例如：如果需要将其存在工作空间中的repo文件夹下，此时在<localRepository>标签中设置如下：

                                                <localRepository>C:\Users\Terence\workspace\repo<localRepository>

然后将setting.xml放在该目录下。

 

Eclipse与maven

Eclipse中安装maven插件

            如果Eclipse版本是4.0以上，或者安装了MyEclipse，都不需要集成Maven插件；否则，都需要向Eclipse中集成maven插件，以便使用Eclipse自动创建Maven项目。

插件安装

将M2E插件，放在Eclipse中的F:\JAVA\Hibernate\eclipse\dropins目录下；或者---

在Eclipse-->Help->Install New Software-->Add：

             Name:Maven

             Location: http://m2eclipse.sonatype.org/sites/m2e

然后点击OK，运行加载插件。

修改配置文件

1.在F:\JAVA\Hibernate\eclipse目录下修改Eclipse.ini文件，添加以下的粗体部分

……
  Org.eclipse.platform
  --launcher.XXMacpermSize
  512m
  -vm
  C:\ProgramFiles\Java\jdk1.7.0_80\bin\javaw.exe
  --launcher.defaultAction
  openFile
……

2.修改Eclipse JREs

Eclipse是运行在JRE之上的，而Maven是用到JDK的，所以要修改一下Eclipse的JREs，方便Maven找到JDK。

Windows-->performances-->Java-->InstalledJREs-->选择JDK的目录添加JDK1.7.0_80 ，添加即可。

更改Maven 默认配置

在继承Maven的eclipse中，windows--->prefrences---->Maven--->Installation--->查看插件安装情况，如果没有，则将新下载的maven文件add进去；

最后在user Setings中确保配置文件的路径是之前配置了mirror的配置文件setting.xml路径：C:\Users\Terence\.m2\repository

然后点击apply->OK，就可以了。

接下来开始利用Maven插件创建项目了。

Eclipser中自动创建Maven项目

项目创建

》Eclipse-->New-->Project-->Maven Project-->

   按照上述步骤选择建立web项目

 添加坐标：

 

 

项目编译、测试、打包

   此时打开项目testWeb，看到pom.xml项目管理描述文件，右击pom.xml--》Run As---》Maven Build……，在Goal方框中填入编译命令：compile

   控制台如果编译成功，则继续测试，如果报错，则需要设置一个参数：

   步骤：重新进入Windows--performances---Java---Installed JREs，点击添加的jdk1.7.0_80---Edit，在Default VM Arguments后面添加参数：-Dmavn.multiModuleProjectDirectory=$M2_HOME,即添加Maven目录。

   随后再按照上述步骤重新编译：compile

   按照上述步骤测试，在Goal方框中填入编译命令：test

   按照上述步骤打包，在Goal方框中填入编译命令：package

 

Maven生命周期和插件

     Maven强大的一个重要的原因是它有一个十分完善的生命周期模型(lifecycle)，这个生命周期可以从两方面来理解。

    第一，顾名思义，运行Maven的每个步骤都由它来定义的，这种预定义的默认行为使得我们使用Maven变得简单，相比而言，Ant的每个步骤都要你手工去定义。

    第二，这个模型是一种标准，在不同的项目中，使用Maven的接口是一样的，这样就不用去仔细理解每个项目的构建了，一般情况下，mvn clean install 这样的命令是通用的。我想，一定是吸收了许多项目的经验，Maven才能定义出如此完善的模型  。   

    前面已经学过几个常用命令：clean/compile/test/package/install，同时这也是一个项目的完整构建过程。

生命周期

  严格来说一个项目的生命周期：清理、编译、测试、打包、集成测试、验证、部署;（clean/compile/test/package/install）

Maven项目可以划分为三个生命周期，对应三个阶段(clean/package/install)，后面一个阶段依赖于前面一个阶段。

            阶段一：clean  清理项目

            阶段二：default 构建项目

            阶段三：site 生成项目站点

根据上述三个阶段，可以知道少了compile和test这两个过程，但是实际当中，在package的同时，已经执行了compile和test。

        特别强调：Maven的三个生命周期是相互独立的，你可以仅仅调用clean来清理工作目录，仅仅调用site来生成站点。当然你也可以直接运行 mvn clean install site 运行所有这三套生命周期。

阶段细化

Clean: 清理项目

           (pre-clean 执行清理前的工作)

           (clean 清理上一次构建生成的文件)

           (post-clean 执行清理后的文件)

default 构建项目（核心）

           (compile/test/package/install)

 

site 生成项目站点

           (pre-site 在生成项目站点前要完成的工作)

           (site 生成项目的站点文档)

           (post-site 在生成项目站点后要完成的工作)

           (site-deploy 发布生成的站点到服务器上)

 

引入插件

 

配置文件

Eclipse只支持JDK，其他的所有功能都是通过第三方插件来实现的。

举个栗子

使用sources插件来打包源码。

在maven项目中的项目管理文件pom.xml文件修改配置：

……
<build>
    <finalName>testWeb</finalName>
    <plugins>
      <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-source-plugin</artifactId>
         <version>2.4</version>
         <executions>
            <execution>
               <phase>package</phase>
               <goals>
                  <goal>jar-no-fork</goal>
               </goals>
            </execution>
         </executions>
      </plugin>
    </plugins>
  </build>
……

解释：首先配置source插件的坐标（groupId、artifactId、version)；然后将该插件的源码打包功能绑定在<phase>package</phase>项目的package下一同执行。

执行

Pom.xml---》run As--->Maven build……--->Goal：clean package

此时执行的两个命clean和Package，根据控制台可以知道：

Clean:在执行前清理以前的执行文件

Package:执行这一步之前就已经执行了compil/test，最后执行了package打包为jar包。

由此可知，后面每一个阶段的执行都依赖于前一个阶段，前面的阶段都会自动执行。

 

pom.xml元素介绍

          项目管理文件，用于项目描述、组织管理、依赖管理和构建信息的管理。

          下面介绍一些项目中pom.xml文件常用到的元素。

pom.xml基本元素

链接：http://blog.csdn.net/csdn_terence/article/details/53811318

参考链接：http://blog.csdn.net/jiangyu1013/article/details/52424726

<!--project：pom的根元素；约束信息 -->

<projectxmlns="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.0http://maven.apache.org/maven-v4_0_0.xsd">

 

   <!-- modelVersion制定了当前pom的版本，是必不可少的 -->

  <modelVersion>4.0.0</modelVersion>

     

      <!-- 项目坐标（groupId、artifactId、version）：定义当前pom文件是属于哪个maven项目

         maven项目是一种模块化的概念，里面将项目划分为模块。

         groupId=反写公司网址.项目名

         artifactId=项目名-模块名

         version=0.0.1SNAPSHOP

         (第一个0表示大本版号，第二个0表示分支版本号，第三个0表示小版本号)

         （版本除了snapshop快照版本之外，还有alpha--α内测版本、beta--β公测版本、Release稳定版本、GA发布版本）

       -->

      <groupId>com.my.mavenweb</groupId>

      <artifactId>testWeb</artifactId>

      <version>0.0.1-SNAPSHOT</version>

     

      <!-- packaging:指定了项目的打包方式，如果内容为空，默认指定打包为Jar包，此外，还要war、zip、pom等类型-->

      <packaging></packaging>

     

      <!-- name:指定了项目的描述名，一般在产生对象文档的时候才会使用 -->

      <name>testWebMaven Webapp</name>

      <!--URl:指定了项目的Url -->

      <url>http://maven.apache.org</url>

      <!-- description：项目描述信息

      developers:开发人员信息

      licenses：开源框架的许可证信息

      organization：组织信息     

      -->

      <descriprion></descriprion>

      <developers></developers>

      <licenses></licenses>

      <organization></organization>

     

   <properties> 

        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> 

        <springversion>3.1.1.RELEASE</springversion> 

        <junitversion>3.8.1</junitversion> 

    </properties> 

 <!--

 dependencies:依赖信息列表

 dependency:依赖项

 groupId、artifactId、version:依赖项的位置坐标，方便查找依赖。

 type:依赖项的类型，jar/war/zip/pom等类型

 scope:依赖范围，是指当前依赖项在哪个范围内有效。

 potional:依赖是否可选，默认为false,则项目可以继承该依赖；如果为true，则子项目必须显式引入该依赖

 exclusions：排除依赖的传递列表

 exclusion：排除依赖，例如排除传递依赖中自己不需要的依赖项

  -->

    <dependencies>     

        <dependency> 

            <groupId>junit</groupId> 

            <artifactId>junit</artifactId> 

            <version>${ junitversion}</version>

            <type></type>

            <scope>test</scope> 

        </dependency> 

        <dependency> 

            <groupId>org.springframework</groupId> 

            <artifactId>spring-aop</artifactId> 

            <version>${ springversion}</version> 

            <type>jar</type> 

            <scope>compile</scope> 

        </dependency> 

        <dependency> 

            <groupId>commons-logging</groupId> 

            <artifactId>commons-logging</artifactId> 

            <version>1.1</version> 

        </dependency> 

    </dependencies>

<!--

 dependencyManagement:依赖管理，主要是针对父模块列出依赖项进行管理，使得下面需要某个父模块的模块直接继承该依赖，

   不用进行传递依赖这么麻烦，但是该标签不会引入到执行当中，只起到一个说明作用。

-->

    <dependencyManagement>

      <dependencies>

         <dependency></dependency>

      </dependencies>   

    </dependencyManagement>

  <!--

  build:系统项目构建行为知识

  plugins:引入的插件的列表

  plugin:插件，这个标签下需要声明插件的坐标，

  -->

  <build>

    <finalName>testWeb</finalName>

    <plugins>

      <plugin>

         <groupId>org.apache.maven.plugins</groupId>

         <artifactId>maven-source-plugin</artifactId>

         <version>2.4</version>

         <executions>

            <execution>

               <phase>package</phase>

               <goals>

                  <goal>jar-no-fork</goal>

               </goals>

            </execution>

         </executions>

      </plugin>

    </plugins>

  </build>

  <!--

    parent:通常用于子模块对父模块POM的集成

   modules:用于聚合运行多个项目，指定多个模块一起编译。

   -->

  <parent></parent>

  <modules></modules>

</project>

Maven依赖范围

 

先看下面一段代码：

……

<dependencies> 

        ……   

        <dependency> 

            <groupId>junit</groupId> 

            <artifactId>junit</artifactId> 

            <version>${ junitversion}</version>

            <type></type>

            <scope>test</scope> 

        </dependency>

      ……

……

上述标签元素<scope> </scope>表示依赖范围

平时开发如果需要某一个框架，就需要将该框架的jar包添加到ClassPath，Maven为我们提供了三种classpath：编译、测试、运行；

而上述的<scope>test</scope>表示juint只存在于测试的classpath。

<scope>属性

• Compile：在编译时有效。
• Provided：在编译和测试时有效
• Runtime:测试和运行时有效
• Test:只在测试的时候有效
• System:在编译和测试时有效，与本机系统相关联，可移植性差。
• Import:导入的范围，它只使用在dependencyManagement中，表示从其他的pom中导入dependency的配置，表示是从吉他地方继承过来的依赖。

例如：

……

<denpendencyManagement>

       <dependencies>

              ……

        <dependency> 

            <groupId>maven</groupId> 

            <artifactId>A</artifactId> 

            <version>1.0</version>

            <type>pom</type>

            <scope>import</scope> 

        </dependency>

      ……

       </dependencies>

</denpendencyManagement>

……

依赖传递

传递性依赖的概念，就像A依赖于B，B依赖于C，那么就可以说A传递依赖于C；

创建三个项目分别是A、B、C

B依赖于C

首先，对C执行package和install，先打包，再发布到本地仓库；

然后，打开B的pom文件，在依赖列表当中添加依赖

……       

<dependency> 

      <groupId>maven</groupId> 

      <artifactId>C</artifactId> 

      <version>1.0</version>

 </dependency>

……

此时编译项目B，执行compile，可以运行编译成功。

A依赖于B

首先，对B执行package和install，先打包，再发布到本地仓库；

然后，打开A的pom文件，在依赖列表当中添加依赖

<dependencies>

……       

<dependency> 

      <groupId>maven</groupId> 

      <artifactId>B</artifactId> 

      <version>1.0</version>

 </dependency>

……

<dependencies>

 

此时再compile，成功之后找到A的Maven Dependencies包，会看到junit、B、C都在这里面，其中C是被传递引用进来的。

排除依赖

如果A只想依赖于B，那么可以使用排除依赖将C依赖项排除出去

在依赖列表中可以添加

<dependencies>

……       

<exclusions>

    <exclusion>

          <groupId>maven</groupId> 

          <artifactId>C</artifactId> 

         <version>1.0</version>

      </exclusion>

 </exclusions >

……

<dependencies>

保存之后，发现项目A的Maven Dependencies包里面的依赖项C消失了。

如果发现项目的JRESystem Library包是JavaSE1.5版本的，可以通过setting.xml文件将其修改，在文件中加入如下代码，创建项目的时候，自动会创建1.7的版本。

<profiles>

……

<profile>

      <id>jdk-1.7</id>

      <activation>

      <activeByDefault>true</activeByDefault>

        <jdk>1.7</jdk>

      </activation>

      <repositories>

         <maven.compiler.source>1.7</maven.compiler.source>

         <maven.compiler.target>1.7</maven.compiler.target>

            <maven.compiler.compilerVersion>1.7</maven.compiler.compilerVersion>

      </repositories>

</profile>

……

</profiles>

依赖冲突

冲突依赖，比如C依赖于A和B不同版本的同一构件，但是它到底依赖于哪个呢！

此时处理方式遵从一下几个规则：

1.短路优先

如果A—>B->C->X(jar)、A->D->X(jar)

那么编译的时候会选在短路优先选择后者进行编译。

2.先声明先优先

A->C->jar,A->D->jar<br>

编译时会选择前者;

如果路径长度相同，则谁先声明，先解析谁。

 

聚合与继承

聚合

对于多个项目一起编译，这种方式叫做聚合。

还以上面的ABC三个项目作为例子说明；

三者设定了传递依赖关系，并且经过配置，但是此时不想一个一个的由高到低的编译/打包/安装,此时可以在A的pom.xml文件的根目录中加入如下元素标签，只需要对A进行打包安装即可实现对B和C的打包和安装，这种一同编译安装的方式，就叫做聚合。

……

    <modules>

      <module>../C</module>

      <module>../B</module>

      <module>../A</module>

</modules>

……

继承

多次使用到的依赖，比如：单元测试，没有必要在所有的项目中都引用一下，此时就可以采用继承的方式来实现，先来一个父类的POM.XML，然后再中继承此POM.XML。

比如，多个项目都使用到了junit这个依赖项，则可以重现建立一个项目，将此依赖项添加进pom.xml，然后其他项目的pom文件可以继承此pom.xml文件

在A项目的pom文件中使用<parent></parent>中间引入父pom.xml本身的坐标

……详细过程参照其他教程……

需要注意的几个方面：

1.packaging改为pom

2 dependencyManagement中并不提取依赖

3.property中定义了unit版本号，之后可以引用

4 父类parent中的main和test没有意义，可以删除

使用Maven构建项目

》Eclipse-->New-->Project-->Maven Project-->

按照上述步骤选择建立web项目

》添加坐标：

 

 

》然后是对pom.xml文件进行属性和依赖配置：

一堆东西的配置：

@Pom.xml文件

…………
<properties> 
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> 
        <springversion>3.1.1.RELEASE</springversion> 
        <junitversion>3.8.1</junitversion> 
</properties>
<dependencies> 
        <dependency> 
            <groupId>junit</groupId> 
            <artifactId>junit</artifactId> 
            <version>${junitversion}</version> 
            <scope>test</scope> 
        </dependency> 
        <dependency> 
            <groupId>org.springframework</groupId> 
            <artifactId>spring-aop</artifactId> 
            <version>${springversion}</version> 
            <type>jar</type> 
            <scope>compile</scope> 
        </dependency> 
……

 

》编辑jsp页面，如果jsp页面打不开，或者报错，那是因为Eclipse缺少了ServletAPI插件，需要在pom.xml文件里面的依赖列表当中添加依赖项，保存后，可以自动下载依赖的jar包，

……
<dependency> 
            <groupId>javax.servlet</groupId> 
            <artifactId>javax.servlet-api</artifactId> 
            <version>3.0.1</version> 
            <scope>provided</scope> 
</dependency> 
……

》然后在pom.xml文件中更改junit版本号为4.10.

 

》更新项目，右击项目名称àMavenàUpdate ProjectàOK

确保输出目录在是target目录，右击项目名称-->Build Path-->Configure Build Path-->Source 确保输出都在TargetClasses即可。

》右击项目名称—>Properties-->Project Facets-->勾选DynamicWeb Module动态web模块。

 

》修改部署默认配置

发布产品时候不需要测试的文件，所以可以删除test文件，做法：

右击项目名称—>PropertiesàDeployment Assemby,，删除/src/test/java、/src/test/resources

 

》对项目编译、运行

第一，选择第三方插件jetty来作为web容器，这就需要，需要在pom.xml配置文件中的<build>标签下引入插件的坐标：

<build>
    <finalName>testMavenWeb</finalName>
    <plugins>
    	<plugin>
    	 
    		<groupId>org.eclipse.jetty</groupId>
    		<artifactId>jetty-maven-plugin</artifactId>
    		<version>9.4.0.RC1</version>
    	<!--
    		<groupId>org.apache.tomcat.maven</groupId>
    		<artifactId>tomcat7-maven-plugin</artifactId>
    		<version>2.2</version>  -->
    		 <executions>
    			<!--  在打包成功后使用jetty：run来运行jetty服务-->
    			<execution>
              		 <phase>package</phase>
              		 <goals>
                		  <goal>run</goal>
              		 </goals>
            	</execution>
            </executions>
    	</plugin>
    </plugins>
  </build>

       启动项目运行，右键项目名字-->run as -->maven build…-->Goals后面输入“jetty:run”命令，便可以可运行。
       此时在控制台可以看到StartedJetty server，可以在浏览器中查看页面显示结果“Hello World”。
      （除了使用jetty，还可以使用tomcat，在官网上找到Maven tomcat的插件坐标，如上述所示的坐标。 ）
第二，选择Tomcat作为web容器，此时需要添加Tomcat插件的坐标，添加方法和上述添加Jetty插件坐标的方法一样。

注意：

使用jetty插件作为容器的时候访问默认网页的时候不用输入项目名字：http://localhost:8080，可以直接出现默认页面

如果访问其他网页，则按照正常访问方法即可，需要加入项目名称：http://localhost:8080/seckill/list.action。

使用Tomcat作为容器的时候url当中需要加入项目名称：http://localhost:8080/testMaveWebDemo，则可以出现默认页面。

                        如果访问其他网页，同样需要加入项目名称：http://localhost:8080/seckill/list.action。

 
                            Attention
小技能：如果不知道第三方插件的坐标，该怎么办！
      进入该插件的官网，找到该插件其中一个合适的版本，点击进去，下面说明里面有该插件的依赖坐标，只需要复制粘贴过来即可，项目运行时候会自动下载该插件到本地仓库中，然后添加到ClassPath中。


友情链接：http://blog.csdn.net/xiaoshunzi111/article/details/52718303
     (此链接讲述了Maven的安装，具有参考价值)