一、什么是Maven?

　　Maven是用来管理java程序包的构建工具插件，他解决了传统开发模式中jar包需要手动复制到WEB-INF/lib目录或BOOT-INF/lib目录下的繁琐操作，当一个项目很大的时候，就不再适合使用package来分模块，而是使用工程来划分模块。一个模块作为一个工程，不同的工程之间需要进行依赖。

　　借助Maven，我们可以将一个大型项目拆分成多个工程，需要依赖jar包时，只需要在pom文件中引用即可，项目打包时会自动将引入的jar打包到WEB-INF/lib目录或BOOT-INF/lib目录中。 jar通常会出现链式依赖，你所依赖的jar包可能又依赖其他jar包，这对于手动解决jar依赖方式来说无疑是痛苦滴，这些问题在Maven工程中都给我们轻松的解决了，他会根据jar包中pom文件自动将所有依赖的jar都下载到本地仓库供其使用。

　　构建指以java源文件、框架配置文件、jsp、html、图片等资源为原材料去生成一个可以运行的项目的过程，项目需要在java运行时环境下才能运行。

二、什么是java运行时环境?

　　一个jar包程序想要正常编译和运行，必须要运行时环境JRE提供支持，实际上， 运行时环境是一种旨在运行其他软件的软件。java提供了2种环境，一种是JDK开发环境，一种是JRE运行环境。 作为Java的运行时环境，JRE包含Java类库，Java类加载器和Java虚拟机。JDK是程序员使用java语言编写java程序所需的开发工具包，是提供给程序员使用的，JDK包含了JRE，同时还包含了编译java源码的编译器javac。　　

• 类加载器负责正确加载类并将它们与核心Java类库连接。
• JVM负责确保Java应用程序具有在设备或云环境中运行和良好运行所需的资源。
• Java程序之所以能在不引入类的情况下使用一些基础类，比如String类等，是因为在JRE基础类库中对齐进行了声明和定义。

三、构建过程的几个环节

　　1、清理：删除以前编译得到的旧class字节码文件，为下一次编译做准备。

　　2、编译：将java源程序编译为class字节码文件。

　　3、测试：自动调用junit程序进行自测。

　　4、报告：显示测试程序执行的结果。

　　5、打包：将编译好的class字节码文件打包成war、jar包。

　　6、安装：将自己的工程安装到maven仓库中指定的位置，才能供其他模块使用。

　　7、部署：将jar、war放到生产环境下运行。

四、Maven的安装和配置

　　1、解压MAVEN程序压缩包时要放到非中文无空格的目录下，解压完成后要配置MAVEN_HOME或M2_HOME环境变量，指向Maven安装目录。同时追加path环境变量值指向bin目录。

　　2、Maven本身是java语言编写的，依赖jre运行时，因此在启动程序时会检查JAVA_HOME环境变量，在电脑本身有多个jdk版本时要注意环境变量的值是指向哪一个版本的，以确定运行时和maven版本是否兼容。

　　3、修改默认本地仓库位置：在安装目录conf子文件下编辑settings.xml文件，修改<localRepository>D:\repostitory</localRepository> 即可。

五、Maven的核心概念

　　1、约定的目录结构：Maven程序开发时要遵循约定的目录结构，Maven要想自动进行构建，它会去约定目录查找java源文件、配置文件来完成构建。如果不按此约定就必须手动告诉maven这些文件的位置。

　　2、pom文件：其名字含义是项目对象模型，配置了一切与构建相关的参数，其表示内容解析如下：

<?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/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  
  
 <!--用于子模块中，指定该pom的父项目的具体信息。其中的relativePath给出父项目相对于子项目的路径，这样在构件子项目时首先从该相
 对路径查找父项目，如果没有才会从本地库或进而远程库中查找父项目。子项目能够继承呼项目的
    dependencies、developers、contributors、plugins、reports 等配置信息-->
  <parent>
        <artifactId>sjht-voicemessage</artifactId>
        <groupId>com.sjht.voicemessage</groupId>
        <version>1.0.0</version>
        <relativePath>../pom.xml</relativePath>
  </parent>
  
  
<!--描述了本工程的信息，简称为GAV，第三方依赖该模块时需要使用这些参数去定位本工程-->
  <groupId>com.sjht.voicemessage</groupId>
  <artifactId>sjht-voicemessage</artifactId>
  <version>1.0.0</version>
  <name>sjht-voicemessage</name>
  <packaging>pom</packaging>
  <description>xxxx服务</description>
  
  
<!--modules聚合标签：描述了本工程包含了哪些工程模块-->
  <modules>
    <module>sjht-voicemessage-entity</module>
    <module>sjht-voicemessage-api</module>
    <module>sjht-voicemessage-biz</module>
    <module>sjht-voicemessage-controller</module>
    <module>sjht-voicemessage-server</module>
  </modules>


<!--声明了一些属性和值，可以在本pom和子pom中通过${属性名}的方式间接的引用这些属性值-->
  <properties>
    <spring-boot-maven-plugin.version>2.2.6.RELEASE</spring-boot-maven-plugin.version>
    <dockerfile-maven-plugin.version>1.4.12</dockerfile-maven-plugin.version>
    <maven-compiler-plugin.version>3.8.1</maven-compiler-plugin.version>
    <maven-resources-plugin.version>3.1.0</maven-resources-plugin.version>
    <maven-javadoc-plugin.version>3.0.0</maven-javadoc-plugin.version>
    <maven-deploy-plugin.version>2.8.2</maven-deploy-plugin.version>
    <maven-deploy-plugin.version>2.8.2</maven-deploy-plugin.version>
    <seata.version>1.2.0</seata.version>
    <java.version>1.8</java.version>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
  </properties>


<!--指定私有仓库和*库的地址，以便maven可以通过这些地址去连接仓库-->
   <!--除此方式外，还可以在maven安装目录/conf中settings.xml文件下配置-->
  <repositories>
    <repository>
      <id>sjht-nexus</id>
      <name>Sjht-Repository</name>
      <url>https://nexus.xxx.com/repository/maven-public/</url>
    </repository>
    <repository>
      <id>aliyun-nexus</id>
      <name>aliyun nexus</name>
      <url>https://maven.aliyun.com/repository/public/</url>
    </repository>
  </repositories>
  
  
<!--指定插件的仓库地址，以便maven可以通过这些地址去连接仓库下载插件(maven的所有行为都由插件来完成)-->
  <pluginRepositories>
    <pluginRepository>
      <id>aliyun-nexus</id>
      <name>aliyun nexus</name>
      <url>https://maven.aliyun.com/repository/public/</url>
    </pluginRepository>
  </pluginRepositories>
 
 
<!--指定Maven分发构建的分发的仓库地址，在使用mvn deploy命令向远程仓库分发生成的构建时使用-->
   <!--  不同的版本可以指定不同的分发仓库，分发需要登录认证，需要在maven安装目录下settings.xml文件中配置账号密码。
         settings.xml中server元素下id的值必须与POM中repository或snapshotRepository下id的值完全一致 -->
   <!-- <servers>    
         <server>    
          <id>nexus-releases</id>    
          <username>admin</username>    
          <password>admin123</password>    
        </server>    
        <server>    
          <id>nexus-snapshots</id>    
          <username>admin</username>    
          <password>admin123</password>    
        </server>      
     </servers>   -->
     
  <distributionManagement>
     <!--指定Releases稳定版本要分发的仓库-->
    <repository>
      <id>nexus-releases</id>
      <name>Releases</name>
      <url>https://nexus.xxxx.com/repository/maven-releases/</url>
    </repository>
    
    <!--指定snapshot开发版本要分发的仓库-->
    <snapshotRepository>
      <id>nexus-snapshots</id>
      <name>Snapshot</name>
      <url>https://nexus.xx.com/repository/maven-snapshots/</url>
    </snapshotRepository>
  </distributionManagement>
 
 
<!--dependencyManagement用于父POM中，子项目在引用工程时可以不指定版本，此时会从上级一直向上查找直到
     找到拥有dependencyManagement元素的POM，然后使用此节点下指定的版本-->
  <dependencyManagement>
    <dependencies>
      <dependency>
        <groupId>io.seata</groupId>
        <artifactId>seata-spring-boot-starter</artifactId>
        <version>1.2.6</version>
      </dependency>
      <dependency>
        <groupId>com.tencentcloudapi</groupId>
        <artifactId>tencentcloud-sdk-java</artifactId>
        <version>3.1.390</version>
      </dependency>
    </dependencies>
  </dependencyManagement>
   
 
<!--该节点与dependencyManagement节点的区别在于：
      1、如果被dependencyManagement包含，其效果如上所述；
      2、如果不被dependencyManagement包含，则该节点下所有声明都会被子项目继承(即使子项目pom中没有引入依赖)；     
　　　 3、dependencyManagement里只是声明依赖，并不实现引入，因此子项目需要显示的声明需要用的依赖。如果不在子项目中声明依赖，是不会从父项目中继承下来的；只有在子项目中写了该依赖项，并且没有指定具体版本，才会从父项目中继承该项，并且version和scope都读取自父pom;另
      外如果子项目中指定了版本号，那么会使用子项目中指定的jar版本。
            -->
  <dependencies>
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-api</artifactId>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>cn.hutool</groupId>
      <artifactId>hutool-all</artifactId>
    </dependency>
  </dependencies>


 <!--  多环境配置文件定义，Profile能让你为一个特殊的环境自定义一个特殊的构建，一个Profile可以覆盖项目构件的最终名称，项目依赖，插件配置以影响构建行为，Profile还可以覆盖分发配置。maven提供了一种针对不同环境参数“激活”一个profile的方式，叫profile激活。profile激活方式：
    1、activeByDefault默认激活。
    2、使用-P参数显示地激活(例如mvn package –P test 表示使用test配置文件来构建工程)。
    3、在settings.xml中使用activeProfiles来指定需要激活的profile，这种方式激活的profile在所有情况下都处于激活状态。
    4、当我们使用activeByDefault或settings.xml中定义了处于激活的profile，但是当我们在进行某些操作的时候又不想它处于激活状态，这个时候我们可以使用 " mvn 操作 -P !profileid " 的方式来表示在当前操作中该profile将不处于激活状态。
 -->
  <profiles>
    <!-- 开发环境 -->
    <profile>
      <id>dev</id>
      <properties>
        <profile.active>dev</profile.active>
      </properties>
      <activation>
        <activeByDefault>true</activeByDefault>
      </activation>
    </profile>
    <!-- 测试环境 -->
    <profile>
      <id>test</id>
      <properties>
        <profile.active>test</profile.active>
      </properties>
    </profile>
    <!-- 生产环境-->
    <profile>
      <id>prod</id>
      <properties>
        <profile.active>prod</profile.active>
      </properties>
    </profile>
  </profiles>

<!-- Project Build,是<project>的直接子元素,maven构建过程的全局配置参数：
    1、finalName节点：指定构建后的目标文件的名称
    2、directory节点：指定构建的目标文件存放目录
    3、defaultGoal节点：执行build任务时，如果没有指定目标，将使用的默认值。例如 在命令行中执行mvn，则相当于执行mvn install    
    4、filter节点：定义*.properties文件，定义在filter文件中的name=value键值对，会在build时代替${name}值应用到resources中。maven的默认filter文件夹为${basedir}/src/main/filters。
    5、resources节点：用于包含或者排除某些资源文件。
    6、resources.resource.directory节点：定义resource文件所在的文件夹，默认为${basedir}/src/main/resources。
    7、resources.resource.includes节点：指定哪些文件将被匹配，以*作为通配符。
    8、resources.resource.excludes节点：指定哪些文件将被忽略。
    9、resources.resource.targetPath节点：指定build后的resource存放的文件夹，默认是basedir。通常被打包在jar中的resources的目标路径是META-INF。
    10、testResources节点： 定义和resources节点类似，只不过在test时使用。
    11、build.plugins节点：用于指定使用的插件。
        1、GAV：指定要使用的插件的坐标。
        2、extensions：是否加载plugin的extensions，默认为false
        3、inherited： true/false，这个plugin是否应用到该pom的孩子pom，默认为true
        4、configuration：配置该plugin期望得到的properties
        5、dependencies：作为plugin的依赖
        6、executions： plugin可以有多个目标，每一个目标都可以有一个分开的配置，可以将一个plugin绑定到不同的阶段    
    12、build.pluginManagement节点： pluginManagement的配置和plugins的配置是一样的，只是用于继承，使得可以在子pom中使用(子pom只需要配置插件groupId、artifactId即可)。
    
-->
  <build>
    <defaultGoal>install</defaultGoal>  
    <finalName>sjht-voicemessage-server</finalName>
    <directory>${basedir}/target</directory>  
    <filters>  
        <filter>/src/main/filters/dev.properties</filter>  
    </filters>  
    <resources>
      <resource>
        <directory>src/main/resources</directory>
        <includes>
          <include>**/*</include>
        </includes>
        <targetPath>META-INF/plexus</targetPath>  
        <filtering>true</filtering>
      </resource>
      <resource>
        <directory>src/main/java</directory>
        <includes>
          <include>**/*.xml</include>
        </includes>
        <targetPath>META-INF/plexus</targetPath>  
        <filtering>true</filtering>
      </resource>
    </resources>
    <testResources>   
    </testResources>  
    <pluginManagement>
      <plugins>
        <plugin>
          <groupId>org.apache.maven.plugins</groupId>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>${maven-compiler-plugin.version}</version>
          <configuration>
            <source>${java.version}</source>
            <target>${java.version}</target>
            <encoding>${project.build.sourceEncoding}</encoding>
          </configuration>
        </plugin>
        <plugin>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-maven-plugin</artifactId>
          <version>${spring-boot-maven-plugin.version}</version>
          <executions>
            <execution>
              <goals>
                <goal>repackage</goal>
              </goals>
            </execution>
          </executions>
        </plugin>
      </plugins>
    </pluginManagement>
  </build>
</project>

　　3、坐标GAV引入依赖：使用三个参数groupId、artifactId、version定位在仓库中的唯一一个MAVEN工程。groupId通常用公司项目网址倒序来表示，artifactId通常表示一个模块，version是版本号，这些坐标对应了maven工程在仓库中的路径。

      <dependency>
        <groupId>com.sjht.starter</groupId>
        <artifactId>sjht-dependencies</artifactId>
        <version>1.0.0</version>
        <exclusions> <!-- 排除子依赖jline  -->
           <exclusion>
             <groupId>jline</groupId>
             <artifactId>jline</artifactId>
           </exclusion>
         </exclusions>
      </dependency>

　　4、依赖范围：一个工程需要使用另一个工程，则工程之间就形成了依赖，在dependency.scope节点下可以配置依赖的范围(compile、test、runntime、provided、system)，其默认值为compile。

　　　　　　compile表示被依赖项目需要参与当前项目的编译。

　　　　　　test表示依赖项目仅仅参与测试相关的工作，包括测试代码的编译，执行。

　　　　　　runntime表示被依赖项目无需参与项目的编译，不过后期的测试和运行周期需要其参与。

　　　　　　provided意味着打包的时候可以不用包进去，别的设施(Web Container)会提供。

　　　　　　system与provided相同，不过被依赖项不会从maven仓库抓，而是从本地文件系统拿，一定需要配合systemPath属性使用。

　　5、依赖传递：在子pom中引入依赖时，当依赖的范围被标识为compile时，这个依赖可以向上传递给父辈pom，父辈不用声明依赖也可以使用这个依赖。(依赖传递可能会导致jar冲突)

　　6、依赖排除：存在两个项目依赖同类型不同版本的jar包时，会导致jar包冲突，我们可以在引入依赖时使用exclusions标签手动排除冗余的且不需要使用的jar包。

　　7、依赖冲突处理原则：maven默认采用最短路径优先原则、同一pom中后声明的覆盖先声明的原则、路径相同不同pom中先声明优先的原则来选择使用jar包。

　　8、依赖版本管理：

　　　　a、统一将版本号放在properties标签中，通过${name}的方式放入version标签可以实现，一处修改多处生效。

　　　　b、通过在父POM声明版本，子POM统一使用的继承方式进行统一管理。要注意的是父工程既不是jar也不是war，打包方式只能为pom，父POM指定版本号，子POM声明依赖时就不需要再指定版本了。

　　9、聚合工程：使用modules标签指定子工程模块的相对路径，所谓聚合就是对项目分模块，聚合工程主要有方便统一管理依赖、将项目进行纵向切分+横向切分的项目整合作用。

　　10、生命周期：构建过程的几个环节是按顺序进行的，Maven提供了三套相对独立的生命周期，分别是Clean Lifecycle、Default Lifecycle、Site Lifecycle，其中

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

　　　　Default Lifecycle：构建的核心周期，包括编译、测试、打包、安装、部署等。

　　　　Site Lifecycle：生成项目报告、站点、发布站点。

　　11、仓库：仓库包括本地仓库(当前电脑)和远程仓库(*仓库、局域网私仓)，*仓库有maven官方管理，私有仓库通常使用Nexus来搭建。maven查找依赖时会先从本地仓库、私有仓库、*仓库依次查找并下载同步到私仓、本地仓库。仓库中保存的内容通常包含Mven自身插件、第三方工具jar包、自己开发的maven工程，这些内容都是按照统一方式管理和使用。

六、常用Maven命令

　　执行与构建过程相关的Maven命令，必须进入到pom.xml所在的目录下才能执行。常用命令有：

　　　　1、清理：mvn clean 

　　　　2、编译主程序：mvn compile

　　　　3、编译测试程序：mvn test-compile

　　　　4、执行测试：mvn test

　　　　5、打包：mvn package

　　　　6、安装到仓库：mvn install

　　　　7、推送maven工程到远程仓库：mvn deploy

　　以上命令，后面的都会包含前一个命令(mvn test-compile除外)，每一个命令执行都从mvn clean开始。如果想在打包或安装时跳过测试环节，则在命令后增加参数  -Dmaven.test.skip=true 。结合dockerfile还可以打包成docker镜像推送到服务器，命令如下：

　　　　8、打包到docker服务器(需要tcp连接到2375端口)：mvn dockerfile:build  -Dmaven.test.skip=true

　　　　9、推送到镜像仓库(需要配置仓库地址并登录仓库)：mvn dockerfile:push  -Dmaven.test.skip=true

七、官网下载jar包

　　访问Maven*仓库https://search.maven.org/或者https://mvnrepository.com/，可以查找自己需要的jar，复制配置代码到自己的pom.xml文件中dependencies节点下，重新加载Maven项目，插件会自动下载jar到本地仓库供其引用。

八、MAVEN插件

　　Maven本质上是只是一个插件框架，它的核心并不执行任何具体的构建任务，全部任务都是由插件来完成的。构建过程的每一个步骤都都对应一个插件来负责，Maven提供了Build plugins、Reporting plugins两种类型的插件。

　　Build plugins在构建时执行，并在 pom.xml 的 元素中配置。Reporting plugins在网站生成过程中执行，并在 pom.xml 的 元素中配置。以下是常用的插件：

　　1、clean插件：构建之后清理目标文件。删除目标目录。

　　2、compiler插件：编译 Java 源文件。

　　3、surefile插件：运行 JUnit 单元测试。创建测试报告。

　　4、jar插件：从当前工程中构建 JAR 文件。

　　5、war插件：从当前工程中构建 WAR 文件。

　　6、javadoc插件：为工程生成 Javadoc。

　　7、antrun插件：从构建过程的任意一个阶段中运行一个 ant 任务的集合。

　　以上这些插件都是在pom.xml中使用plugins元素定义的，每个插件可以有多个目标，可以定义插件使用的阶段，可以通过绑定到插件的目标的方式来配置要执行的任务。Maven 将处理剩下的事情。它将下载本地仓库中获取不到的插件，并开始处理。例如：

<build>
<plugins>
   <plugin>
   <groupId>org.apache.maven.plugins</groupId>
   <artifactId>maven-antrun-plugin</artifactId>
   <version>1.1</version>
   <executions>
      <execution>
         <id>id.clean</id>
         <phase>clean</phase>
         <goals>
            <goal>run</goal>
         </goals>
         <configuration>
            <tasks>
               <echo>clean phase</echo>
            </tasks>
         </configuration>
      </execution>     
   </executions>
   </plugin>
</plugins>
</build>