maven运⾏时的配置及命令详解
上⾯是指定端⼝运⾏程序的，也可以先指定好，直接在上⾯的地⽅写jettty:run          当然，如果你是在控制台运⾏且安装了maven，直接可以进⼊项⽬的⽂件中：mvn jetty:run
就是说，在控制台运⾏只要加上⼀个mvn就ok了
源代码格式的包
Maven install将项⽬输出构件部署到本地仓库
maven最主要的作⽤有两个⽅⾯，⼀个是对jar包的依赖解决功能，⾃⼰管理jar包，另⼀个功能就是项⽬的构建，打包部署。现在我觉得最重要的还是maven的⽣命周期和插件机制，下⾯就来总结⼀下吧。
mvn install 是将你打好的jar包安装到你的本地库中，⼀般没有设置过是在⽤户⽬录下的 .\下⾯。
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⼯程后，如果没有使⽤这两个命令，直接针对类进⾏测试，会跑出found的错误。因为此时还没有编译⽣成class⽂件。
  只有使⽤了上⾯的两个命令后，才能针对某个类进⾏单元测试。
　什么是maven?
  Maven是⼀个⽤于项⽬构建的⼯具，通过它便捷的管理项⽬的⽣命周期。即项⽬的jar包依赖，开发，测试，发布打包。
  下⾯我⾃⼰总结⼀下它的⼏个特点，看了这些特点，也许对maven有更多的了解。
  1 jar包依赖
  这个也许会maven最突出的特点了使⽤maven不需要上⽹单独下载jar包，只需要在配置⽂件l中配置jar包的依赖关系，就可以⾃动的下载jar包到我们的项⽬中。这样，别⼈开发或者使⽤这个⼯程时，不需要来回的拷贝jar包，只需要复制这个l就可以⾃动的下载这些jar包。
  ⽽且，我们⾃⼰下载jar包，还有可能造成版本的不⼀致，这样在协同开发的过程中就有可能造成代码运⾏的不⼀致。通过使⽤maven精确的匹配jar包，就不会出现这种问题了。
  2 项⽬坐标
  Maven通过特定的标识来定义项⽬名称，这样既可以唯⼀的匹配其他的jar包，也可以通过发布，使别⼈能使⽤⾃⼰的发布产品。这个标识就被叫做坐标，长的其实很普通，就是简单的xml⽽已：
1  <groupId&st</groupId>
2  <artifactId>maventest</artifactId>
3  <version>0.0.1-SNAPSHOT</version>
4  <packaging>jar</packaging>
5
6  <name>maventest</name>
7  <url></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
  ⽐如上⾯的l⽣成的jar包名字就是：maventest-0.0.1-SNAPSHOT.jar。
  这⾥的classifier是可选的，但是有的项⽬可能还需要导出附属的⼀些⽂件，如javadoc，source等等，那么这个地⽅就需要配置⼀个字符串。⼀般都是JDKXXX之类的。
Maven 使⽤介绍
创建project
maven⽆⾮也就是⽤来build⼀个project的，直接先上⼀个例⼦，在命令⾏下输⼊下⾯的命令：
mvn archetype:generate DarchetypeGroupId=org.apache.maven.archetypes -pany.app -DartifactId=myapp
mvn就是maven的命令⾏程序，archetype:generate中的archetype是plugin的名字，generate是goal的名字，命令⾏后⾯的是⼀些参数。关于archetype和goal以及后⾯的参数，后⾯再细说。
如果是第⼀次运⾏，这个过程会有点慢，maven需要下载⼀些依赖项，中间如果有输⼊提⽰信息，直接回车使⽤默认值就可以了。这条命令执⾏完后，会在你的当前⽬录下⽣成⼀个名为myapp的⽬录：
注意这个⽬录结构，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还⽣成了⼀个重要的⽂件l，maven就是通过这个⽂件来来管理整个project，可以理解位类似于eclipse的.project⽂件。默认⽣成的l⽂件的内容如下：
1
2
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22/* 1-1 */
<project xmlns="" xmlns:xsi=""
xsi:schemaLocation=" ">
<modelVersion>4.0.0</modelVersion>
<groupId&pany.app</groupId>
<artifactId>my-app</artifactId>
<version>1.1.0.1</version>
<packaging>jar</packaging>
<name>myapp</name>
<url></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的所有者或者机构的⼀个标识，⼀般是这种格式
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) ⼀个默认的l⽂件，这个默认的l⽂件中的groupId，artifactId，version⽤占位符表⽰，在创建project的时候通过参数
传进来。
仔细看⼀下我们前⾯创建project的命令：mvn archetype:generate DarchetypeGroupId=org.apache.maven.archetypes -
pany.app -DartifactId=myapp
1. 1) archetype:generate，这是⼀个maven的plugin，⽤来从⼀个archetype创建⼀个project，关于plugin后⾯再说。
2. 2) DarchetypeGroupId，这个就是指的archetype的groupid，也就是说是⽤的哪个archetype，或者说⽤哪个项⽬模板。
3. 3) 后⾯的两个参数，⽤来放⼤l⽂件⾥⾯，作为当前创建的project的描述信息。
Project创建好了，看如何去编译，直接进⼊的project的⽬录，在命令⾏下：
mvn compile
编译完后maven会创建⼀个target⽬录去保存编译结果。我们需要编译成⼀个什么样的内容，以及要输出到什么地⽅等等，都是可以在l⽂件⾥⾯配置的，但是因为我们⽬前并没有指定这些内容，所以maven会使⽤默认值。
我们还可以⽤maven执⾏test：
mvn test
第⼀次执⾏时，maven会去下载⼀些依赖项。另外要注意的时，如果我们更改了默认的⽬录结构，maven会因为bu到test⽽⽆法去执⾏test。如果只需要编译test可以执⾏：
mvn test-compile
要把项⽬打包，执⾏：
mvn package
mvn会根据l⾥⾯的packaging选项打包成相应的⽂件。
repository & dependency
maven⾥⾯有⼀个repository的概念，当我们的项⽬依赖于某个jar时，maven会去repository⾥⾯去。repository分两种，⼀种是远程的，⼀种是本地的。如果有⼏个project都⽤到junit，我们可以把junit放在repository⾥⾯，⼏个project可以公⽤，节约存储空间⽽且⽅便管理，这个repository的位置可以在l⾥⾯设置。
也就是说，我们如果我们的project需要要引⽤⼀个依赖项，我们只需要在l⽂件中进⾏配置，maven会⾃动帮我们去引⽤。我们之前的创建project⾥⾯需要写单元测试，引⽤到了junit，看pom中的配置：
1 2 3 4 5 6 7 8<dependencies>
<dependency>
<groupId>junit</groupId>        <artifactId>junit</artifactId>        <version>3.8.1</version>        <scope>test</scope>
</dependency>
</dependencies>
如果要把⼀个project安装到本地的repository⾥⾯，可以执⾏下⾯的命令：
mvn install
到这⾥就说完了创建，编译，测试，打包以及安装，⼤部分的项⽬也就是做这些事情。
再介绍⼏个其它命令：
1. mvn site ：为你的project创建⼀个站点
2. mvn clean：清除target⽬录下的所有⽂件
3. 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.maven打包本地jar包
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上。可以在l ⾥⾯配置。看两个配置：
1
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18<plugin>
<groupId&dello</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>

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。