JAVAWEB开发之Maven的入门详解——Maven的安装以及项目的结构和Maven的使用以及私服的搭建与配置

什么是Maven？

 翻译为专家，内行。Maven是跨平台的项目管理工具。主要服务于基于Java平台的项目构建，项目管理和项目信息管理。那么怎么样才算是理想的项目构建呢？理想的项目构建就是必须具备高度自动化，跨平台，可重用的组件，标准化这些特性。

什么是依赖？为什么要进行依赖管理？

- 所谓的依赖就是自动下载。进行依赖管理主要是为了统一的对这些依赖进行管理。

都有哪些项目信息？

-项目名称描述，开发者信息，开发人员信息，项目的版本号等等。

什么项目构建？

- 所谓的项目构建就是对项目进行清理、编译、测试、报告、打包、部署等一系列的过程称为项目的构建如下图所示：

Maven模型 

如下图所示：

它将每一个项目都当成了一个对象POM，通过依赖管理Dependency从仓库中进行存取。通过插件对Maven的生命周期进行管理，生命周期的每一个阶段都由相应的插件进行支持。由不同的命令激活不同的插件进行工作。

Maven的主要内容主要包括以下几个部分：

• 为什么要使用Maven
• Maven的安装与配置
• 第一个Maven相关概念
• Maven与Eclispe整合-Nexus
• 部署构建至Nexus

为什么使用Maven？

项目构建的工具有很多 IDE、Eclipse、Ant、Maven

不使用IDE和Eclipse构建项目的原因？

• 手工操作较多，编译、测试、部署等工作都是独立的，很难一步完成。
• 每个人的IDE配置都不同，很容易出现本地代码换个地方编译就出错。

不使用Ant的原因？

• 没有一个约定的目录结构
• 必须明确让Ant做什么，什么时候做然后编译，打包。
• 没有生命周期，必须定义目标及其实现的任务序列。
• 没有集成依赖管理。

使用Maven的原因？

• 拥有约定的目录结构，知道你的代码在哪里，放到哪。
• 拥有一个生命周期，例如执行mvn install 就可以自动执行编译，测试，打包等构建过程。
• 只需要定义一个pom.xml，然后将源码放到默认的目录，Maven帮你自动处理其他事情。
• 拥有依赖管理，仓库管理。

Maven的安装

(一) Windows系统安装Maven：

1、检查JDK安装的情况(需要1.6以上)

echo %JAVA_HOME%

java -version

2、对apache-maven-3.0.3-bin.zip进行解压，例如解压到如下目录(解压目录路径中最好不要包含中文)

3.设置系统环境变量，MAVEN_HOME

4、设置环境变量Path，将%MAVEN_HOME%\bin加入Path中，一定要注意使用分号 ; 与其他值隔开。

5、验证安装是否成功，打开cmd窗口，输入mvn  -v进行查看

(二) Mac系统安装Maven的方式  

1、打开终端，查看JDK的安装情况，查看JDK版本

[plain] view plain copy

1. liuliuxundeMacBook-Pro:~ liuxun$ echo $JAVA_HOME  
2. /Library/Java/JavaVirtualMachines/jdk1.8.0_102.jdk/Contents/Home  
3. liuliuxundeMacBook-Pro:~ liuxun$ java -version  
4. java version "1.8.0_102"  
5. Java(TM) SE Runtime Environment (build 1.8.0_102-b14)  
6. Java HotSpot(TM) 64-Bit Server VM (build 25.102-b14, mixed mode)  

2、将maven包解压到用户目录下 如下图所示

3、配置变量 MAVEN_HOME以及Path变量

使用vi编辑器编辑  ~/.bash_profile 文件，即vi  ~/,bash_profile配置如下：

然后 输入 :wq 保存并退出。

4、重启终端 输入 mvn -v

需要注意的是：Mac 查看变量 需要在变量前加$号。另外设置Path的时候 多个变量间使用:分开。

Maven的配置

Maven安装目录分析

bin：含有mvn运行的脚本。

boot：含有plexus-classworlds类加载器框架。

conf：含有setting.xml配置文件

lib: 含有Maven运行时所需要的Java类库。

LISTENSE.txt，NOTICE.txt，README.txt针对Maven的版本，第三方软件等简要介绍。

初始化配置：

设置MAVEN_HOME环境变量: 已设置, 升级时只需要下载最新版本，解压后重新设置MAVEN_HOME环境变量即可。

设置MAVEN_OPTS环境变量：-Xms128m -Xmx512m  设置Maven仓库占用的空间大小。

配置用户范围的settings.xml：

MAVEN_HOME/conf/settings.xml全局的配置文件

~/.m2/settings.xml: 与默认仓库对应的配置文件。

 默认仓库: 当前用户C:\users\[username]\.m2\repository

一般可以自定义用户的仓库 而不再使用默认仓库 配置方法 在 MAVEN_HOME/conf/settings.xml配置中设置路径执行仓库目录 

 

[html] view plain copy

1. <localRepository>/Users/liuxun/maven_repository/repository</localRepository>  

 

然后将此全局的配置文件保存，并复制到自己仓库的同级目录

本地仓库同级目录的settings.xml文件的内容必须和全局的settings.xml配置文件完全一致。

注意：

  用户级别的仓库在全局配置中一旦设置，全局配置将不再生效 专用用户设置的仓库，否则使用默认路径仓库。

遵守Maven的约定

src/main/java ——存放项目的.java文件

src/main/resources ——存放项目的资源文件，如spring，hibernate配置文件

src/test/java —— 存放所有测试的.java文件，例如Junit测试类

src/test/resources —— 测试的资源文件

target —— 项目的输出位置

pom.xml —— maven项目核心配置文件

Maven的简单入门

第一个简单示例：

第一步：首先建立MavenHelloWorld项目同时建立Maven约定的目录结构。

MavenHelloWorld

第二步：在/src/main/java/my/test/maven目录下新建文件HelloWorld.java

[java] view plain copy

1. package my.test.maven;  
2.   
3. public class HelloWorld {  
4.     public String sayHello(String name){  
5.         return "Hello World :" + name + "!";  
6.     }  
7. }  

 第三步：在/src/test/java/my/test/maven目录下新建测试文件HellTest.java

[java] view plain copy

1. package my.test.maven;  
2.   
3. import org.junit.Test;  
4. import static junit.framework.Assert.*;  
5.   
6. public class HelloTest {  
7.   
8.     @Test  
9.     public void testHello(){  
10.           
11.         HelloWorld hello = new HelloWorld();  
12.         String results = hello.sayHello("maven");  
13.         assertEquals("Hello maven!",results);         
14.   
15.     }  
16.       
17. }  

第四步：在项目MavenHelloWorld 根目录新建pom.xml

[html] view plain copy

1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">  
2.   <!-- 版本：4.0.0 -->  
3.   <modelVersion>4.0.0</modelVersion>  
4.   <!-- 组织名称：暂时使用 组织名称+项目名称 作为组织名称 -->  
5.   <!-- 组织名称：实际名称 按照访问路径规范设置，通常以功能作为名称：eg: junit spring -->  
6.   <groupId>my.test.maven</groupId>  
7.   <!-- 项目名称 -->  
8.   <artifactId>HelloWorld</artifactId>  
9.   <!-- 当前项目版本号：同一个项目开发过程中可以发布多个版本，此处标示0.0.1版 -->  
10.   <!-- 当前项目版本号：每个工程发布后可以发布多个版本，依赖时调取不同的版本，使用不同的版本号 -->  
11.   <version>0.0.1</version>  
12.   <!-- 名称：可省略 -->  
13.   <name>Hello</name>  
14.     
15.   <!-- 依赖关系 -->  
16.     <dependencies>  
17.         <!-- 依赖设置 -->  
18.         <dependency>  
19.             <!-- 依赖组织名称 -->  
20.             <groupId>junit</groupId>  
21.             <!-- 依赖项目名称 -->  
22.             <artifactId>junit</artifactId>  
23.             <!-- 依赖版本名称 -->  
24.             <version>4.9</version>  
25.             <!-- 依赖范围：test包下依赖该设置 -->  
26.             <scope>test</scope>  
27.         </dependency>       
28.           
29.     </dependencies>  
30. </project>  

第五步：

a) 打开cmd或Mac终端命令行，进入Hello项目根目录(包含pom.xml的目录)

b) 执行mvn compile命令

    执行完毕后，生成了maven工程编译完成后字节码文件的生成目录target

c) 在终端中继续输入mvn clean命令

    执行完毕后，字节码生成目录被删除

d) 在cmd或终端输入mvn test命令

    执行完毕后，字节码生成目录中生成了被测试类与测试类的编译字节码和测试执行过程日志与详细报告。

e) cmd或终端中输入mvn clean compile命令

    组合指令，先执行clean，再执行compile，通常应用于上线前执行，清除测试类

f) cmd或终端输入mvn clean test

    组合指令，先执行clean，再执行test，通常用于测试环节

g) cmd或终端输入mvn clean package命令

    组合指令，先执行clean，再执行package，将项目打包，通常应用于发布前。

    执行过程：

                   清理——清理环境

                   编译——编译源码

                   测试——测试源码

                   打包——将编译的非测试类打包

h) cmd或终端输mvn clean install 查看仓库，当前项目被发布到仓库中

    组合指令，先执行clean，再执行install，将项目打包，通常应用于发布前。

    执行过程：

                  清理——清空环境

                  编译——编译源码

                  测试——测试源码

                  打包——将编译的非测试类打包

                  部署——将打好的包发布到资源仓库中

第二个简单示例
第六步：新建第二个项目模块HelloFriend目录以及约定的目录结构。

第七步：在项目HelloFriend根目录创建pom.xml

[html] view plain copy

1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">  
2.   <modelVersion>4.0.0</modelVersion>  
3.   <groupId>my.test.maven</groupId>  
4.   <artifactId>HelloFriend</artifactId>  
5.   <version>0.0.1-SNAPSHOT</version>  
6.   <name>HelloFriend</name>  
7.     
8.     <dependencies>  
9.         <dependency>  
10.             <groupId>junit</groupId>  
11.             <artifactId>junit</artifactId>  
12.             <version>4.9</version>  
13.             <scope>test</scope>  
14.         </dependency>       
15.           
16.         <dependency>  
17.             <groupId>my.test.maven</groupId>  
18.             <artifactId>HelloWorld</artifactId>  
19.             <version>0.0.1</version>  
20.             <scope>compile</scope>  
21.         </dependency>       
22.     </dependencies>  
23. </project>  

第八步：在src/main/java/my/test/maven目录下新建文件HelloFriend.java

[java] view plain copy

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

第九步：在src/test/java/my/test/maven目录下新建测试文件HelloFriendTest.java

[java] view plain copy

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

第十步：在HelloFriend目录下执行命令mvn package   系统报错说没有找到依赖

第十一步：需要重新构建HelloWorld第一个项目并安装到数据仓库，在命令行HelloWorld根目录下执行mvn clean install
第十二步：重新再HelloFriend目录下执行命令mvn package

运行成功

MyEclipse上Maven的配置 打开偏好设置 搜索Maven 配置如下

Maven的核心概念

坐标、依赖管理、仓库管理、生命周期、插件和目标、聚合继承

什么是坐标？

- 在平面几何中坐标可以标识平面中唯一的点。

Maven坐标主要组成

• groupId：定义当前Maven项目隶属项目。
• artifactId：定义实际项目中的一个模块。
• version：定义当前项目的当前版本。
• packaging：定义该项目的打包方式 默认是jar 还可以设置为war、pom、maven-plugin等

Maven为什么使用坐标？

- Maven世界拥有大量构建，我们需要找一个用来唯一标识一个构建的统一规范。

- 拥有了统一规范，就可以将查找工作交给机器。

依赖管理—依赖范围

依赖声明主要包含如下元素

[html] view plain copy

1. <dependencies>  
2.     <dependency>  
3.         <groupId>junit</groupId>  
4.         <artifactId>junit</artifactId>  
5.         <version>4.10</version>  
6.         <scope>test</scope>  
7.     </dependency>           
8. </dependencies>  

其中依赖范围scope 用来控制依赖和编译，测试，运行的classpath的关系，主要的是三种依赖关系如下：

1.compile：默认编译依赖范围。对于编译，测试，运行三种classpath都有效

2.test：测试依赖范围。只对测试classpath有效

3.provided：已提供的依赖范围。对于编译，测试的classpath都有效，但对于运行无效。因为已经由容器提供。例如：servlet-api

4.runtime：运行时提供。例如：jdbc驱动

如何进行依赖配置？

传递性依赖和可选依赖，排除依赖。

依赖管理—传递依赖

Two中使用One，Three中使用Two，称Two是Three的直接依赖，称One是Three的间接依赖。

C—>B     B—>A  称C直接依赖B，称C间接依赖A

依赖管理—依赖范围对传递依赖的影响

列是第一直接依赖，行是第二直接依赖

A—>B：第一直接依赖

B—>C：第二直接依赖

A—>C：间接依赖的依赖范围受到第一直接依赖和第二直接依赖的影响。如上图所示。

依赖管理—可选依赖

<optional>  true/false 如果为true表示为可选依赖 不会被传递，默认是false是向下传递的。例如A—>B  B—>C 如果在B中配置自身的依赖包C为可选依赖，那么C不会被传递到A中。A中就看不到C的依赖包 也不能使用C的内容。实际上可选依赖就是设置自己所依赖的某个包 是否可以向下传递。是在<dependency>标签对中进行设置

依赖管理—排除依赖

方式是 在<dependency>具体某个依赖标签对中设置<exclusions>表示所要排除的多个间接依赖 在<exclusions>中的<exclusion>标签对中设置坐标表示具体所要排除的依赖。这种方式的排除其实是在自己的pom文件中将直接依赖传递过来的某些不需要的间接依赖给排除掉(只有在直接依赖所对应的pom文件中没有设置可选依赖即可选依赖为false的情况下才有可能设置排除，因为只有间接依赖被传递过来 才有可能进行排除)

注意：排除依赖不需要所包含的间接依赖只需要添加坐标 直接进行类别排除，不需要添加版本号。

依赖管理—依赖冲突

如果直接与间接依赖中包含同一坐标不同版本的资源依赖，以直接依赖的版本为准(就近原则)

如果直接依赖中包含同一个坐标不同版本的资源依赖，以配置顺序下方的版本为准，即以最后配置的为准。

生命周期

何为生命周期？

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

Maven的三大生命周期：

• clean：清理项目的
• default：构建项目的
• site：生成项目站点的

生命周期概述：

• 生命周期Maven有三套相互独立的生命周期，注意：是三套，而且相互独立，这三套生命周期分别是：
• Clean Lifecycle：在进行真正的构建之前进行一些清理工作。
• Default Lifecycle：构建的核心部分，编译、测试、打包、部署等等。
• Site Lifecycle：生成项目报告，站点，发布站点。
• 切记：它们是相互独立的，仅仅调用clean来清理工作目录，仅仅调用site来生成站点。当然可以组合使用直接运行mvn clean install site 运行所有这三套生命周期。

生命周期clean：

• clean生命周期每套生命周期都由一组阶段(phase)组成，我们平时在命令行输入的命令总会对应一个特定的阶段。比如，运行mvn clean，这个的clean是Clean生命周期的一个阶段。有Clean的生命周期，也有clean阶段，Clean生命周期一共包含三个阶段：
• pre-celan：执行一些需要在clean之前完成的工作。
• clean：移除上一次构建生成的文件。
• post-clean：执行一些需要在clean之后立刻完成的工作。
• mvn clean中的clean就是Clean生命周期中的一个阶段，在一个生命周期中，运行某个阶段的时候，它之前的所有阶段都会被执行，也就是说，mvn clean等同于mvn pre-clean clean，如果我们运行mvn post-clean 那么pre-clean和clean都会被执行。这是Maven的一个规则，可以大大简化命令行的输入。

生命周期default

• 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的生命周期的，因此理解生命周期至关重要。 

生命周期site:

• Site生命周期pre-site 执行一些需要在生成站点文档之前完成的工作 
• site 生成项目的站点文档 
• post-site 执行一些需要在生成站点文档之后完成的工作，并且为部署做准备 
• site-deploy 将生成的站点文档部署到特定的服务器上 
• 这里经常用到的是site阶段和site-deploy阶段，用以生成和发布Maven站点，这可是Maven相当强大的功能，Manager比较喜欢，文档及统计数据自动生成，很好看。 

插件目标

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

POM中插件配置方式示例如下：

[html] view plain copy

1. <build>  
2.     <plugins>  
3.         <plugin>  
4.                 <groupId>org.apache.maven.plugins</groupId>  
5.             <artifactId>maven-source-plugin</artifactId>  
6.             <version>2.2.1</version>  
7.             <executions>  
8.                         <execution>  
9.                     <goals>  
10.                         <goal>jar-no-fork</goal>  
11.                             </goals>  
12.                             <phase>verify</phase>  
13.                 </execution>  
14.                 </executions>  
15.         </plugin>  
16.     </plugins>  
17. </build>  

继承：

继承为了消除重复，我们把很多相同的配置提取出来
例如：grouptId，version等
父工程设置为被继承
<packaging>pom</packaging>
子工程继承父工程
省略父工程中定义的坐标除访问名称中的所有设定，添加继承父工程
<parent>
<groupId>…</groupId>
<artifactId>… </artifactId>
<version>… </version>
<relativePath>../父工程项目名</relativePath>
</parent>

父工程统一管理子工程依赖版本
<dependencyManagement>
<dependencies>
//添加公共依赖包
</dependencies>
</dependencyManagement>
子工程仅仅添加依赖包，无需添加版本，版本由父工程继承而来
为了进一步便于管理，将所有的版本管理设置在一起，设置为系统属性值
<properties>
<junit.version>4.9</junit.version>
……
</properties>
引用使用${junit.version}格式进行，只能在依赖范围设置

父工程统一管理子工程依赖关系
如果所有子工程都需要依赖某些包，父工程可以通过设置依赖，将依赖关系传递到子工程中
<dependencies>
//添加公共依赖包
</dependencies>

父工程统一管理子工程依赖关系
如果所有子工程都需要依赖某些包，父工程可以通过设置依赖，将依赖关系传递到子工程中
<dependencies>
//添加公共依赖包
</dependencies>

需要注意的是：<dependencyManagement>只是管理子工程依赖包的版本  依赖关系是不会传递到子工程的，只是子工程在添加对应依赖时不用写对应依赖的版本号了 由父工程统一定义管理。 而<dependencies>是公共依赖，会传递到子工程中，子工程中不用再添加对应的公共依赖。

聚合

何为聚合？

如果我们想一次构建多个项目模块，那我们就需要对多个项目模块进行聚合，一般在父工程的pom文件中进行配置。
<modules>
<module>../子项目名称1</module>
<module>../子项目名称2</module>
<module>../子项目名称3</module>

</modules>

继承与聚合的关系

  聚合主要为了快速构建项目

  继承主要为了消除重复

仓库管理

何为Maven仓库？
    用来统一存储所有Maven共享构建的位置就是仓库
Maven仓库布局
    根据Maven坐标定义每个构建在仓库中唯一存储路径
    大致为：groupId/artifactId/version/artifactId-version.packaging
仓库的分类
    本地仓库
          ~/.m2/repository/
          每个用户只有一个本地仓库
    远程仓库
         中央仓库：Maven默认的远程仓库，不包含版权资源
              http://repo1.maven.org/maven2
         私服：是一种特殊的远程仓库，它是架设在局域网内的仓库

项目演示各种依赖关系

新建四个项目One Two WThree ZParent  其中Two中依赖One  WThree中依赖Two 都继承自ZParent

项目One中

One.java

[java] view plain copy

1. package liuxun.maven.One;  
2.   
3. public class One {  
4.     public String say(String name){  
5.         return "Hello "+name+" one";  
6.     }  
7. }  

OneTest.java

[java] view plain copy

1. package liuxun.maven.One;  
2.   
3. import org.junit.Test;  
4.   
5. import junit.framework.Assert;  
6.   
7. public class OneTest {  
8.   @Test  
9.   public void testSay(){  
10.       One one = new One();  
11.       String result = one.say("liuxun");  
12.       Assert.assertEquals("Hello liuxun one", result);  
13.   }  
14. }  

One/pom.xml

[html] view plain copy

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.     <!-- 群组ID:单位域名反写 -->  
6.     <!-- <groupId>liuxun.maven</groupId> -->  
7.     <!-- 项目ID:一个单位只有一个域名，但是一个单位可以做多个项目 也可以理解为组件 -->  
8.     <artifactId>One</artifactId>  
9.     <!-- 版本号:用于描述开发过程的阶段性标志 -->  
10.     <!-- <version>0.0.1-SNAPSHOT</version> -->  
11.     <!-- 如果打包默认是jar文件 可以设置为ejb ear war jar maven-plugin等 -->  
12.     <packaging>jar</packaging>  
13.     <!-- 继承 -->  
14.     <parent>  
15.         <groupId>liuxun.maven</groupId>  
16.         <artifactId>ZParent</artifactId>  
17.         <version>0.0.1-SNAPSHOT</version>  
18.         <!-- 如果想不进行install父工程 能进行找到的话 必须设置相对路径 -->  
19.         <relativePath>../ZParent</relativePath>  
20.     </parent>  
21.   
22.     <!-- 显示的名称 可以省略不写 -->  
23.     <name>One</name>  
24.     <!-- 也可以省略不写 -->  
25.     <url>http://maven.apache.org</url>  
26.   
27.     <properties>  
28.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>  
29.     </properties>  
30.   
31.     <!-- 依赖管理 -->  
32.     <dependencies>  
33.         <!-- 具体的依赖 -->  
34.         <!-- 可以将通用的依赖添加到父工程中 -->  
35.         <!-- <dependency>  
36.             <groupId>junit</groupId>  
37.             <artifactId>junit</artifactId>  
38.             <version>4.9</version>  
39.             <scope>test</scope>  
40.         </dependency> -->  
41.           
42.         <!-- <dependency>  
43.             <groupId>log4j</groupId>  
44.             <artifactId>log4j</artifactId>  
45.             <version>1.2.17</version>  
46.         </dependency>  
47.   
48.         <dependency>  
49.             <groupId>log4j</groupId>  
50.             <artifactId>log4j</artifactId>  
51.             <version>1.2.16</version>  
52.         </dependency> -->  
53.         <!-- 如果配置了直接依赖的多个版本 1️以最下面 最后一次的配置为准 -->  
54.         <dependency>  
55.             <groupId>log4j</groupId>  
56.             <artifactId>log4j</artifactId>  
57.         </dependency>  
58.     </dependencies>  
59.     <build>  
60.         <plugins>  
61.             <!-- 声明具体的插件 -->  
62.             <plugin>  
63.                 <groupId>org.apache.maven.plugins</groupId>  
64.                 <artifactId>maven-source-plugin</artifactId>  
65.                 <version>2.2.1</version>  
66.                 <!-- 声明插件的执行位置 -->  
67.                 <executions>  
68.                     <!-- 具体的执行位置 -->  
69.                     <execution>  
70.                         <goals>  
71.                             <goal>jar-no-fork</goal>  
72.                         </goals>  
73.                         <!-- 生命周期中的某个阶段 -->  
74.                         <phase>test</phase>  
75.                     </execution>  
76.                 </executions>  
77.             </plugin>  
78.         </plugins>  
79.     </build>  
80.   
81. </project>  

Two项目中

Two.java

[java] view plain copy

1. package liuxun.maven.Two;  
2.   
3. import liuxun.maven.One.One;  
4.   
5. public class Two {  
6.   public String say(String name){  
7.       One one = new One();  
8.       String result = one.say(name);  
9.       return result+" two";  
10.   }  
11. }  

TwoTest.java

[java] view plain copy

1. package liuxun.maven.Two;  
2.   
3. import org.junit.Test;  
4.   
5. import junit.framework.Assert;  
6.   
7. public class TwoTest {  
8.    @Test  
9.   public void testSay(){  
10.        Two two = new Two();  
11.        String res = two.say("liuxun");  
12.        Assert.assertEquals("Hello liuxun one two", res);  
13.    }  
14. }  

Two/pom.xml

[html] view plain copy

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.     <artifactId>Two</artifactId>  
6.     <packaging>jar</packaging>  
7.   
8.     <!-- 继承 -->  
9.     <parent>  
10.         <groupId>liuxun.maven</groupId>  
11.         <artifactId>ZParent</artifactId>  
12.         <version>0.0.1-SNAPSHOT</version>  
13.         <!-- 如果想不进行install父工程 能进行找到的话 必须设置相对路径 -->  
14.         <relativePath>../ZParent</relativePath>  
15.     </parent>  
16.   
17.   
18.     <properties>  
19.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>  
20.     </properties>  
21.   
22.     <dependencies>  
23.         <dependency>  
24.             <groupId>junit</groupId>   
25.             <artifactId>junit</artifactId>   
26.             <version>4.9</version>  
27.             <scope>test</scope>  
28.         </dependency>  
29.         <!-- 直接依赖会覆盖传递过来的依赖 再往下传递时以生效的依赖向下传递-->  
30.         <!-- 传递到WThree时  log4j的版本为1.2.16 -->  
31.         <!-- <dependency>  
32.             <groupId>log4j</groupId>  
33.             <artifactId>log4j</artifactId>  
34.             <version>1.2.16</version>  
35.         </dependency> -->  
36.         <dependency>   
37.             <groupId>liuxun.maven</groupId>  
38.             <artifactId>One</artifactId>  
39.             <version>0.0.1-SNAPSHOT</version>  
40.             <!-- 设置自己的依赖是否向下传递 -->  
41.             <!-- <optional>true</optional> -->  
42.         </dependency>  
43.     </dependencies>  
44. </project>  

项目WThree中

Three.java

[java] view plain copy

1. package liuxun.maven.WThree;  
2.   
3. import liuxun.maven.Two.Two;  
4.   
5. public class Three {  
6.   public String say(String name){  
7.       Two two = new Two();  
8.       String result = two.say(name);  
9.       return result+" three";  
10.   }  
11. }  

ThreeTest.java

[java] view plain copy

1. package liuxun.maven.WThree;  
2.   
3. import org.junit.Test;  
4.   
5. import junit.framework.Assert;  
6.   
7. public class ThreeTest {  
8. @Test  
9. public void testSay(){  
10.     Three three = new Three();  
11.     String result = three.say("liuxun");  
12.     Assert.assertEquals("Hello liuxun one two three", result);  
13. }  
14. }  

WThree/pom.xml

[html] view plain copy

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>liuxun.maven</groupId>  
6.     <artifactId>WThree</artifactId>  
7.     <version>0.0.1-SNAPSHOT</version>  
8.     <packaging>jar</packaging>  
9.   
10.     <name>WThree</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>4.9</version>  
22.             <scope>test</scope>  
23.         </dependency>  
24.   
25.         <dependency>  
26.             <groupId>liuxun.maven</groupId>  
27.             <artifactId>Two</artifactId>  
28.             <version>0.0.1-SNAPSHOT</version>  
29.             <scope>compile</scope>  
30.             <!-- 设置排除 -->  
31.             <!-- 排除依赖必须基于直接依赖中的间接依赖设置可选依赖为false -->  
32.             <!-- 因为只有直接依赖中设置可选依赖向下传递，才有可能进行排除 -->  
33.             <!-- 设置当前依赖中是否使用间接依赖 -->  
34.             <!-- <exclusions>  
35.                 具体排除  
36.                 <exclusion>  
37.                     <groupId>liuxun.maven</groupId>  
38.                     <artifactId>One</artifactId>  
39.                 </exclusion>  
40.             </exclusions> -->  
41.         </dependency>  
42.   
43.           
44.     </dependencies>  
45. </project>  

父项目ZParent中

ZParent/pom.xml

[html] view plain copy

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>liuxun.maven</groupId>  
6.     <artifactId>ZParent</artifactId>  
7.     <version>0.0.1-SNAPSHOT</version>  
8.     <!-- 必须设置为pom 声明此为父工程 专门做配置的 -->  
9.     <packaging>pom</packaging>  
10.   
11.     <properties>  
12.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>  
13.         <abc>1.2.17</abc>  
14.         <junit.version>4.9</junit.version>  
15.     </properties>  
16.     <dependencyManagement>  
17.         <dependencies>  
18.             <dependency>  
19.                 <groupId>log4j</groupId>  
20.                 <artifactId>log4j</artifactId>  
21.                 <version>${abc}</version>  
22.             </dependency>  
23.             <dependency>  
24.                 <groupId>junit</groupId>  
25.                 <artifactId>junit</artifactId>  
26.                 <version>${junit.version}</version>  
27.             </dependency>  
28.         </dependencies>  
29.     </dependencyManagement>  
30.   
31.     <dependencies>  
32.         <dependency>  
33.             <groupId>junit</groupId>  
34.             <artifactId>junit</artifactId>  
35.             <scope>test</scope>  
36.         </dependency>  
37.         <dependency>  
38.             <groupId>mysql</groupId>  
39.             <artifactId>mysql-connector-java</artifactId>  
40.             <version>6.0.6</version>  
41.         </dependency>  
42.     </dependencies>  
43.     <modules>  
44.         <module>../One</module>  
45.         <module>../Two</module>  
46.         <module>../WThree</module>  
47.     </modules>  
48. </project>  

右键父工程中的pom.xml Run As——>Maven build ..  添加参数 clean test 运行结果如下

Maven私服

在一个项目中有很多人开发，项目所依赖的包大致一样，可以建立一台私服专门从Maven远程仓库进行读取。所有的开发人员都可以从私服中进行下载了。

私服的安装与配置

第一步：下载nexus-2.9.0.war 然后拷贝到Tomcat下的webapps

第二步：启动Tomcat

第三步：访问http://localhost:8080/nexus-2.9.0/ 显示如下

第四步：点击右上角的login 输入username: admin  和password：admin123 登录

第五步：登录成功

第六步：点击左侧Views/Repositories中的Repositories

Nexus内置仓库说明

(1) Maven Central：该仓库代理Maven中央仓库，其策略为Release，因此只会下载和缓存中央仓库中的发布版本构件

(2) Releases：这是一种策略为Release的宿主类型仓库，用来部署组织内部的发布版本构件。

(3) Snapshots：这是一个策略为Snapshots的宿主类型仓库，用来部署组织内部的快照版本构件。

(4)3rd party：这是一个策略为Release的宿主类型仓库，用来部署无法从公共仓库获得的第三方发布版本构件。

(5)Public Repositories：该仓库组将上述所有策略为Release的仓库聚合并通过一致的地址提供服务。
第七步：创建宿主目录和代理仓库
   Hosted：本地仓库，通常我们会部署自己的构件到这一类型的仓库。 
       包括3rd party仓库，Releases仓库，Snapshots仓库
   Proxy：代理仓库，它们被用来代理远程的公共仓库，如maven中央仓库。 
   Group：仓库组，用来合并多个hosted/proxy仓库，通常我们配置maven依赖仓库组。 
第八步：创建仓库组
   点击Public Repositories仓库，在Configurations栏中选取需要合并的仓库,点击箭头加到左边保存即可

第九步：下载index索引并进行构建搜索(GAV搜索)

配置索引位置(根据自己的用户名进行查找) 在如下目录进行覆盖

/Users/liuxun/sonatype-work/nexus/indexer 

配置好以后 重启服务器 刷新页面如下

第十步：配置所有构建均从私服下载

编辑 MANEN_HOME/conf/setting.xml

10.1找到<mirrors>标签在内部配置 私服策略

[html] view plain copy

1. <mirrors>  
2.   <mirror>  
3.      <!--此处配置所有的构建均从私有仓库中下载 *代表所有，也可以写central -->  
4.      <id>nexus</id>  
5.      <mirrorOf>*</mirrorOf>  
6.      <url>http://localhost:8080/nexus-2.9.0/content/groups/public/</url>  
7.    </mirror>  
8. </mirrors>  

这个url其实是公共群组的策略

可以在nexus服务器上找到 如下图

10.2在setting.xml中找到<profiles>标签 进行配置

[html] view plain copy

1. <profiles>  
2. <profile>  
3.      <id>nexus</id>  
4.      <!--所有请求均通过镜像 -->  
5.      <repositories>  
6.        <repository>  
7.          <id>central</id>  
8.          <!-- 这个网址根本没有实际作用 因为上面已经配置所有下载的地址 但是不能删除 不然会报节点错误 -->  
9.          <url>http://central</url>  
10.          <releases><enabled>true</enabled></releases>  
11.          <snapshots><enabled>true</enabled></snapshots>  
12.        </repository>  
13.      </repositories>  
14.      <pluginRepositories>  
15.        <pluginRepository>  
16.          <id>central</id>  
17.           <!-- 这个网址根本没有实际作用 因为上面已经配置所有下载的地址 但是不能删除 不然会报节点错误 -->  
18.          <url>http://central</url>  
19.          <releases><enabled>true</enabled></releases>  
20.          <snapshots><enabled>true</enabled></snapshots>  
21.        </pluginRepository>  
22.      </pluginRepositories>  
23.    </profile>  
24. </profiles>  

10.3 配置nexus发布版本的权限在setting.xml中找到<servers> 配置如下

[html] view plain copy

1. <!-- 设置发布时的用户名和密码 -->  
2.    <server>  
3.      <id> releases </id>  
4.      <username>admin</username>  
5.      <password>admin123</password>  
6.    </server>  
7.    <server>  
8.      <id> snapshots </id>  
9.      <username>admin</username>  
10.      <password>admin123</password>  
11.    </server>  

注意：在发布项目时 配置的发布id要和上面的一致

10.4启用nexus私服策略  在setting.xml中找到<activeProfiles>标签进行配置

[html] view plain copy

1. <activeProfiles>  
2. <!-- 启用nexus私服策略 -->  
3. <activeProfile>nexus</activeProfile>  
4. </activeProfiles>  

然后保存 复制一份将与本地仓库同级目录下的setting.xml替换 保持一致

最后需要在项目的pom.xml中进行配置 部署构建到nexus，包含release和snapshot。

就拿上面的项目为例  在ZParent/pom.xml中添加如下配置（一般都是在父工程的pom文件中添加发布配置）：

[html] view plain copy

1. <distributionManagement>   
2.     <repository>   
3.         <id>releases</id>   
4.         <name>Internal Releases</name>   
5.         <url>http://localhost:8080/nexus-2.9.0/content/repositories/releases/</url>   
6.     </repository>   
7.     <snapshotRepository>   
8.         <id>snapshots</id>   
9.         <name>Internal Snapshots</name>   
10.         <url>http://localhost:8080/nexus-2.9.0/content/repositories/snapshots/</url>   
11.     </snapshotRepository>   
12.   </distributionManagement>  

其中两个url分别也是从私服的主页上拷贝的 发布的时候 就会发布到releases和snapshots中

重启服务器

然后分别运行ZParent One Two  使用命令 clean  deploy
后观察

OK 执行完毕

可以在私服上的找到 /Users/liuxun/sonatype-work/nexus/storage/snapshots/liuxun/maven/One

在实际开发中，一般都由项目经理将setting.xml发给我们，我们只需要修改里面的本地仓库路径 即可  然后分别覆盖全局与本地仓库的setting.xml