1. Maven——项目管理工具

项目自动构建、依赖管理、项目信息管理、自动生成项目站点

跨平台

Apache 开源

1.1 项目自动构建：

编译、测试、部署等工作一步到位

clean compile test site package deploy

1.2 依赖管理：

自动下载相关的jar包，统一依赖管理

1.3 项目信息管理：

项目信息、开发人员信息、开发者信息，文档自动生成

2. 为什么使用Maven：

IDE pk Eclipse

手工操作较多，编译、测试、部署等工作都是独立的，很难一步完成

每个人的IDE配置都不同，很容易出现本地代码换个地方编译就出错

Ant

没有一个约定的目录结构

必须明确让ant做什么，什么时候做，然后编译，打包

没有生命周期，必须定义目标及其实现的任务序列

没有集成依赖管理

Maven

拥有约定，知道你的代码在哪里，放到哪里去

拥有一个生命周期，例如执行mvn install 就可以自动执行编译、测试、打包等构件过程

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

拥有依赖管理，仓库管理

3. MAVEN安装和配置

下载Maven

地址：http://maven.apache.org/download.html

版本：apache-maven-3.0.5

3.1 Maven安装

1. 检查jdk安装的情况(1.6以上版本):

%JAVA_HOME%

Java -version

2. 对apache-maven-3.0.5-bin.zip进行解压缩，例如解压到如下目录(解压目录不要有中文字，不要有空格)：

D:\javaenv\apache-maven-3.0.5

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

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

5. 验证安装是否成功，打开cmd窗口，敲入mvn –v 查看

3.2 目录结构

bin目录下

mvn.bat 处理所有的maven命令

boot目录下

plexus-classloader-2.4.jar类加载器

conf目录下

setting.xml文件，maven配置文件，重点接触

lib目录下

maven依赖的jar包

3.3初始化配置

1、JAVE_HOEM

不在系统环境变量中配置JAVA_HOME，如何运行mavn

修改mvn.bat文件，加入下面语句

@REM ==== START VALIDATION ====

if not "%JAVA_HOME%" == "" goto OkJHome

前面加上

1.使用绝对路径

set JAVA_HOME=E:\\Program-Files\\Java\\jdk1.7.0_75

2.使用相对路径

set JAVA_HOME=%MAVEN_HOME%\bin\..\..\jdk1.6

JDK 和 MAVEN放在同一个目录就可以找到JDK，..\表示向上级目录查找

2、MAVEN_OPTS

在使用maven时，如果报内存溢出，

如使用 mvn site会耗费大量内存，则修改默认配置

mvn.bat文件

在@REM set MAVEN_OPTS=……后加入

set MAVEN_OPTS= -Xms128m -Xmx512m

3、setting.xml

配置用户自己的settings.xml

MAVEN_HOME/conf/settions.xml是全局的

~/.m2/settings.xml为用户自己的

初始安装文件settings.xml不存在，复制上面全局的即可

4、本地资源库

本地资源库的位置，

默认为C:\Documents and Settings\％username%\.m2\ repository，

默认配置不是很合适，很不安全，重装系统及其容易被误删除。

修改本地资源库保存路径为maven安装目录下:

修改全局setting.xml文件，

<settings>下找到localRepository标签，默认为注释掉的，在该注释段之外添加

<localRepository>D:/javaenv/apache-maven-3.0.5/m2/repository</localRepository>注意路径的斜杠

4. MAVEN约定（重点）

4.1.目录结构-基础约定

target项目输出位置，每次构建自动产生，临时文件 =bin

src/pom.xml Maven工程配置文件，相对于web工程中的web.xml

4.2早期工程如何满足基础约定？

在pom.xml文件配置映射关系，比如把原来在src目录下的文件映射在src/java目录下

5. 第一个MAVEN项目

5.1 首先建立Hello项目同时建立Maven约定的目录结构

5.2 Hello.java

在src/main/java/cn/itcast/maven目录下新建文件

package cn.itcast.maven;

public class Hello {

public String sayHello(String name){

return "Hello "+name+"!";

}

5.3 HelloTest.java

在/src/test/java/cn/itcast/maven目录下新建测试文件

package cn.itcast.maven;

import org.junit.Test;

import static junit.framework.Assert.*;

public class HelloTest {

@Test

public void testHello(){

Hello hello = new Hello();

String results = hello.sayHello("litingwei");

assertEquals("Hello litingwei!",results);

}

5.4 pom.xml

在项目Hello根目录建立

<groupId>cn.itcast.maven</groupId>

<artifactId>Hello</artifactId>

<version>0.0.1-SNAPSHOT</version>

<name>Hello</name>

<groupId>junit</groupId>

<artifactId>junit</artifactId>

</dependency>

</dependencies>

</project>

5.5 注意看目录的变化

注意查看目录E:\Program-Files\maven\m2\Repository\org\apache\maven\plugins变化

dos进入到项目的根目录

1、执行 mvn compile

自动创建target目录，自动编译类

2、清除 mvn clean

3、测试 mvn test 执行junit测试，并输出报告

4、打包 mvn package 生成jar包

5、安装 mvn install 发布到个人仓库中

注意：如首次运行下载文件失败，重新运行

5.6 maven解决问题：

1、jar依赖

2、自动构建

6. 第二个Maven项目（依赖）

maven自动下载外部jar包，maven也可以依赖之前的项目，只要把之前的项目打成了一个jar包。

6.1 新建第二个项目模块HelloFriend目录及约定的目录结构

6.2 在项目HelloFriend根目录建立pom.xml

<groupId>cn.itcast.maven</groupId>

<artifactId>HelloFriend</artifactId>

<version>0.0.1-SNAPSHOT</version>

<name>HelloFriend</name>

<groupId>junit</groupId>

<artifactId>junit</artifactId>

</dependency>

<groupId>cn.itcast.maven</groupId>

<artifactId>Hello</artifactId>

<version>0.0.1-SNAPSHOT</version>

<scope>compile</scope>

</dependency>

</dependencies>

</project>

6.3 在src/main/java/cn/itcast/maven目录下新建文件HelloFriend.java

package cn.itcast.maven;

import cn.itcast.maven.Hello;

public class HelloFriend {

public String sayHelloToFriend(String name){

Hello hello = new Hello();

String str = hello.sayHello(name)+" I am "+this.getMyName();

System.out.println(str);

return str;

}

public String getMyName(){

return "John";

}

6.4 在/src/test/java/cn/itcast/maven目录下新建测试文件HelloFriendTest.java

package cn.itcast.maven;

import static junit.framework.Assert.assertEquals;

import org.junit.Test;

import cn.itcast.maven.Hello;

public class HelloFriendTest {

@Test

public void tesHelloFriend(){

HelloFriend helloFriend = new HelloFriend();

String results = helloFriend.sayHelloToFriend("litingwei");

assertEquals("Hello litingwei! I am John",results);

}

6.5 在HelloFriend目录下执行命令mvn package

系统报错说没有找到依赖

6.6 需要重新构建Hello第一个项目并安装到数据仓库，

在命令行Hello根目录下执行mvn clean install

6.7 重新在HelloFriend目录下执行命令mvn package

成功

7. Maven相关概念介绍

7.1核心概念

7.1.1项目对象模型

（POM）Project Object Model

7.1.2座标

pom.xml文件中的标签意义

<groupId>cn.itcast.maven</groupId>

<artifactId>Hello</artifactId>

<version>0.0.1-SNAPSHOT</version>

<name>Hello</name>

Maven座标主要组成

groupId：定义当前Maven项目隶属项目，分组【maven仓库中项目路径】

artifactId：定义实际项目中的一个模块，【模块】

version：定义当前项目的当前版本，【版本】

packaging：定义该项目的打包方式，默认jar，还可以是war、jar、ear

Maven为什么使用座标？

Maven的大量构建，需要找一个用来唯一标识一个构建的统一规范

目的：拥有了统一规范，就可以把查找工作交给机器，默认查找jar包

也就是说在其他项目中依赖它时，能找到它。

7.1.3 依赖管理

<groupId>cn.itcast.maven</groupId>

<artifactId>Hello</artifactId>

<version>0.0.1-SNAPSHOT</version>

<scope>compile</scope>默认依赖的范围 scope（编译，测试，打包运行）

</dependency>

还有这些范围：

test 测试

provided 编译，测试

runtime 打包运行

如何进行依赖配置？默认依赖jar包的范围compile=都有效果

传递性依赖和可选依赖

依赖多个项目，这些项目中有相同jar包，但版本不同，那选择哪个呢？

如何解决依赖中的版本冲突？HelloFriends引用了HelloFriend ,而HelloFriend引用了Hello

传递性依赖

Hello中的pom.xml增加：

</dependency>

HelloFriends中的pom.xml中增加

</dependency>

注意引用的log4j版本不同

传递性依赖原则：

路径最近者优先

路径相同，第一声明者优先

*最终依赖log4j1.2.13

7.1.4 仓库管理

1. 何为Maven仓库？

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

Maven仓库布局

根据Maven座标定义每个构建在仓库中唯一存储路径

大致为：groupId/artifactId/version/artifactId-version.packaging

2. 仓库的分类

2.1本地仓库

~/.m2/repository/

每个用户只有一个本地仓库

2.2 远程仓库

中央仓库：Maven默认的远程仓库http://repo1.maven.org/maven2

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

镜像：用来替代中央仓库，速度一般比中央仓库快

pom.xml文件定义项目存储在仓库的路径及名称

<groupId>cn.itcast.maven</groupId>

<artifactId>HelloFriend</artifactId>

<version>0.0.1-SNAPSHOT</version>

<name>HelloFriend</name>

存储在仓库中的项目路径及名称

repository\cn\itcast\maven\HelloFriend\0.0.1-SNAPSHOT\

HelloFriend-0.0.1-SNAPSHOT.jar

7.1.5 生命周期管理

所有构建步骤称为maven的一个生命周期

1. 何为生命周期？

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

2. 所有步骤又可以分为三类步骤，及三个生命周期

Maven Lifecycle 三大生命周期“相互独立”

clean：清理项目的 pre-clean 、clean、post-clean

default：构建项目的【重点】编译，打包，测试，部署

site：生成项目站点的 site、post-site、site-deploy

它们是相互独立的，你可以仅仅调用clean来清理工作目录，仅仅调用site来生成站点。

直接运行 mvn clean install site 运行这三套生命周期。

mvn test clean能执行吗？能

2.1 Clean Lifecycle 生命周期：

pre-clean 执行一些需要在clean之前完成的工作

clean移除所有上一次构建生成的文件

post-clean 执行一些需要在clean之后立刻完成的工作

mvn clean 中的clean就是上面的clean，在一个生命周期中，运行某个阶段的时候，它之前的所有阶段都会被运行，也就是说，mvn clean 等同于 mvn pre-clean clean

如果我们运行 mvn post-clean ，那么 pre-clean，clean 都会被运行。

这是Maven很重要的一个规则，可以大大简化命令行的输入。

2.2 Default Lifecycle 生命周期：

Default生命周期，绝大部分工作都发生在这个生命周期中。

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 将最终的包复制到远程的仓库，以让其它开发人员与项目共享

2.3 Site Lifecycle 生命周期：

pre-site 执行一些需要在生成站点文档之前完成的工作

site 生成项目的站点文档

post-site 执行一些需要在生成站点文档之后完成的工作，并且为部署做准备

site-deploy 将生成的站点文档部署到特定的服务器上

　　这里经常用到的是site阶段和site-deploy阶段，用以生成和发布Maven站点，这可是Maven相当强大的功能，Manager比较喜欢，文档及统计数据自动生成，很好看。

执行mvn clean site

中文乱码问题：

将pom.xml文件另存，

保存时选择utf-8格式即可

Pom.xml 添加备注信息，在站点文档呈现，站点文档一般是网页文件

<name>北京传智播客教育科技有限公司</name>

<url>http://www.itcast.cn/</url>

</organization>

<id>weichen</id>

<email>[email protected]</email>

<roles>

<role>研发工程师</role>

</roles>

</developer>

</developers>

<email>[email protected]</email>

<roles><role>研发工程师</role></roles>

</contributor>

</contributors>

7.1.6 插件管理

Maven的核心仅仅定义了抽象的生命周期，具体的任务都是交由插件完成的

每个插件都能实现多个功能，每个功能就是一个插件目标

Maven的生命周期与插件目标相互绑定，以完成某个具体的构建任务

例如compile就是插件maven-compiler-plugin的一个插件目标

mvn compile 隐含没有显式的指定

mvn 插件名：目标名

mvn compiler:compile

调用maven-compiler-plugin插件的compile目标

7.1.7 聚合继承

新的项目是在以前的项目基础上进行开发，如果能直接聚合或者基础拿来用，能省事。

何为继承？

继承为了消除重复，我们把很多相同的配置提取出来

例如：grouptId，version等

何为聚合？

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

聚合与继承的关系

继承主要为了消除重复

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

继承：

1、新建工程Parent，目的消除子工程的配置文件中重复的内容，所以无需代码类，删除代码。

2、子工程统一junit版本4.9

3、加入Hello、HelloFriend依赖dependency

4、最后在各个子工程中引入父工程即可<parent>，放在<denpendencies>上面，同时在所有子项目中Hello、HelloFriend、MakeFridens中删除重复的<groupId>、<version>、<dependency>

<groupId>cn.itcast.maven</groupId>

<artifactId>Parent</artifactId>

<version>0.0.1-SNAPSHOT</version>

<relativePath>../Parent/pom.xml</relativePath>

</parent>

<artifactId>Hello</artifactId>

<groupId>cn.itcast.maven</groupId>

<artifactId>Parent</artifactId>

<version>0.0.1-SNAPSHOT</version>

<relativePath>../Parent/pom.xml</relativePath>

</parent>

<groupId>junit</groupId>

<artifactId>junit</artifactId>

</dependency>

</dependencies>

此时Run As Hello工程的pom.xml“maven install” 报错，

Project build error: Invalid packaging for parent POM cn.itcast.maven.HelloParent:0.0.1-SNAPSHOT, must be "pom" but is "jar"

修改HelloParent的pom.xml

这是一个父工程，实际是一个聚合工程，它没有实际代码，它的作用是抽象出子工程公用的内容，

Run As 一下 Hello工程的pom.xml

报错：parent.relativePath' points at wrong local POM

注意：在Run As子工程前，一定先要对parent工程进行安装mvn install。

6、修改HelloFriend、MakeFriends项目，Run As “maven install”都成功。

但发现Hello工程依赖不对，怎么多了HelloFriend的依赖？

将依赖进行管理：

1、在parent项目中将依赖进行管理<dependencyManagement>，此时其他项目依赖全部消失

2、再在各个项目中加入依赖，但不需加入版本和范围，<version><scope>

这样防止开发团队中大家使用不同的版本，造成整合项目时，发生冲突，导致异常。

此时各工程依赖关系又正确了

<groupId>junit</groupId>

<artifactId>junit</artifactId>

</dependency>

</dependencies>

将依赖进行管理：

1、在parent项目中将依赖进行管理<dependencyManagement>，此时其他项目依赖全部消失

2、再在各个项目中加入依赖，但不需加入版本和范围，<version><scope>

这样防止开发团队中大家使用不同的版本，造成整合项目时，发生冲突，导致异常。

此时各工程依赖关系又正确了

聚合：

Parent pom.xml文件中加入

<module>../Hello</module>

<module>../HelloFriend</module>

<module>../MakeFriends</module>

</modules>

这样就无需一个一个的安装 mvn install

只需 HelloParent pom.xml 上 Run As，就会连同全部一起进行安装

8.MyEclipse 与 Maven整合

8.1 配置MyEclipse

myeclipse自带maven插件，不需要自动更新

windows-->Preferences-->Maven4MyEclipse

Enable Maven4MyEclipse feature

Do not automaticallu update dependencies

使用自定义的Maven插件

Maven4MyEclipse

Installations

External E://...

设置本地仓库，选择对应的setting.xml就会从这个xml文件中读取本地仓库的路径

Maven4MyEclipse

User Settings

8.2 创建满足maven规约的java项目

1.新建一个maven的普通项目，右键新建，选other

输入maven

Maven Project

2.- archetype ：骨架、框架、模型

maven-archetype-quickstart : 快速构建项目的骨架，简单的满足maven规范的java项目

中央仓库下载

8.3 创建满足maven规约的web项目

8.3.1 第一种创建方法

1. 直接建立一webProject

new -->webProject

2. 要选择maven支持

和myeclipse结构的web项目，

在pom.xml文件会有web和maven目录结构的映射

Add Maven support

MyEclipse Maven JEE Project

8.3.2 第二种创建的方法

1. 依然是新建maven project

New --> Other --> Maven Project

2.骨架：maven-archetype-webapp

运行

普通

1、手工创建目录src/main/webapp/WEB-INF/classes，并加入web.xml文件

2、新建target/classes目录，删除WebRoot目录

web.xml

<!DOCTYPE web-app PUBLIC

"-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"

"http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>

<display-name>Archetype Created Web Application</display-name>

</web-app>

3、选中工程，属性，编辑Java Build Path/Source选项卡，编辑Output folder和Default output folder

选择target/classes目录

4、删除WebRoot目录

4、修改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/maven-v4_0_0.xsd">

<artifactId>HelloWeb</artifactId>

7、仓库中的war出现，配置无错，顺利打包、发布完成

拷贝war包到tomcat/webapps下，启动tomcat，

访问：http://localhost:8090/HelloWeb-0.0.1-SNAPSHOT/

8、成功

技术要点：设置虚拟路径，并自动启动tomcat

在HelloWeb/pom.xml中加入build标签。使用org.codehaus.cargo插件，设置tomcat路径，端口

首先在C:\Documents and Settings\settings.xml

中的<pluginGroups>中加入插件：

<pluginGroup>org.codehaus.cargo</pluginGroup>

技术要点：设置虚拟路径，并自动启动tomcat

仓库中的war出现，配置无错，顺利打包、发布完成

<build>

<finalName>AaaWeb</finalName>

<groupId>org.codehaus.cargo</groupId>

<artifactId>cargo-maven2-plugin</artifactId>

<containerId>tomcat7x</containerId>

<home>E:/Program-Files/apache-tomcat-7-01</home>

</container>

<type>existing</type>

<home>E:/Program-Files/apache-tomcat-7-01</home>

</configuration>

<id>cargo-run</id>

<phase>install</phase>

<goals>

</goals>

</execution>

</executions>

</plugin>

</plugins>

</build>

MyEclipse中没有停止tomcat的命令：

可以在tomcat目录手工停止，否则下次install时，会报错：java.net.BindException: Address already in use: JVM_Bind

D:\tomcat7\bin\

shutdown.bat

8.4 注意事项

利用之前项目里面的jar包，把之前项目的里面的jar包依赖的范围 scope 设置为compile

<scope>compile</scope>

9、搭建Maven的私有服务器

maven中心仓库：面向全球的

存放jar包和war等

里面集成了大部分优秀的开源框架的jar包和war包

- apache旗下的框架基本都发布在maven仓库中

- 保存框架大部分不同版本

9.1 nexus介绍 .

是开源的框架，属于sonatype 机构的开源框架，用该框架架设maven 私有服务器

网线：外网：ip地址（动态的）

l 地址: 目前来说: http://repo1.maven.org/maven2/是真正的Maven中央仓库的地址，该地址内置在Maven的源码中其他的都是镜像

l 索引: 中央仓库带有索引文件以方便用户对其进行搜索，完整的索引文件大小约为60M，索引每周更新一次

l 黑名单: 如果某个IP地址恶意的下载中央仓库内容，例如全公司100台机器使用同一个IP反复下载，这个IP（甚至是IP段）会进入黑名单，因此稍有规模的使用Maven时，应该用Nexus架设私服

为什么要搭建nexus私服，原因很简单，有些公司都不提供外网给项目组人员，因此就不能使用maven访问远程的仓库地址，所以很有必要在局域网里找一台有外网权限的机器，搭建nexus私服，然后开发人员连到这台私服上，这样的话就可以通过这台搭建了nexus私服的电脑访问maven的远程仓库

用户私服 Maven Central

Apatche

用户其他远程仓库

9.2 nexus私服环境搭建

第一步：下载nexus-webapp-1.9.2.4.war包，然后拷贝到tomcat下的webapps目录中

第二步：启动tomcat 默认登录账户密码为: admin admin123

第三步：访问http://localhost:8080/项目名称/

9.3 nexus 仓库的分类

Nexus仓库的默认的地址, nexus-2.1.2\WEB-INF\plexus.properties 中定义的

在Views/Repositories-->Repositories里进行配置, nexus里可以配置3种类型的仓库，分别是proxy、hosted、group

proxy：是远程仓库的代理。比如说在nexus中配置了一个central repository的proxy，当用户向这个proxy请求一个artifact，这个proxy就会先在本地查找，如果找不到的话，就会从远程仓库下载，然后返回给用户，相当于起到一个中转的作用

Hosted：是宿主仓库，用户可以把自己的一些构件，deploy到hosted中，也可以手工上传构件到hosted里。比如说oracle的驱动程序，ojdbc6.jar，在central repository是获取不到的，就需要手工上传到hosted里

Group：是仓库组，在maven里没有这个概念，是nexus特有的。目的是将上述多个仓库聚合，对用户暴露统一的地址，这样用户就不需要在pom中配置多个地址，只要统一配置group的地址就可以了右边那个Repository Path可以点击进去，看到仓库中artifact列表。不过要注意浏览器缓存。我今天就发现，明明构件已经更新了，在浏览器里却看不到，还以为是BUG，其实是被浏览器缓存了

virtual：也是中央仓库镜像,支持M1老版本

- hosted ：宿主仓库，该仓库属于该公司私有的

1. 3rd part ：第三方的jar包，但是该jar包没有在中心仓库保存，驱动.jar

2. snapshot ：测试版本、镜像版本 easyNet.war

3. release : 发行版本

- proxy : 代理仓库 :代理中心仓库的jar包

- public ：仓库组：虚拟的概念

可以包含其他的仓库

9.4 每个仓库的作用

3rd party: 无法从公共仓库获得的第三方发布版本的构件仓库
Apache Snapshots: 用了代理ApacheMaven仓库快照版本的构件仓库
Central: 用来代理maven中央仓库中发布版本构件的仓库
Central M1 shadow: 用于提供中央仓库中M1格式的发布版本的构件镜像仓库
Codehaus Snapshots: 用来代理CodehausMaven 仓库的快照版本构件的仓库
Releases: 用来部署管理内部的发布版本构件的宿主类型仓库
Snapshots:用来部署管理内部的快照版本构件的宿主类型仓库

9.5 通过私服上传下载jar包

pom.xml文件

定义项目下载jar包的地址和项目上传到私服的地址

1. 下载项目所依赖的jar包

<enabled>true</enabled> //true表示测试版本可以要

</snapshots>

<id>public</id>

<name>public</name>

<url>http://127.0.0.1:8080/nexus-2.6.2/content/groups/public/</url>

</repository>

</repositories>

2. 下载maven执行插件的jar包

<updatePolicy>never</updatePolicy>

</releases>

</snapshots>

<id>public</id>

<name>public</name>

<url>http://127.0.0.1:8080/nexus-2.6.2/content/groups/public/</url>

</pluginRepository>

</pluginRepositories>

2. 分销管理，把jar包发布到私服中，上传到私服deploy

<id>snapshots</id>

<url>http://127.0.0.1:8080/nexus-2.6.2/content/repositories/snapshots/</url>

</snapshotRepository>

<id>releases</id>

<url>http://127.0.0.1:8080/nexus-2.6.2/content/repositories/releases/</url>

</repository>

</distributionManagement>

setting.xml文件

中配置使用私服那个服务器和登录私服的账户密码

<id>releases</id>

<username>admin</username>

<password>admin123</password>

</server>

<id>snapshots</id>

<username>admin</username>

<password>admin123</password>

</server>

-->

10. 总结

重点：

1. maven 特点

- jar依赖

- 自动构建项目

2. maven目录结构

3. maven专业术语

- 座标

- pom.xml

4. 在myeclispe中创建maven java项目 maven web项目

5. 私服

-nexus

- 从私服中下载jar包、上传jar包

<!-- 假如没有私服，则本地仓库找不到，则访问中心仓库

假如有私服：访问顺序

首先访问本地仓库

本地仓库没有，则访问私服仓库

私服仓库也没有，则访问中心仓库

-->