Maven——快速入门手册（学习记录）

前言：

　　前段时间进行了一点maven的入门学习，在这里做个记录，希望能帮到一些正在学习的朋友们。maven版本为3.3.9。希望大家觉得好的点个赞，觉得不好的多提提意见和建议做个交流。这里也贴出我学习Maven的视频地址，大家也可以自行观看http://www.imooc.com/learn/443

---

 

目录：

1. 安装配置maven环境

2. maven目录结构

3. HelloMaven

4. 常用构建命令

5. 使用archetype插件自动建立目录

6. 坐标&仓库

7. 生命周期&插件的使用

8. pom.xml常用标签介绍

9. maven依赖（范围、传递、冲突）

10. 聚合&继承

11. 构建规范目录的web项目

12. 构建非规范目录的web项目

13. 构建web项目中使用tomcat插件

---

 正文：

　　1.安装配置maven环境

　　　　首先，在官网中下载maven组件。进入官网后，在左边菜单找到Download选项，点击进入Download页面。

　　　　　　

　　　　下拉页面，在File下选择合适的文件进行下载。

　　　　　　

　　　　Maven与JDK一样，需要配置环境变量，先建立一个M2_HOME变量，方便以后移动的时候修改路径，随后在Path中加入：%M2_HOME%\bin;

　　　　

　　　　配置后在控制台输入 mvn -v ,出现maven及jdk的相关信息即为配置成功：

　　　　

　　　　至此，即可完成maven环境变量的配置。

　2.maven目录结构

　　maven工程与以往的java工程目录结构有所不同，以往的java工程目录目录一般只有一个src用于存放包及java文件，而maven工程目录长这样：　

　　src
　　　　-main
　　　　　　-java
　　　　　　　　-包
　　　　-test
　　　　　　-java
　　　　　　　　-包

　　一般我们将一些主要的内容，放在main/java下面，而测试代码放在test/java下，这样在运行时，maven才可以识别目录并进行编译。

　3.HelloMaven

　　了解了目录结构后，就可以开始第一个maven项目了。(为了更加便于理解maven，暂时采用控制台+记事本Editplus的操作方式，IDE将在后面使用。）

　　先按照目录结构建立好目录：、，这里包名为cn.edu.HelloWorld

　　先编写Hello.java：

1 package cn.edu.HelloWorld;
2 
3 public class Hello{
4     public String sayHello(){
5         return "Hello Maven";
6     }
7 }

　　再编写测试TestClass.java，这里使用junit4框架：

 1 package cn.edu.HelloWorld;
 2 
 3 import org.junit.*;
 4 
 5 public class TestClass{
 6     @Test
 7     public void testHello(){
 8         System.out.println(new Hello().sayHello());
 9     }
10 }

 　　添加一个maven的配置文件pom.xml（该文件在一些开源框架中如struts，spring中可以找到，也可以百度进行下载，在这里也提供一份，以供复制）：

pom.xml

 　　打开控制台，进入到工程的目录下，执行mvn compile命令：

　　　

 　　看到BUILD SUCCESS表示编译成功（第一次编译可能需要下载环境比较慢）

　　　

　　　编译成功后会在项目下生成一个target文件夹，里面存放编译后的文件

　　

　　　编译成功后执行mvn test命令，运行测试类：

　　　　

　　看到SUCCESS即可看到结果，输出Hello Maven：

　　

　4.常用构建命令

　　来看一下maven几个常用的构建命令，格式为mvn xxx:　　　

　　　　mvn
　　　　　　 -v 查看maven版本及其他相关信息
　　　　　　 compile 编译maven项目，并生成target文件夹
　　　　　　 test 运行test目录下的测试文件，即测试
　　　　　　 package 将项目打包，默认打包为jar格式，也可以打包成war格式用于服务器运行
　　　　　　 install 将打包的jar文件安装到maven本地仓库（仓库后面会详细介绍）
　　　　　　 clean 删除targert，相当于清除缓存

　5.使用archetype插件自动建立目录

　　在前面我们采用手动的方式进行目录建立，显得略微有点繁琐，那么这里介绍一个插件用于生成符合maven规范的目录。

　　首先从控制台进入需要生成文件夹的位置，然后运行mvn archetype:generate（第一次需要下载组件比较慢,若是下载不下来可以设置一下maven的国内镜像库，百度即有步骤，这里不做介绍）:

　　

　　出现以下界面，提示我们选择生成一个版本类型的maven结构，这里选择7(默认为7)，quickstart：

　　

　　确认后要求输入groupId、artifactId(也会作为文件夹名)、version(默认为1.0-SNAPSHOT)、package（即包的结构），这里依次输入：

　　

　　提示确认，输入Y确认后进行生成。出现SUCCESS，则表示生成成功：

 　　

　　进入生成的项目中，输入mvn compile test进行确认：

　　

 　　

　　打开文件夹即可看到我们生成的文件目录，已经符合了maven规范，且可以运行。

　6.坐标&仓库

　　坐标：

　　　maven使用groupId、artifactId、version表示坐标，每个坐标都唯一的指向一个maven项目，简单介绍一下这几个标签

　　　　　　groupId:项目组织唯一的标识符，一般为反写的公司网址+项目名
　　　　　　artifactId:项目的唯一的标识符，一般为项目名+模块名
　　　　　　version:版本号 x.x.x+版本类型
　　　　　　　　第一个x表示大版本号
　　　　　　　　第二个x表示分支版本号
　　　　　　　　第三个x表示小版本号（可省略）
　　　　　　　　常见版本类型：
　　　　　　　　　　snapshot快照
　　　　　　　　　　alpha内部测试
　　　　　　　　　　beta公测
　　　　　　　　　　release稳定
　　　　　　　　　　GA正式发布

　　　　　　注：包名应与groupId+artifactId相吻合

 　　仓库：

　　　　maven中的依赖管理就是靠着仓库，仓库分为中央仓库及本地仓库。在编译项目时，maven会根据配置的依赖，先在本地仓库中进行搜索，若是没有则再去中央仓库进行搜索，而搜索便是采用坐标进行查找。

　　　　默认本地仓库位于C盘之下，如果进行还原系统之类的便会清空十分不便，这里说一下更改本地仓库路径的方法：

　　　　在maven组件目录下的conf文件夹内，有一个setting.xml，打开文件，搜索localRepository标签，使用localRepository标签修改路径即可

　　　　

　7.生命周期&插件的使用

　　生命周期：

　　多个生命周期之间相互独立。每个生命周期含有多个阶段，阶段按顺序执行，运行后阶段时，前阶段会自动执行。比如，直接运行mvn test命令，那么执行该命令时，会自动的附带mvn compile命令，因为test阶段在compile阶段之后。　　

　　完整的项目构建构成包括：
　　　　清理、编译、测试、打包、集成测试、验证、部署

　　　　clean 清理项目，包括以下阶段：
　　　　　　pre-clean 执行清理前
　　　　　　clean 清理上一次构建生成的所有文件
　　　　　　post-clean 执行清理后的文件
　　　　default 构建项目(核心：常用)，包括以下阶段
　　　　　　compile 编译
　　　　　　test 测试
　　　　　　packeage 打包
　　　　　　install 安装
　　　　site 生成项目站点,根据pom中信息生成项目站点，包括以下阶段
　　　　　　pre-site 在生成项目站点前要完成的工作
　　　　　　site生成项目的站点文档
　　　　　　post-site在生成项目站点后要完成的工作
　　　　　　site-deploy发布生成的站点到服务器上

　　　　插件：

 　　　　maven中提供了许多功能强大的插件，让我们更好的管理项目。一个插件通常提供了一组目标，可使用以下语法来执行：

　　　　　　mvn [plugin-name]:[goal-name]
　　　例如我们之前使用mvn archetype:generate,插件名为archetype,而目标为generate。我们可以在官网的Plugins标签下，查找到插件的坐标及插件目标的详细描述。
　　　Maven 提供以下两种类型插件：

类型	描述
构建插件	在生成过程中执行，并在 pom.xml 中的<build/> 元素进行配置
报告插件	在网站生成期间执行，在 pom.xml 中的 <reporting/> 元素进行配置

　　　　以下是一些常见的插件列表：

插件	描述
clean	编译后的清理目标，删除目标目录
compiler	编译 Java 源文件
surefile	运行JUnit单元测试，创建测试报告
jar	从当前项目构建 JAR 文件
war	从当前项目构建 WAR 文件
javadoc	产生用于该项目的 Javadoc
antrun	从构建所述的任何阶段运行一组 Ant 任务
source	从当前项目构建带源码的JAR文件

 　　　　这里我们通过使用source插件作为例子，来看看如何在maven中配置插件：

　　　    首先我们快速创建一个maven项目（可以使用archetype），在pom.xml中加入以下内容：

 <build>
  <!-- 配置插件集 -->
      <plugins>
          <plugin>
            <!--使用插件的坐标进行引用 -->
              <groupId>org.apache.maven.plugins</groupId>
              <artifactId>maven-source-plugin</artifactId>
              <version>3.0.0</version>
              
              <executions>
                  <execution>
                      <!-- 绑定在哪个过程时一同执行,这里我们让它在使用package打包时一同执行 -->
                      <phase>package</phase>
                    <!--执行的目标类型，关于目标的详细介绍可以在maven官网中查到-->
                      <goals>
                          <goal>jar-no-fork</goal>
                      </goals>
                  </execution>
              </executions>
          </plugin>
      </plugins>
  </build>

　　接下来，在命令控制台，输入mvn package查看结果：

　　

　　

　　出现成功信息后，可以在我项目的target中找到打包后的jar文件及src-jar文件

　　

 　　从这个例子中，我们可以总结出以下几个关键点：

• • 插件可在 pom.xml 使用的 plugin 元素来指定
  • 可以通过将它们绑定到其他的过程中一起执行，这里绑定到package中。

　8.pom.xml常用标签介绍

<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">
    <!-- 当前pom的版本-->
    <modelVersion>4.0.0</modelVersion>

    <!--坐标-->
    <groupId>cn.edu</groupId>
    <artifactId>maven04</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <!-- 默认是jar，其他war zip pom等 -->
    <packaging>jar</packaging>

    <!--项目描述名 -->
    <name>maven04</name>
    <!-- 项目地址 -->
    <url>http://maven.apache.org</url>

    <!-- 配置参数 -->
    <properties>
        <!-- 这里配置项目编译编码为UTF-8-->
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
    
    <!-- 开发人员信息 -->
    <developers></developers>
    <!-- 项目描述 -->
    <description></description>
    <!-- 许可信息 -->
    <licenses></licenses>
    <!-- 组织信息 -->
    <organization></organization>
    <!-- 依赖集，用于配置依赖 -->
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
            
            <!-- 依赖范围：这个jar包只在范围内生效，范围外引用会报错，这里让junit只在test时被依赖。
                            其他一些情况，如：servlet-api.jar，在编译阶段需要引用，而在服务器运行阶段则不需要引用，就可以使用scope-->
            <scope>test</scope>

            <!-- 默认为false，子项目将会继承，true时子项目并需显式引用 -->
            <optional>false</optional>

            <!-- 排除依赖列表：用于去除传递依赖等，在后面会详细介绍-->
            <exclusions>
                <exclusion></exclusion>
            </exclusions>
            

        </dependency>
    </dependencies>
    
    <!-- 依赖管理
            为依赖进行统一管理，如果在父项目中声明此标签时，在子项目中不需声明，确保父子项目依赖版本一致；
            如子项目需要不同版本的依赖，只需在子项目中进行声明即可，将会覆盖父项目中的声明。
     -->
    <!--     
        <dependencyManagement>
            <dependencies>
                <dependency></dependency>
            </dependencies>
        </dependencyManagement> 
    -->
    
    <!--配置构建时的属性-->
    <build>
        <plugins></plugins>
    </build>
    
    <!-- 指定父模块 -->
        <!-- <parent></parent> -->

    <!-- 用于聚合编译多个maven模块 -->
    <modules></modules>
</project>

　9.maven依赖（范围、传递、冲突）

　　本节开始使用Eclipse进行编写，使用上与控制台方式出入不大。先略微介绍下Eclipse中构建maven项目：在新建项目时选择maven project（需安装maven插件，eclipse3.1以上自带）

　　

　　设置好路径后在选择版本的界面，选择quickstart版本：

　　

　　输入信息后点击finish即可构建maven项目：

　　

　　完成步骤后，一般情况下会自动创建符合规范的maven项目。个别出现文件夹不符合规范的情况，可以使用项目右键→new→source folder自行创建补充。

　　运行命令只要右键项目，run as→maven build的Goals中输入即可，这里输入时不需输入mvn。例如：mvn compile只需输入compile。

　　范围：　　　

　　　　首先要知道，maven中提供了三种classpath:编译、测试、运行
　　　　scope标签
　　　　　　-compile 默认，编译测试运行均有效，会传递
　　　　　　-provided 在编译和测试时有效，如servletAPI可以加入，不传递
　　　　　　-runtime 在测试和运行时有效，如JDBCAPI可以加入
　　　　　　-test 在测试时有效，如junit可以加入
　　　　　　-system 在编译和测试时有效，与本机系统相关联，移植性差，在系统中以外部jar包的形式引入，不会在仓库中查找
　　　　　　-import 导入，只能用在dependecyManagement中，表示从其他pom中导入dependecy的配置

　　传递：

　　　　先来看看什么是传递依赖，比如现在有这么个情况：

　　　　C依赖B、B依赖A——C→B→A，那么此时C也会依赖A且会包含A中的依赖,这就是传递依赖。接下来我们通过一个例子来详细了解依赖及如何消除传递依赖：

　　　　现有ABC三个项目：

　　　　

　　A中额外依赖了一个commons-io的jar包：

　　

　　B中对A进行依赖：

　　

　　C中对B进行依赖：

　　

　　保存之后可以看到，C中不但包含B，还包含A和A依赖的common-io:

　　

　　那么如何消除传递依赖呢，这里就使用到<exclusion>标签了，在C中配置依赖B的地方加入以下内容：

　　

　　保存后就可以看到，C中关于A的依赖消失了，传递依赖的问题就解决了。

 　　

 　　冲突：

　　　　假设现在有这么个情况：A依赖common-io的2.4版本，B依赖common-io的2.5版本，C依赖A、B，那么此时C中的common-io是哪个版本的？

　　　　这就是依赖冲突，在maven中应对依赖冲突有两种解决方式：短路优先，先声明优先

　　　　　　先声明优先：顾名思义，在pom中，写在配置文件上面的优先，比如此时A的依赖配置在B之上，那C中就为2.4版本的common-io。

　　　　　　短路优先：优先选择依赖路径较短的一端。假设现在多出一个D，依赖情况改为D依赖B，C依赖A、D——C→A、C→D→B，那么这里就是A的依赖路径比较短，所以为2.4版本。

　10.聚合&继承

　　聚合：

　　　　试想一下这样的情况，在一个项目中，分模块使用了maven，那么可能在这个项目中会有五六个，或者更多的maven项目存在。如果此时需要编译或测试要怎么办呢，进入每个maven项目中进行mvn compile么，那就要执行五六次的compile命令，十分繁琐，这里就可以用maven的聚合来解决这个问题。

　　　　现有ABC三个工程，那么我们使用一个新的工程D，来聚合他们，以后只要对D进行编译即可对三个工程同时进行编译。使用module标签进行聚合：

  <modules>
    <!--这里的路径是基于D项目的pom.xml路径，module标签内为指向其他项目的pom文件的路径
        这里我的ABCD项目在同一个文件夹内，那么从D内的pom中，通过../项目名，来找到其他项目的pom.xml-->
      <module>../A</module>
      <module>../B</module>
      <module>../C</module>
  </modules>

　　继承：

　　　　另一种情形，如果多个maven项目具有相同的依赖时或配置时，那么应该如何处理呢？这里就用到继承的概念，在maven中使用<parent>标签来进行继承，下面通过一个例子来看一下：

　　　　首先建立一个项目，命名为parent，在parent的pom文件声明一个common-io的依赖，不过这里用到了dependencyManagement：

<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>cn.edu</groupId>
    <artifactId>parent</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>pom</packaging>

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

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

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

    <dependencyManagement>
        <!-- 在这里声明的依赖可以被子项目继承引用 -->
        <dependencies>
            <dependency>
                <groupId>commons-io</groupId>
                <artifactId>commons-io</artifactId>
                <version>2.4</version>
            </dependency>
        </dependencies>
    </dependencyManagement>
</project>

　　可以看到，虽然我们在父项目中配置了依赖，但是却不会在父项目中被引用：

　　　　

　　在子项目B中，配置继承parent并使用parent中的common-io版本：

<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>cn.edu</groupId>
    <artifactId>B</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

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

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

    <!-- 在parent标签中使用父项目的坐标进行配置 -->
     <parent>
          <groupId>cn.edu</groupId> 
          <artifactId>parent</artifactId> 
        <version>0.0.1-SNAPSHOT</version> 
    </parent>
    
    <dependencies>
        <!-- 此处使用依赖时，就不需声明版本 -->
        <dependency> 
            <groupId>commons-io</groupId> 
            <artifactId>commons-io</artifactId> 
        </dependency>
        
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>

 　　配置后保存即可看到，此处的依赖版本即为父项目中的版本：

　　

　11.构建web项目

　　这里介绍两种的web项目：规范目录的web项目及传统目录的web项目。再介绍使用两种服务器容器：tomcat和jetty运行的方法。由于tomcat中有许多的需要注意的问题，较为复杂，所以这里先从简单的jetty入手。

　　首先构建项目，这次选择版本的时候我们选择webapp:

　　

　　建立好后的webapp项目，其目录结构是这样的：

　　

　　这里的resources文件夹用于存放java文件、包、xml配置文件等等，与我们传统意义上的src文件夹是一致的。这里src下的webapp文件夹则等同于我们Web项目中的WebRoot或WebContent，一些页面和样式等文件放在这个目录下。

　　接下来看看pom文件：

　　先注意到我们这里的打包方式变为了war，web项目必需先编译打包，然后才能部署到web容器上运行。之后只需配置我们的jetty运行插件。

<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>cn.edu</groupId>
    <artifactId>mavenweb</artifactId>
    <packaging>war</packaging>
    <version>1.2.2-SNAPSHOT</version>

    <name>mavenweb Maven Webapp</name>

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

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

    <build>
        <finalName>mavenweb</finalName>
        <plugins>
            <!--这里用到jetty的插件，在官网中可以找到坐标-->
            <plugin>
                <groupId>org.eclipse.jetty</groupId>
                <artifactId>jetty-maven-plugin</artifactId>
                <version>9.4.1.v20170120</version>
            </plugin>
        </plugins>
    </build>
</project>
        

　　先使用package命令进行打包，可以看到target中出现了我们webapp文件夹下的内容，以及打包好的war文件。

 　　

　　复制使用这个war文件也可完成部署。但我们这里使用jetty插件，在命令框中输入jetty:run命令,观察到

说明服务器启动完成。

　　接下来在浏览器使用localhost:8080即可看到我们的项目中的index.jsp

　　

　　至此就完成了我们规范目录的web项目构建。

　12.构建非规范目录的web项目

　　使用maven的web项目结构，可能会有少许的不习惯，或者我们要将以前开发的项目转为mavenweb项目的话，那要怎么办呢？这里就介绍下非规范目录的web项目要如何构建。

 　　首先，这是我们的项目目录结构，java等文件还是放在main/java下，而页面等其他资源文件放在WebContent下：

　　

　　看看pom文件中的配置方法：

<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>cn.edu</groupId>
    <artifactId>mavenweb</artifactId>
    <packaging>war</packaging>
    <version>1.2.2-SNAPSHOT</version>
    <name>mavenweb Maven Webapp</name>
    <url>http://maven.apache.org</url>

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

    <build>
        <finalName>mavenweb</finalName>
        <!-- 资源集 -->
        <resources>
            <!-- 非规范资源文件目录打包 -->
            <resource>
                 <!-- 指定资源存放的目录(必需，不写会报错)，即resources目录的变更。以下配置中的的相对目录改为该目录 -->
                <directory>src/main/java</directory>
                <includes>
                    <include>*.xml</include>
                </includes>
                <!-- 是否替换资源文件中的属性,如${username},替换为pom中指定的properties-->  
                <filtering>false</filtering>    
            </resource>
        </resources>
        <plugins>
                        <!--这里使用到war plugin，同样的，详细介绍及坐标在官网中可以找到-->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-war-plugin</artifactId>
                <version>3.0.0</version>
                <configuration>
                    <!-- 指定web.xml的文件位置 -->
                    <webXml>WebContent/WEB-INF/web.xml</webXml>
                    <!-- war的源目录，由哪个文件夹打包成war文件，用于更改页面样式等的资源目录 -->
                    <warSourceDirectory>WebContent</warSourceDirectory>        
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.eclipse.jetty</groupId>
                <artifactId>jetty-maven-plugin</artifactId>
                <version>9.4.1.v20170120</version>
            </plugin>
        </plugins>
    </build>
</project>

　　完成配置后，使用package命令进行打包。看到target中的打包结果，确实更改了来源目录并打包成功：

　　

　　

 　　接下来使用jetty:run或jetty:deploy等运行命令即可成功运行项目。

　13.构建web项目中使用tomcat插件

　　使用tomcat时，会遇上许多的问题，在这里整理，希望能帮上一些朋友。

　　问题一：tomcat插件版本问题

　　tomcat这个插件在官网的描述中是这样的：

　　

　　那么我这里使用的是tomcat7,我就使用了下面的那份坐标，但是在使用tomcat:run命令是发现：

 　　

　　也是找了好久才发现这个问题，我明明使用的是tomcat7的插件，但是运行起来却是不知道哪里来的6.0版本。

　　正确的方式是：运行tomcat7:run命令，其实这点在官网中也有提到，怪自己没认真看了。

 　　

　　tomcat:run默认使用的是6.0版本的tomcat，但是奇怪的一点，我机子上并没有6.0版本的tomcat，那么这里的是哪来的呢？希望有大神知晓的能够解答，先谢过了！

　　问题二：Cannot invoke Tomcat manager: Server rened HTTP response code: 403 for URL

　　这个问题，第一是要打开tomcat的Manage权限，在百度有许多相关的解决方法，我就不多说了。这里贴几个我觉得写的还不错的帖子：

　　http://blog.csdn.net/u012052168/article/details/52448943

　　https://my.oschina.net/angel243/blog/178554

　　第二个点，也是我遇上的主要问题：Eclipse的tomcat的webapp目录为workspace/.metadata/.plugins/org.eclipse.wst.server.core/tmp0/wtpwebapps，而并非$CATALINA_HOME/webapp，这也就导致了Eclipse中启动tomcat的话，是没有Root、Manage等项目的，更不用说Manage权限了。

　　解决方式：http://blog.csdn.net/snakewarhead/article/details/6175833

　　最后，贴上最终我的pom文件，供大家做个参考：

<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>cn.edu</groupId>
    <artifactId>mavenweb</artifactId>
    <packaging>war</packaging>
    <version>1.2.2-SNAPSHOT</version>
    <name>mavenweb Maven Webapp</name>
    <url>http://maven.apache.org</url>

    <dependencies>

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

        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <scope>provided</scope>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.apache.struts/struts2-core -->
        <dependency>
            <groupId>org.apache.struts</groupId>
            <artifactId>struts2-core</artifactId>
            <version>2.5.8</version>
        </dependency>

    </dependencies>

    <build>

        <finalName>mavenweb</finalName>
        <!-- 资源集 -->
        <resources>
            <!-- 非规范资源文件目录打包 -->
            <resource>
                 <!-- 指定资源存放的目录(必需，不写会报错)基础目录,以下目录全在该目录下 -->
                <directory>src/main/java</directory>
                <includes>
                    <include>*.xml</include>
                </includes>
                <!-- 是否替换资源文件中的属性,如${username},替换为pom中指定的properties-->  
                <filtering>false</filtering>    
            </resource>
        </resources>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-war-plugin</artifactId>
                <version>3.0.0</version>
                <configuration>
                    <!-- 指定web.xml的文件位置 -->
                    <webXml>WebContent/WEB-INF/web.xml</webXml>
                    <!-- war的源目录，由哪个文件夹打包成war文件，用于更改资源目录 -->
                    <warSourceDirectory>WebContent</warSourceDirectory>    
<!--                     <webappDirectory>WebContent</webappDirectory> 打包的目标目录-->    
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <version>2.1</version>
                <configuration>
                    <url>http://localhost:8080/manager/html</url>
                    <server>tomcat7</server> <!-- 此处的名字必须和setting.xml中配置的ID一致 -->
                    <username>admin</username>
                    <password>root</password>
                    <path>/mavenweb</path> <!-- 此处的名字是项目发布的工程名 -->
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.eclipse.jetty</groupId>
                <artifactId>jetty-maven-plugin</artifactId>
                <version>9.4.1.v20170120</version>
            </plugin>
        </plugins>
    </build>
</project>

作者： 薄峰
出处： http://www.cnblogs.com/qbzf-Blog/
本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。