Maven 学习总结

Maven 学习总结

一、Maven的基本概念

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

http://www.cnblogs.com/xdp-gacl/p/4240930.html

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代表的就是\目录 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

2 7 4.0.0

8 9 cn.gacl.maven.hello

10 13 SNAPSHOT-0.0.1 14

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(\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}表示当前登录系统的用户目录(如\，如下图所示

Jar包存放在这个位置不太好，我们希望能够自己定义下载下来的jar包的存放位置，因此我们可以自己设置下载到本地时的jar包的存放目录。 在“E:\\”目录下创建一个“repository”文件夹

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

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

加上下面的代码

1 E:/repository

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

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

第一次执行\和\这两个命令时，Maven会去中央仓库下载需要的jar包，而第二次执行这两个命令时，由于所需的jar包已经在本地的仓库中存储，所以就可以直接拿来用了，这样就省去了去中央仓库下载jar包的时间。 以上就是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 4.0.0

4 me.gacl.maven 5 Hello 6 0.0.1-SNAPSHOT 7 Hello 8

9 10

11

12

13 junit

14 junit 15 4.9 16 test 17 18

19 20

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 \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(\12 assertEquals(\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仓库中，如下图所示：

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

1.2、组合使用Maven的命令

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

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

还有的就是\，\，\，这些组合命令都比较常用。

以上就是关于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 4.0.0 4 me.gacl.maven

5 HelloFriend 6 0.0.1-SNAPSHOT 7 HelloFriend 8

9 10

11

12

13 junit

14 junit 15 4.9 16 test 17

18

19

20 me.gacl.maven 21 Hello 22 0.0.1-SNAPSHOT 23 compile 24 25 26

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 \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(\14 assertEquals(\15 } 16 }

5、在HelloFriend目录下执行命令\测试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

2 xsi:schemaLocation=\http://maven.apache.org/xsd/maven-4.0.0.xsd\ 3 4.0.0 4

5 com.mycompany.app

6 myapp 7 1.0-SNAPSHOT 8 jar 9

10 myapp

11 http://maven.apache.org 12

13 14

UTF-8 15 16

17 18

19 junit

20 junit 21 3.8.1 22 test 23 24 25

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

pom文件的顶级节点

object model版本，对Maven2和Maven3来说，只能是4.0.0

项目创建组织的标识符，一般是域名的倒写

定义了项目在所属组织的标识符下的唯一标识，一个组织下可以有多个项目

当前项目的版本，SNAPSHOT，表示是快照版本，在开发中

打包的方式，有jar、war、ear等 项目的名称 项目的地址 属性配置，比如：

UTF-8 构建项目依赖的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

2 xsi:schemaLocation=\http://maven.apache.org/maven-v4_0_0.xsd\ 3 4.0.0 4 com.mycompany.app 5 myWebApp 6 war

7 1.0-SNAPSHOT 8 myWebApp Maven Webapp 9 http://maven.apache.org 10 11

12 junit

13 junit 14 3.8.1 15 test 16 17 18

19 myWebApp 20 21 22 23

24 org.mortbay.jetty

25 maven-jetty-plugin 26 27 28 29 30

打开命令行窗口，切换到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坐标

1.1、什么是坐标？

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

1.2、Maven坐标主要组成

? ? ? ? 样例：

groupId：组织标识（包名） artifactId：项目名称 version：项目的当前版本

packaging：项目的打包方式，最为常见的jar和war两种

1.3、Maven为什么使用坐标？

? ?

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

二、依赖管理

2.1、依赖配置

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

1 2

3

4

5 junit

6 junit 7 4.9 8 test 9

10

11

12 me.gacl.maven 13 Hello 14 0.0.1-SNAPSHOT 15 compile 16 17

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之后立刻完成的工作

\中的clean就是上面的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的一个插件目标。

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

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

6. 一、聚合

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

8. 1.1、聚合配置代码

9. 1

10.2 模块一 11.3 模块二 12.4 模块三 13.5

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

15.1

16.2 ../Hello

17.3 ../HelloFriend 18.4 ../MakeFriends 19.5

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

21. 二、继承

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

等

23. 2.1、继承配置代码

24.1

25.2 me.gacl.maven

26.3 ParentProject 27.4 0.0.1-SNAPSHOT 28.5

../ParentProject/pom.xml

29.6

30. 2.2、继承代码中定义属性

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

32.1 33.2

UTF-8

34.3 4.9

35.4 0.0.1-SNAPSHOT 36.5

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

38.1

39.2 junit

40.3 junit

41.4 ${junit.version} 42.5 test 43.6

44. 2.3、父模块用dependencyManagement进行管理

45.

46. 1 47. 2 48. 3

49. 4 junit

50. 5 junit

51. 6 ${junit.version} 52. 7 test 53. 8 54. 9

55.10 cn.itcast.maven 56.11 HelloFriend 57.12 ${maven.version} 58.13 jar

59.14 compile 60.15 61.16 62.17

63.

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

65. 三、聚合与继承的关系

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

67. 四、聚合与继承实战演练

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

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

72. Parent项目是其它三个项目的父项目，主要是用来配置一些公共的配置，其它三

个项目再通过继承的方式拥有Parent项目中的配置，首先配置Parent项目的pom.xml，添加对项目的Hello、HelloFriend、MakeFriends这三个模块进行聚合以及jar包依赖，pom.xml的配置信息如下： 73. Parent项目的pom.xml配置 74.

75. 1

76. 2 xsi:schemaLocation=\http://maven.apache.org/xsd/maven-4.0.0.xsd\ 77. 3 4.0.0 78. 4

79. 5 me.gacl.maven 80. 6 Parent 81. 7 0.0.1-SNAPSHOT 82. 8 pom 83. 9

84.10 Parent

85.11 http://maven.apache.org 86.12

87.13

88.14

89.15 ../Hello

90.16 ../HelloFriend 91.17 ../MakeFriends 92.18 93.19

94.20 95.21

96.22

UTF-8

97.23 4.9

98.24 0.0.1-SNAPSHOT 99.25 100. 26

101. 27 102. 28

103. 29 104. 30 105. 31

106. 32 junit

107. 33 junit 108. 34

109. 35 ${junit.version} 110. 36 test 111. 37 112. 38

113. 39 me.gacl.maven 114. 40 Hello 115. 41

116. 42 ${maven.version} 117. 43 compile 118. 44 119. 45

120. 46 me.gacl.maven 121. 47 HelloFriend 122. 48

123. 49 ${maven.version} 124. 50 125. 51

126. 52 127. 53

128.

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

131. 1

134. 4 4.0.0

135. 5 Hello 136. 6

137. 7 138. 8

139. 9 me.gacl.maven 140. 10 Parent 141. 11 0.0.1-SNAPSHOT 142. 12

143. 13 ../Parent/pom.xml 144. 14 145. 15

146. 16 147. 17

148. 18 junit

149. 19 junit 150. 20 151. 21 152. 22

153.

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

156. 1

157. 2 xsi:schemaLocation=\http://maven.apache.org/xsd/maven-4.0.0.xsd\ 158. 3 4.0.0 159. 4 HelloFriend 160. 5 HelloFriend 161. 6

162. 7 163. 8

164. 9 me.gacl.maven 165. 10 Parent 166. 11 0.0.1-SNAPSHOT

167. 12 ../Parent/pom.xml 168. 13

169. 14 170. 15 171. 16 173. 18 junit

174. 19 junit 175. 20

176. 21

180. 25

181. 26 me.gacl.maven 182. 27 Hello 183. 28 184. 29 185. 30

186.

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

189. 1

190. 2 xsi:schemaLocation=\http://maven.apache.org/xsd/maven-4.0.0.xsd\ 191. 3 4.0.0 192. 4 MakeFriends 193. 5 194. 6

195. 7 me.gacl.maven 196. 8 Parent 197. 9 0.0.1-SNAPSHOT

198. 10 ../Parent/pom.xml 199. 11

200. 12 201. 13 202. 14 204. 16 junit

205. 17 junit 206. 18 207. 19

208. 20

212. 24 me.gacl.maven

213. 25 HelloFriend 214. 26 215. 27 216. 28

217.

218. 以上的四个项目的pom.xml经过这样的配置之后，就完成了在Parent项目中聚

合Hello、HelloFriend、MakeFriends这三个子项目(子模块)，而Hello、HelloFriend、MakeFriends这三个子项目(子模块)也继承了Parent项目中的公共配置，这样就可以使用Maven一次性构建所有的项目了，如下图所示： 219.

220. 选中Parent项目的pom.xml文件→【Run As】→【Maven install】，这样

Maven就会一次性同时构建Parent、Hello、HelloFriend、MakeFriends这四个项目，如下图所示：

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

Maven学习总结(六)——Maven与Eclipse整合

一、安装Maven插件

下载下来的maven插件如下图所示：，插件存放的路径是：E:/MavenProject/Maven2EclipsePlugin

1. 进入到eclipse中的dropins目录下，新建三个txt文件（zest.txt,m2e.txt,m2e-extras.txt）。

如下图所示：

m2e.txtt文件的内容如下：path=E:/MavenProject/Maven2EclipsePlugin/m2e

m2e-extras.txt文件的内容如下：path=E:/MavenProject/Maven2EclipsePlugin/m2e-extras zest.txt文件的内容如下：path=E:/MavenProject/Maven2EclipsePlugin/GEF-zest-3.7.1 path路径的值为插件在本机上存放的路径地址

重新启动eclipse,点击windows→preferences,Maven插件安装成功后看到如下画面：

二、配置Maven插件

2.1、配置使用的Maven

我们不使用默认安装的那个Maven，配置我们自己下载安装好的那个Maven，如下图所示：

2.2、配置User Settings

User Settings的默认配置如下图所示：

在之前安装和配置Maven时，我已经将Maven本地仓库的位置设置成了\目录，所以需要将\改成\

首先找到Maven安装目录下的conf目录下的settings.xml文件，如下图所示：

将conf目录下的settings.xml文件拷贝一份到Maven本地仓库的位置\目录，如下图所示：

经过以上两步，Maven插件就算是设置好了。

2.3、配置Maven编译时使用的JDK

因为Maven必须要JDK1.6以上才能够正常运行，所以需要配置一下Eclipse使用的JDK。 进入window->preferences窗口，选择java->Installed JREs，通过add按钮增加jdk对对应的路径加进来，否则在编译的时候会报错：

No compiler is provided in this environment. Perhaps you are running on a JRE rather than a JDK?

接着，进入Installed JREs的子项Execute Environment：在左侧选择JavaSE-1.5、JavaSE-1.6、JavaSE-1.7，右侧选择编译时使用的jdk版本，如下图所示：

三、Eclipse中使用Maven插件

3.1、导入Maven项目

File→import

点击【Finish】按钮，完成项目的导入，如下图所示：

3.2、新建Maven项目

点击【Finish】按钮，完成项目的创建，创建好的项目如下图所示：

3.3、在Eclipse执行mvn命令

选中项目，点击鼠标右键→【Run As】或者【Debug As】→选择相应的Maven命令执行，如下图所示：

这种方式每次只能执行一个Maven命令，如果想像在cmd命令行那样使用组合命令，那么可以这样做

此时会弹出如下所示的对话框

在Goals输入框中输入要执行的组合命令，如下图所示：

以上就是Maven与Eclipse整合使用的内容。

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

222. Maven学习总结(七)——eclipse中使用Maven创建Web项目

223. 一、创建Web项目

224. 1.1 选择建立Maven Project

225. 选择File -> New ->Project，如下图所示： 226.

227. 在New窗口中选择 Maven -> Maven Project。点击【next】如下图所示： 228. 229.

230. 1.2 选择项目路径

231. 根据项目的实际情况选择项目的存放目录，也可以选择

【Use default Workspace location】默认工作空间。如下图所示： 232.

233. 1.3 选择项目类型

234. 在Artifact Id中选择maven-archetype-webapp，如下图所示： 235.

236. 1.4 输入Group ID和 Artifact ID以及Package

237. Group ID一般写大项目名称。Artifact ID是子项目名称。

238. 例如Spring的web包，Group ID：org.springframework，artifactId：spring-web。 239. Package是默认给你建一个包，不写也可以。如下图所示： 240.

241. 1.5 项目建立好后的文件结构

242. 刚建立好后的文件结构如下图如下图如下图所示： 243.

244. 二、将Web项目自动部署到tomcat服务器

245. 2.1、在pom.xml文件中配置tomcat服务器

246. 配置web项目的pom.xml文件，配置如下：

247.

248. 1

249. 2 xsi:schemaLocation=\http://maven.apache.org/maven-v4_0_0.xsd\ 250. 3 4.0.0 251. 4 me.gacl.maven 252. 5 WebProject 253. 6 war

254. 7 0.0.1-SNAPSHOT 255. 8 WebProject Maven Webapp 256. 9 http://maven.apache.org 257. 10 258. 11

259. 12 junit

260. 13 junit 261. 14 3.8.1 262. 15 test 263. 16 264. 17 265. 18

266. 19

269. 22 WebProject 270. 23

271. 24

272. 25 org.codehaus.cargo

273. 26 cargo-maven2-plugin 274. 27 1.2.3 275. 28 276. 29

277. 30

278. 31

tomcat7x

279. 32 280. 33

D:/apache-tomcat-7.0.53 281. 34 282. 35

283. 36 existing

284. 37

285. 38

D:/apache-tomcat-7.0.53

286. 39 287. 40 288. 41 289. 42

290. 43 cargo-run 291. 44 install 292. 45

293. 46 run 294. 47 295. 48 296. 49 297. 50 298. 51 299. 52 300. 53

301.

302. 2.2、将web项目发布到tomca服务器的webapps目录

303. 选中Web项目(或者选中Web项目的pom.xml文件)→【Run As】→【Maven

install】，如下图所示： 304.

305. 执行完【Maven install】命令之后，就可以将WebProject项目打包成

WebProject.war包发布到tomca服务器的webapps目录下，如下图所示： 306.

307. 测试部署好的Web项目，如下图所示： 308.

309. 浏览器正常输出了index.jsp页面中的内容，这说明我们的部署成功了。这就是

在Eclipse中使用Maven将Web项目自动部署到tomcat服务器的过程。

310.

311.

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

Maven学习总结(八)——使用Maven构建多模块项目

312. 在平时的Javaweb项目开发中为了便于后期的维护，我们一般会进行分层开发，

最常见的就是分为domain（域模型层）、dao（数据库访问层）、service（业务逻辑层）、web（表现层），这样分层之后，各个层之间的职责会比较明确，后期维护起来也相对比较容易，今天我们就是使用Maven来构建以上的各个层。 313. 项目结构如下：

314. system-parent

|----pom.xml |----system-domain |----pom.xml |----system-dao

|----pom.xml |----system-service |----pom.xml |----system-web |----pom.xml

315. 一、创建system-parent项目

316. 创建system-parent，用来给各个子模块继承。 317. 进入命令行，输入以下命令：

318. mvn archetype:create -DgroupId=me.gacl -DartifactId=system-parent

-DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

319. 如下图所示： 320.

321. 命令执行完成之后可以看到在当前目录(C:\\Documents and

Settings\\Administrator)生成了system-parent目录，里面有一个src目录和一个pom.xml文件，如下图所示： 322.

323. 将src文件夹删除，然后修改pom.xml文件，将

jar修改为

pom，pom表示它是一个被继承的模块，修改后的内容如下： 324.

325. 1

326. 2 xsi:schemaLocation=\http://maven.apache.org/xsd/maven-4.0.0.xsd\ 327. 3 4.0.0 328. 4

329. 5 me.gacl

330. 6 system-parent 331. 7 1.0-SNAPSHOT 332. 8 pom

333. 9

334. 10 system-parent

335. 11 http://maven.apache.org 336. 12

337. 13 338. 14

UTF-8

339. 15 340. 16

341. 17 342. 18

343. 19 junit

344. 20 junit 345. 21 3.8.1 346. 22 test 347. 23 348. 24 349. 25

350.

351. 二、创建sytem-domain模块

352. 在命令行进入创建好的system-parent目录，然后执行下列命令：

353. mvn archetype:create -DgroupId=me.gacl -DartifactId=system-domain

-DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

354. 如下图所示： 355.

356. 命令执行完成之后可以看到在system-parent目录中生成了system-domain，

里面包含src目录和pom.xml文件。如下图所示： 357. 358.

359. 同时，在system-parent目录中的pom.xml文件自动添加了如下内容：

360.

361. system-domain 362.

363. 这时，system-parent的pom.xml文件如下：

364.

365. 1

366. 2 4.0.0 368. 4

369. 5 me.gacl

370. 6 system-parent 371. 7 1.0-SNAPSHOT 372. 8 pom 373. 9

374. 10 system-parent

375. 11 http://maven.apache.org 376. 12

377. 13 378. 14

UTF-8

379. 15 380. 16

381. 17 382. 18

383. 19 junit

384. 20 junit 385. 21 3.8.1 386. 22 test 387. 23 388. 24 389. 25

390. 26 system-domain 391. 27 392. 28

393.

394. 修改system-domain目录中的pom.xml文件，把

me.gacl和

1.0-SNAPSHOT去掉，加上

jar，因为groupId和version会继承system-parent中的groupId和version，packaging设置打包方式为jar 395. 修改过后的pom.xml文件如下： 396.

397. 1

398. 2

xsi:schemaLocation=\http://maven.apache.org/xsd/maven-4.0.0.xsd\ xmlns=\

399. 3 xmlns:xsi=\ 400. 4 4.0.0 401. 5

402. 6 me.gacl

403. 7 system-parent 404. 8 1.0-SNAPSHOT 405. 9 406. 10

407. 11 system-domain 408. 12 jar 409. 13

410. 14 system-domain

411. 15 http://maven.apache.org 412. 16

413.

414. 三、创建sytem-dao模块

415. 在命令行进入创建好的system-parent目录，然后执行下列命令：

416. mvn archetype:create -DgroupId=me.gacl -DartifactId=system-dao -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

417. 如下图所示： 418.

419. 命令执行完成之后可以看到在system-parent目录中生成了system-dao，里

面包含src目录和pom.xml文件。如下图所示： 420.

421. 同时，在system-parent目录中的pom.xml文件自动变成如下内容： 422.

423. 1

424. 2 4.0.0 426. 4

427. 5 me.gacl

428. 6 system-parent 429. 7 1.0-SNAPSHOT 430. 8 pom 431. 9

432. 10 system-parent

433. 11 http://maven.apache.org 434. 12

435. 13 436. 14

UTF-8

437. 15 438. 16

439. 17 440. 18

441. 19 junit

442. 20 junit 443. 21 3.8.1 444. 22 test 445. 23 446. 24 447. 25

448. 26 system-domain 449. 27 system-dao 450. 28 451. 29

452.

453. 修改system-dao目录中的pom.xml文件，，把

me.gacl和

1.0-SNAPSHOT去掉，加上

jar，因为groupId和version会继承

system-parent中的groupId和version，packaging设置打包方式为jar，同时添加对system-domain模块的依赖，修改后的内容如下： 454.

455. 1 456. 2

xsi:schemaLocation=\http://maven.apache.org/xsd/maven-4.0.0.xsd\ xmlns=\

457. 3 xmlns:xsi=\ 458. 4 4.0.0 459. 5

460. 6 me.gacl

461. 7 system-parent 462. 8 1.0-SNAPSHOT 463. 9 464. 10

465. 11 system-dao 466. 12 jar 467. 13

468. 14 system-dao

469. 15 http://maven.apache.org 470. 16 471. 17

UTF-8

472. 18 473. 19

474. 20 475. 21

476. 22 me.gacl

477. 23 system-domain 478. 24 ${project.version} 479. 25 480. 26 481. 27

482.

483. 四、创建system-service模块

484. 在命令行进入创建好的system-parent目录，然后执行下列命令：

485. mvn archetype:create -DgroupId=me.gacl -DartifactId=system-service

-DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

486. 如下图所示： 487.

488. 命令执行完成之后可以看到在system-parent目录中生成了system-service，

里面包含src目录和pom.xml文件。如下图所示： 489.

490. 同时，在system-parent目录中的pom.xml文件自动变成如下内容： 491.

492. 1

493. 2 4.0.0 495. 4

496. 5 me.gacl

497. 6 system-parent 498. 7 1.0-SNAPSHOT 499. 8 pom 500. 9

501. 10 system-parent

502. 11 http://maven.apache.org 503. 12

504. 13 505. 14

UTF-8

506. 15 507. 16

508. 17 509. 18

510. 19 junit

511. 20 junit 512. 21 3.8.1 513. 22 test 514. 23 515. 24 516. 25

517. 26 system-domain 518. 27 system-dao 519. 28 system-service 520. 29 521. 30

522.

523. 修改system-service目录中的pom.xml文件，，把

me.gacl和

1.0-SNAPSHOT去掉，加上

jar，因为groupId和version会继承

system-parent中的groupId和version，packaging设置打包方式为jar，同时添加对system-dao模块的依赖，system-service依赖system-dao和system-domain，但是我们只需添加system-dao的依赖即可，因为system-dao已经依赖了system-domain。修改后的内容如下：

524.

525. 1 526. 2

xsi:schemaLocation=\http://maven.apache.org/xsd/maven-4.0.0.xsd\ xmlns=\

527. 3 xmlns:xsi=\ 528. 4 4.0.0 529. 5

530. 6 me.gacl

531. 7 system-parent 532. 8 1.0-SNAPSHOT 533. 9 534. 10

535. 11 system-service 536. 12 jar 537. 13

538. 14 system-service

539. 15 http://maven.apache.org 540. 16 541. 17

UTF-8

542. 18 543. 19 544. 20

548. 24

549. 25 me.gacl

550. 26 system-dao 551. 27 ${project.version} 552. 28 553. 29 554. 30

555.

556. 五、创建system-web模块

557. 在命令行进入创建好的system-parent目录，然后执行下列命令：

558. mvn archetype:create -DgroupId=me.gacl -DartifactId=system-web -DarchetypeArtifactId=maven-archetype-webapp -DinteractiveMode=false

559. 如下图所示： 560.

561. 命令执行完成之后可以看到在system-parent目录中生成了system-web，里

面包含src目录和pom.xml文件。如下图所示： 562.

563. 在\\system-web\\src\\main\\webapp目录中还生成了一个简单的index.jsp,如

下图所示： 564.

565. 里面的内容为

566. 567.

568.

Hello World!

571. system-web\\src\\main\\webapp\\WEB-INF目录中生成了web.xml 572.

573. 同时，在system-parent目录中的pom.xml文件自动变成如下内容： 574.

575. 1

576. 2 4.0.0 578. 4

579. 5 me.gacl

580. 6 system-parent 581. 7 1.0-SNAPSHOT 582. 8 pom 583. 9

584. 10 system-parent

585. 11 http://maven.apache.org 586. 12

587. 13

588. 14

UTF-8

589. 15 590. 16

591. 17 592. 18

593. 19 junit

594. 20 junit 595. 21 3.8.1 596. 22 test 597. 23 598. 24 599. 25

600. 26 system-domain 601. 27 system-dao 602. 28 system-service 603. 29 system-web 604. 30 605. 31

606.

607. 修改system-web目录中的pom.xml文件，，把

me.gacl和

1.0-SNAPSHOT去掉，因为groupId和version会继承system-parent中的groupId和version，同时添加对system-service模块的依赖，修改后的内容如下： 608.

609. 1 610. 2

xsi:schemaLocation=\http://maven.apache.org/xsd/maven-4.0.0.xsd\ xmlns=\

611. 3 xmlns:xsi=\ 612. 4 4.0.0 613. 5

614. 6 me.gacl

615. 7 system-parent 616. 8 1.0-SNAPSHOT 617. 9 618. 10

619. 11 system-web 620. 12 war 621. 13

622. 14 system-web Maven Webapp 623. 15 http://maven.apache.org 624. 16 625. 17

628. 20

629. 21 me.gacl

630. 22 system-service 631. 23 ${project.version} 632. 24 633. 25 634. 26

635. 27 system-web 636. 28 637. 29

638.

639. 注意，web项目的打包方式是war。

640. 六、编译运行项目

641. 经过上面的五个步骤，相关的模块全部创建完成，怎么运行起来呢。由于最终运

行的是system-web模块，所以我们对该模块添加jetty支持，方便测试运行。修改system-web项目的pom.xml如下： 642.

643. 1 644. 2

xsi:schemaLocation=\http://maven.apache.org/xsd/maven-4.0.0.xsd\ xmlns=\

645. 3 xmlns:xsi=\ 646. 4 4.0.0 647. 5

648. 6 me.gacl

649. 7 system-parent 650. 8 1.0-SNAPSHOT 651. 9 652. 10

653. 11 system-web 654. 12 war 655. 13

656. 14 system-web Maven Webapp 657. 15 http://maven.apache.org

658. 16 659. 17

662. 20

663. 21 me.gacl

664. 22 system-service 665. 23 ${project.version} 666. 24 667. 25 668. 26

669. 27 system-web 670. 28

671. 29 672. 30

673. 31 org.mortbay.jetty

674. 32 maven-jetty-plugin 675. 33 676. 34 677. 35 678. 36

679.

680. 在命令行进入system-parent目录，然后执行下列命令：

681. mvn clean install

682. 如下图所示： 683. 684.

685. 命令执行完后，在system-web目录下多出了target目录，里面有了

system-web.war，如下图所示： 686.

687. 命令行进入sytem-web目录，执行如下命令，启动jetty

688. mvn jetty:run

689. 如下图所示： 690. 691.

692. 启动jetty服务器后，访问http://localhost:8080/system-web/ 运行结果如

下图所示： 693.

694. 七、导入Eclipse中进行开发

695. 操作步骤如下所示： 696. 697. 698. 699. 700. 701.

702.

703.

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

Maven学习总结(九)——使用Nexus搭建Maven私服

704. 一、搭建nexus私服的目的

705. 为什么要搭建nexus私服，原因很简单，有些公司都不提供外网给项目组人员，

因此就不能使用maven访问远程的仓库地址，所以很有必要在局域网里找一台有外网权限的机器，搭建nexus私服，然后开发人员连到这台私服上，这样的话就可以通过这台搭建了nexus私服的电脑访问maven的远程仓库。

706. 1.1、Nexus架构

707.

708. 二、nexus私服的下载和安装

709. 2.1、nexus下载

710. 去下载最新版本的nexus，下载地址：http://www.sonatype.org/nexus/go ，

如下图所示： 711.

712. 下载完成之后得到的压缩包。

713. 2.2、nexus安装

714. 解压压缩包，如下图所示： 715.

716. 打开目录nexus-2.10.0-02-bundle\\nexus-2.10.0-02\\bin\\jsw ，这个目录

下面你会发现有很多系统版本的nexus环境，如下图所示： 717.

718. 我的电脑是win7 (64)为的系统，所以我选择的是windows-x86-64这个版本，

当然可以根据个人的电脑系统选择对应的版本，打开windows-x86-64文件夹，可以看到里面有如下图所示的文件： 719.

720. 一般都是将nexus安装成windows服务，所以点击install-nexus.bat这个批

处理程序将nexus安装成window服务，开机时自动启动。如下图所示： 721.

722. 从服务列表中可以看到，目前nexus服务的还没有启动，所以我们要启动nexus

服务，运行

nexus-2.10.0-02-bundle\\nexus-2.10.0-02\\bin\\jsw\\windows-x86-64下的【start-nexus.bat】批处理程序启动服务，如下图所示： 723.

724. 启动服务过程如下图所示： 725.

726. 注意，启动服务时必须要保证8081端口没有被其他程序占用，否则是无法启动

服务的。

727. 2.3、测试nexus是否安装成功

728. nexus服务启动之后，在浏览器中输入\进行

访问，如下图所示：

729.

730. 在右上角有个【Log in】 的超链接，点击登录，默认的用户名是 admin 密码是

admin123 731. 732.

733. 可以看到，nexus可以正常访问和登录，这就说明nexus已经安装成功。 734.

本文来源：https://www.bwwdw.com/article/pkvp.html