maven运行时的配置及命令详解

2023-08-10 10:11:04

上面是指定端口运行程序的，也可以先指定好，直接在上面的地方写jettty:run 当然，如果你是在控制台运行且安装了maven，直接可以进入项目的文件中：mvn jetty:run

就是说，在控制台运行只要加上一个mvn就ok了

源代码格式的包

Maven install将项目输出构件部署到本地仓库

maven最主要的作用有两个方面，一个是对jar包的依赖解决功能，自己管理jar包，另一个功能就是项目的构建，打包部署。现在我觉得最重要的还是maven的生命周期和插件机制，下面就来总结一下吧。

mvn install 是将你打好的jar包安装到你的本地库中，一般没有设置过是在 用户目录下的 .m2\下面。

mvn package 只是将你的代码打包到输出目录，一般的是 target下面。

eclipse插件，m2eclipse

1.maven install相当于maven原生的命令： mvn install

2.aven build是 m2eclipse这个插件自己创造的概念，需要你来配置到底需要执行什么命令，如下图中的goals输入的就是你想执行的命令：

Goals就是mvn的意思，所以中间不需要加mvn了

　　Eclipse中maven常用的命令

　　点击Run As就可以发现几个Maven的命令：

　　Maven Build:

　　这个命令用于编译Maven工程，执行命令后会在target文件夹中的classes中生成对应的class文件。

　　Maven Clean:

　　删除target文件夹，即删除生成的package包以及class等文件。

　　Maven Test:

　　先自动进行编译，在运行所有的测试用例。

　　Maven install:

　　发布生成对应的package包。

注意：

　　留意上面的命令的作用，build和test都会生成相应的class文件。也就是说，当你新建一个maven工程，或者clean一个maven工程后，如果没有使用这两个命令，直接针对类进行测试，会跑出java.class.notfound的错误。因为此时还没有编译生成class文件。

　　只有使用了上面的两个命令后，才能针对某个类进行单元测试。

　什么是maven?

　　Maven是一个用于项目构建的工具，通过它便捷的管理项目的生命周期。即项目的jar包依赖，开发，测试，发布打包。

　　下面我自己总结一下它的几个特点，看了这些特点，也许对maven有更多的了解。

　　1 jar包依赖

　　这个也许会maven最突出的特点了使用maven不需要上网单独下载jar包，只需要在配置文件pom.xml中配置jar包的依赖关系，就可以自动的下载jar包到我们的项目中。这样，别人开发或者使用这个工程时，不需要来回的拷贝jar包，只需要复制这个pom.xml就可以自动的下载这些jar包。

　　而且，我们自己下载jar包，还有可能造成版本的不一致，这样在协同开发的过程中就有可能造成代码运行的不一致。通过使用maven精确的匹配jar包，就不会出现这种问题了。

　　2 项目坐标

　　Maven通过特定的标识来定义项目名称，这样既可以唯一的匹配其他的jar包，也可以通过发布，使别人能使用自己的发布产品。这个标识就被叫做坐标，长的其实很普通，就是简单的xml而已：

1   <groupId>com.test</groupId>

2   <artifactId>maventest</artifactId>

3   <version>0.0.1-SNAPSHOT</version>

4   <packaging>jar</packaging>

5

6   <name>maventest</name>

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

　　groupId：所述的项目名称，由于有的项目并不是一个jar包构成的，而是由很多的jar包组成的。因此这个groupId就是整个项目的名称。

　　artifactId：包的名称。

　　version：版本号。

　　packaging：包的类型，一般都是jar，也可以是war之类的。如果不填，默认就是jar。

　　name和url，一个是名称，一个是maven的地址。主要就是上面的几个参数。

　　当想要依赖什么jar的时候就可以通过下面的方式依赖：

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>

　　各个属性的内容基本上都是一样的。

　　这里要注意的是jar包的命名规则：

　　artifactId-version[-classifier].packaging

　　比如上面的pom.xml生成的jar包名字就是：maventest-0.0.1-SNAPSHOT.jar。

　　这里的classifier是可选的，但是有的项目可能还需要导出附属的一些文件，如javadoc，source等等，那么这个地方就需要配置一个字符串。一般都是JDKXXX之类的。

Maven 使用介绍

创建project

先去官方网站下载一个最新版本http://maven.apache.org/download.cgi.
下载后解压，使用之前最好先将maven的bin目录设置到path环境变量里面。

maven无非也就是用来build一个project的，直接先上一个例子，在命令行下输入下面的命令：

mvn archetype:generate DarchetypeGroupId=org.apache.maven.archetypes -DgroupId=com.mycompany.app -DartifactId=myapp

mvn就是maven的命令行程序，archetype:generate中的archetype是plugin的名字，generate是goal的名字，命令行后面的是一些参数。关于archetype和goal以及后面的参数，后面再细说。

如果是第一次运行，这个过程会有点慢，maven需要下载一些依赖项，中间如果有输入提示信息，直接回车使用默认值就可以了。这条命令执行完后，会在你的当前目录下生成一个名为myapp的目录：

maven运行时的配置及命令详解

注意这个目录结构，src/main/java 和 src/test/java 是不能改动，不然maven会无法找到源文件。下面是maven一个标准的目录结构：

src/main/java	Application/Library sources
src/main/resources	Application/Library resources
src/main/filters	Resource filter files
src/main/assembly	Assembly descriptors
src/main/config	Configuration files
src/main/scripts	Application/Library scripts
src/main/webapp	Web application sources
src/test/java	Test sources
src/test/resources	Test resources
src/test/filters	Test resource filter files
src/site	Site

另外maven还生成了一个重要的文件pom.xml，maven就是通过这个文件来来管理整个project，可以理解位类似于eclipse的.project文件。默认生成的pom.xml文件的内容如下：

/* 1-1 */

<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>com.mycompany.app</groupId>

<artifactId>my-app</artifactId>

<version>1.1.0.1</version>

<packaging>jar</packaging>

<name>myapp</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>3.8.1</version>

<scope>test</scope>

</dependency>

</dependencies>

</project>

解释一下这个xml文件的内容：

modelVersion：这个XML文件所使用的POM格式的版本
groupId：相当于这个project的所有者或者机构的一个标识，一般是com.company.xxx这种格式
artifactId：这个project最后所生成的文档(jar、war)的名字，比如对于junit这个开源的project，它的artifactId就是junit
packaging：这个project的打包的类型，一般是war、jar等值
version： project的版本
name： project的名字，生成文档等内容的时候会用的这个名字

这个project创建好后和普通的project没有什么不同，我们直接往里面放源代码进行开发就可以了，如果有目录想修改的也完全可以。

POM & archetype

archetype就是一个project的模板，上面我们生成的project就是用默认的archetype生成的。如果使用不同的archetype，生成的project结构会有所不同。一个archetype指明了

1) 项目的目录结构以及什么目录是放source code，哪些是放test source code，哪些目录是放resource的。
2) 一个默认的pom.xml文件，这个默认的pom.xml文件中的groupId，artifactId，version用占位符表示，在创建project的时候通过参数传进来。

pom.xml文件的POM全称是Project Object Model，这个文件对于maven的使用者来说是一个和maven交互的渠道，pom.xml包含了一个maven project的配置，一个project该如何编译打包，project有哪些依赖项等等。

仔细看一下我们前面创建project的命令：mvn archetype:generate DarchetypeGroupId=org.apache.maven.archetypes -DgroupId=com.mycompany.app -DartifactId=myapp

1) archetype:generate，这是一个maven的plugin，用来从一个archetype创建一个project，关于plugin后面再说。
2) DarchetypeGroupId，这个就是指的archetype的groupid，也就是说是用的哪个archetype，或者说用哪个项目模板。
3) 后面的两个参数，用来放大pom.xml文件里面，作为当前创建的project的描述信息。

Project创建好了，看如何去编译，直接进入的project的目录，在命令行下：

mvn compile

编译完后maven会创建一个target目录去保存编译结果。我们需要编译成一个什么样的内容，以及要输出到什么地方等等，都是可以在pom.xml文件里面配置的，但是因为我们目前并没有指定这些内容，所以maven会使用默认值。

我们还可以用maven执行test：

mvn test

第一次执行时，maven会去下载一些依赖项。另外要注意的时，如果我们更改了默认的目录结构，maven会因为找bu到test而无法去执行test。如果只需要编译test可以执行：

mvn test-compile

要把项目打包，执行：

mvn package

mvn会根据pom.xml里面的packaging选项打包成相应的文件。

repository & dependency

maven里面有一个repository的概念，当我们的项目依赖于某个jar时，maven会去repository里面去找。repository分两种，一种是远程的，一种是本地的。如果有几个project都用到junit，我们可以把junit放在repository里面，几个project可以公用，节约存储空间而且方便管理，这个repository的位置可以在pom.xml里面设置。

本地的默认的路径是安装用户的目录下的 .m2\repository 文件夹。如果一个依赖项在本地的repository里面没有，那么maven会去他自己的远程的repositoryhttp://repo.maven.apache.org/maven2 去下载后放到本地的repository里面。

也就是说，我们如果我们的project需要要引用一个依赖项，我们只需要在pom.xml文件中进行配置，maven会自动帮我们去引用。我们之前的创建project里面需要写单元测试，引用到了junit，看pom中的配置：

<dependencies>

<dependency>

<groupId>junit</groupId>

<artifactId>junit</artifactId>

<version>3.8.1</version>

<scope>test</scope>

</dependency>

</dependencies>

每一个需要为每一个 dependency 指明groupId，artifactId，version。scope很简单，意思是说我们需要怎么引用，比如我们上面的例子里面设置的是test，意思是说只在test里面引用junit。但是我们如何知道groupId，artifactId和version呢？比如我现在想引用log4j，这个几个值怎么填？可以去http://mirrors.ibiblio.org/maven2/ 上去查找。比如log4j，我们就在上面这个地址加上log4j，也就是http://mirrors.ibiblio.org/maven2/junit/。进去后会有一个maven-metadata.xml，打开就可以知道这些值了然后添加这个dependency了。

如果要把一个project安装到本地的repository里面，可以执行下面的命令：

mvn install

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

再介绍几个其它命令：

mvn site ：为你的project创建一个站点
mvn clean：清除target目录下的所有文件
mvn eclipse:eclipse ：为project生成eclipse的工程文件和classpath文件

build lifecycle & build phase & goal

maven有一套build的生命周期，是按照一套顺序走下来的，这一套顺序就叫一个生命周期(lifecycle)。maven内置三种生命周期：default, clean 和 site。一个生命周期分为多个build phase，下面是default生命周期全部的build phase：

validate：validate the project is correct and all necessary information is available.
initialize：initialize build state, e.g. set properties or create directories.
generate-sources：generate any source code for inclusion in compilation.
process-sources：process the source code, for example to filter any values.
generate-resources：generate resources for inclusion in the package.
process-resources：copy and process the resources into the destination directory, ready for packaging.
compile：compile the source code of the project.
process-classes：post-process the generated files from compilation, for example to do bytecode enhancement on Java classes.
generate-test-sources：generate any test source code for inclusion in compilation.
process-test-sources：process the test source code, for example to filter any values.
generate-test-resources：create resources for testing.
process-test-resources：copy and process the resources into the test destination directory.
test-compile：compile the test source code into the test destination directory
process-test-classes：post-process the generated files from test compilation, for example to do bytecode enhancement on Java classes. For Maven 2.0.5 and above.
test：run tests using a suitable unit testing framework. These tests should not require the code be packaged or deployed.
prepare-package：perform any operations necessary to prepare a package before the actual packaging. This often results in an unpacked, processed version of the package. (Maven 2.1 and above)
package：take the compiled code and package it in its distributable format, such as a JAR.
pre-integration-test：perform actions required before integration tests are executed. This may involve things such as setting up the required environment.
integration-test：process and deploy the package if necessary into an environment where integration tests can be run.
post-integration-test：perform actions required after integration tests have been executed. This may including cleaning up the environment.
verify：run any checks to verify the package is valid and meets quality criteria.
install：install the package into the local repository, for use as a dependency in other projects locally.
deploy：done in an integration or release environment, copies the final package to the remote repository for sharing with other developers and projects.

这些build phase是按照顺序执行的，如果执行后面的build phase，前面的build phase 也会被执行。例如如果执行：

mvn deploy

前面的install、verify一直到validate这些build phase都会执行。

每一个build phase是由goal组成的，一个goal其实就是一个任务，一个goal可以关联到一个build phase也可以不关联到任何build phase 。不关联到任何phase的goal是可以独立执行的，例如：

mvn clean dependency:copy-dependencies package

上面的命令会导致先执行clean这个phase，然后拷贝依赖项，最后打包。注意，这里clean这个goal是clean这个lifecycle里面的一个goal，所以可以看到不同lifecycle的build phase和goal是可以混合在一起执行的。如果一个goal被绑定到多个phase上，那么goal就会被执行多次。

phase的顺序是已经固定的，如果一个phase没有绑定到任何goal，那么phase就不会被执行。一个goal可以通过两种方式绑定到一个phase，一个是指定packaging，另一个就是plugin。

packaging&plugin

plugin就是用来向maven提供goal的。一个plugin里面可以有多个goal，这就是为什么我们在指明goal时，前面会用一个冒号与plugin的名字。

一个plugin自己可以指定自己的goal绑定到哪个lifecycle的哪一个Phase上，另外也可以配置一个goal绑定到哪个phase上。可以在pom.xml里面配置。看两个配置：

<plugin>

<groupId>org.codehaus.modello</groupId>

<artifactId>modello-maven-plugin</artifactId>

<version>1.4</version>

<executions>

<execution>

<configuration>

<models>

<model>src/main/mdo/maven.mdo</model>

</models>

<version>4.0.0</version>

</configuration>

<goals>

<goal>java</goal>

</goals>

</execution>

</executions>

</plugin>

这个就在当前的lifecycle里面添加了一个名字叫java的goal，这goal会根据自己的配置去绑定到一个phase，在phase执行的时候这个goal会执行。并且在这个配置里面，可以指定多个execution来让这个goal执行多次。

看另一个示例配置：

<plugin>

<groupId>com.mycompany.example</groupId>

<artifactId>display-maven-plugin</artifactId>

<version>1.0</version>

<executions>

<execution>

<phase>process-test-resources</phase>

<goals>

<goal>time</goal>

</goals>

</execution>

</executions>

</plugin>

这个名为time的goal把自己绑定到了process-test-resource这个phase上。

在默认情况下，并不是所有的phase都绑定了goal，比如clean这个lifecycle是有三个phase的，但是只有其中的一个名为clean的phase默认绑定了一个clean:clean goal，其它两个phase默认没有绑定任何goal。

之前已经提到过packaging，在pom.xml可以指定packaging，每种packaging都设定了一组phase和goal之间的绑定关系。在default lifecycle下，当packaging为 ejb/ejb3/jar/par/rar/war 其中之一的值的时候，只有以下的phase绑定了goal，具体如下：

process-resources	resources:resources
compile	compiler:compile
process-test-resources	resources:testResources
test-compile	compiler:testCompile
test	surefire:test
package	jar:jar
install	install:install
deploy	deploy:deploy

总结

首先搞清楚maven的project的目录结构，然后理解maven的lifecycle，lifecycle是由build phase组成，每一个build phase会绑定到goal。goal是由plugin提供的。每一种packaging的值都表明了一定的phase和goal之间的绑定关系。

另外一个很重要的就是dependency，我们要在项目中引用一个依赖，只需要在pom.xml指定依赖的名字和版本，maven会自动去远程的repository下载，然后放到本地的repository里面，这样以后所有的project都可以共用

其它细节可以参考http://maven.apache.org/guides/index.html。

分类: Java, Maven

转:MAVEN常用命令

Maven库：

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

Maven依赖查询：

http://mvnrepository.com/

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. 编译源代码： mvn compile
4. 编译测试代码：mvn test-compile
5. 运行测试：mvn test
6. 产生site：mvn site
7. 打包：mvn package
8. 在本地Repository中安装jar：mvn install
9. 清除产生的项目：mvn clean
10. 生成eclipse项目：mvn eclipse:eclipse
11. 生成idea项目：mvn idea:idea
12. 组合使用goal命令，如只打包不测试：mvn -Dtest package
13. 编译测试的内容：mvn test-compile
14. 只打jar包: mvn jar:jar
15. 只测试而不编译，也不测试编译：mvn test -skipping compile -skipping test-compile
      ( -skipping 的灵活运用，当然也可以用于其他组合命令)
16. 清除eclipse的一些系统设置:mvn eclipse:clean

ps：

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

mvn -version/-v 显示版本信息
mvn archetype:generate 创建mvn项目
mvn archetype:create -DgroupId=com.oreilly -DartifactId=my-app 创建mvn项目

mvn package            生成target目录，编译、测试代码，生成测试报告，生成jar/war文件
mvn jetty:run            运行项目于jetty上,
mvn compile                    编译
mvn test                    编译并测试
mvn clean                    清空生成的文件
mvn site                    生成项目相关信息的网站
mvn -Dwtpversion=1.0 eclipse:eclipse        生成Wtp插件的Web项目
mvn -Dwtpversion=1.0 eclipse:clean        清除Eclipse项目的配置信息(Web项目)
mvn eclipse:eclipse                将项目转化为Eclipse项目

在应用程序用使用多个存储库
<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

mvn -e 显示详细错误信息.

mvn validate        验证工程是否正确，所有需要的资源是否可用。
mvn test-compile    编译项目测试代码。。
mvn integration-test     在集成测试可以运行的环境中处理和发布包。
mvn verify        运行任何检查，验证包是否有效且达到质量标准。
mvn generate-sources    产生应用需要的任何额外的源代码，如xdoclet。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/lifxue/archive/2009/10/14/4662902.aspx

常用命令：
mvn -v 显示版本
mvn help:describe -Dplugin=help 使用 help 插件的 describe 目标来输出 Maven Help 插件的信息。
mvn help:describe -Dplugin=help -Dfull 使用Help 插件输出完整的带有参数的目标列
mvn help:describe -Dplugin=compiler -Dmojo=compile -Dfull 获取单个目标的信息,设置 mojo 参数和 plugin 参数。此命令列出了Compiler 插件的compile 目标的所有信息
mvn help:describe -Dplugin=exec -Dfull 列出所有 Maven Exec 插件可用的目标
mvn help:effective-pom 看这个“有效的 (effective)”POM，它暴露了 Maven的默认设置

mvn archetype:create -DgroupId=org.sonatype.mavenbook.ch03 -DartifactId=simple -DpackageName=org.sonatype.mavenbook 创建Maven的普通java项目，在命令行使用Maven Archetype 插件
mvn exec:java -Dexec.mainClass=org.sonatype.mavenbook.weather.Main Exec 插件让我们能够在不往 classpath 载入适当的依赖的情况下，运行这个程序
mvn dependency:resolve 打印出已解决依赖的列表
mvn dependency:tree 打印整个依赖树

mvn install -X 想要查看完整的依赖踪迹，包含那些因为冲突或者其它原因而被拒绝引入的构件，打开 Maven 的调试标记运行
mvn install -Dmaven.test.skip=true 给任何目标添加maven.test.skip 属性就能跳过测试
mvn install assembly:assembly 构建装配Maven Assembly 插件是一个用来创建你应用程序特有分发包的插件

mvn jetty:run 调用 Jetty 插件的 Run 目标在 Jetty Servlet 容器中启动 web 应用
mvn compile 编译你的项目
mvn clean install 删除再编译

mvn hibernate3:hbm2ddl 使用 Hibernate3 插件构造数据库

---------------------
作者：fireflies爱人如己
来源：CSDN
原文：https://blog.csdn.net/sinat_29581293/article/details/51700093?utm_source=copy
版权声明：本文为博主原创文章，转载请附上博文链接！

码农公寓

Eclipse中maven常用的命令

什么是maven?

转:MAVEN常用命令

相关文章

　　Eclipse中maven常用的命令

　什么是maven?