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中可以找到,也可以百度进行下载,在这里也提供一份,以供复制):

<?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、artifactId、version为必需,将在后面介绍-->
    <groupId>cn.edu.HelloWorld</groupId>
    <artifactId>maven01</artifactId>
    <version>0.0.1SNAPSHOT</version>

    <dependencies>
                <!--在这里引入junit4的依赖-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        
    </dependencies>
</project>
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>
pom.xml
posted @ 2017-03-20 21:00 薄峰 阅读(...) 评论(...) 编辑 收藏