maven构建过程 -maven坐标 -maven依赖 -maven继承 -maven聚合 -maven生命周期 -常用的Maven命令 -maven自动部署插件

1. 构建过程环节

   1. 清理：编译之前删除旧的class字节码文件
   2. 编译：将java源程序编译成class字节码文件
   3. 测试：自动测试，自动调用junit程序
   4. 报告：测试程序执行结果
   5. 打包：动态web工程打war包，java工程打jar包
   6. 安装：Maven特定的概念——将打包得到的文件复制到”仓库“中的指定位置
   7. 部署：将动态Web工程生成的war包复制到servlet容器的指定目录下，使其可以运行。
   • 构建概念：
     • 编译
     • 部署：一个BS项目最终运行的并不是动态Web工程本身，而是这个动态Web工程“编译的结果”
     • 搭建

2. 安装Maven核心程序

   1. 检查JAVA_HOME环境变量
   2. 解压Maven核心程序
   3. 配置maven相关环境变量
      1. MAVEN_HOME或M2_HOME
      2. Path
      3. 运行mvn -v命令查看Maven版本

3. Maven的核心概念

   1. 约定的目录结构

      1. 目录结构

         1. 根目录：工程名
         2. src目录：源码
         3. pom.xml文件：Maven工程的核心配置文件
         4. main目录：存放主程序
         5. test目录：存放测试程序
         6. java目录：存放java源文件
         7. resources目录：存放框架或其他工具的配置文件

      2. 结构图

         Hello
         |---src
         |---|---main
         |---|---|---java
         |---|---|---resources
         |---|---test
         |---|---|---java
         |---|---|---resources
         |---pom.xml
         

      3. 为什么使用规定的目录结构

         1. Maven负责项目的自动化构建，编译时，Maven需要知道Java源文件保存的位置
         2. 自定义的内容如何让框架或工具知道？
            1. 以配置的方式明确告诉框架
            2. 遵守框架内部已经存在的约定
         3. 约定>配置>编码

      4. 补充：为什么要区分java和resources目录

         1. java目录里面要放我们的java源文件（.java后缀的文件），构建时，这些文件需要先编译成.class文件，然后放到编译结果对应的目录下
         2. resources目录里面放其它的资源文件，构建时，这些文件是不需要编译的，直接复制到编译结果对应的目录下
         3. java目录下也可以放其它的文件，但是构建时，默认是不会放到编译结果里面的，我们可以通过一些配置达到这一目的。同样的，这些其它文件是不需要编译的，直接复制到编译结果对应的目录下

   2. POM

      1. pom.xml文件内容，maven2开始固定的结构

         <?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
             <modelVersion>4.0.0</modelVersion>
            
             <groupId>xin.yangshuai</groupId>
             <artifactId>Hello</artifactId>
             <version>0.0.1-SNAPSHOT</version>
             
             <name>Hello</name>
             <description>Demo project for Hello</description>
         
             <dependencies>
                 <dependency>
                     <groupId>junit</groupId>
                     <artifactId>junit</artifactId>
                     <version>4.0</version>
                     <scope>test</scope>
                 </dependency>
             </dependencies>
         </project>
         
         

      2. 含义：Project Object Model项目对象模型

         1. Dom Document Object Model 文档对象模型

      3. pom.xml对于Maven工程是核心配置文件，与构建过程相关的一切设置都在这个文件中进行配置。

         1. 重要程度相当于web.xml对于动态Web工程

   3. 坐标

      1. 数学中的坐标：

         1. 在平面上，使用X、Y两个向量可以唯一的定位平面中的任何一个点
         2. 在空间中，使用X、Y、Z三个向量可以唯一的定位空间中的任何一个点

      2. Maven的坐标（GAV）

         1. 使用三个向量在仓库中唯一定位一个Maven工程

            1. groupid：公司或组织域名倒序+项目名

               <groupid>com.shuai.maven</groupid>

            2. artifactid：模块名

               <artifactid>Hello</artifactid>

            3. version：版本

               <version>1.0.0</version>

               • -SNAPSHOT：快照，不稳定版
               • RELEASE：分离，稳定版本

      3. Maven工程的坐标 与仓库中路径的对应关系

         1. 位置

            1. 路径：D:\work\mavenCK\org\springframework\spring-core\4.3.20.RELEASE
            2. 文件名：spring-core-4.3.20.RELEASE.jar

         2. pom

            1. 坐标

               <groupId>org.springframework</groupId>
               <artifactId>spring-core</artifactId>
               <version>4.3.20.RELEASE</version>
               

            2. 命名规则

               1. 路径

                  groupId(.换成\)\artifactId\version

               2. 文件名

                  artifactId-version.jar

   4. 依赖

      1. Maven解析依赖信息时会到本地仓库中查找被依赖的jar包。

         1. 对于我们自己开发的Maven工程，使用mvn install命令安装后就可以进入仓库。

         2. 引用一个依赖

            <dependency>
                <groupId>xin.yangshuai</groupId>
                <artifactId>Hello</artifactId>
                <version>0.0.1-SNAPSHOT</version>
                <scope>compile</scope>
            </dependency>
            

      2. 依赖的范围（scope）

         1. compile：编译范围依赖
            1. 对主程序是否有效：有效
            2. 对测试程序是否有效：有效
            3. 是否参与打包：参与
            4. 是否参与部署：参与
            5. 典型例子：spring-core
         2. test：测试范围依赖
            1. 对主程序是否有效：无效
            2. 对测试程序是否有效：有效
            3. 是否参与打包：不参与
            4. 是否参与部署：不参与
            5. 典型例子：junit
         3. provided：通常Web工程使用
            1. 对主程序是否有效：有效
            2. 对测试程序是否有效：有效
            3. 是否参与打包：不参与
            4. 是否参与部署：不参与（开发时没有服务器运行时环境，需要提供jar包，部署时由Servlet服务器提供）
            5. 典型例子：servlet-api.jar

   5. 仓库

      1. 仓库分类
         1. 本地仓库：当前电脑上部署的仓库目录，为当前电脑上所有Maven工程服务
         2. 远程仓库
            1. 私服（Nexus私服）：搭建在局域网环境中，为局域网范围内的所有Maven工程服务
            2. 中央仓库：架设在Internet上，为全世界所有Maven工程服务
            3. 中央仓库镜像：分担中央仓库的流量，提升用户访问速度
      2. 仓库中保存的内容：Maven工程（统一的规范去管理）
         1. Maven自身所需要的插件
         2. 第三方框架或工具的jar包（第一方：jdk，第二方：自己（写的代码））
         3. 我们自己开发的Maven工程

   6. 生命周期/插件/目标

      1. 各个构建环节执行的顺序：不能打乱顺序，必须按照既定的正确顺序来执行。

      2. Maven的核心程序中定义了抽象的生命周期，生命周期中各个阶段的具体任务是由插件来完成的。

      3. Maven有三套相互独立的生命周期

         1. Clean Lifecycle：在进行真正的构建之前进行一些清理工作

            1. pre-clean：执行一些需要在clean之前完成的工作
            2. clean：移除所有上一次构建生成的文件
            3. post-clean：执行一些需要在clean之后立刻完成的工作

         2. Default Lifecycle：构建的核心部分，编译，测试，打包，安装，部署等

         3. Site Lifecycle：生成项目报告，站点，发布站点

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

            2. site：生成项目的站点文档

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

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

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

      4. Maven核心程序为了更好的实现自动化构建，按照这一特点执行生命周期中的各个阶段：不论现在要执行生命周期中的哪一个阶段，都是从这个生命周期的最初的位置开始执行。

         1. mvn compile

            maven-resources-plugin:2.6:resources
            maven-compiler-plugin:2.5.1:compile
            

         2. mvn test

            maven-resources-plugin:2.6:resources
            maven-compiler-plugin:2.5.1:compile
            maven-resources-plugin:2.6:testResources
            maven-compiler-plugin:2.5.1:testCompile
            maven-surefire-plugin:2.12.4:test
            T E S T S
            

      5. 插件和目标

         1. 生命周期的各个阶段仅仅定义了要执行的任务是什么

         2. 各个阶段和插件的目标是对应的

         3. 相似的目标由特定的插件来完成

            生命周期阶段	插件目标	插件
            compile	compile	maven-compiler-plugin
            test-compile	testCompile	maven-compiler-plugin

         4. 可以将目标看作“调用插件功能的命令”

   7. 依赖[高级]

      1. 依赖的传递性

         1. 好处：可以传递的依赖不必在每个模块工程中都重复声明，在“最下面”的工程中依赖一次即可。
         2. 注意：非compile范围的依赖不能传递。所以在各个工程模块中，如果有需要就得重复声明依赖。

      2. 依赖的排除

         1. 依赖排除的设置方式

            <dependency>
            	<groupId>xin.yangshuai.maven</groupId>
            	<artifactId>HelloFriend</artifactId>
            	<version>0.0.1-SNAPSHOT</version>
            	<scope>compile</scope>
            	<exclusions>
            		<exclusion>
            			<groupId>commons-logging</groupId>
            			<artifactId>commons-logging</artifactId>
            		</exclusion>
            	</exclusions>
            </dependency>
            

      3. 依赖的原则

         1. 作用：解决模块工程之间的jar包冲突问题，maven根据自己的内置原则自动处理冲突
         2. 原则：
            1. 路径最短者优先原则
            2. 先声明者优先：dependency标签的声明顺序

      4. 统一管理依赖的版本

         1. 建议配置方式

            1. 使用properties标签，标签内使用自定义标签统一声明版本号

               <properties>
               	<spring.version>4.3.13.RELEASE</spring.version>
               </properties>
               

            2. 在需要统一版本的位置，使用${自定义标签名}引用声明的版本号

               <dependency>
               	<groupId>org.springframework</groupId>
               	<artifactId>spring-core</artifactId>
               	<version>${spring.version}</version>
               </dependency>
               

            3. 其实properties标签配合自定义标签声明数据的配置并不是只能用于声明依赖的版本号，凡是需要统一声明后再引用的场合都可以使用。

   8. 继承

      1. 现状

         1. Hello依赖的junit：4.0
         2. HelloF人多依赖的junit：4.0
         3. MakeFriends依赖的junit：4.9
         4. 由于test范围的依赖不能传递，所以必然会分散在各个模块工程中，很容易造成版本不一致。

      2. 需求：统一管理各个模块工程中对junit依赖的版本。

      3. 解决思路：将junit依赖统一提取到“父”工程中，在子工程中声明junit依赖时不指定版本，以父工程中统一设定的为准。同时也便于修改。

      4. 操作步骤

         1. 创建一个Maven工程做为父工程，注意：打包方式pom

         2. 在子工程中声明对父工程的引用

            <!--子工程声明父工程-->
            <parent>
            	<groupId>com.shuai.maven</groupId>
            	<artifactId>maventest</artifactId>
            	<version>0.0.1-SNAPSHOT</version>
            
            	<!--以当前文件为基准的父工程pom.xml文件的相对路径-->
            	<relativePath>../pom.xml</relativePath>
            </parent>
            

         3. 将子工程的坐标中与父工程坐标重复的内容删除：groupId、version等

         4. 在父工程中统一管理junit的依赖

            <!--配置依赖的管理-->
            <dependencyManagement>
            	<dependencies>
            		<dependency>
            			<groupId>junit</groupId>
            			<artifactId>junit</artifactId>
            			<version>4.12</version>
            			<scope>test</scope>
            		</dependency>
            	</dependencies>
            </dependencyManagement>
            

         5. 在子工程中删除junit依赖的版本号部分

            <dependency>
            	<groupId>junit</groupId>
            	<artifactId>junit</artifactId>
            	<scope>test</scope>
            </dependency>
            

      5. 注意：配置继承后，执行安装命令时要先安装父工程

   9. 聚合

      1. 作用：一键安装各个模块工程

      2. 配置方式：在一个“总的聚合工程”中配置各个参与聚合的模块

         <!--配置聚合-->
         <modules>
         	<!--指定各个子工程的相对路径（顺序没有关系）-->
         	<module>Hello</module>
         	<module>HelloFriend</module>
         	<module>MakeFriends</module>
         </modules>
         

      3. 使用方式：在聚合工程上运行mvn install

      4. 说明一点：父工程可以做为聚合工程（一般也是这样），但并非一定要在父工程里面做聚合，聚合与继承是两个不相干的概念，可以另外建一个工程做聚合

4. 常用的Maven命令

   1. 执行与构建过程相关的Maven命令，必须进入pom.xml所在的目录
      1. 编译、测试、打包、……
   2. 常用命令
      1. mvn clean：清理
      2. mvn compile：编译主程序
      3. mvn test-compile：编译测试程序
      4. mvn test：执行测试
      5. mvn package：打包
      6. mvn install：安装
      7. mvn site：生成站点

5. 关于联网的问题

   1. Maven的核心程序仅仅定义了抽象的生命周期，但是具体的工作必须由特定的插件来完成，而插件本身并不包含在Maven的核心程序中。

   2. 当我们执行的Maven命令需要用到某些插件时，Maven核心程序会首先到本地仓库查找

   3. 本地仓库的默认位置：[系统中当前用户的家目录]\.m2\repository

   4. 本地仓库找不到插件，会自动连接外网到中央仓库下载

   5. 如果无法连接外网，则构建失败

   6. 修改默认本地仓库的位置

      <localRepository>D:\work\mavenCK</localRepository>

6. 自动部署插件

   1. 使用命令：mvn deploy，在命令行使用

   2. deploy：将最终的包复制到远程的仓库，以让其他开发人员与项目共享或部署到服务器上运行。

   3. 插件内容

      <!-- 配置当前工程构建过程中的特殊设置 -->
      <build>
      
          <finalName>WebTest</finalName>
      
          <!-- 配置构建过程中需要使用的插件 -->
          <plugins>
              <plugin>
                  <!--cargo是一家专门从事“启动Servlet容器”的组织-->
                  <groupId>org.codehaus.cargo</groupId>
                  <artifactId>cargo-maven2-plugin</artifactId>
                  <version>1.2.3</version>
      
                  <!--针对插件进行的配置-->
                  <configuration>
                      <!-- 配置当前系统中容器的位置 -->
                      <container>
                          <containerId>tomcat7x</containerId>
                          <home>D:\work\apache-tomcat-7.0.85-8080</home>
                      </container>
                      <configuration>
                          <type>existing</type>
                          <home>D:\work\apache-tomcat-7.0.85-8080</home>
                          <!--如果Tomcat端口为默认值8080则不必设置该属性-->
                          <!--<properties>
                              <cargo.servlet.port>8989</cargo.servlet.port>
                          </properties>-->
                      </configuration>
                  </configuration>
      
                  <!--配置插件在什么情况下执行-->
                  <executions>
                      <execution>
                          <id>cargo-run</id>
                          <!--生命周期的阶段-->
                          <phase>install</phase>
                          <goals>
                              <!--插件的目标-->
                              <goal>run</goal>
                          </goals>
                      </execution>
                  </executions>
              </plugin>
          </plugins>
      </build>
      

   4. 插件网站

      cargo

7. maven依赖信息网站

   1. https://mvnrepository.com/

8. 参考教程

   1. http://www.gulixueyuan.com/my/course/42