Maven学习总结

转载至：http://www.cnblogs.com/xdp-gacl/p/3498271.html

一 入门

一、Maven的基本概念

　　Maven(翻译为"专家"，"内行")是跨平台的项目管理工具。主要服务于基于Java平台的项目构建，依赖管理和项目信息管理。

1.1、项目构建

　　项目构建过程包括【清理项目】→【编译项目】→【测试项目】→【生成测试报告】→【打包项目】→【部署项目】这几个步骤，这六个步骤就是一个项目的完整构建过程。

　　理想的项目构建是高度自动化，跨平台，可重用的组件，标准化的，使用maven就可以帮我们完成上述所说的项目构建过程。

1.2、依赖管理

　　依赖指的是jar包之间的相互依赖，比如我们搭建一个Struts2的开发框架时，光光有struts2-core-2.3.16.3.jar这个jar包是不行的，struts2-core-2.3.16.3.jar还依赖其它的jar包，依赖管理指的就是使用Maven来管理项目中使用到的jar包，Maven管理的方式就是“自动下载项目所需要的jar包，统一管理jar包之间的依赖关系”。

1.3、使用Maven的好处

　　Maven中使用约定，约定java源代码代码必须放在哪个目录下，编译好的java代码又必须放到哪个目录下，这些目录都有明确的约定。

　　Maven的每一个动作都拥有一个生命周期，例如执行 mvn install 就可以自动执行编译，测试，打包等构建过程

　　只需要定义一个pom.xml,然后把源码放到默认的目录，Maven帮我们处理其他事情

　　使用Maven可以进行项目高度自动化构建，依赖管理(这是使用Maven最大的好处)，仓库管理。

二、Maven下载

　　下载地址：http://maven.apache.org/download.cgi

　　下载完成后，得到一个压缩包，解压，可以看到maven的组成目录

　　Maven目录分析

• bin：含有mvn运行的脚本
• boot：含有plexus-classworlds类加载器框架
• conf：含有settings.xml配置文件
• lib：含有Maven运行时所需要的java类库
• LICENSE.txt, NOTICE.txt, README.txt针对Maven版本，第三方软件等简要介绍

三、Maven安装

　　1、首先要确保电脑上已经安装了JDK(要jdk 1.6+的版本)，配置好JDK的环境变量，使用如下的两个命令检查检查JDK安装的情况。

1 Echo %JAVA_HOME%
2 Java -version

　　2、对apache-maven-3.2.3-bin.zip进行解压缩

　　对apache-maven-3.2.3-bin.zip进行解压缩，例如解压到如下目录(解压目录最好不要有中文)

　　3、设置系统环境变量：MAVEN_HOME

　　4、设置环境变量Path，将%MAVEN_HOME%\bin加入Path中，一定要注意要用分号；与其他值隔开，如下图所示：

　　%MAVEN_HOME%\bin代表的就是"E:\apache-maven-3.2.3\bin"目录

　　5、验证Maven安装是否成功

　　打开cmd窗口

　　输入"mvn –v"命令 查看Maven的相关信息，如下图所示：

　　能够出现这样的信息就说明Maven的安装已经成功了。

　　6、设置MAVEN_OPTS环境变量(可选配置)

　　由于Maven命令实际上是执行了Java命令，所以可以通过JAVA命令参数的方式来设置MAVEN运行参数。MAVEN_OPTS环境变量正是用于此用途

　　MAVEN_OPTS

　　-Xms128m -Xmx512m，分别设置JVM的最小和最大内存，如下图所示：

四、Maven的简单使用

4.1、Maven项目的目录约定

MavenProjectRoot(项目根目录)
   |----src
   |     |----main
   |     |         |----java ——存放项目的.java文件
   |     |         |----resources ——存放项目资源文件，如spring, hibernate配置文件
   |     |----test
   |     |         |----java ——存放所有测试.java文件，如JUnit测试类
   |     |         |----resources ——存放项目资源文件，如spring, hibernate配置文件
   |----target ——项目输出位置
   |----pom.xml ----用于标识该项目是一个Maven项目

4.2、手动创建Maven项目，使用Maven编译

　　1、创建项目根文件夹，例如Maven01

　　2、在Maven01文件夹中创建“pom.xml”文件，如下图所示：

　　pom.xml文件中的内容如下：

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <project xmlns="http://maven.apache.org/POM/4.0.0" 
 3 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
 4 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
 5 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 6     <!--所有的Maven项目都必须配置这四个配置项-->
 7     <modelVersion>4.0.0</modelVersion>
 8     <!--groupId指的是项目名的项目组，默认就是包名-->
 9     <groupId>cn.gacl.maven.hello</groupId>
10     <!--artifactId指的是项目中的某一个模块，默认命名方式是"项目名-模块名"-->
11     <artifactId>hello-first</artifactId>
12     <!--version指的是版本，这里使用的是Maven的快照版本-->
13     <version>SNAPSHOT-0.0.1</version>
14 </project>

　　3.编写Java类文件，Maven项目规定，所有的*.java文件必须放在src目录下的main目录下的java目录中，在Maven01项目根目录中创建一个src目录，然后在src目录中创建main目录，在main目录中再创建java文件夹，如下图所示：

　　在java文件夹下创建一个Hello.java文件，如下图所示

　　在Hello.java文件中编写如下代码：

1 public class Hello{
2     public static void main(String[] args){
3         System.out.println("Hello Maven");
4     }
5 }

　　4.使用Maven编译Hello.java，首先进入到项目根目录，然后使用命令”mvn compile”进行编译，如下图所示：

　　使用Maven编译完成之后，在项目根目录下会生成一个target文件夹，如下图所示：

　　打开target文件夹，可以看到里面有一个classes文件夹，如下图所示：

　　classes文件夹存放的就是编译成功后生成的.class文件，如下图所示：

　　5.使用"mvn clean"命令清除编译结果，也就是把编译生成的target文件夹删掉，如下图所示：

　　执行完"mvn clean"命令后，target文件夹就会被删除了。

五、修改从Maven中心仓库下载到本地的jar包的默认存储位置

　　从Maven中心仓库下载到本地的jar包的默认存放在”${user.home}/.m2/repository”中，${user.home}表示当前登录系统的用户目录(如"C:\Users\gacl")，如下图所示

　　Jar包存放在这个位置不太好，我们希望能够自己定义下载下来的jar包的存放位置，因此我们可以自己设置下载到本地时的jar包的存放目录。

　　在“E:\”目录下创建一个“repository”文件夹

　　找到apache-maven-3.2.3\conf目录下的settings.xml文件，如下图所示：

　　编辑setting.xml文件，如下图所示：

　　加上下面的代码

1 <localRepository>E:/repository</localRepository>

　　这样就可以把jar包下载到我们指定的E:/repository目录中了，如下图所示：

　　把jar包下载到本地的好处就是，当编译时，会优先从本地的jar包去找，如果本地存在，就直接拿来用，如果不存在，就从Maven的中心仓库去下载。如下图所示：

　　第一次执行"mvn compile"和"mvn clean"这两个命令时，Maven会去中央仓库下载需要的jar包，而第二次执行这两个命令时，由于所需的jar包已经在本地的仓库中存储，所以就可以直接拿来用了，这样就省去了去中央仓库下载jar包的时间。

　　以上就是Maven的简单入门讲解。

=============================================

上一篇只是简单介绍了一下maven入门的一些相关知识，这一篇主要是体验一下Maven高度自动化构建项目的过程

一、创建Maven项目

1.1、建立Hello项目

　　1、首先建立Hello项目，同时建立Maven约定的目录结构和pom.xml文件

　　　　Hello
　　　　　　| --src
　　　　　　| -----main
　　　　　　| ----------java
　　　　　　| ----------resources
　　　　　　| -----test
　　　　　　| ---------java
　　　　　　| ---------resources
　　　　　　| --pom.xml

　　2、编辑项目Hello根目录下的pom.xml，添加如下的代码：

 1 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
 2 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 3   <modelVersion>4.0.0</modelVersion>
 4   <groupId>me.gacl.maven</groupId>
 5   <artifactId>Hello</artifactId>
 6   <version>0.0.1-SNAPSHOT</version>
 7   <name>Hello</name>
 8   
 9     <!--添加依赖的jar包-->
10     <dependencies>
11         <!--项目要使用到junit的jar包，所以在这里添加junit的jar包的依赖-->
12         <dependency>
13             <groupId>junit</groupId>
14             <artifactId>junit</artifactId>
15             <version>4.9</version>
16             <scope>test</scope>
17         </dependency>        
18         
19     </dependencies>
20 </project>

　　3、在src/main/java/me/gacl/maven目录下新建文件Hello.java

　　Hello.java的代码如下：

1 package me.gacl.maven;
2 
3 public class Hello {
4     
5     public String sayHello(String name){
6         return "Hello "+name+"!";
7     }
8 }

　　4、在/src/test/java/me/gacl/maven目录下新建测试文件HelloTest.java　　

　　HelloTest.java的代码如下：

 1 package me.gacl.maven;
 2 //导入junit的包
 3 import org.junit.Test;
 4 import static junit.framework.Assert.*;
 5 
 6 public class HelloTest {
 7 
 8     @Test
 9     public void testHello(){
10         Hello hello = new Hello();
11         String results = hello.sayHello("gacl");
12         assertEquals("Hello gacl!",results);        
13     }
14 }

1.2、使用Maven编译、清理、测试、打包项目

1、使用Maven编译项目，编译项目的命令是："mvn compile"

　　打开cmd命令行，

　　进入Hello项目根目录执行"mvn compile"命令编译项目的java类

　　编译成功之后，可以看到hello项目的根目录下多了一个【target】文件夹，这个文件夹就是编译成功之后Maven帮我们生成的文件夹，如下图所示：

　　打开【target】文件夹，可以看到里面有一个【classes】文件夹，如下图所示：

　　【classes】文件夹中存放的就是Maven我们编译好的java类，如下图所示：

　　这就是使用Maven自动编译项目的过程。

2、使用Maven清理项目，清理项目的命令是："mvn clean"

　　进入Hello项目根目录执行"mvn clean"命令清理项目，清理项目的过程就是把执行"mvn compile"命令编译项目时生成的target文件夹删掉，如下图所示：

3、使用Maven测试项目，测试项目的命令是："mvn test"

　　进入Hello项目根目录执行"mvn test"命令测试项目，如下图所示：

　　测试成功之后，可以看到hello项目的根目录下多了一个【target】文件夹，这个文件夹就是测试成功之后Maven帮我们生成的文件夹，如下图所示：

　　打开【target】文件夹，可以看到里面有一个【classes】和【test-classes】文件夹，如下图所示：

　　也就是说，我们执行执行"mvn test"命令测试项目时，Maven先帮我们编译项目，然后再执行测试代码。

4、使用Maven打包项目，打包项目的命令是："mvn package"

　　进入Hello项目根目录执行"mvn package"命令测试项目，如下图所示：

　　打包成功之后，可以看到hello项目的根目录下的【target】文件夹中多了一个Hello-0.0.1-SNAPSHOT.jar，这个Hello-0.0.1-SNAPSHOT.jar就是打包成功之后Maven帮我们生成的jar文件，如下图所示：

5、使用Maven部署项目，部署项目的命令是："mvn install"

　　进入Hello项目根目录执行"mvn install"命令测试项目，如下图所示：

　　安装成功之后，首先会在hello项目的根目录下生成【target】文件夹，打开【target】文件夹，可以看到里面会有Hello-0.0.1-SNAPSHOT.jar，这个Hello-0.0.1-SNAPSHOT.jar就是安装成功之后Maven帮我们生成的jar文件，如下图所示：

　　除此之外，在我们存放Maven下载下来的jar包的仓库也会有一个Hello-0.0.1-SNAPSHOT.jar，所以Maven安装项目的过程，实际上就是把项目进行【清理】→【编译】→【测试】→【打包】，再把打包好的jar放到我们指定的存放jar包的Maven仓库中，如下图所示：

　　所以使用"mvn install"命令，就把maven构建项目的【清理】→【编译】→【测试】→【打包】的这几个过程都做了，同时将打包好的jar包发布到本地的Maven仓库中，所以maven最常用的命令还是"mvn install"，这个命令能够做的事情最多。

1.2、组合使用Maven的命令

　　maven的编译，清理，测试，打包，部署命令是可以几个命令同时组合起来使用的，常用的命令组合如下：

　　1、先清理再编译："mvn clean compile"，如下所示：

　　还有的就是"mvn clean test"，"mvn clean package"，"mvn clean install"，这些组合命令都比较常用。

　　以上就是关于Maven构建项目的各个个过程演示。

二、在别的项目中使用通过Maven安装生成的项目的jar包

　　在上面，我们使用mvn install命令将hello这个项目打包成了Hello-0.0.1-SNAPSHOT.jar包并且发布到本地的maven仓库E:\repository\me\gacl\maven\Hello\0.0.1-SNAPSHOT中，下面我们来看看如何在别的项目中使用Hello-0.0.1-SNAPSHOT.jar

　　1、新建HelloFriend项目，同时建立Maven约定的目录结构和pom.xml文件
　　　　HelloFriend
 　　　　　  | --src
　　　　　　| -----main
　　　　　　| ----------java
　　　　　　| ----------resources
　　　　　　| -----test
　　　　　　| ---------java
　　　　　　| ---------resources
　　　　　　| --pom.xml

　　如下图所示：

　　2、编辑项目HelloFriend根目录下的pom.xml，添加如下的代码：

 1 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
 2 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 3   <modelVersion>4.0.0</modelVersion>
 4   <groupId>me.gacl.maven</groupId>
 5   <artifactId>HelloFriend</artifactId>
 6   <version>0.0.1-SNAPSHOT</version>
 7   <name>HelloFriend</name>
 8   
 9     <!--添加依赖的jar包-->
10     <dependencies>
11         <!--项目要使用到junit的jar包，所以在这里添加junit的jar包的依赖-->
12         <dependency>
13             <groupId>junit</groupId>
14             <artifactId>junit</artifactId>
15             <version>4.9</version>
16             <scope>test</scope>
17         </dependency>
18         <!--项目要使用到Hello的jar包，所以在这里添加Hello的jar包的依赖-->
19         <dependency>
20             <groupId>me.gacl.maven</groupId>
21             <artifactId>Hello</artifactId>
22             <version>0.0.1-SNAPSHOT</version>
23             <scope>compile</scope>
24         </dependency>    
25     </dependencies>
26 </project>

　　3、在src/main/java/me/gacl/maven目录下新建文件HelloFriend.java，如下图所示：

　　HelloFriend.java的代码如下：

 1 package me.gacl.maven;
 2 
 3 import me.gacl.maven.Hello;
 4 
 5 public class HelloFriend {
 6 
 7     public String sayHelloToFriend(String name){
 8         
 9         Hello hello = new Hello();
10         String str = hello.sayHello(name)+" I am "+this.getMyName();
11         System.out.println(str);
12         return str;
13     }
14     
15     public String getMyName(){
16         return "John";
17     }
18 }

　　4、在/src/test/java/me/gacl/maven目录下新建测试文件HelloFriendTest.java，如下图所示：

　　HelloFriendTest.java的代码如下：

 1 package me.gacl.maven;
 2 
 3 import static junit.framework.Assert.assertEquals;
 4 import org.junit.Test;
 5 import me.gacl.maven.Hello;
 6 
 7 public class HelloFriendTest {
 8 
 9     @Test
10     public void tesHelloFriend(){
11         
12         HelloFriend helloFriend = new HelloFriend();
13         String results = helloFriend.sayHelloToFriend("gacl");
14         assertEquals("Hello gacl! I am John",results);
15     }
16 }

　　5、在HelloFriend目录下执行命令"mvn package"测试Hello-0.0.1-SNAPSHOT.jar里面的类是否引用成功，如下所示：

=====================================================

　　maven作为一个高度自动化构建工具，本身提供了构建项目的功能，下面就来体验一下使用maven构建项目的过程。

一、构建Jave项目

1.1、创建Jave Project

　　1、使用mvn archetype:generate命令，如下所示：

mvn archetype:generate -DgroupId=com.mycompany.app -DartifactId=myapp -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

　　2、使用mvn archetype:create命令，如下所示：

mvn archetype:create -DgroupId=com.mycompany.app -DartifactId=myapp -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

　　使用"mvn archetype:generate"命令和"mvn archetype:create"都可以创建项目，目前没有发现这两者的区别，唯一区别的地方就是发现使用"mvn archetype:generate"命令创建项目时要特别长的时间才能够将项目创建好，而使用"mvn archetype:create"命令则可以很快将项目创建出来。

　　使用"mvn archetype:create"命令创建一个java项目的过程如下图所示：

　　BUILD SUCCESS就表示项目构建成功，当在前用户目录下（即C:\Documents and Settings\Administrator）下构建了一个Java Project叫做myapp。

　　构建好的Java项目的目录结构如下：

　　可以看到，Maven帮我们创建的项目是一个标准的Maven项目，不过目前Maven只是帮我们生成了src/main/java(存放项目的源代码)和src/test/java(存放测试源代码)这两个目录，但实际项目开发中我们一般都会有配置文件，例如log4j.properties，所以我们还需要手动创建src/main/resources(存放项目开发中用到的配置文件，如存放log4j.properties等)和src/test/resources(存放测试时用到的配置文件)，如下图所示：

　　然后我们就可以将创建好的myapp项目导入到Eclipse中进行开发了，如下图所示：

1.2、JavaProject的pom.xml文件说明

　　通过Maven构建的JavaProject，在项目的根目录下都会存在一个pom.xml文件，进入myapp目录，可以看到有一个pom.xml文件，这个文件是Maven的核心。如下图所示：

　　　　1、pom意思就是project object model。

　　　　2、pom.xml包含了项目构建的信息，包括项目的信息、项目的依赖等。

　　　　3、pom.xml文件是可以继承的，大型项目中，子模块的pom.xml一般都会继承于父模块的pom.xml

　　pom.xml文件的内容如下：

 1 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 2   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 3   <modelVersion>4.0.0</modelVersion>
 4 
 5   <groupId>com.mycompany.app</groupId>
 6   <artifactId>myapp</artifactId>
 7   <version>1.0-SNAPSHOT</version>
 8   <packaging>jar</packaging>
 9 
10   <name>myapp</name>
11   <url>http://maven.apache.org</url>
12 
13   <properties>
14     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
15   </properties>
16 
17   <dependencies>
18     <dependency>
19       <groupId>junit</groupId>
20       <artifactId>junit</artifactId>
21       <version>3.8.1</version>
22       <scope>test</scope>
23     </dependency>
24   </dependencies>
25 </project>

　　pom.xml文件的节点元素说明：

　　　　<project>　　　　　　　pom文件的顶级节点
　　　　<modelVersion>　　　　 object model版本，对Maven2和Maven3来说，只能是4.0.0　
　　　　<groupId>　　　　　　　项目创建组织的标识符，一般是域名的倒写
　　　　<artifactId>　　　　　 定义了项目在所属组织的标识符下的唯一标识，一个组织下可以有多个项目
　　　　<version>　　　　　  　当前项目的版本，SNAPSHOT，表示是快照版本，在开发中

　　　　<packaging>　　　　  打包的方式，有jar、war、ear等
　　　　<name>　　　　　　　 项目的名称
　　　　<url>　　　　　　　　  项目的地址

　　　　<properties>　　　　属性配置，比如：<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
　　　　<dependencies>　　   构建项目依赖的jar

　　其中由groupId、artifactId和version唯一的确定了一个项目坐标

1.3、使用Maven编译-测试-打包-安装项目

1.3.1、编译

　　编译源程序，进入命令行，切换到myapp目录，执行命令：mvn clean compile，如下图所示：

　　编译成功，在myapp目录下多出一个target目录，target\classes里面存放的就是编译后的class文件，如下图所示：

1.3.2、测试

　　进入命令行，切换到myapp目录，执行命令：mvn clean test，如下图所示：

　　测试成功，在myapp\target目录下会有一个test-classes目录，存放的就是测试代码的class文件，如下图所示：

1.3.3、打包

　　进入命令行，切换到myapp目录，执行命令：mvn clean package，执行打包命令前，会先执行编译和测试命令，如下图所示：

　　构建成功后，会在target目录下生成myapp-1.0-SNAPSHOT.jar包，如下图所示：

1.3.4、安装

　　进入命令行，切换到my-app目录，执行命令：mvn clean install ，执行安装命令前，会先执行编译、测试、打包命令，如下图所示：

　　构建成功，就会将项目的jar包安装到本地仓库，如下图所示：

1.3.5、运行jar包

　　进入命令行，切换到myapp目录，执行命令：java -cp target\myapp-1.0-SNAPSHOT.jar com.mycompany.app.App，如下图所示：

二、构建JavaWeb项目

2.1、创建JavaWeb项目

　　1、使用mvn archetype:generate命令，如下所示：

mvn archetype:generate -DgroupId=com.mycompany.app -DartifactId=my-WebApp -DarchetypeArtifactId=maven-archetype-webapp -DinteractiveMode=false

　　使用"mvn archetype:generate"命令创建一个javaWeb项目的过程如下图所示：　　

　　使用"mvn archetype:generate"命令创建一个javaWeb项目的时间非常长，要了40多秒，有时甚至会更久，不知道为啥。

　　2、使用mvn archetype:create命令，如下所示：

mvn archetype:create -DgroupId=com.mycompany.app -DartifactId=myWebApp -DarchetypeArtifactId=maven-archetype-webapp -DinteractiveMode=false

　　使用"mvn archetype:create"命令创建一个javaWeb项目的过程如下图所示：　　

　　使用"mvn archetype:create"命令创建一个javaWeb项目的时间非常快，几秒钟就可以了。

　　创建好的JavaWeb项目的目录结构如下：

　　创建好的JavaWeb项目中目前只有src/main/resources目录，因此还需要手动添加src/main/java、src/test/java、src/test/resources

　　如下图所示：

　　接着我们就可以将创建好的JavaWeb导入Eclipse中进行开发了，如下图所示：

2.2、使用Maven打包发布Web项目

　　Maven帮我们创建的JavaWeb项目是一个空的项目，只有一个index.jsp页面，我们使用Maven将Web项目打包发布运行。

　　在命令行切换到myWebApp目录，执行：mvn package，构建成功后，myWebApp目录目录下多了一个target目录，在这个目录下会打包成myWebApp目录.war，把这个war包拷贝到Tomcat的发布目录下就可以运行了。如下图所示：

　　打包成功，在myWebApp\target目录下生成了一个myWebApp.war文件，如下图所示：

　　将myWebApp.war放到tomcat服务器中运行，如下图所示：

　　运行效果如下：

　　除了使用Tomcat服务器运行Web项目之外，我们还可以在Web项目中集成Jetty发布运行，首先在pom.xml文件中配置Jetty插件，如下：

 1 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 2   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
 3   <modelVersion>4.0.0</modelVersion>
 4   <groupId>com.mycompany.app</groupId>
 5   <artifactId>myWebApp</artifactId>
 6   <packaging>war</packaging>
 7   <version>1.0-SNAPSHOT</version>
 8   <name>myWebApp Maven Webapp</name>
 9   <url>http://maven.apache.org</url>
10   <dependencies>
11     <dependency>
12       <groupId>junit</groupId>
13       <artifactId>junit</artifactId>
14       <version>3.8.1</version>
15       <scope>test</scope>
16     </dependency>
17   </dependencies>
18   <build>
19     <finalName>myWebApp</finalName>
20      <pluginManagement>
21         <!--配置Jetty-->
22           <plugins>
23             <plugin>
24              <groupId>org.mortbay.jetty</groupId>   
25              <artifactId>maven-jetty-plugin</artifactId>
26             </plugin>
27           </plugins>
28     </pluginManagement>
29   </build>
30 </project>

　　打开命令行窗口，切换到myWebApp目录，然后执行：mvn jetty:run启动Jetty服务器，如下图所示：

　　接着就可以在8080端口上访问应用了。如下图所示：

三、Maven创建项目的命令说明

　　mvn archetype:create或者mvn archetype:generate　　固定写法

　　-DgroupId　　　　　　　　　　　　　　　　　　　　　　　组织标识（包名）

　　-DartifactId　　　　　　　　　　　　　　　　　　　　　　项目名称

　　-DarchetypeArtifactId　　  　　　　　　　　　　　　　　指定ArchetypeId，maven-archetype-quickstart，创建一个Java Project；maven-archetype-webapp，创建一个Web Project

　　-DinteractiveMode　　　　　　　　　　　　　　　　　　　　是否使用交互模式

　　archetype是mvn内置的一个插件，create任务可以创建一个java项目骨架，DgroupId是软件包的名称，DartifactId是项目名，DarchetypeArtifactId是可用的mvn项目骨架，目前可以使用的骨架有：

• maven-archetype-archetype
• maven-archetype-j2ee-simple
• maven-archetype-mojo
• maven-archetype-portlet
• maven-archetype-profiles (currently under development)
• maven-archetype-quickstart
• maven-archetype-simple (currently under development)
• maven-archetype-site
• maven-archetype-site-simple
• maven-archetype-webapp

　　每一个骨架都会建相应的目录结构和一些通用文件，最常用的是maven-archetype-quickstart和maven-archetype-webapp骨架。maven-archetype-quickstart骨架是用来创建一个Java Project，而maven-archetype-webapp骨架则是用来创建一个JavaWeb Project。

　　不得不说，Maven的确是一个很好的项目构建工具。掌握好Maven对于项目开发是非常有帮助的。

========================================

Maven学习总结(四)——Maven核心概念

一、Maven坐标

1.1、什么是坐标？

　　在平面几何中坐标（x,y）可以标识平面中唯一的一点。

1.2、Maven坐标主要组成

• groupId：组织标识（包名）
• artifactId：项目名称
• version：项目的当前版本
• packaging：项目的打包方式，最为常见的jar和war两种

样例：

　　

　　

1.3、Maven为什么使用坐标？

• Maven世界拥有大量构建，我们需要找一个用来唯一标识一个构建的统一规范。
• 拥有了统一规范，就可以把查找工作交给机器。

二、依赖管理

2.1、依赖配置

　　依赖配置主要包含如下元素：

 1     <!--添加依赖配置-->
 2     <dependencies>
 3         <!--项目要使用到junit的jar包，所以在这里添加junit的jar包的依赖-->
 4         <dependency>
 5             <groupId>junit</groupId>
 6             <artifactId>junit</artifactId>
 7             <version>4.9</version>
 8             <scope>test</scope>
 9         </dependency>
10         <!--项目要使用到Hello的jar包，所以在这里添加Hello的jar包的依赖-->
11         <dependency>
12             <groupId>me.gacl.maven</groupId>
13             <artifactId>Hello</artifactId>
14             <version>0.0.1-SNAPSHOT</version>
15             <scope>compile</scope>
16         </dependency>    
17     </dependencies>

2.2、依赖范围

　　依赖范围scope用来控制依赖和编译，测试，运行的classpath的关系. 主要的是三种依赖关系如下：
　　　　1.compile： 默认编译依赖范围。对于编译，测试，运行三种classpath都有效
　　　　2.test：测试依赖范围。只对于测试classpath有效
　　　　3.provided：已提供依赖范围。对于编译，测试的classpath都有效，但对于运行无效。因为由容器已经提供，例如servlet-api
　　　　4.runtime:运行时提供。例如:jdbc驱动

2.3、传递性依赖

　　MakeFriends.jar直接依赖于HelloFriends.jar，而HelloFriends.jar又直接依赖于Hello.jar，那么MakeFriends.jar也依赖于Hello.jar，这就是传递性依赖，只不过这种依赖是间接依赖，如下图所示：

　　

2.4、可选依赖

三、仓库管理

3.1、Maven仓库

　　用来统一存储所有Maven共享构建的位置就是仓库

3.2、Maven仓库布局

　　根据Maven坐标定义每个构建在仓库中唯一存储路径，大致为：groupId/artifactId/version/artifactId-version.packaging

3.3、仓库的分类

3.3.1、本地仓库

　　每个用户只有一个本地仓库，默认是在~/.m2/repository/，~代表的是用户目录

3.3.2、远程仓库

　　1、中央仓库：Maven默认的远程仓库，URL地址：http://search.maven.org/

　　

　　2、私服：是一种特殊的远程仓库，它是架设在局域网内的仓库

　　

四、生命周期

4.1、何为生命周期？

　　Maven生命周期就是为了对所有的构建过程进行抽象和统一，包括项目清理，初始化，编译，打包，测试，部署等几乎所有构建步骤

4.2、Maven三大生命周期

　　Maven有三套相互独立的生命周期，请注意这里说的是"三套"，而且"相互独立"，这三套生命周期分别是：

1. Clean Lifecycle 在进行真正的构建之前进行一些清理工作。
2. Default Lifecycle 构建的核心部分，编译，测试，打包，部署等等。
3. Site Lifecycle 生成项目报告，站点，发布站点。

　　再次强调一下它们是相互独立的，你可以仅仅调用clean来清理工作目录，仅仅调用site来生成站点。当然你也可以直接运行 mvn clean install site 运行所有这三套生命周期。 
　　clean生命周期每套生命周期都由一组阶段(Phase)组成，我们平时在命令行输入的命令总会对应于一个特定的阶段。比如，运行mvn clean ，这个的clean是Clean生命周期的一个阶段。有Clean生命周期，也有clean阶段。Clean生命周期一共包含了三个阶段：

1. pre-clean 执行一些需要在clean之前完成的工作
2. clean 移除所有上一次构建生成的文件
3. post-clean 执行一些需要在clean之后立刻完成的工作

　　"mvn clean" 中的clean就是上面的clean，在一个生命周期中，运行某个阶段的时候，它之前的所有阶段都会被运行，也就是说，"mvn clean"等同于 mvn pre-clean clean ，如果我们运行 mvn post-clean ，那么 pre-clean，clean 都会被运行。这是Maven很重要的一个规则，可以大大简化命令行的输入。 
　　Site生命周期pre-site 执行一些需要在生成站点文档之前完成的工作

1. site 生成项目的站点文档
2. post-site 执行一些需要在生成站点文档之后完成的工作，并且为部署做准备
3. site-deploy 将生成的站点文档部署到特定的服务器上

　　这里经常用到的是site阶段和site-deploy阶段，用以生成和发布Maven站点，这可是Maven相当强大的功能，Manager比较喜欢，文档及统计数据自动生成，很好看。
　　Default生命周期Default生命周期是Maven生命周期中最重要的一个，绝大部分工作都发生在这个生命周期中。这里，只解释一些比较重要和常用的阶段：

• validate
• generate-sources
• process-sources
• generate-resources
• process-resources 复制并处理资源文件，至目标目录，准备打包。
• compile 编译项目的源代码。
• process-classes
• generate-test-sources
• process-test-sources
• generate-test-resources
• process-test-resources 复制并处理资源文件，至目标测试目录。
• test-compile 编译测试源代码。
• process-test-classes
• test 使用合适的单元测试框架运行测试。这些测试代码不会被打包或部署。
• prepare-package
• package 接受编译好的代码，打包成可发布的格式，如 JAR 。
• pre-integration-test
• integration-test
• post-integration-test
• verify
• install 将包安装至本地仓库，以让其它项目依赖。
• deploy 将最终的包复制到远程的仓库，以让其它开发人员与项目共享。

　　运行任何一个阶段的时候，它前面的所有阶段都会被运行，这也就是为什么我们运行mvn install 的时候，代码会被编译，测试，打包。此外，Maven的插件机制是完全依赖Maven的生命周期的，因此理解生命周期至关重要。

五、Maven插件

1. Maven的核心仅仅定义了抽象的生命周期，具体的任务都是交由插件完成的。
2. 每个插件都能实现多个功能，每个功能就是一个插件目标。
3. Maven的生命周期与插件目标相互绑定，以完成某个具体的构建任务，例如compile就是插件maven-compiler-plugin的一个插件目标。

只为成功找方法，不为失败找借口！

Maven学习总结(五)——聚合与继承

一、聚合

　　如果我们想一次构建多个项目模块，那我们就需要对多个项目模块进行聚合

1.1、聚合配置代码

1 <modules>
2       <module>模块一</module>
3       <module>模块二</module>
4       <module>模块三</module>
5 </modules>

　　例如：对项目的Hello、HelloFriend、MakeFriends这三个模块进行聚合

1 <modules>
2       <module>../Hello</module>  
3       <module>../HelloFriend</module>        
4       <module>../MakeFriends</module>
5 </modules>

　　其中module的路径为相对路径。

二、继承

　　继承为了消除重复，我们把很多相同的配置提取出来，例如：grouptId，version等

2.1、继承配置代码

1 <parent>  
2          <groupId>me.gacl.maven</groupId>
3          <artifactId>ParentProject</artifactId>
4          <version>0.0.1-SNAPSHOT</version>
5          <relativePath>../ParentProject/pom.xml</relativePath>  
6 </parent>

2.2、继承代码中定义属性

　　继承代码过程中，可以定义属性，例如：

1 <properties>
2     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
3     <junit.version>4.9</junit.version>
4     <maven.version>0.0.1-SNAPSHOT</maven.version>
5 </properties>

　　访问属性的方式为${junit.version}，例如：

1 <dependency>
2     <groupId>junit</groupId>
3     <artifactId>junit</artifactId>
4     <version>${junit.version}</version>
5     <scope>test</scope>
6 </dependency>    

2.3、父模块用dependencyManagement进行管理

 1 <dependencyManagement>
 2     <dependencies>
 3     <dependency>
 4         <groupId>junit</groupId>
 5         <artifactId>junit</artifactId>
 6         <version>${junit.version}</version>
 7         <scope>test</scope>
 8     </dependency>    
 9     <dependency>
10             <groupId>cn.itcast.maven</groupId>
11             <artifactId>HelloFriend</artifactId>
12             <version>${maven.version}</version>
13             <type>jar</type>
14             <scope>compile</scope>
15        </dependency>
16      </dependencies>
17 </dependencyManagement>

　　这样的好处是子模块可以有选择行的继承，而不需要全部继承。

三、聚合与继承的关系

　　聚合主要为了快速构建项目，继承主要为了消除重复

四、聚合与继承实战演练

　　创建四个Maven项目，如下图所示：

 　　

　　这四个项目放在同一个目录下，方便后面进行聚合和继承

　　

　　Parent项目是其它三个项目的父项目，主要是用来配置一些公共的配置，其它三个项目再通过继承的方式拥有Parent项目中的配置，首先配置Parent项目的pom.xml，添加对项目的Hello、HelloFriend、MakeFriends这三个模块进行聚合以及jar包依赖，pom.xml的配置信息如下：

　　Parent项目的pom.xml配置

 1 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 2     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 3     <modelVersion>4.0.0</modelVersion>
 4 
 5     <groupId>me.gacl.maven</groupId>
 6     <artifactId>Parent</artifactId>
 7     <version>0.0.1-SNAPSHOT</version>
 8     <packaging>pom</packaging>
 9 
10     <name>Parent</name>
11     <url>http://maven.apache.org</url>
12     
13     <!-- 对项目的Hello、HelloFriend、MakeFriends这三个模块进行聚合 -->
14     <modules>
15         <module>../Hello</module>
16         <module>../HelloFriend</module>
17         <module>../MakeFriends</module>
18     </modules>
19     
20     <!-- 定义属性 -->
21     <properties>
22         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
23         <junit.version>4.9</junit.version>
24         <maven.version>0.0.1-SNAPSHOT</maven.version>
25     </properties>
26 
27     <!-- 用dependencyManagement进行jar包依赖管理 -->
28     <dependencyManagement>
29         <!-- 配置jar包依赖 -->
30         <dependencies>
31             <dependency>
32                 <groupId>junit</groupId>
33                 <artifactId>junit</artifactId>
34                 <!-- 访问junit.version属性 -->
35                 <version>${junit.version}</version>
36                 <scope>test</scope>
37             </dependency>
38             <dependency>
39                 <groupId>me.gacl.maven</groupId>
40                 <artifactId>Hello</artifactId>
41                 <!-- 访问maven.version属性 -->
42                 <version>${maven.version}</version>
43                 <scope>compile</scope>
44             </dependency>
45             <dependency>
46                 <groupId>me.gacl.maven</groupId>
47                 <artifactId>HelloFriend</artifactId>
48                 <!-- 访问maven.version属性 -->
49                 <version>${maven.version}</version>
50             </dependency>
51         </dependencies>
52     </dependencyManagement>
53 </project>

　　在Hello项目的pom.xml中继承Parent项目的pom.xml配置

 1 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
 2 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 3   
 4   <modelVersion>4.0.0</modelVersion>
 5   <artifactId>Hello</artifactId>
 6   
 7       <!-- 继承Parent项目中的pom.xml配置 -->
 8        <parent>  
 9           <groupId>me.gacl.maven</groupId>
10          <artifactId>Parent</artifactId>
11           <version>0.0.1-SNAPSHOT</version>
12           <!-- 使用相对路径 -->
13         <relativePath>../Parent/pom.xml</relativePath>  
14     </parent>
15     
16     <dependencies>
17         <dependency>
18             <groupId>junit</groupId>
19             <artifactId>junit</artifactId>
20         </dependency>
21     </dependencies>
22 </project>

　　在HelloFriend项目的pom.xml中继承Parent项目的pom.xml配置

 1 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 2     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 3     <modelVersion>4.0.0</modelVersion>
 4     <artifactId>HelloFriend</artifactId>
 5     <name>HelloFriend</name>
 6     
 7     <!-- 继承Parent项目中的pom.xml配置 -->
 8     <parent>
 9         <groupId>me.gacl.maven</groupId>
10         <artifactId>Parent</artifactId>
11         <version>0.0.1-SNAPSHOT</version>
12         <relativePath>../Parent/pom.xml</relativePath>
13     </parent>
14     <dependencies>
15         <dependency>
16             <!-- Parent项目的pom.xml文件配置中已经指明了要使用的Junit的版本号，因此在这里添加junit的依赖时，
17             可以不指明<version></version>和<scope>test</scope>，会直接从Parent项目的pom.xml继承 -->
18             <groupId>junit</groupId>
19             <artifactId>junit</artifactId>
20         </dependency>
21         <!-- HelloFriend项目中使用到了Hello项目中的类，因此需要添加对Hello.jar的依赖 
22         Hello.jar的<version>和<scope>也已经在Parent项目的pom.xml文件配置中已经指明了
23         因此这里也可以省略不写了
24         -->
25         <dependency>
26             <groupId>me.gacl.maven</groupId>
27             <artifactId>Hello</artifactId>
28         </dependency>
29     </dependencies>
30 </project>

　　在MakeFriends项目的pom.xml中继承Parent项目的pom.xml配置

 1 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 2     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 3     <modelVersion>4.0.0</modelVersion>
 4     <artifactId>MakeFriends</artifactId>
 5     <!-- 继承Parent项目中的pom.xml配置 -->
 6     <parent>
 7         <groupId>me.gacl.maven</groupId>
 8         <artifactId>Parent</artifactId>
 9         <version>0.0.1-SNAPSHOT</version>
10         <relativePath>../Parent/pom.xml</relativePath>
11     </parent>
12     <dependencies>
13         <dependency>
14         <!-- Parent项目的pom.xml文件配置中已经指明了要使用的Junit的版本号，因此在这里添加junit的依赖时，
15             可以不指明<version></version>和<scope>test</scope>，会直接从Parent项目的pom.xml继承 -->
16             <groupId>junit</groupId>
17             <artifactId>junit</artifactId>
18         </dependency>
19         <dependency>
20         <!-- MakeFriends项目中使用到了HelloFriend项目中的类，因此需要添加对HelloFriend.jar的依赖 
21         HelloFriend.jar的<version>和<scope>也已经在Parent项目的pom.xml文件配置中已经指明了
22         因此这里也可以省略不写了
23         -->
24             <groupId>me.gacl.maven</groupId>
25             <artifactId>HelloFriend</artifactId>
26         </dependency>
27     </dependencies>
28 </project>

　　以上的四个项目的pom.xml经过这样的配置之后，就完成了在Parent项目中聚合Hello、HelloFriend、MakeFriends这三个子项目(子模块)，而Hello、HelloFriend、MakeFriends这三个子项目(子模块)也继承了Parent项目中的公共配置，这样就可以使用Maven一次性构建所有的项目了，如下图所示：

　　

　　选中Parent项目的pom.xml文件→【Run As】→【Maven install】，这样Maven就会一次性同时构建Parent、Hello、HelloFriend、MakeFriends这四个项目，如下图所示：

　　

Maven学习总结

原文：http://www.cnblogs.com/xingzc/p/5986262.html