1 概述4

1.1 Maven简介 4

2 Maven安装4

2.1 java环境 4

2.2 Maven环境安装 4

2.2.1 windows下安装4

2.2.2 Linux下安装4

2.3 eclipse插件安装 5

3 Maven配置使用7

3.1Maven项目创建 7

3.1.1使用archetype生成骨架7

3.1.2使用m2eclipse工具9

3.1.3 依赖管理和运行13

3.2 Maven的目录结构 16

3.3 settings.xml 17

3.4 repository 17

3.5 maven的项目对象模型pom.xml 17

3.5.1 project下的maven元素17

3.5.2 maven的基本配置19

3.5.3 maven的运行配置20

3.5.4 扩展信息21

3.5.5 环境设置21

4 项目模块化管理21

5 私服及客户端配置34

5.1 nexus的安装 34

5.2 客户端配置私服 34

5.2.1 项目单独设置34

5.2.2 settings.xml全局设置35

5.3 把构件发布到私服 35

5.4 第三方构架的部署 36

6 版本管理36

6.1 maven的版本 36

6.2 结合Maven的项目版本演进 36

6.3自动化版本管理 37

6.3.1基础设置37

6.3.2 scm配置38

6.3.3 设置maven-release-plugin38

8 自定义骨架47

8.1新建一个骨架 47

8.2 archetype-metadata.xml配置 49

8.3 archetype-resources介绍 50

8.4 安装和部署骨架 50

8.5客户端使用 51

附录52

settsing.xml的配置文件详解 52

1 概述

本文档主要讲述一下在实际开发中，经常使用的maven功能。如果想了解更多内容，访问http://maven.apache.org/网站的文档内容，或者书籍《Maven实战》。

1.1 Maven简介

什么是maven？

Maven 是一个项目管理工具，它包含了一个项目对象模型 (POM)，一组标准集合，一个项目生命周期(ProjectLifecycle)，一个依赖管理系统(Dependency ManagementSystem)，和用来运行定义在生命周期阶段(phase)中插件(plugin)目标(goal)的逻辑。当你使用Maven 的时候，你用一个明确定义的项目对象模型来描述你的项目，然后 Maven 可以应用横切的逻辑，这些逻辑来自一组共享的（或者自定义的）插件。

这个解释有点麻烦，简单点讲，maven能提供：项目的依赖管理，编译，测试，打包，分发的工具。这一切都在他的pom.xml中。

2 Maven安装

2.1 java环境

安装maven之前，先必须安装java环境，这个大家都很熟悉了，这里不做介绍。

2.2 Maven环境安装

去maven网站http://maven.apache.org下载maven，推荐maven3的发布版本。

下载完成后，解压。设置环境变量,和path

2.2.1 windows下安装

假设解压后目录为D:\maven3

控制面板-->系统-->高级-->环境变量，添加一个name为M2_HOME,值为d:\maven3

然后在path最后添加;%M2_HOME%\bin，保存退出。然后cmd命令下，输入 mvn -version，看到maven的版本说明安装成功。

2.2.2 Linux下安装

假设解压目录/usr/local/maven3下

#vi /etc/profile

在文档末尾加上

JAVA_HOME=/usr/lib/java-6-sun

M2_HOME=/usr/local/maven3

PATH=$JAVA_HOME/bin:$M2_HOME/bin:$PATH

export JAVA_HOME M2_HOME PATH

保存退出

#source /etc/profile

lava@lava-laptop:~$ mvn -version

Apache Maven 3.0.3 (r1075438; 2011-03-01 01:31:09+0800)

Maven home: /usr/local/maven3

Java version: 1.6.0_26, vendor: Sun Microsystems Inc.

Java home: /usr/lib/jvm/java-6-sun-1.6.0.26/jre

Default locale: zh_CN, platform encoding: UTF-8

OS name: "linux", version: "2.6.38-11-generic", arch: "i386", family: "unix"

说明基本的maven已经安装成功，我们可以使用mvn命令来操作。

3 Maven配置使用

*3.1Maven项目创建***

前面我们已经搭建了maven环境，现在我们来创建一个maven的工程。

Maven项目可以通过手工写pom.xml和创建相关的目录，或通过mvn命令用骨架（Archetype）生成，已经eclipse的m2eclipse插件来创建。

手工来写比较麻烦，下面通过mvn命令和m2eclipse插件来演示。

3.1.1使用archetype生成骨架

在我们的工作空间目录，输入

#mvn archetype：generate

接下来会下载相关插件，然后会列出很多骨架.

458: remote -> se.vgregion.javg.maven.archetypes:javg-minimal-archetype (-)

Choose a number or apply filter (format: [groupId:]artifactId, case sensitive contains): 135: 135

(上面列出很多版本，默认为135的archetype。我们选择默认的回车。接下来里出版本选择：)

Choose version:

1: 1.0-alpha-1

2: 1.0-alpha-2

3: 1.0-alpha-3

4: 1.0-alpha-4

5: 1.0

6: 1.1

Choose a number: 6: 6

（我们选择最新版本，输入6，接下来叫输入groupId）

Define value for property 'groupId': : com.ambow

（输入com.ambow后回车要求输入artifactId）

Define value for property 'artifactId': : ambow-mvn-research

（输入ambow-mvn-research后，要求输入版本，默认为1.0-SNAPSHOT）

Define value for property 'version': 1.0-SNAPSHOT: :

（直接回车，要求输入包结构，默认为com.ambow）

Define value for property 'package': com.ambow: : com.ambow.mvn.research

(我们输入com.ambow.mvn.research,接下来列出我们的输入信息，要求确认)

Confirm properties configuration:

groupId: com.ambow

artifactId: ambow-mvn-research

version: 1.0-SNAPSHOT

package: com.ambow.mvn.research

Y: : Y

（输入Y，回车，我们的maven的工程创建完了。）

这就是我们默认创建的maven骨架。

3.1.3 依赖管理和运行

maven的依赖管理和运行插件都在pom.xml里面配置。一个简单的pom.xml如下：

<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">

<groupId>com.ambow</groupId>

<artifactId>mvn-account</artifactId>

<version>0.0.1-SNAPSHOT</version>

<name>mvn-account</name>

<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

</properties>

<groupId>junit</groupId>

<artifactId>junit</artifactId>

</dependency>

</dependencies>

</project>

maven设置完成后，在项目右击-->run as-->选择maven相关的，比如测试为maven test，安装到本地 maven install，如果没有，就选择maven build... 然后可以输入自己的命令，如

在

Goals里面输入clean package，为清空和打包，点击run，之后我们就会把工程打包为jar包了。

如果需要用其他插件运行，比如一个web项目，用jetty来运行测试。

在pom.xml的<build> <plugins>下增加一个jetty-maven-plugin（没有build和plugins可以在project里面自己增加）

<groupId>org.mortbay.jetty</groupId>

<artifactId>jetty-maven-plugin</artifactId>

<stopKey>stop-jetty-for-it</stopKey>

</webAppConfig>

</configuration>

<id>start-jetty</id>

<phase>pre-integration-test</phase>

<goals>

</goals>

</configuration>

</execution>

<id>stop-jetty</id>

<phase>post-integration-test</phase>

<goals>

</goals>

</execution>

</executions>

</plugin>

配置完成，然后项目上右键单机，run as-->maven build...

在goals里面输入 clean jetty:run点击run就可以执行了，不用再装tomcat了，是不是很方便。

3.2 Maven的目录结构

看了基本的使用，再介绍一下maven的目录结构，maven分为一个全局的目录和个人目录。全局目录结构在你的安装目录下，即M2_HOME下面，如上面的d:\maven3,该目录下有如下文件。

bin：该目录是maven的运行命令mvn

boot：maven的加载器。

conf：这里有一个settings.xml,是当前maven的全局配置文件。

lib：这里是存放的是maven运行所需的jar包。

maven除了全局目录结构外，还有一个个人目录结构。这个在个人目录下有一个.m2的文件夹，如window比如说用户lava，那么就在c:\Document and Settings\lava\.m2 。

linux用户应该在 /home/lava/.m2 linux root用户的话是 /root/.m2。

该目录下面包含一个settings.xml(有些可能默认没有该文件，可以手动从M2_HOME的conf目录下面拷贝一个）文件和repository目录。

3.3 settings.xml

maven的settings.xml，这两个的默认配置是一样的，只是作用域不同，M2_HOME下是全局的，即使用该计算机的用户都设置。而.m2下是私有的，即当前登录的账户，所以一般建议设置.m2下面的settings.xml，如果是个人电脑，那也无所谓拉。settings.xml的具体内容，查看附录。

3.4 repository

这个是本地库目录，该目录默认在.m2目录下面，也可以通过settings.xml更改到其他位置。具体看附录。

repository即本地库，maven从中央仓库中下载的jar包都会存在此处。

3.5 maven的项目对象模型pom.xml

pom.xml是maven的项目对象模型，maven项目的依赖管理，编译，测试，打包，分发，都是通过这个文件来配置。maven以项目为中心，project是pom.xml的顶层元素，表明一个项目。

3.5.1 project下的maven元素

project下包含很多元素，下面列出主要的元素。

元素名称	作用	是否可继承	备注
modelVersion	表明对象模型的版本	否	maven2，3都是用4.0.0
groupId	组id，该项目创建者组织或者小组，是项目坐标的核心元素	是
artifactId	构件id，项目或模块的名称，也是项目坐标的核心元素	否
version	当前项目或模块的版本，也是项目坐标的核心元素	是
packaging	打包格式jar，war，pom，maven-plugin等	否
name	项目名称	否	通常用于maven产生的文档中
url	指定项目站点	否	通常用户maven产生的文档中
description	项目描述	是	用户项目产生文档中
organization	项目的组织信息	是
inceptionYear	项目的创建年份	是
developers	项目的开发者信息	是
contributors	项目的贡献者信息	是
parent	指定父项目，里面包含父项目坐标和路径	否	这个只在有父子项目的情况下，子项目可用
modules	项目包含的其他项目模块，里面通过module元素指定具体的artifactId	否	只有父模块可用
properties	用户自定义maven属性	是
scm	项目的版本控制系统信息	是
build	项目的源代码目录配置，输出目录配置，插件配置，插件管理配置等	是
dependencies	项目的依赖配置	是
dependencyManagement	项目的依赖管理配置	是	配置依赖的定义，但是不具体引入依赖。
distributionManagement	项目的部署配置	是
issueManagement	项目的缺陷跟踪系统信息	是
repositories	项目的仓库配置	是
reporting	包括项目的报告输出目录配置，报告的插件	是
mailLingLists	项目邮件列表	是
ciManagement	项目持续集成系统信息	是
profiles	根据不同环境来作管理maven项目	否
licenses	授权信息	否

上面的maven元素，可以分为基本配置，运行设置，扩展信息和环境变量这4个类型：

基本配置
<groupId>...</groupId>
<artifactId>...</artifactId>
<version>...</version>
<packaging>...</packaging>
<dependencies>...</dependencies>
<parent>...</parent>
<dependencyManagement>...</dependencyManagement>
<modules>...</modules>
<properties>...</properties>

运行设置
<build>...</build>
<reporting>...</reporting>

扩展信息
<name>...</name>
<description>...</description>
<url>...</url>
<inceptionYear>...</inceptionYear>
<licenses>...</licenses>
<organization>...</organization>
<developers>...</developers>
<contributors>...</contributors>

环境设置
<issueManagement>...</issueManagement>
<ciManagement>...</ciManagement>
<mailingLists>...</mailingLists>
<scm>...</scm>
<prerequisites>...</prerequisites>
<repositories>...</repositories>
<pluginRepositories>...</pluginRepositories>
<distributionManagement>...</distributionManagement>
<profiles>...</profiles>

3.5.2 maven的基本配置

基本配置中，最关键是maven的坐标。任何maven的项目必须要有坐标的定义，其他项目对其依赖，maven库的存储路径都需要坐标来定位。

maven的坐标包含3个元素:

groupId:组ID是表示一个组织，比如com.ambow是安博的组Id,org.springframework表示spring组织。一个组Id可以在pom.xml用如下方式定义：

<groupId>com.ambow</groupId>

artifactId：构件Id表示某个模块，在一个组织下可以分很多的构件或模块，比如spring下有spring-core，spring-beans等模块。比如我们想创建一个账户的某块，命名为ambow-account可以通过如下方式定义。

<artifactId>ambow-account</artifactId>

version：版本这个好理解，在开发中，到一定时候会形成一个版本，供其他应用使用，当前版本继续开发。SNAPSHOT标示快照版本。版本的创建如下

<version>0.0.1-SNAPSHOT</version>

这3个定义好，就定义他的坐标了，即com.ambow组织下，有一个ambow-account的构件，当前版本为0.0.1-SNAPSHOT。如果运行mvn install，加入编译测试没有问题，那么就会安装到我们的本地库中。

可以通过groupId/artifactId/version/具体jar包和sha1文件等文件。

groupId中间有.会转换成包，比如org.springframework会变成org/springframework。

packaging是maven的打包格式，jar是不同的lib包，war为web的包，pom是maven的父项目时配置，maven-plugin是maven的插件项目。

dependencies 与 dependencyManagement一个是依赖，一个是依赖管理，这两个都是项目需要引入的依赖包的配置，却别是，前者是即定义又引入包，而后者只是定义，但不具体引入，一般在多某块项目中，为了配置简化，dependencyManagement会比较有用。

properties是自定义属性，这个在很多项目中都会用到，比如依赖了spring的多个类库，每一个库都有相同的groupId和version，但是version随着spring的升级而升级，我们要升级时，需要把version都该一遍，这样很麻烦，有时候难免疏漏。这时候我们可以吧spring的version定义自定义属性，其他地方引用该属性，那么以后只要改一处就行，带来方便。举例说明：

<junit.version>4.8.2</junit.version>

<org.springframework.version>3.0.5.RELEASE</org.springframework.version>

</properties>

<groupId>org.springframework</groupId>

<artifactId>spring-core</artifactId>

<version>${org.springframework.version}</version>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-beans</artifactId>

<version>${org.springframework.version}</version>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-aop</artifactId>

<version>${org.springframework.version}</version>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-context</artifactId>

<version>${org.springframework.version}</version>

</dependency>

</dependencies>

parent与modules主要在多模块项目中使用，父模块用modules定义它包含的子模块，而子模块通过parent元素定义他的父模块。这个内容在项目模块化管理中具体介绍。

3.5.3 maven的运行配置

说到maven的运行配置，就得先说说maven的生命周期。

maven有3组声明周期：clean，default，site，它们相互独立运行。

clean：项目的清理，主要负责把其他生命周期生成的输出文件清理掉。

default：该声明周期是负责构件项目，这个生命周期具体执行些什么，就要看运行配置的build元素中的插件，和构件的目标（goal）。

site：该声明周期的目的是建立项目站点，声明周期的执行也跟 reporting元素中的插件几目标有关。

运行maven很简单，可以到项目跟目录，输入命令，比如：

mvn clean执行清理

mvn test 执行测试

mvn clean deploy site-deploy 执行清理，部署和站点部署。

也可以通过eclipse的插件执行，项目右键单击--》run as--》选择maven相关的命令或则在maven build。。。，再goal里面输入自己想要执行的命令。

3.5.4 扩展信息

扩展信息主要是一些组织项目的信息，这里不做详细介绍了。

3.5.5 环境设置

环境设置主要设置svn之类的设置，这里略。

4 项目模块化管理

项目模块化的管理，有几个好处，设计上解耦。对于单独的某块，可以被其他项目引用，不用重复代码。

Maven项目是模块化的有力工具。

下面来实践一个模块化的项目。

新建一个父项目：ambow-parent

点击完成

生成的pom.xml如下：

<?xml version="1.0" encoding="UTF-8"?>

<artifactId>ambow-parent</artifactId>

<groupId>com.ambow</groupId>

<version>1-SNAPSHOT</version>

<name>ambow-parent</name>

</project>

因为是父项目，所以packaging为pom。父项目现在除了pom.xml之外，其他都没什么用。接下来创建一个某块，简单点，常用的账户吧。

File--》New--》Project...

此处选择Maven Module，点击Next，到New Maven Module页面。

这里写上ModuleName为ambow-account，Parent Probject为ambow-parent。点击Next，

这一块是底层的开发包，就选择默认的quickstart吧，当然不同的可以创建其他的骨架创建。

然后Filish。项目创建完了，我们的eclipse工程目录如下：

ambow-parent下面有一个子工程ambow-account，原来的pom.xml还在，子工程里面还有一个pom.xml.打开看看，发现父pom.xml里面增加了

<module>ambow-account</module>

</modules>

子pom.xml文件与前面创建普通项目maven项目的时候，区别为增加了：

<artifactId>ambow-parent</artifactId>

<groupId>com.ambow</groupId>

<version>1-SNAPSHOT</version>

</parent>

Maven正式通过这两个标签来确定父子关系，子模块继承一些父模块的属性。

继续创建一个web项目来作前端。其他步骤同上，选择骨架时为maven-archetype-webapp

点finish，完成。

项目目录上又加了一个目：

这样ambow-account-web写前端，ambow-account写后面的代码。现在有3个pom.xml文件，分别是ambow-account-web的：

<?xml version="1.0"?>

<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">

<artifactId>ambow-parent</artifactId>

<groupId>com.ambow</groupId>

<version>1-SNAPSHOT</version>

</parent>

<groupId>com.ambow</groupId>

<artifactId>ambow-account-web</artifactId>

<version>1-SNAPSHOT</version>

<name>ambow-account-web Maven Webapp</name>

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

<groupId>junit</groupId>

<artifactId>junit</artifactId>

</dependency>

</dependencies>

<build>

<finalName>ambow-account-web</finalName>

</build>

</project>

ambow-account的

<?xml version="1.0"?>

<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">

<artifactId>ambow-parent</artifactId>

<groupId>com.ambow</groupId>

<version>1-SNAPSHOT</version>

</parent>

<groupId>com.ambow</groupId>

<artifactId>ambow-account</artifactId>

<version>1-SNAPSHOT</version>

<name>ambow-account</name>

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

<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

</properties>

<groupId>junit</groupId>

<artifactId>junit</artifactId>

</dependency>

</dependencies>

</project>

ambow-parent的

<?xml version="1.0" encoding="UTF-8"?>

<artifactId>ambow-parent</artifactId>

<groupId>com.ambow</groupId>

<version>1-SNAPSHOT</version>

<name>ambow-parent</name>

<module>ambow-account</module>

<module>ambow-account-web</module>

</modules>

<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

</properties>

</project>

看一下，项目中的groupId和version都是重复的，properties也是重复的，还有同时引用了junit。似乎嗅出了一些坏味道，对，对我们程序员来说，相同的东西，不能让她重复，那就改一下。

对于groupId和version，这个如果子模块没有特殊的改变，那就直接继承父模块的，在子模块直接去掉。

属性也是，直接去掉。

接下来是junit，能直接去掉吗？显然不行，那怎么办呢，这这时候依赖管理器(dependencyManagement)登场。

dependencyManagement配置项目的依赖的定义，但不会实际被引入。DependencyManagement可以被子某块继承。

那么，可以把junit配置到父项目上去，在子项目里去掉版本和作用域。

在依赖一个，组和构件应该是很少变动的，但是这个版本是经常变动的，所以，可以把经常变的抽出来作为属性。

改完了之后，ambow-account的jar包是可以给ambow-account-web引用的，这里应该加上依赖。怎么依赖呢？前面提到过坐标，对，就是坐标，在依赖里面加上

<groupId>com.ambow</groupId>

<artifactId>ambow-account</artifactId>

<version>1-SNAPSHOT</version>

</dependency>

这样家好像这version又重复了，那就用属性替换

<version>${project.version}</version>

修改后的三个pom.xml为：

ambow-account-web

<?xml version="1.0"?>

<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">

<artifactId>ambow-parent</artifactId>

<groupId>com.ambow</groupId>

<version>1-SNAPSHOT</version>

</parent>

<artifactId>ambow-account-web</artifactId>

<name>ambow-account-web Maven Webapp</name>

<groupId>com.ambow</groupId>

<artifactId>ambow-account</artifactId>

<version>${project.version}</version>

</dependency>

<groupId>junit</groupId>

<artifactId>junit</artifactId>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-web</artifactId>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-webmvc</artifactId>

</dependency>

</dependencies>

<build>

<finalName>ambow-account-web</finalName>

</build>

</project>

ambow-account

<?xml version="1.0"?>

<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">

<artifactId>ambow-parent</artifactId>

<groupId>com.ambow</groupId>

<version>1-SNAPSHOT</version>

</parent>

<artifactId>ambow-account</artifactId>

<name>ambow-account</name>

</properties>

<groupId>junit</groupId>

<artifactId>junit</artifactId>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-core</artifactId>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-beans</artifactId>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-context</artifactId>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-context-support</artifactId>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-jdbc</artifactId>

</dependency>

</dependencies>

</project>

ambow-parent

<?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/maven-v4_0_0.xsd">

<artifactId>ambow-parent</artifactId>

<groupId>com.ambow</groupId>

<version>1-SNAPSHOT</version>

<name>ambow-parent</name>

<module>ambow-account</module>

<module>ambow-account-web</module>

</modules>

<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

<junit.version>4.8.2</junit.version>

<org.springframework.version>3.0.5.RELEASE</org.springframework.version>

<javax.servlet.version>2.4</javax.servlet.version>

</properties>

<groupId>javax.servlet</groupId>

<artifactId>servlet-api</artifactId>

<version>${javax.servlet.version}</version>

<scope>provided</scope>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-core</artifactId>

<version>${org.springframework.version}</version>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-beans</artifactId>

<version>${org.springframework.version}</version>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-aop</artifactId>

<version>${org.springframework.version}</version>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-context</artifactId>

<version>${org.springframework.version}</version>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-context-support</artifactId>

<version>${org.springframework.version}</version>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-jdbc</artifactId>

<version>${org.springframework.version}</version>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-web</artifactId>

<version>${org.springframework.version}</version>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-webmvc</artifactId>

<version>${org.springframework.version}</version>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-asm</artifactId>

<version>${org.springframework.version}</version>

</dependency>

<groupId>junit</groupId>

<artifactId>junit</artifactId>

<version>${junit.version}</version>

</dependency>

</dependencies>

</dependencyManagement>

<build>

</plugins>

</plugins>

</pluginManagement>

</build>

</project>

5 私服及客户端配置

maven的依赖包，一般需要从外网的中间仓库下载，这样比较慢，而且需要把自己的jar包共享的时候，也不便于保存。这些问题，可以通过maven私服来解决。

5.1 nexus的安装

Nexus是一个比较流行的maven私服软件，这里简单介绍一下。

下载：http://nexus.sonatype.org/download-nexus.html

下载完成后，进入 nexus的启动目录 nexus根目录/bin/jsw/系统

我这里是linux32位系统，所以进入linux-x86-32目录下面，输入命令

$ ./nexus start

启动后访问nexus来访问。

http://localhost:8081/nexus/index.html#welcome

nexus的默认管理用户名：admin，密码：admin123登录就可以管理了。

nexus的界面做的比较友好，具体就不再介绍了。

私服创建完了

5.2 客户端配置私服

客户端可以针对某一个项目设置，也可以设置一个全局的设置。

5.2.1 项目单独设置

对某一项目单独设置，可以在pom.xml上加上私服

<id>nexus</id>

<name>local nexus server</name>

<url>http://localhost:8081/nexus/content/groups/public/</url>

</repository>

</repositories>

<id>nexus</id>

<name>local nexus server</name>

<url>http://localhost:8081/nexus/content/groups/public/</url>

</pluginRepository>

</pluginRepositories>

这样，设置这个项目的依赖和插件都通过代理

5.2.2 settings.xml全局设置

正对全局，在Settings.xml里面配置镜像mirrors元素。

<id>nexus</id>

<name>Nexus</name>

<url>http://localhost:8081/nexus/content/groups/public</url>

</mirror>

</mirrors>

这样就配置一个所有仓库都通过私服，如果只配置中央仓库

5.3 把构件发布到私服

在我们开发中，有时候需要把自己开发的包发布，让别人引用，这时候，可以把构件发不到私服，那就跟其他的构件一样了。

需要发布构件，需要在pom.xml定义发布路径。

<id>nexus-releases</id>

<name>Internal Releases</name>

<url>http://localhost:8081/nexus/content/repositories/releases/</url>

</repository>

<id>nexus-snapshots</id>

<name>Internal snapshot</name>

<url>http://localhost:8081/nexus/content/repositories/snapshots/</url>

</snapshotRepository>

</distributionManagement>

接下来定义setting设置权限

<id>nexus-releases</id>

<username>deployment</username>

</server>

<id>nexus-snapshots</id>

<username>deployment</username>

</server>

这里把deployment的默认密码为deployment123，这里已经改为123456，这个可在nexus的权限管理里面设置。

设置完成后，在eclipse对项目右键单机，Run as --》maven build。。。goals输入 deploy点击run执行。执行后就部署上去了。

5.4 第三方构架的部署

第三方构件，如oracle的jdbc驱动等，在maven中间仓库没有，这时候，我们可以自己添加到私服里面去。

登录nexus，在Repositories里面选择3rd party，点击Artifact Upload选项卡

GAV Definition:这里，如果是maven构件工程，选择From POM，不是就选择GAV Parameters。

接下来填写相关参数，上传就OK。

6 版本管理

6.1 maven的版本

Maven的版本一般分为快照版本和发布版本。快照版本每次构件后自动会打时间戳，比如又xxx-1.0-SNAPSHOT这个快照，构件一次，那么会生成一个xxx-1.0-20111021.101010-10到我们的私服，依赖xxx-1.0-SNAPSHOT的其他项目构件时就会自动去比对，如果又更新，自动下载。

快照和稳定版本只是正对maven而言，跟版本控制然间的版本没有直接的关系。

6.2 结合Maven的项目版本演进

项目版本控制，最常用的svn，svn分为trunk，tag和branch。

trunk：为主干，一般开发在主干上进行。

tag：标签，项目开发到一段时间后，功能测试基本完成，可以独立发布一个版本，这时候我们独立的生成一个tag。

branch：分支，一般用于对已经发布的版本，有bug修改，或对现有版本有较大的调整时，独立出一个分支。

上面的版本控制与maven的版本是两个不同的维度，需要分清。

概念说完，在举例说明一下：

创建了一个项目，其实版本为1.0，为了快速开发，我们在maven配置里为snapshot版本，即1.0-SNAPSHOT。

1.0-SNAPSHOT版本开发到一定阶段，预期的功能完成，测试通过。可以发布版本。这是我们在maven中去-SNAPSHOT，并打标签，发布为1.0版本。

版本的发布后，项目中有新的功能需要开发。下一个版本定义为1.1，在主干上开发。我们需要改变maven的配置为1.1-SNAPSHOT，发开完成，在此生成标签1.1，如此循环下去。

在我们开发1.1版本的时候，发现了已发布1.0版本的bug，这是需要针对1.0作修改，但是主干已经有了代码的改动，这时候，可以对tag1.0的基础上生成一个分支（branch）1.0.1-SNAPSHOT，在分支上进行修改，修改完成测试通过，生成新的tag，1.0.1。并把修改的代码合并到主干。这样依次演进。

6.3自动化版本管理

6.3.1基础设置

在自动话版本管理之前，先做点准备工作。创建一个svn

$ svnadmin create /opt/svn-repos/ambow-account-obj

修改svn的conf内权限配置

权限文件authz配置

[groups]

admin = lava

[/]

@admin = rw

用户密码passwd文件配置

[users]

lava = 123456

svn服务svnserve.conf配置（把#去掉，前面不要有空格）

auth-access = write

password-db = passwd

authz-db = authz

use-sasl = true

配置完成后，启动服务

svnserve -d -r /opt/svn-repos --listen-host 0.0.0.0

参数意义：

-d 以后台运行

-r svn仓库位置

--linsten-host 监听host，以ipv4绑定

svn服务创建好了。

安装我们先前的样子创建一个svn的模板

创建一个空的目录，比如prj-tmp，里面再创建trunk，tags，branches三个目录

用svn把模板导入库中：

svn import -m "new import" ./prj-tmp/ svn://localhost/ambow-account-obj/

输入密码，导入就完成了。

这样就把项目模板里的trunk，tags，branches导入到了svn://localhost/ambow-obj/中了，svn的模板文件弄完（如果公司同意管理svn项目，上面的不需要作，只要管理员告知svn的地址和用户名密码就可以了）。接下来导入项目

svn import -m “import init project” ~/workspaces/ambow-account-obj/ svn://localhost/ambow-account-obj/trunk/

导入完成，通过eclipse新建项目。

eclipse里面切换svn资源库视图，在svn资源库里面右键单击--》新建--》资源库位置

然后输入资源库位置：svn://localhost/ambow-account-obj/点击完成，这时候在svn资源库里面已经又svn://localhost/ambow-account-obj了，点击会提示输入用户名密码。输入后可以看到项目下的内容。

对trunk新建项目，右键单击--》检出为，弹出新建项目向导，这里不做详细叙述，可以参考前面的章节。

6.3.2 scm配置

项目建立后，需要配置scm信息。

在父项目的pom.xml里面添加scm信息。

<scm>

<connection>scm:svn:svn://localhost/ambow-account-obj/trunk/</connection>

<developerConnection>scm:svn:svn://localhost/ambow-account-obj/trunk/ </developerConnection>

<url>svn://localhost/ambow-account-obj/trunk/</url>

</scm>

connection是只读的scm地址

developerConnection是开发scm地址

url是浏览器访问地址

scm的地址以scm开头，第一个：后面是版本控制工具的类型，这里是svn，也可以是git,cvs。接下来是具体的svn地址。

6.3.3 设置maven-release-plugin

在pom.xml的build中添加如下

<groupId>org.apache.maven.plugins</groupId>

<artifactId>maven-release-plugin</artifactId>

<tagBase>svn://localhost/ambow-account-obj/tags/</tagBase>

<branchBase>svn://localhost/ambow-account-obj/tags/</branchBase>

</configuration>

</plugin>

设置完成，发布的设置完成，接下来svn提交所有代码。

在eclipse中run as--》maven build...

在目标中输入 release:prepare然后点击运行，来发布版本。

7 测试与持续集成

测试是项目开发中的必要环节，为了提升快发效率和质量，敏捷开发也越来约流行，单元测试成了日常开发必不可少的一部分。maven可以通过maven-surefire-plugin跟主流测试工具junit和TestNG来集成，完成自动华测试。

7.1 JUnit进行单元测试

7.1.1 简单JUnit测试

用junit进行单元测试，其实很简单，在pom.xml引入junit的依赖即可。

<groupId>junit</groupId>

<artifactId>junit</artifactId>

<version>${junit.version}</version>

</dependency>

然后就是编写普通junit的代码是一样的，比如现在有一个UserDao.java代码如下

package com.ambow.account.dao;

import org.springframework.jdbc.core.support.JdbcDaoSupport;

import com.ambow.account.model.User;

public class UserDao extends JdbcDaoSupport{

public User getUser(String username,String password){

if("lava".equals(username)&&"123456".equals(password)){

return new User(username,password);

}

return null;

}

编写测试代码：

package com.ambow.account.dao;

import org.junit.Assert;

import org.junit.Test;

import com.ambow.account.model.User;

public class TestUserDao {

private UserDao userDao = new UserDao();

@Test

public void getUser(){

String username = "lava";

String password = "123456";

User user = userDao.getUser(username,password);

Assert.assertNotNull(user);

}

接下来运行maven test，maven就自动为我们测试了，如下：

-------------------------------------------------------

T E S T S

-------------------------------------------------------

Running com.ambow.account.dao.TestUserDao

Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.123 sec

Results :

Tests run: 1, Failures: 0, Errors: 0, Skipped: 0

7.1.2 Spring的单元测试

在项目中是用了Spring，这时候需要配置Spring的环境，把spring的配置加载到项目中。spring提供了spring-test的工具包，给测试带来方便。

首先引入spring的依赖包：

<groupId>org.springframework</groupId>

<artifactId>spring-test</artifactId>

</dependency>

为了测试方便，写一个spring的基础测试类SpringBaseTest.java

package com.ambow.account.test;

import org.springframework.test.context.ContextConfiguration;

import org.springframework.test.context.junit4.AbstractTransactionalJUnit4SpringContextTests;

import org.springframework.test.context.transaction.TransactionConfiguration;

@ContextConfiguration(locations = { "classpath:applicationContext.xml" })

@TransactionConfiguration(transactionManager = "springTransactionManager", defaultRollback = true)

public abstract class SpringBaseTest extends

AbstractTransactionalJUnit4SpringContextTests {

}

这是稍微解释一下：@ContextConfiguration注解，主要标记spring的配置，这里把所有配置都写上。

AbstractTransactionalJUnit4SpringContextTests提供了对JUnit4的事务支持，这样方便我们事务控制，该类有@TransactionConfiguration的事务注解配置，transactionManager 属性跟Spring配置文件里面的事务一致。defaultollback这个属性表示是否自动回滚，true为是，设置为true时，测试完成，数据库不会新增数据，为我们下次测试带来方便。

具体的测试类需要继承 SpringBaseTest

package com.ambow.account.service;

import javax.annotation.Resource;

import org.junit.Assert;

import org.junit.Test;

import com.ambow.account.model.User;

import com.ambow.account.test.SpringBaseTest;

public class TestUserService extends SpringBaseTest{

@Resource

UserService userService;

@Test

public void getUserTest(){

String username = "test";

String password = "test";

User user = userService.getUser(username, password);

Assert.assertNull(user);

}

@Resource注解获取Spring的配置userService。

接下来就可以运行测试了，运行方式跟上面的一样。

8 自定义骨架

自定义骨架，可以根据我们项目的需要，来生成，比如，公司有一个自定义的框架，新项目都可以根据该框架上来做，那么，可以把该框架定义为自定义骨架。

8.1新建一个骨架

下面演示一下自定义骨架。

eclipse：File-->New选择Maven-->Maven Project点击Next，在New Maven Project面板上直接Next，在Catalog选择All Catalogs后，找到maven-archetype-archetype，如图

然后Next，输入groupId和artifactId,去掉包结构，然后点击Finish就创建完成了。创建后如图：

骨架也是maven项目，所以在项目工程低下有一个pom.xml文件，这个文件不需要配置，默认就OK。

src/main/resources/archetype-resources目录，该目录是我们想要存放的骨架主目录。里面包含一个pom.xml文件，以及资源，包结构等内容。

src/main/resources/META-INF/maven/archetype.xml:这个是骨架的描述文件，而且基于maven-archetype-plugin 的1.0.x的版本，比较老，改为archetype-metadata.xml，2.x的版本。

8.2 archetype-metadata.xml配置

一个简单的ArcheType-metadata文件如下。

<?xml version="1.0" encoding="UTF-8"?>

<archetype-descriptor name="archetype-jdt">

</includes>

</fileSet>

<directory>src/main/resources</directory>

<include>**/*.properties</include>

</includes>

</fileSet>

</includes>

</fileSet>

</includes>

</fileSet>

<directory>src/main/webapp</directory>

</includes>

</fileSet>

</fileSets>

<defaultValue>com.ambow</defaultValue>

</requireProperty>

</requireProperties>

</archetype-descriptor>

一个archetype-descriptor 包含一个名字，我们jdt为例，为archetype-jdt。

下面包含一个fileSets和requireProperties.

fileSets可包含多个fileSet子元素，filtered标示是否对该文件集合应用属性替换。即是否对${}的内容是否用命令行替换。Packaged标示是否将该目录下的内容放在生成的项目的包路经下。fileSet的directory标示指定具体的目录，includes标示要引入的文件，excludes标示排除的文件。

requireProperties标示规定的属性，可以设置默认值。

8.3 archetype-resources介绍

这里存放骨架的内容，其实里面也是一个标准的maven工程，把一些相关的内容用属性替换。所以，必须要又一个pom.xml，接下来就是相关的默认文件，这个最好遵守maven的约定。src/main/java下面存放一些java文件等，src/main/resources，存放配型配置文件等。

把某个目录下fileSet的 packaged属性设置为true，java类

package ${package}.dao

public class Dao{

}

那么在生成骨架的时候比如输入包为com.ambow.mvn，那么骨架生成后，在src/main/java的下面有com/ambow/mvn/dao/Dao.java文件，内容为：

package com.ambow.mvn.dao

public class Dao{

}

8.4 安装和部署骨架

本地安装很简单，主要在骨架项目内运行mvn clean install，或者eclipse内直接运行选择maven install就可以。

接下来就跟通过其它骨架一家来生成我们自己的骨架了。mvn archetype：generate 选择自己的骨架就OK

maven的骨架是通过archetype-catalog.xml文件来描述的。这个文件可以通过命令来生成

mvn archetype:crawl，这样在.m2/repository下面就会有一个archetype-catalog.xml文件了。

8.5客户端使用

客户端如果没有，则直接下载archetype-catelog.xml文件到 .m2/repository下面，然后就可以用eclipse创建项目，如图

这里Catalog选择All Catalogs，Filter输入骨架关键字。找到你的骨架选择就好。

如果已经生成，把你下面内容拷贝到.m2/repository/archetype-catelog.xml文件的archetypes中

<groupId>com.ambow</groupId>

<artifactId>ambow-archetype-jdt</artifactId>

<description>archetype-jdt</description>

<repository>http://repos.ambow.com:8081/nexus/content/repositories/rel eases</repository>

</archetype>

这里groupId是你创建骨架的组Id，artifactId是构件Id，版本，描述，repository表示构建的地址，如果在settings.xml里面已经设置私服，那么这行可以去掉，没有的话加上私服的地址。

接下来新建项目同上。

附录

settsing.xml的配置文件详解

<?xml version="1.0" encoding="UTF-8"?>

<settings 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/settings-1.0.0.xsd">

<!--本地仓库。该值表示构建系统本地仓库的路径。其默认值为~/.m2/repository。如果用户空间比较小，可以设置到一个空间比较大路径。

<localRepository>usr/local/maven</localRepository>

-->

<!--Maven是否需要和用户交互以获得输入。如果Maven需要和用户交互以获得输入，则设置成true，反之则应为false。默认为true。

-->

<!--表示Maven是否需要在离线模式下运行。如果构建系统需要在离线模式下运行，则为true，默认为false。当由于网络设置原因或者安全因素，构建服务器不能连接远程仓库的时候，该配置就十分有用。

<offline>false</offline>

-->

<pluginGroup>org.codehaus.mojo</pluginGroup>

</pluginGroups>

<!-- proxy

| Specification for one proxy, to be used in connecting to the network.

<proxy>

<id>optional</id>

<username>proxyuser</username>

<password>proxypass</password>

<host>proxy.host.net</host>

<nonProxyHosts>local.net|some.host.com</nonProxyHosts>

</proxy>

-->

</proxies>

<id>server001</id>

<!--鉴权用户名。鉴权用户名和鉴权密码表示服务器认证所需要的登录名和密码。

<username>my_login</username>

-->

<!--鉴权密码。鉴权用户名和鉴权密码表示服务器认证所需要的登录名和密码。

<password>my_password</password>

-->

<passphrase>some_passphrase</passphrase>

</server>

</servers>

<id>planetmirror.com</id>

<name>PlanetMirror Australia</name>

<url>http://downloads.planetmirror.com/pub/maven2</url>

<mirrorOf>central</mirrorOf>

</mirror>

</mirrors>

<activeByDefault>false</activeByDefault>

<os>

<name>Windows XP</name>

<family>Windows</family>

</os>

<name>mavenVersion</name>

</property>

<file>

<exists>/usr/local/hudson/hudson-home/jobs/maven-guide-zh-to-production/workspace/</exists>

<missing>/usr/local/hudson/hudson-home/jobs/maven-guide-zh-to-production/workspace/</missing>

</file>

</activation>

<!--对应profile的扩展属性列表。Maven属性和Ant中的属性一样，可以用来存放一些值。这些值可以在POM中的任何地方使用标记${X}来使用，这里X是指属性的名称。属性有五种不同的形式，并且都能在settings.xml文件中访问。

1. env.X: 在一个变量前加上"env."的前缀，会返回一个shell环境变量。例如,"env.PATH"指代了$path环境变量（在Windows上是%PATH%）。

2. project.x：指代了POM中对应的元素值。

3. settings.x: 指代了settings.xml中对应元素的值。

4. Java System Properties: 所有可通过java.lang.System.getProperties()访问的属性都能在POM中使用该形式访问，

如/usr/lib/jvm/java-1.6.0-openjdk-1.6.0.0/jre。

5. x: 在<properties/>元素中，或者外部文件中设置，以${someVar}的形式使用。 -->

<user.install>/ebs1/build-machine/usr/local/hudson/hudson-home/jobs/maven-guide-</user.install>

</properties>

<id>codehausSnapshots</id>

<name>Codehaus Snapshots</name>

<enabled>false</enabled>

<updatePolicy>always</updatePolicy>

</releases>

</snapshots>

<url>http://snapshots.maven.codehaus.org/maven2</url>

<layout>default</layout>

</repository>

</repositories>

</releases>

</snapshots>

</pluginRepository>

</pluginRepositories>

<!--手动激活profiles的列表，按照profile被应用的顺序定义activeProfile。该元素包含了一组activeProfile元素，每个activeProfile都含有一个profile id。任何在activeProfile中定义的profile id，不论环境设置如何，其对应的

profile都会被激活。如果没有匹配的profile，则什么都不会发生。例如，env-test是一个activeProfile，则在pom.xml（或者profile.xml）中对应id的profile会被激活。如果运行过程中找不到这样一个profile，Maven则会像往常一样运行。 -->

</activeProfiles>

</profile>

</profiles>

</settings>

发表于 2020-10-09 11:34 zhangzhen894095789 阅读(166) 评论(0) 编辑收藏举报

Maven学习手册

1 概述

1.1 Maven简介

2 Maven安装

2.1 java环境

2.2 Maven环境安装

2.2.1 windows下安装

2.2.2 Linux下安装

3 Maven配置使用

3.1Maven项目创建

3.1.1使用archetype生成骨架

3.1.3 依赖管理和运行

3.2 Maven的目录结构

3.3 settings.xml

3.4 repository

3.5 maven的项目对象模型pom.xml

3.5.1 project下的maven元素

3.5.2 maven的基本配置

3.5.3 maven的运行配置

3.5.4 扩展信息

3.5.5 环境设置

4 项目模块化管理

5 私服及客户端配置

5.1 nexus的安装

5.2 客户端配置私服

5.2.1 项目单独设置

5.2.2 settings.xml全局设置

5.3 把构件发布到私服

5.4 第三方构架的部署

6 版本管理

6.1 maven的版本

6.2 结合Maven的项目版本演进

6.3自动化版本管理

6.3.1基础设置

6.3.2 scm配置

6.3.3 设置maven-release-plugin

7 测试与持续集成

7.1 JUnit进行单元测试

7.1.1 简单JUnit测试

7.1.2 Spring的单元测试

8 自定义骨架

8.1新建一个骨架

8.2 archetype-metadata.xml配置

8.3 archetype-resources介绍

8.4 安装和部署骨架

8.5客户端使用

附录

settsing.xml的配置文件详解

*3.1Maven项目创建***