一、简介：
什么是maven
是apache下的一个开源项目，是纯java开发，并且只是用来管理java项目的.
依赖管理、jar包、工程之间的依赖。
项目构建。实现项目的一步构建。
工程聚合、继承、依赖。
1.自动化构建和项目管理工具
Ant→Make→Maven→Gradle
2.Maven概述
①读音：妹文、麦文
②Maven作用一：自动化构建
③Maven作用二：依赖管理[多了重复、少了报错]
④Maven作用三：项目信息管理
3.自动化构建
①构建[build]：将程序员编写的代码从源文件到服务器部署的整个过程。
清理→编译→测试→报告→打包→部署→运行……
②自动化构建：将构建过程中的各个操作步骤交给构建工具自动完成。
二、Maven的优点
节省空间
依赖管理，对jar包的统一管理，可以节省空间
一键构建
可以跨平台
应用于大型项目，可以提高开发效率
用户管理 订单管理 支付管理 ...
maven的分模块开发
互联网项目 按业务分
传统项目 按层分
三、Maven的配置
1.依赖管理
①依赖复杂性
[1]路径最短者优先
MakeFriends --------> HelloFriends----------->Hello
| |
log4j.2.1.14 log4j.2.1.17
[2]路径相同时，先声明者优先
MakeFriends --------> HelloFriends ------>log4j.2.1.14
|
-------------->OurFriends ------->log4j.2.1.12
②版本冲突的解决方案
[1]调节原则：
[1]路径最短者优先原则
[2]路径相同时，先声明者优先原则
[2]排除原则
<dependency> <groupId>javax.servlet</groupId> <artifactId>servlet-api</artifactId> <version>2.5</version> <exclusions> <exclusion> <groupId></groupId> <artifactId></artifactId> <!--这里不需要指定版本号 --> </exclusion> </exclusions> <scope>provided</scope> </dependency>
[3]版本锁定原则
<dependencyManagement> <dependencies> <dependency> <!--jar包坐标 --> <groupId></groupId> <artifactId></artifactId> <version></version> </dependency> </dependencies> </dependencyManagement>
版本锁定之后，后面再使用到这个的 依赖的时候，就不要写版本号了！
而且如果有多个相同的需要锁定的jar包的版本号一致的话，我们可以单独提取到properties标签中，
在properties标签中，子标签自己定义，标签的值就是版本号，下面只需要在依赖的地方用${}引用就可以了！
③依赖方式
[1]在pom.xml配置文件中使用dependencies/dependency元素配置依赖信息
[2]通过目标jar包的坐标找到被依赖的文件
④依赖范围
默认compile：当前所依赖的jar包是当前Maven工程中所有类都需要使用的，最终也需要参与打包。
test：只是当前工程中的测试类需要，最终不参与打包。
provided：当工程在服务器上运行起来后，可以由服务器提供，所以也只是在开发或测试时使用，部署到服务器上时就不需要。
⑤一个自己开发的Maven工程，需要执行“安装”命令，才能够被放入到仓库中。
2.项目信息管理
将项目信息生成一个静态站点，用于展示。
3.Maven程序本身安装
①要求当前系统环境下配置了JAVA_HOME
在CMD命令行中输入：echo %JAVA_HOME% 如果能出来JDK的安装目录，说明我们配置了JAVA环境
②将Maven的ZIP压缩包解压到一个非中文无空格目录下【maven.apache.org官方网站下载jar包】
apache-maven-3.3.9-bin.zip
③.配置环境变量，用mvn -v查看是否正确配置了maven【要配置jdk， maven3.3.9这个版本所需的jdk版本必须要1.7以上】
path:
D:\DevSoft\apache-maven-3.3.9\bin
mvn -v查看maven版本
④.先了解一下maven的目录结构：
projectname
-src
-main
-java
-package
-resources【配置文件或者说资源文件】
-test
-java
-package
-resources
pom.xml
按照上面的maven的目录结构创建一个maven项目，参照word文档！
⑤当针对某个Maven工程执行诸如“编译”、“测试”、“打包”、“部署”等命令时，需要进入到pom.xml所在的目录下执行。
mvn compile
4.关于Maven联网
①联网下载内容：当前命令需要的Maven插件
②Maven主程序仅负责宏观调度，并不能执行具体的命令。而具体的命令是通过Maven插件完成的。
③Maven主程序会首先到本地仓库目录下查找需要的插件，若没有则联网从“中央仓库”下载。若当前环境不能联网则无法执行构建命令。
④可以修改Maven默认的本地仓库路径，使其指向一个提前下载好的目录
配置文件路径
Maven解压目录/conf/settings.xml
修改
<localRepository>D:\Maven\Repository</localRepository>
mvn -v 查看maven的版本号
clean
compile 编译
test 测试
package 打包(并将jar包放入到target的目录中)
install 安装jar包到本地仓库中
deploy
site 生成一个站点
clean 删除target目录
自动创建目录的两种方式:
1.mvn archetype:generate 按照提示进行选择
2.mvn archetype:generate -DgroupId=组织名，公司网址的反写+项目名
-DartifactId=项目名-模块名
-Dversion=版本号
-Dpackage=代码所存在的包名
5.Project Object Model项目对象模型
①Maven将一个Java工程的相关信息封装后得到的对象。简称POM。
②POM配置集中体现在pom.xml文件中，作为一个Maven工程，pom.xml是最核心的配置文件，作用相当于动态Web工程的web.xml。
6.约定的目录结构
①Maven之所以能够实现自动化构建，其中一个很重要的原因是要求将特定的文件保存在指定的目录中。
Hello [工程根目录]
--src [存放源代码文件]
-----main [存放主程序目录]
---------java [存放.java源文件]
---------resources [资源文件或配置文件]
-----test [存放测试程序目录]
---------java [存放.java源文件]
---------resources [资源文件或配置文件]
--pom.xml 核心配置文件]
②思想：Convention Over Configuration 约定优于配置
四、maven的几个概念：
1.坐标
①数学坐标：平面中使用横纵两个坐标系可以唯一的定位平面中的任何一个点。
向量x：横坐标
向量y：纵坐标
②使用三个向量在Maven仓库中唯一的定位一个Maven工程。
向量groupid：公司或组织的名称+项目名称
向量artifactId：模块名称
向量version：模块版本
<groupId>com.neuedu.maven</groupId>
<artifactId>Hello</artifactId>
<version>0.0.1-SNAPSHOT</version>
③如何根据坐标zhao到仓库中查找对应的Maven工程
坐标
<groupId>org.springframework</groupId> <artifactId>spring-core</artifactId> <version>4.0.0.RELEASE</version>
仓库中的路径
org/springframework/spring-core/4.0.0.RELEASE/spring-core-4.0.0.RELEASE.jar
④如何查找指定jar包的坐标：
1.从maven仓库下载
http://search.maven.org/
http://mvnrepository.com/【建议使用这个】
五、依赖
1、依赖方式
【1】在pom.xml配置文件中使用dependencies/dependency元素配置依赖信息
【2】通过目标jar包的坐标做到被依赖的文件
2、依赖范围：
构件的依赖范围。Maven在项目的构建过程中，会编译三套classpath，当我们需要引用某个类的时候，只需要将包含某个类的jar包加入到classpath中即可，maven在这里为我们提供了三种classpath，分别对应：编译期，运行期，测试期。而依赖范围，就是为构件指定它可以作用于哪套classpath。
编译期 测试期 运行期 说明
compile √ √ √ 默认范围
provided √ √ 如jsp-api.jarservlet-api.jar,运行期由web容器提供
runtime √ √ 编译期无需直接引用,只在测试和运行时有效，例如jdbc驱动类。
test √ 只在测试的时候有效，如junit.jar
system √ √ 与本地系统相关联，可移植性差。必须通过<systemPath></systemPath>元素，显示指定依赖文件的路径，如本机的 JAVA_HOME路径，移植到其它机器就可能导致错误！
import 表示是继承父POM.XML中的依赖范围设置，只能使用在<dependencyManagement> 这个标签中。
- 注意：依赖范围对依赖的传递是有影响的！
- 一个自己开发的maven工程，需要执行maven安装操作，才会将这个jar包放入到仓库的指定位置！
六、仓库
1、作用
保存Maven工程
2、分类
[1]本地仓库：为当前电脑上所有Maven工程服务【本地仓库的配置只需要修改settings.xml文件就可以】
[2]远程仓库[私服]：为当前局域网中的所有Maven工程服务器,公司维护
[3]中央仓库：为全世界所有的Maven工程服务
[4]中央仓库的镜像：内容和中央仓库一样，架设在全世界各个大洲，让Maven用户可以就近获取需要
的Maven资源，同时也能够减轻中央仓库的压力。
这几个仓库之间的关系
3、Maven工程分类
[1]Maven用户自己开发的工程
[2]Maven的插件
[3]使用Maven构建得到的第三方jar包
4、Maven的工程类型
1）war包工程（工程中必须要有一个war包）
2）Jar包工程（jar包工程可以被其它工程所引用）
3）Pom工程。（父工程或者聚合工程）
注意：通常父类都是自己创建的项目，依赖是第三方的。父工程应该是一个pom工程。在父工程中定义依赖的jar包的版本信息和Maven插件的版本。
在<dependencyManagement>标签中并不定义实际依赖，只是定义项目版本！
七、生命周期
mvn clean
mvn compile
mvn test
mvn package
mvn install
①Maven为了能够将构建过程自动化处理，定义了三个主要的生命周期。其中定义了相关的构建过程。
②三个生命周期
[1]清理周期
[2]站点周期
[3]默认周期
③最重要的特点：每个生命周期中执行任何一个操作，都是从这个生命周期最初的位置开始执行，直到到达命令指定的位。
八、继承
①目的一：将pom.xml文件中重复的信息统一提取到父工程中，简化pom.xml中的配置
②目的二：将各个子工程都需要依赖的jar包提取到父工程中统一管理
③注意：父工程打包的方式——pom，表示这是一个管理其他工程的工程
< packaging>pom</ packaging>
④指定当前工程的父工程
<parent > <groupId>com.atguigu.maven</groupId> <artifactId>Parent</artifactId> <version>0.0.1-SNAPSHOT</version> <!-- 如何通过当前工程的pom.xml文件找到父工程的pom.xml文件 --> <!-- 配置父工程的pom.xml文件相对于当前工程pom.xml文件的相对路径 --> <relativePath> ../Parent/pom.xml</relativePath > </parent >
在tomcat运行一遍，用插件运行一遍
解决-Dmaven.multiModuleProjectDirectory system property is not set. Check $M2_HOME environment variable and mvn script match.
1.添加M2_HOME的环境变量
2.Preference->Java->Installed JREs->Edit 选择一个jdk,
添加 -Dmaven.multiModuleProjectDirectory=$M2_HOME
九、 处理编译版本
在pom.xml中添加如下代码
<build> <!-- 配置了很多插件JDK1.7 --> <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-compiler-plugin</artifactId> <version>3.5.1</version> <configuration> <source>1.7</source> <target>1.7</target> <encoding>UTF-8</encoding> </configuration> </plugin> <!-- tomcat7的插件--> <plugin> <groupId>org.apache.tomcat.maven</groupId> <artifactId>tomcat7-maven-plugin</artifactId> <version>2.2</version> <configuration> <path>/ssm</path> <port>8888</port> </configuration> </plugin> </plugins> </build>
<!--- 可以使用下面的这个插件启动本地的tomcat服务器 --> <plugin> <groupId>org.codehaus.cargo</groupId> <artifactId>cargo-maven2-plugin</artifactId> <version>1.2.3</version> <configuration> <container> <containerId>tomcat7x</containerId> <home>D:\DevSoft\apache-tomcat-7.0.67</home> </container> <configuration> <type>existing</type> <home>D:\DevSoft\apache-tomcat-7.0.67</home> <!--- 如果Tomcat端口为默认值8080则不必设置该属性 --> <properties> <cargo.servlet.port>8080</cargo.servlet.port> </properties> </configuration> </configuration> <executions> <execution> <id>cargo-run</id> <phase>install</phase> <goals> <goal>run</goal> </goals> </execution> </executions> </plugin>
添加jar包
在pom中添加如下代码：
<dependencies> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.9</version> <scope>test</scope> </dependency> <dependency> <groupId>javax.servlet</groupId> <artifactId>servlet-api</artifactId> <version>2.5</version> <scope>provided</scope> </dependency> <dependency> <groupId>javax.servlet</groupId> <artifactId>jsp-api</artifactId> <version>2.0</version> <scope>provided</scope> </dependency> </dependencies>
十、聚合
①目的：通过安装一个工程，将多个模块工程统一安装到仓库中
②配置
<modules> <module >../Hello </module> <module >../HelloFriend </module> <module >../MakeFriends </module> <module >../MavenWeb </module> </modules>
十一、实际作用
①将一个项目拆分成多个子项目分别开发,并进行分布式部署
②下载第三方jar包。
十二、Maven酷站
①http://mavenrepository.com/
搜索JAR包，下载JAR包，查询JAR包的坐标
十三、添加依赖
打开maven仓库的视图、重建索引
十四、完整的项目构建过程
清理、 编译、 测试、 打包 、集成测试、 验证、 部署等步骤！
十五、pom.xml文件中的标签含义
| <modelVersion>4.0.0</modelVersion> ：Maven仓库中模型对象的版本号【实际是约束版本号】 |
| <groupId>com.neuedu.ssm</groupId> |
| <artifactId>ssm-maven</artifactId> #坐标【GAV】 |
| <version>0.0.1-SNAPSHOT</version> |
| <packaging>war</packaging> #打包方式：三种[Jar包，POM包，War包] |
| <dependencies> <dependency> #Jar包的依赖，每个jar包所需要的GAV坐标 |
| <build> #build标签里面放的是插件 |
| <plugins> #插件【复数】 <plugin> 该标签下是每个插件的坐标，每个插件还有各自的配置，配置写在Configuration标签中 |
注意：创建一个父工程【pom工程】,父工程不干事，只是管理子模块工程！
父工程里面可以放入一些jar包，而子工程继承父工程依赖的jar包【项目级别的继承】！
十六、私服(Nexus)
1、maven的几个概念：
1）坐标
2）构件
3）仓库
a）本地仓库
b）远程仓库 注意：如果在本地仓库中找不到我们所需要的构件，那么它会去全球的中央仓库去查找，找到之后就会下载到本地仓库中，供我们使用，如果远程仓库也找不到就会报错！
注意：中央仓库的位置可以在：maven安装目录下面的lib目录中的maven-model-builder-3.3.9.jar中找到，打开这个jar包\org\apache\maven\model\pom-4.0.0.xml文件中可以看到repositories标签中的url中指定的值https://repo.maven.apache.org/maven2就是全球的中央仓库地址，中央仓库包含了绝大多数开源的java项目！
4)镜像仓库
所谓镜像仓库，就是指A和B提供了一样的功能，maven的中央仓库都是位于国外的，有时因为一些原因导致我们可能无法访问外网，好在国内有它的镜像仓库,这样就可以直接访问国内的镜像仓库，速度也更快更稳定
注意:如何修改镜像仓库(也就是远程)的位置呢？
在maven的安装目录下的conf目录中有settings.xml这个文件，找到mirrors标签，然后将mirrors标签中的mirror实例拷贝出来，改成国内的镜像仓库，如下所示：
<mirror>
<id>nexus-aliyun</id> #镜像仓库的id
<mirrorOf>*</mirrorOf> #默认全球中央仓库的名字就是central
<name>Nexus aliyun</name> #镜像仓库的名字
<url>http://maven.aliyun.com/nexus/content/groups/public</url>
</mirror>
更改仓库位置：
本地仓库：默认是存放在c盘用户目录下的如：C:\Users\LIUHUI\.m2\repository
但是我们一般不会将本地仓库放在C盘中，如果重装系统，那么仓库中的数据就会丢失了！所以我们可以
修改settings.xml文件修改里面的本地仓库<localRepository>D:/DevSoft/apache-maven-3.3.9/m2/repository</localRepository>
上面的<localRepository>/path</localRepository> 这里的/path要注意/哦，不是\哦！
在eclipse 上安装maven;
注意：别忘了在配置jdk的地方加一个参数设置-Dmaven.multiModuleProjectDirectory=$M2_HOME
2、maven中定义了3套相互独立的生命周期
分别包括：
clean 清理项目
default 构建项目
site 生成项目站点
以上三套生命周期是相互独立的，每个生命周期又包含一些阶段，各个生命周期中 的阶段却是有顺序的，且后面的阶段依赖于前面的阶段，
执行某个阶段的时候其前面的阶段会依次顺序执行，但是不会触发另外两套生命周期的任何阶段！
举例：
maven生命周期：
clean 、compile、test、package、install
也就是说运行这里面的任何一个命令，那么此命令之前的命令都会依次执行！
clean清理项目，clean又分为3个阶段
pre-clean 执行清理前的工作
clean 清理上一次构建生成的所有文件
post-clean 执行清理后的文件
default:是生命周期中最核心的，主要用于构建项目，default又分为如下阶段：
compile、test、package、install
site:生成项目站点,主要包含以下几个阶段：
pre-site 在生成项目站点前要完成的工作
site 生成项目的站点文档
post-site 在生成项目站点要完成的工作
site-deploy 发布生成的站点到服务器上
maven的source插件可以将当前项目的源码打成jar包，然后将source插件绑定到default周期的package阶段，也就是说在package这个阶段运行source这个插件，如下配置pom.xml文件,
它有5个运行目标，我们这里设置运行目标为：jar-no-fork,如下配置！
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-source-plugin</artifactId>
<version>2.4</version>
<executions>
<execution>
<phase>package</phase>
<goals>
<goal>jar-no-fork</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
3、 pom.xml常用元素介绍
pom是maven项目的核心管理文件，用于项目项目描述，组织管理，依赖管理和构建信息的管理，pom中标注了许多的标签，这里我们介绍几个：
<project>标签是pom.xml文件的根元素，它包含pom.xml的一些约束信息。
<modelVersion>是一个固定的版本，也是一个必须的元素，它的值为4.0.0,它指定了当前pom的版本
紧接着就是坐标信息：由<groupId> 、<artifactId>、<version>、<packaging>这几部分组成,其中
<groupId> 是主项目的标识，用于标识我们的maven项目是属于哪个实际项目的，格式：<groupId>反写的公司网址+项目名</groupId>
这里有一点要注意；maven的项目和我们实际的项目不是一个概念，maven的项目体现的是一个个模块化的概念，因此一个实际项目实际上会被
划分为很多的模块！
<artifactId>是一个模块的标识,是实际项目中的一个模块，格式：<artifactId>项目名+模块名</artifactId>
<version>标识当前项目的版本号，版本号一般都是由3个数字来组成的，第一个0表示大版本号，第二个0表示分支版本号，第3个0表示小版本号，eg:0.0.1snapshot除了这种
snapshot快照版本，一般还有alpha版本，也就是内测的测试版本，一般不向外部发布,会有很多Bug.除非你也是测试人员,否则不建议使用。再就是Beta版本，就是公测版，这个阶段的版本会一直加入新的功能。
还有就是release版本，release版本是一个稳定版本，
最后一个是GA版本，GA版本是正式的发布版本！
<packaging>:表示maven打包的方式，不指定的话maven默认的是jar包；当然还可以打成war包，zip包，pom包等等！
<name> :name标签一般是项目的描述名，一般是产生项目文档的时候才会使用
<url> ：url是项目的地址
<description>：description是项目的描述
<developers> :developers表示开发人员的列表；当项目发布的时候，可以将我们开发人员的信息填写上去！
<licenses>:licenses表示许可证的信息，比如我们经常用到的一些开源框架，它都会有些许可证信息
<organization>: organization表示的是组织的信息
<dependencies>:依赖列表，它底下可以包含多个依赖项<dependency>，依赖项中如何确定一个依赖所在的位置呢，我们需要指定它的坐标，也就是
<groupId>、<artifactId>、<version>当然还可以指定<type>、<scope>，这个scope指的是一个依赖的范围，我们之前的junit写的依赖的
范围是test，这个test表示junit构建，也就是这个jar在我们的测试依赖范围内有用!比如在我们的主代码中引用这个junit类的话就会报错！
在依赖项中还有<optional>标签，这个标签只有两个值，true或者false,它的意思是用来设置依赖是否可选，默认是false,子项目
如果默认是false的话，子项目默认是继承的，如果是true，那么子项目必须显示的引入改依赖！
<dependency>依赖项中还有一个<exclusions>列表，它表示排除依赖的传递列表，这个标签下面可以排除多个依赖<exclusion>，这有什么用呢？
比如Ajar包依赖B，而Bjar包又依赖于Cjar包，那么C对于A来说就是传递依赖，如果A不想依赖于C就可以使用这个<exclusion>标签！
<dependencyManagement> <dependencies> </dependencies> </dependencyManagement>
注意： 上面这个<dependencyManagement> 标签是依赖管理，在里面我们也可以声明依赖的列表，然后里面包含多个依赖，但是呢，它并不会引用到实际的依赖中！
这个<dependencyManagement> 标签主要定义在父模块中，供子模块继承用的，比如我们的多个maven项目中都用到了junit,那么我们就可以抽象出来
一个父类的模块，然后再父类模块中对junit进行定义，其它子模块直接继承它（父模块）就可以了
<build>：这个build通常为我们构建的行为提供相应的支持！这个build标签里面经常用到的标签是plugins插件标签如下所示：
<build>
<!--插件列表--> 在这个plugins插件列表中可以包含多个<plugin>标签，也就是可以有多个plugin插件，我们之前使用到了打包的source插件，在plugin中我们依旧要指出插件的坐标
<groupId> <artifactId> <version>！
<plugins>
<plugin>
</plugin>
</plugins>
</build>
<parent> ：这个标签通常在子模块中用于对父模块的POM的一个继承！
<modules>: 这个标签是用来聚合运行多个的maven项目，如果有很多的maven模块需要编译的话，我们之前的办法是一个一个的编译，使用了这个标签，我们就可以在这里
定义多个的<module>模块，然后可以放在一起编译
例子1：此pom工程依赖于hadoop-demo02，而hadoop-demo02又依赖于hadoop-demo01，但是在这个工程中如果不想依赖于hadoop-demo01那么可以如下所示使用<exclusions>标签将其排除，但是这里要注意：排除的时候在<exclusion>标签中只有<groupId>、<artifactId>这两个标签，并没有<version>标签！
<dependency>
<groupId>com.bawie.hadoop</groupId>
<artifactId>hadoop-demo02</artifactId>
<version>0.0.1-SNAPSHOT</version>
<exclusions>
<exclusion>
<groupId>com.bawie.hadoop</groupId>
<artifactId>hadoop-demo01</artifactId>
</exclusion>
</exclusions>
</dependency>
除此之外，我们在clipse中创建maven项目的时候，会显示jdk的版本是J2SE-1.5但是我们看的时候又发现实际上我们使用的是我们自己安装的1.7的jdk版本，这是因为maven默认使用的就是jdk1.5版本的，
这时候我们可以右键单击JRE Sysstem Library[J2SE-1.5]，在弹出的properties属性中修改为1.7。但是这么修改起来比较麻烦，每次创建一个项目都需要这样修改一遍，那么有没有一劳永逸的方法呢？
我们可以打开我们的maven的配置文件settings.xml文件,找到profiles标签，加入如下代码即可！
<profile>
<id>jdk-1.7</id>
<activation>
<activeByDefault>true</activeByDefault>
<jdk>1.7</jdk> #指定jdk的版本为1.7,
</activation>
<properties>
<maven.compiler.source>1.7</maven.compiler.source>
<maven.compiler.target>1.7</maven.compiler.target>
<maven.compiler.compilerVersion>1.7</maven.compiler.compilerVersion>
</properties>
</profile>
这里配置好了，重启eclipse,再次创建maven项目的时候就是显示jdk1.7了，这是全局的设置，如果这种方式不是很奏效，那么也可以设置局部的，如下所示：在自己项目的pom.xml文件中做如下设置！
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>1.7</source>
<target>1.7</target>
</configuration>
</plugin>
</plugins>
</build>
设置好了之后更新一下项目就好了！
jar包的pom文件的查询：可以在百度上直接搜索：ssm pom.xml直接改改版本号就可以了！
http://doc.okbase.net/Naploen8/archive/124775.html
注意：
maven构件定义
构件：在Maven中，任何依赖(jar包,tomcat等)，或项目(自己打包的jar,war等)输出都可成为构件。每个构件都有自己的唯一标识(唯一坐标)，由groupId，artifactId，和version等信息构成，由此，Maven就可以对构件进行版本控制，管理。
groupId：当前Maven构件隶属的项目名。实际开发中，项目往往会模块化开发，如spring-core,spring-aop等，他们都是Spring项目下不同的模块。命名方式与Java包名类似，通常是域名的反向书写。如ch.qos.logback，事实上项目管理组织的网址是：http://logback.qos.ch/ 。(必须)
artifactId：隶属项目中的模块名（通常为项目名-模块名的方式书写）。(必须)
version：当前版本。(必须)
packaging：打包方式，如jar,war... (必须)
classifier：帮助定义构建输出的一些附属构件。如spring-core.jar，还生成有文档javadoc.jar，源码sources.jar。
构件特性
- 构件（依赖）具有依赖传递。例如：项目依赖构件A，而构件A又依赖B，Maven会将A和B都视为项目的依赖。
- 构件之间存在版本冲突时，Maven会依据 “短路优先” 原则加载构件。此外，我们也可以在POM.XML中，使用<exclusions></exclusions>显式排除某个版本的依赖，以确保项目能够运行。
- 项目依赖构件A和B，构件A → C → D(version:1.0.0)，构件B → D(version:1.1.0)，此时，Maven会优先解析加载D(version:1.1.0)。
- 项目依赖构件A和B，构件A → D(version:1.0.0)， 构件B → D(version:1.1.0)，此时，Maven会优先解析加载D(version:1.0.0)。
总结：依赖冲突的意思就是说：如果有A和B依赖了一个不同版本的相同构件，那么对于C来说，它到底是依赖的A里面的构件还是B里面的构件！
这里有两条原则：第一，短路优先（优先解析路径短的版本），第二：如果路径长度相同，则谁先声明,谁优先！
构件的依赖范围。Maven在项目的构建过程中，会编译三套classpath，当我们需要引用某个类的时候，只需要将包含某个类的jar包加入到classpath中即可，maven在这里为我们提供了
三种classpath，分别对应：编译期，运行期，测试期。而依赖范围，就是为构件指定它可以作用于哪套classpath。
聚合
如果在maven中我们想将多个项目进行install，将其安装到本地仓库中，必须对其依次执行install命令，maven中有一种方式，可以将其放到一起运行，
这种方式称之为聚合，这里我们将之前的maven项目，进行聚合，只需要在创建maven项目（此项目作为其它POM的容器）的时候，将pom.xml文件的<packaging>标签修改为pom,不再是jar或者war包了
然后使用<modules>标签，在<modules>标签中用<module>标签来找到我们要聚合的项目，如下所示：
<groupId>com.bawie.hadoop</groupId> <artifactId>hadoop-demo03</artifactId> <version>0.0.1-SNAPSHOT</version> <packaging>pom</packaging> <name>hadoop-demo03</name> <url>http://maven.apache.org</url> <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> </properties> <modules> <module>../hadoop-demo01</module> <module>../hadoop-demo02</module> <module>../hadoop-demo03</module> </modules> <dependencies> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>3.8.1</version> <scope>test</scope> </dependency> </dependencies>
这样就可以对所有的项目进行全局的控制了！
继承
在上面的每个demo中无论是jar包的hadoop-demo01、hadoop-demo02、hadoop-demo03以及还是打成pom包的hadoop-demo05我们都用到了junit的，都对其进行了配置
那么这就有很多重复的地方，其实在maven中也可以像在java中一样，将其共同的组件配置到一个父工程中，此时我们就可以创建一个parent父maven工程。
然后将<dependencies>标签放入到<dependencyManagement>标签中，在<dependencyManagement>标签中的依赖并不会在本项目中运行，同时也可以将junit依赖的版本号
提取出来，在上面的<properties>的属性中，在这里自定义一个版本号的标签并写入版本号，在下面依赖的地方只需要用类似于EL表达式的方式来调用它即可，并将
本项目的 <packaging>修改为pom,其实对于parent父maven工程而言，src下面的test目录和main目录是没有任何作用的,将这两个目录删除之后更新一下maven 项目就好，如下所示：
<groupId>com.bawie.hadoop</groupId> <artifactId>hadoop-parent</artifactId> <version>0.0.1-SNAPSHOT</version> <packaging>pom</packaging> <name>hadoop-parent</name> <url>http://maven.apache.org</url> <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <junit.version>3.8.1</junit.version> </properties> <dependencyManagement> <dependencies> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>${junit.version}</version> <scope>test</scope> </dependency> </dependencies> </dependencyManagement>
在子项目中就可以使用<parent>标签引入父POM的坐标，并删除junit的版本号和scope，这样junit就从父POM中继承过来了，如下所示：
<groupId>com.bawie.hadoop</groupId> <artifactId>hadoop-demo01</artifactId> <version>0.0.1-SNAPSHOT</version> <packaging>jar</packaging> <name>hadoop-demo01</name> <url>http://maven.apache.org</url> <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> </properties> <parent> <groupId>com.bawie.hadoop</groupId> <artifactId>hadoop-parent</artifactId> <version>0.0.1-SNAPSHOT</version> </parent> <dependencies> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> </dependency> </dependencies>
4.在maven中如果创建web项目
在创建maven项目的时候要选择webapp的archetype插件！
创建好了maven项目之后，补齐没有创建的maven的目录 比如：src/main/java、src/main/resources、src/test/java、src/test/resources目录，然后选择本项目右击properties属性，在
弹出的框中选择Deployment Assembly然后将test目录下东东都删除，方式测试目录下的东西发布到服务器上，然后选择project facets在弹出来的对话框中选择Dynamic Web Module
模块，这样就是一个web项目了，当然也可以在后面的runtime选择我们自己安装的tomcat,也可不选（不选就手动加入或者用插件）！
5、后台管理系统工程结构
crm-parent -- 管理依赖jar包的版本，全局，公司级别
|--crm-common --- 通用组件、工具类
|--crm-manager -- 后台系统
|--com.crm.manage.web
|--com.crm.manage.service
|--com.crm.manage.mapper
|--com.crm.manage.pojo
如果要运行maven工程，最好是运行pom聚合工程！
<build> <plugins> <plugin> <groupId>org.apache.tomcat.maven</groupId> <artifactId>tomcat7-maven-plugin</artifactId> <configuration> <port>8080</port> <path>/</path> </configuration> </plugin> </plugins> </build>
当然运行项目的时候，可以使用上面的maven的tomcat插件(此tomcat是maven的，不是我们安装的那个tomcat)，只需要点击pom聚合工程的run as选择Maven build ...然后在
出来的地方出现：输入clean tomcat7:run注意：这里是tomcat7哦，不是tomcat,如果运行的时候用的是tomcat:run那么这里的tomcat指的是tomcat6!
tomcat服务器不支持从jar包中读取配置文件，所以我们的配置文件一般都是放在war包工程的resources配置文件中的！mybatis是支持从jar包中读取配置文件的！
使用tomcat插件的时候，会有个小bug,当我们打断点调试的时候，当程序到达断点，但是当我们查看源码的时候，发现原本的源码找不到啦，我们只需要在弹出来的小
图标中点击Edit Source Lookup Path;，然后再弹出的窗口中选择java project（这里不是选择project哦，而是java protect），然后找到对应的java项目，点击ok，然后重启项目就好！
注意：每个进程对应一个 端口号，在java中也就对应一个main方法，一个进程中有多个线程！
一个tomcat的并发是600左右，所以互联网项目中出现高并发的时候，一个tomcat就顶不住了，这时候就需要构建tomcat集群！
但是这时候通常我们在tomcat集群前面有一个负载均衡服务器！
6、图片服务器两个服务
http：可以使用nginx做静态资源服务器。也可以使用apache。推荐使用nginx，效率更高。
Nginx：
1）http服务
2）反向代理
3）负载均衡
ftp服务：
使用linux做服务器，在linux中有个ftp组件vsftpd。
