Maven

项目构建工具

之前是用Ant, 现在被maven替换了

Apache基于ANT进行了升级, 研发出了全新的自动化构建工具Maven.

Maven是Apache的一款开源的项目管理工具

以后无论是普通javese项目还是javaee项目, 我们都创建的是maven项目.

/*
Maven使用项目对象模型(POM-Project Object Model，项目对象模型)的概念，
可以通过一小段描述信息来管理项目的构建，报告和文档的软件项目管理工具。
在Maven中每个项目都相当于是一个对象，对象（项目）和对象（项目）之间是有关系的。
关系包含了：依赖、继承、聚合，实现Maven项目可以更加方便的实现导jar包、拆分项目等效果。
*/

maven.apache.org

一、Maven的下载_目录结构_IDEA整合Maven

 IDEA默认整合了Maven

 手动下载

 

 bin：存放的是执行文件，命令

在IDEA中可以直接集成Maven

 选中->OK

conf目录：有一个非常重要的配置文件--》settings.xml --- maven的核心配置文件/全局配置文件。

执行命令mvn help:system 后就会有.m2文件夹了, 是一个隐藏文件

二、Maven仓库

Maven仓库是基于简单文件系统存储的，集中化管理Java API资源（构建 jar包）的一个服务

仓库中的任何一个构建都有其唯一的坐标，根据这个坐标可以定义其在仓库中的唯一存储路径。得益于Maven的坐标机制，

任何Maven项目使用任何一个构建的方式都是完全相同的。

Maven可以在某个位置统一存储所有的Maven项目共享的构建。这个统一的位置就是仓库，项目构建完毕后生成的构建

也可以安装或者部署到仓库中，供其他项目使用。

对应Maven来说，仓库分为两类：本地仓库和远程仓库。

远程仓库：mvnrepository.com

比如搜索一个Mybatis

配置本地仓库远程仓库路径

打开settings.xml文件，

配置本地仓库路径

在settings.xml配置镜像仓库

  <mirror>
    <!-- 指定镜像ID（可自己改名）-->
    <id>nexus-aliyun</id>
    <!-- 匹配中央仓库（阿里云的仓库名称,不可以自己起名,必须这样写）-->
    <mirrorOf>central</mirrorOf>
    <!-- 指定镜像名称（可自己改名）-->
    <name>Nexus aliyun</name>
    <!-- 指定镜像路径（镜像地址）-->
    <url>http://maven.aliyun.com/nexus/content/groups/public</url>
  </mirror>

仓库优先级别问题:

/*
最先本地仓库---->>到配置文件中指定的仓库中查找---->>看是否配置镜像仓库---->>没有配置到中央仓库
                                                    |
　　　　　　　　　　　　　　　　　　　　　　　　　　   　　   |-------- -->>配置了到镜像仓库中找----->> 可能没有再到中央仓库查找
*/

三、JDK的配置

setting.xml中

    <profile>
      <!-- settings.xml中的id不能随便起名的 -->
      <!-- 告诉maven我们用的是jdk1.8 -->
      <id>jdk-1.8</id>
      <!-- 开启JDK的使用 -->
      <activation>
        <activeByDefault>true</activeByDefault>
        <jdk>1.8</jdk>
      </activation>

      <properties>
        <!-- 配置编译器信息 -->
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion>
      </properties>
    </profile>

四、Maven工程类型

1、POM工程

POM工程是逻辑工程。用在父级工程或聚合工程中。用来做jar包的版本控制

2、JAR工程

将会打包成jar，用作jar包使用。即常见的本地工程 -------》 Java Project

3、WAR工程

将会打包成war，发布到服务器上的工程

五、在IDEA中创建Maven工程

 

/*
这个其实就是项目的坐标

   GroupId: 类似包名 ---> 防止重名 ---> 规则一般为 域名反转 ---> eg: sale.kxq
   Atifactld: 一般使用项目名字
   Version: 版本 1.0-snapshot(快照版)   
*/

六、Maven目录结构

标准目录结构：

src/main/java

这个目录下存储java源代码

src/main/resources

存储主要的资源文件. 比如xml配置文件和properties文件

src/test/java

存储测试用的类, 比如JUNIT的测试一般就放在这个目录下面

因为测试类本身实际是不属于项目的, 所以放在任何一个包下都显得尴尬,

所以Maven专门创建了一个测试包

src/test/resources

可以自己创建你存储测试环境用的资源文件

src

包含了项目所有的源代码和资源文件, 以及其他项目相关的文件

target

编译后内容放置的文件夹

七、Maven工程关系

1、依赖关系

即A工程开发或运行过程中需要B工程提供支持，则代表A工程依赖B工程

在这种情况下，需要在A项目的pom.xml文件中增加下属配置定义依赖关系。

通俗理解：就是导jar包

B工程可以是自己的项目打包后的jar包， 也可以是中央仓库的jar包

如何注入依赖：

/*
在pom.xml文件根元素project下的dependencies标签中, 配置依赖信息, 
内可以包含多个dependence元素, 以声明多个依赖。每个依赖dependence标签都应该包含一下元素： 
groupId， artifactld，version：依赖的基本坐标，
对于任何一个依赖来说，基本坐标是最重要的，Maven根据坐标才能找到需要的依赖。
*/

 2、依赖的传递性

 传递性依赖是Maven2.0的新特性。假设你的项目依赖于一个库，而这个库又依赖于其他库。你不必自己去找出所有的依赖，

你只需要加上你直接依赖的库，Maven会隐式的把这些库间接依赖的库加入到你的项目中。这个特性是靠解析从远程仓库中

获取的依赖库的项目文件实现的。一般的，这些项目的所有依赖都会加入到项目中，或者从父项目继承，或者通过传递性依赖。

如果A依赖了B，那么C依赖A时会自动把A和B都导入进来。

创建A项目后，选中IDEA最右侧Maven面板lifecycle，双击install后就会把项目安装到本地仓库中，其他项目就可以通过坐标引用次项目

 上面MavenDemo项目依赖了mybatis，将项目重新打包为jar包

clean把之前打的包删掉，install打包

再创建一个项目让MavenDemo2 依赖于 MavenDemo1

从上面可以证明：项目2依赖项目1， 项目1依赖mybatis工程，传递性项目2可以直接使用mybatis

3、依赖的两个原则 排除依赖

1）最短路径优先原则

“最短路径优先”以为着项目依赖关系树中路径最短的版本会被使用

假如，假设A、B、C之间的依赖关系是A-》B-》C-》D（2.0）和 A-》E-》D（1.0），那么D（1.0）会被使用，因为A通过E到D的路径最短

2）最先声明原则

依赖路径长度是一样的时候，第一原则不能解决所有问题，比如这样的依赖关系：A-》B-》Y（1.0），A-》C-》Y（2.0），Y（1.0）和（2.0）的

依赖长度是一样的，都为2，那么到底谁会被解析使用呢？再maven2.0.8及之前的版本中，这是不确定的，但是maven2.0.9开始，为了尽可能避免

构建的不确定性，maven定义了依赖调解的第二原则：第一声明者优先。在依赖路径长度相等的前提下，在POM中依赖声明的顺序决定了谁会被

解析使用。顺序最靠前的哪个依赖优胜。

3）排除依赖

exclusions：用来排除传递性依赖 其中可配置多个exclusion标签，每个exclusion标签里面对应的有groupId，artifactld，version三项基本元素。

注意：不用写版本号。

比如：A----》B----》C（Mybatis.jar）排除C中的Mybatis.jar

 

 

 这样就把mybatis排除了

4、依赖范围

依赖范围就决定了你依赖的坐标在什么情况下有效，什么情况下无效：

compile

这是默认范围。如果没有指定，就会使用该依赖范围，表示该依赖在编译和运行时都生效。

provided

已提供依赖范围。使用此依赖范围的 Maven依赖。典型的例子时servlet-api，编译和测试项目的时候需要该依赖，但在运行项目的时候，由于

容器已经提供，就不需要Maven重复引入一遍（如：servlet-api）

runtime

runtime范围表明编译时不需要生效，而只在运行时生效。典型的例子时JDBC驱动实现，项目主代码的编译只需要JDK提供的JDBC接口，

只有在执行测试或者运行项目的时候才需要实现上述接口的具体JDBC驱动。

system

系统范围于provided类似，不过你必须显式指定一个本地系统路径的JAR，此类依赖应该一直有效，Maven也不会取仓库中寻找它。但是

使用system范围依赖时必须通过systemPath元素显式地指定依赖文件的路径

test

test范围表明使用此依赖范围的依赖，只在编译测试代码和运行测试的时候需要，应用的正常运行不需要此类依赖。典型的例子就是

jUnit，它只有在编译测试代码及运行测试的时候才需要。jUnit的jar包就在测试阶段用就行了，你导出项目的时候没有必要把jUnit的

东西导出去，在junit坐标下加入scope-test

import

import范围只适用于pom文件中的<dependcyManagement>部分。表明指定的POM必须使用<dependcyManagement>部分的依赖

注意：import只能在<dependcyManagement>的scope里。

定义一个父工程--》POM工程

 

 只是管理

定义一个子工程

注意：工程1要打成自己的jar包

<?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>sale.kxq</groupId>
    <artifactId>MavenDemo2</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <parent>
        <groupId>sale.kxq</groupId>
        <artifactId>MavenDemo</artifactId>
        <version>1.0-SNAPSHOT</version>
        <relativePath>../MavenDemo/pom.xml</relativePath>
    </parent>

    <dependencies>
        <dependency>
            <groupId>sale.kxq</groupId>
            <artifactId>mybatis</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>

    </dependencies>

</project>

5、继承关系

如果A工程继承B工程，则代表A工程默认依赖B工程依赖的所有资源，且可以应用B工程中定义的所有的资源信息。

被继承的工程（B工程）只能时POM工程。

注意：在父项目中放在<dependencyManagement>中的内容时不被子项目继承，不可以直接使用放在 <dependencyManagement>

中的内容主要目的是进行版本管理。里面的内容在子项目中依赖时坐标只需要填写<group_id> 和 <artifac_id>即可

注意：如果子项目不希望使用父项目的版本，可以明确配置version。

本质就是POM文件的继承

6、集合关系

当我们开发的工程有2个以上模块的时候，每个模块都是一个独立的功能集合。比如某大学系统中拥有搜索平台、学习平台，考试平台等。

开发的时候每个平台都可以独立编译，测试，运行。这个时候我们就需要一个聚合工程。

在创建聚合工程的过程中，总的工程必须时一个POM工程（Maven Project) (聚合项目必须是一个pom类型的项目，jar项目war项目是没

有办法做聚合工程的)，各子模块可以是任意类型模块（Maven Module）。

前提：继承

聚合包含了继承的特性

聚合时多个项目的本质还是一个项目。这些项目被一个大的父项目包含。且这时夫项目类型为pom类型。同时在父项目的pom.xml中

出现<modules>表示包含的所有子模块.

<?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>sale.kxq</groupId>
    <artifactId>ParentPro</artifactId>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>ChildPro</module>
    </modules>
    <!--定义为pom项目-->
    <packaging>pom</packaging>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <!--定义版本号-->
        <mybatis.version>3.5.4</mybatis.version>
        <spring.version>5.1.11.RELEAS</spring.version>
    </properties>

    <dependencyManagement>
        <dependencies>
            <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
            <dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis</artifactId>
                <version>${mybatis.version}</version>
            </dependency>
            <!-- https://mvnrepository.com/artifact/org.springframework/spring-core -->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-core</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>${spring.version}</version>
            </dependency>

        </dependencies>
    </dependencyManagement>

</project>

子模块

<?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">
    <parent>
        <artifactId>ParentPro</artifactId>
        <groupId>sale.kxq</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>ChildPro</artifactId>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
        </dependency>
    </dependencies>

</project>

 一般总项目为POM项目，PraentPro

八、常见插件

1、编译器插件

通过编译器插件，我们可以配置使用的JDK或者说编译器的版本：

1）settings.xml文件中配置全局编译器插件:

找到profiles节点,在里面加入profile节点:

    <profile>
        <!--定义的编译器插件ID，全局唯一，名字随便起-->
        <id>jdk-1.7</id>
        <!-- 插件标记,activeByDefault:true默认编译器,jdk提供编译器版本-->
        <activation>
            <activeByDefault>true</activeByDefault>
            <jdk>1.7</jdk>
        </activation>
        <!--配置信息source-源信息,target-字节码信息, compilerVersion-编译过程版本-->
        <properties>
            <maven.compiler.source>1.7</maven.compiler.source>
            <maven.compiler.target>1.7</maven.compiler.target>
            <maven.compiler.compileVersion>1.7</maven.compiler.compileVersion>
        </properties>
    </profile>

2)配置编译器插件: pom.xml配置片段

    <build>
        <!--JDK编译插件-->
        <plugins>
            <plugin>
                <!--插件坐标-->
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>

                <configuration>
                    <!--源代码使用JDK版本-->
                    <source>1.7</source>
                    <!--源代码编译为class文件的版本,要抱持跟上面版本一直-->
                    <target>1.7</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
        </plugins>
    </build>

2、资源拷贝插件

Maven在打包时默认只将src/main/resources里的配置文件拷贝到项目中并做打包处理,而非resource目录下的配置文件在打包时不会添加到项目中.

我现在想把非resources下面的文件也打包到classes下面:

    <build>
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
            </resource>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.xml</include>
                    <include>**/*.properties</include>
                </includes>
            </resource>
        </resources>
    </build>

配置好以后,那么你设置的位置下的配置文件就会被打包了

3、Tomcat插件

我们如果创建war项目，必然要部署在服务器上，方式

（1）部署在远程服务器上

（2）将IDEA和外部tomcat产生关联，然后将项目部署在外部tomcat上

现在学习一个新的方式，不再依赖外部的tomcat，maven提供了tomcat插件，我们可以配置来使用。

使用tomcat插件发布部署并执行war工程的时候，需要使用启动命令，启动命令为：tomcat7:run。命令中的

tomcat7时插件命名，有插件提供商决定。run为插件中的具体功能。

（注意：之前用的编译器插件，资源拷贝插件，不是可运行的插件在，maven直接帮我们运行了，但是tomcat属于

可运行插件，它什么时候工作需要程序员控制，怎么控制呢，我们必须通过命令来运行控制）

具体pom.xml文件配置如下：

 

 

 

 

 缺省的目录可以自己补全

<build>
    <plugins>
      <!--配置Tomcat插件-->
      <plugin>
        <groupId>org.apache.tomcat.maven</groupId>
        <artifactId>tomcat7-maven-plugin</artifactId>
        <version>2.2</version>
        <configuration>
          <!--配置Tomcat监听接口-->
          <port>8080</port>
          <!--配置项目的访问路径(Application Context) -->
          <path>/</path>
        </configuration>
      </plugin>
    </plugins>
    ...
    ...
    ...
  </build>

执行命令:

 

 

九、Maven常用命令

Maven库：

http://repo2.maven.org/maven2/

Maven依赖查询：

http://mvnrepository.com/

1、Maven常用命令：

1. 创建Maven的普通Java项目：

mvn archetype:create
    -DgroupId=packageName
    -DartifactId=projectName

2. 创建Maven的Web项目：

mvn archetype:create
    -DgroupId=packageName
    -DartifactId=webappName
    -DarchetypeArtifactId=maven-archetype-webapp

3. 反向生成 maven 项目的骨架：

mvn archetype:generate

　　你是怎么创建你的maven项目的?是不是像这样:

mvn archetype:create -DarchetypeArtifactId=maven-archetype-quickstart -DgroupId=com.ryanote -Dartifact=common

　　如果你还再用的话,那你就out了,现代人都用mvn archetype:generate了,它将创建项目这件枯燥的事更加人性化,你再也不需要记那么多的archetypeArtifactId,你只需输入archetype:generate,剩下的就是做”选择题”了.

　　cmd步骤：

　　缩写写法：

mvn archetype:generate -DgroupId=otowa.user.dao -DartifactId=user-dao -Dversion=0.01-SNAPSHOT

4. 编译源代码：

mvn compile

5. 编译测试代码：

mvn test-compile

6. 运行测试:

mvn test

7. 产生site：

mvn site

8. 打包：

mvn package

install和package的区别：

　　package命令完成了项目编译、单元测试、打包功能，但没有把打好的可执行jar包（war包或其他形式的包）

部署到本地maven仓库和远程maven私服仓库

　　install     命令完成了项目编译、单元测试、打包功能，同时把打好的可执行jar包（war包或其他形式的包）

部署到本地maven仓库，但没有部署到远程maven私服仓库

9. 在本地Repository中安装jar：

mvn install
例：installing D:\xxx\xx.jar to D:\xx\xxxx

10. 清除产生的项目：

mvn clean

11. 生成eclipse项目：

mvn eclipse:eclipse

12. 生成idea项目：

mvn idea:idea

13. 组合使用goal命令，如只打包不测试：

mvn -Dtest package

14. 编译测试的内容：

mvn test-compile

15. 只打jar包:

mvn jar:jar

16. 只测试而不编译，也不测试编译：

mvn test -skipping compile -skipping test-compile
 ( -skipping 的灵活运用，当然也可以用于其他组合命令) 

17. 清除eclipse的一些系统设置:

mvn eclipse:clean 

18.查看当前项目已被解析的依赖：

mvn dependency:list

19.上传到私服：

mvn deploy

20. 强制检查更新，由于快照版本的更新策略(一天更新几次、隔段时间更新一次)存在，如果想强制更新就会用到此命令: 

mvn clean install-U

21. 源码打包：

mvn source:jar
或
mvn source:jar-no-fork

mvn compile与mvn install、mvn deploy的区别

1. mvn compile，编译类文件
2. mvn install，包含mvn compile，mvn package，然后上传到本地仓库
3. mvn deploy,包含mvn install,然后，上传到私服

2、PS:

　　一般使用情况是这样，首先通过cvs或svn下载代码到本机，然后执行mvn eclipse:eclipse生成ecllipse项目文件，然后导入到eclipse就行了；修改代码后执行mvn compile或mvn test检验，也可以下载eclipse的maven插件。

1. 显示版本信息 :

mvn -version/-v

2. 创建mvn项目:

mvn archetype:create -DgroupId=com.oreilly -DartifactId=my-app

3. 生成target目录，编译、测试代码，生成测试报告，生成jar/war文件 :

mvn package

4. 运行项目于jetty上:

mvn jetty:run

5. 显示详细错误 信息:

mvn -e

6. 验证工程是否正确，所有需要的资源是否可用:

mvn validate

7. 在集成测试可以运行的环境中处理和发布包:

mvn integration-test

8. 运行任何检查，验证包是否有效且达到质量标准:

mvn verify

9. 产生应用需要的任何额外的源代码，如xdoclet :

mvn generate-sources

10. 使用 help 插件的  describe 目标来输出 Maven Help 插件的信息:

mvn help:describe -Dplugin=help

11. 使用Help 插件输出完整的带有参数的目标列 :

mvn help:describe -Dplugin=help -Dfull

12. 获取单个目标的信息,设置  mojo 参数和  plugin 参数。此命令列出了Compiler 插件的compile 目标的所有信息 :

mvn help:describe -Dplugin=compiler -Dmojo=compile -Dfull

13. 列出所有 Maven Exec 插件可用的目标:

mvn help:describe -Dplugin=exec -Dfull

14. 看这个“有效的 (effective)”POM，它暴露了 Maven的默认设置 :

mvn help:effective-pom

15. 想要查看完整的依赖踪迹，包含那些因为冲突或者其它原因而被拒绝引入的构件，打开 Maven 的调试标记运行 :

mvn install -X

16. 给任何目标添加maven.test.skip 属性就能跳过测试 :

mvn install -Dmaven.test.skip=true

17. 构建装配Maven Assembly 插件是一个用来创建你应用程序特有分发包的插件 :

mvn install assembly:assembly

18. 生成Wtp插件的Web项目 :

mvn -Dwtpversion=1.0 eclipse:eclipse

19. 清除Eclipse项目的配置信息(Web项目) :

mvn -Dwtpversion=1.0 eclipse:clean

20. 将项目转化为Eclipse项目 :

mvn eclipse:eclipse

21. mvn exec命令可以执行项目中的main函数 :

首先需要编译java工程：mvn compile
不存在参数的情况下：mvn exec:java -Dexec.mainClass="***.Main"
存在参数：mvn exec:java -Dexec.mainClass="***.Main" -Dexec.args="arg0 arg1 arg2"
指定运行时库：mvn exec:java -Dexec.mainClass="***.Main" -Dexec.classpathScope=runtime

22. 打印出已解决依赖的列表 :

mvn dependency:resolve

23. 打印整个依赖树 :

mvn dependency:tree

在应用程序用使用多个存储库 

<repositories>    
    <repository>     
        <id>Ibiblio</id>     
        <name>Ibiblio</name>     
        <url>http://www.ibiblio.org/maven/</url>   
    </repository>   
    <repository>     
        <id>PlanetMirror</id>     
        <name>Planet Mirror</name>     
        <url>http://public.planetmirror.com/pub/maven/</url>   
    </repository>  
</repositories>

mvn deploy:deploy-file -DgroupId=com -DartifactId=client -Dversion=0.1.0 -Dpackaging=jar -Dfile=d:\client-0.1.0.jar -DrepositoryId=maven-repository-inner -Durl=ftp://xxxxxxx/opt/maven/repository/

发布第三方Jar到本地库中

mvn install:install-file -DgroupId=com -DartifactId=client -Dversion=0.1.0 -Dpackaging=jar -Dfile=d:\client-0.1.0.jar


-DdownloadSources=true

-DdownloadJavadocs=true

3，附加

mvn help:describe

你是否因为记不清某个插件有哪些goal而痛苦过,你是否因为想不起某个goal有哪些参数而苦恼,那就试试这个命令吧,它会告诉你一切的.

参数: 1. -Dplugin=pluginName   2. -Dgoal(或-Dmojo)=goalName:与-Dplugin一起使用,它会列出某个插件的goal信息,

如果嫌不够详细,同样可以加-Ddetail.(注:一个插件goal也被认为是一个 “Mojo”)

下面大家就运行mvn help:describe -Dplugin=help -Dmojo=describe感受一下吧!

mvn tomcat:run

用了maven后,你再也不需要用eclipse里的tomcat来运行web项目(实际工作中经常会发现用它会出现不同步更新的情况),只需在对应目录里运行 mvn tomat:run命令,然后就可在浏览器里运行查看了.如果你想要更多的定制,可以在pom.xml文件里加下面配置:

01 02 03 04 org.codehaus.mojo 05 tomcat-maven-plugin 06 07 /web 08 9090 09 10 11 12 当然你也可以在命令里加参数来实现特定的功能,

下面几个比较常用:

　　1>. 跳过测试:-Dmaven.test.skip(=true)

　　2>. 指定端口:-Dmaven.tomcat.port=9090

　　3>. 忽略测试失败:-Dmaven.test.failure.ignore=true 当然,如果你的其它关联项目有过更新的话,一定要在项目根目录下运行mvn clean install来执行更新,再运行mvn tomcat:run使改动生效.

mvnDebug tomcat:run

这条命令主要用来远程测试,它会监听远程测试用的8000端口,在eclipse里打开远程测试后,它就会跑起来了,设断点,调试,一切都是这么简单.上面提到的那几个参数在这里同样适用.

mvn dependency:sources

故名思义,有了它,你就不用到处找源码了,运行一下,你项目里所依赖的jar包的源码就都有了