a17787b6a9d9be15a5b8

参考：

https://blog.csdn.net/u012152619/article/details/51485297
新建一个目录，在目录下创建一个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/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
        <groupId>com.cqq</groupId>
        <artifactId>test-maven</artifactId>
        <version>7.0.0-SNAPSHOT</version>
        <packaging>jar</packaging>

<dependencies>
<dependency> 
<groupId>com.fasterxml.jackson.core</groupId> 
<artifactId>jackson-databind</artifactId> 
<version>2.9.6</version> 
</dependency>
</dependencies>

</project>

很简单，然后使用命令：
mvn package -DskipTests

就打包成功了：






原来只有一个pom.xml的，现在看看多了什么：

1 Maven 简介
 Maven 使用项目对象模型（POM，Project Object Model） 的概念，可以通过一小段描述信息来管理项目的构建、报告和文档的软件项目管理工具
2 Maven 的下载与IDE 的整合
1 下载地址
http://maven.apche.org
2 Eclipse 整合Maven
Step1:打开 Eclipse 中window -> preference -> maven ->  InstallLocations 
更换为自己下载的 maven ，不使用 eclipse 自带的 maven
Step2:打开 maven -> UserSetting 
更换为自己的 settings.xml  配置文件，并修改 settings.xml 文件
3 Maven 仓库与配置
3.1远程仓库
中央仓库  https://mvnrepository.com/ 
3.2 本地仓库
存储本机的拷贝，以及远程仓库中的下载的构件（Java API 资源）
4 仓库配置
5.1 settings.xml
设置本地仓库的地址 -->
<localRepository>E://Maven//repository</localRepository>
5.2 配置镜像源
<mirrors>
    <mirror>
      <!-- 镜像的ID -->
      <id>alimaven</id>
      <name>aliyun maven</name>
      <!-- 指定镜像路径 -->
      <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
       <!-- 匹配中央仓库 -->
      <mirrorOf>central</mirrorOf>        
    </mirror>
  </mirrors>
6 仓库优先级
 本地仓库   > 指定仓库  >  远程仓库（镜像仓库 > 中央仓库）
6.1 本地仓库
6.2 指定仓库
6.3 远程仓库
镜像仓库
中央仓库
3  Maven 工程
3.1 Pom 工程
pom 工程是逻辑工程。
用在父级工程或者聚合工程。
用来做 jar 包的版本控制
3.2 jar 工程
将会打包成 jar 用作 jar 包使用
3.3 war 工程
将会打包成 war ，发布在服务器上的工程。
4 创建Maven 项目
 使用 Eclipse 创建 Maven 项目，勾选简单工程，即创建纯净的项目。
4.1 Maven 创建
 Group Id  Artifact Id  Version 这三个组合起来唯一定位项目的位置
Group Id ： 域名倒着写
Artifact Id：项目名称
Version ： 版本
Packing ：项目类型
Name：任意
Description：描述任意
4.2 Maven 目录
|                   |                                                              | | :---------------- | ------------------------------------------------------------ | | src/main/java     | 存储 java 源代码                                             | | src/man/resources | 存储资源配置文件                                             | | src/main/test     | 测试 java 源代码和资源文件                                   | | src/              | 存储源代码和资源文件                                         | | target            | 编译后内容放置的文件夹                                       | | pom.xml           | Maven 的基础配置文件。配置项目与项目之间关系，包括配置依赖关系等等 |
5 工程关系
5.1 依赖
如果 A工程 依赖于 B 工程的资源，则称 A 工程依赖于 B 工程
做法：将 B 工程的坐标加入 A 工程的 pom.xml 的依赖中。
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.2</version>
    <!--
        complie 编译中有效
        runtime 运行中有效
        system 全部中有效[默认]
        provided 当前工程中有效
        test 只在测试有效
    -->
    <scope>test</scope>
</dependency>
5.2  继承
 如果 A 工程继承 B 工程，则A 工程可以使用 B 工程所有资源。
 前提 B 工程必须是 pom 工程类型.
父工程的配置文件
<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>
  <groupId>cn.edu.ahszu</groupId>
  <artifactId>ParentProject</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>pom</packaging>
  <name>Demo</name>
  <properties>
        <!-- 配置当前项目依赖构建的版本 
             项目名最好见名知意
         -->
        <junit-version>4.2</junit-version>
  </properties>
  <dependencyManagement>
    <dependencies>
        <dependency>
             <groupId>junit</groupId>
             <artifactId>junit</artifactId>
            <version>${junit-version}</version>
        </dependency>
    </dependencies>
  </dependencyManagement>
</project>
子工程的配置文件
<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>
  <!-- 继承父项目 -->
  <parent>
    <groupId>cn.edu.ahszu</groupId>
    <artifactId>ParentProject</artifactId>
    <version>0.0.1-SNAPSHOT</version>
  </parent>
  <groupId>cn.edu.ahszu</groupId>
  <artifactId>ChildProject</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <dependencies>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
    </dependency>
  </dependencies>
</project>
5.3 聚合
当我们开发的工程拥有 2 个以上模块的时候，每个模块都是一个独立的功能集合。
注意：在创建聚合工程的过程中，总的工程必须是 pom 类型的工程，子模块的工程类型任意。
<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>
  <groupId>cn.edu.ahszu</groupId>
  <artifactId>04-Maven-Managerment</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>pom</packaging>
  <!-- 子模块 -->
  <modules>
    <module>04-Maben-sub</module>
    <module>04-Maven-sub2</module>
  </modules>
</project>
6 创建 war 类型的项目
创建war 类型的项目后，
war 默认没有 WEB-INF 目录及下面的 web.xml 文件，所以需要手动添加。
在 webapp 目录下创建 WEB-INF 目录该目录下的 web.xm 文件
7 Maven 常用插件
7.1  编译器插件
前提是本机必须有 JDK ，并且JDK 的版本要对应
在 pom.xml 配置编译器插件，用于选择 JDK 的版本，并且对本项目生效。
若需全局配置，需要在 settings.xml 中配置编译器插件。
pom.xml 局部配置
<build> 
    <plugins> 
    <!-- java 编译插件 --> 
      <plugin> 
        <groupId>org.apache.maven.plugins</groupId>        
        <artifactId>maven-compiler-plugin</artifactId> 
        <version>3.2</version> 
        <configuration> 
            <source>1.7</source> 
            <target>1.7</target> 
            <encoding>UTF-8</encoding> 
        </configuration> 
      </plugin> 
    </plugins> 
  </build>
settings.xml 全局配置
<profile> 
    <!-- 定义的编译器插件 ID，全局唯一 --> 
    <id>jdk-1.7</id> 
    <!-- 插件标记，activeByDefault 默认编译器，jdk 提供编译器版本 --> 
    <activation> 
        <activeByDefault>true</activeByDefault> 
        <jdk>1.7</jdk> 
    </activation> 
    <!-- 配置信息 source-源信息，target-字节码信息，compilerVersion-编译过程版-->
    <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>
7.2  Tomcat  插件
 启动 tomcat 命令：tocmat7 :run
 命令中的 tomcat7 是插件命名，由插件提供商决定。run 为插件中的具体功能.
本地应用
<build> 
    <plugins> 
      <!-- 配置 Tomcat 插件 --> 
      <plugin> 
        <groupId>org.apache.tomcat.maven</groupId> 
        <artifactId>tomcat7-maven-plugin</artifactId> 
        <version>2.2</version> 
        <configuration> 
          <port>8080</port> 
          <!--
                    / 表示访问 tocmat 中 webapp 中 ROOT 目录
                    访问 http://localhost:8080/
           -->
          <path>/</path>  
        </configuration> 
      </plugin> 
    </plugins> 
  </build>
远程热部署
在 tomcat 容器运行过程中，动态实现 war 工程的部署，重新部署的功能。
使用 maven build ，使用 run:deploy  或者 run:redeploy
配置 tocmat 服务器用户
<role rolename="manager-gui"/> 
<role rolename="manager-script"/> 
<user username="tomcatUsername" password="tomcatPassword" 
      roles="manager-gui,manager-script"/>
修改 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/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>cn.szxy</groupId>
  <artifactId>07-Maven-tomcat</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>war</packaging>
  <build> 
    <plugins> 
      <!-- 配置 Tomcat 插件 --> 
      <plugin> 
        <groupId>org.apache.tomcat.maven</groupId> 
        <artifactId>tomcat7-maven-plugin</artifactId> 
        <version>2.2</version> 
        <configuration> 
          <port>8080</port> 
           <!-- path: 上传的 war 包解压后的路径命名 --> 
          <path>/ROOT</path> 
           <!-- url : 上传 war 包到什么位置,除 IP 和端口可以修改外其他不变 --> 
          <url>http://192.168.170.8:8080//manager/text</url> 
          <!-- 为 tomcat 配置的管理用户名和密码. --> 
          <username>tomcatUsername</username> 
          <password>tomcatPassword</password> 
        </configuration> 
      </plugin> 
    </plugins> 
  </build> 
</project>
7.3 资源拷贝插件
使用 maven 命令生成 war 类型的工程，默认打包 src/main/resources 下的配置文件，并不会打包src 目录下的配置文件，所以这时需要配置 pom.xml ，让maven 也打包src目录下的配置文件。
注意：当在 pom.xml 配置 src 目录配置文件时，还需再添加原来默认打包路径下 src/mian/resources 下的配置文件。
<!-- 配置资源插件 -->
<resources>
    <resource>
        <directory>src/main/java</directory>
        <includes>
            <include>**/**.xml</include>
        </includes>
    </resource>
    <resource>
        <directory>src/main/resources</directory>
        <includes>
            <include>**/**.xml</include>
            <include>**/**.properties</include>
        </includes>
    </resource>
</resources>
8 Maven 常用命令
install
本地安装，包含编译，打包，安装到本地仓库
编译 javac 
打包 jar
安装到本地仓库，将打包 jar 文件，保存到本地仓库中。
clean
清除已编译信息，删除工程中的 target 目录。
compile
只编译，javac
deploy
部署。
package
打包。包括编译，打包的两个功能
9 Maven 私服
私服是一种特殊的远程仓库，它是架设在局域网的仓库服务，
私服代理广域网上的远程仓库，供局域网使用。
安装私服 Nexus
默认端口为8081
修改防火墙,开放端口
service stop iptables
开启 nexus 服务器
./nexus start
访问网站
http://IP:8081/nexus/
配置私服
登录
Nexus 默认用户名是 admin、密码是admin123
仓库类型
hosted
存放自己项目的构件
proxy
代理仓库：代理公共的远程仓库
3rd party
存放第三方构建
设置 proxy 代理仓库准许远程下载
setting.xml
注意：配置了 nexus 服务器，就不需要配置镜像源
当 setting.xml 配置文件出错，则 eclipse maven插件不能读取 setting.xml
<?xml version="1.0" encoding="UTF-8"?> 
<settings  
    xmlns="http://maven.apache.org/SETTINGS/1.0.0"                                       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"   
     xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0                       http://maven.apache.org/xsd/settings-1.0.0.xsd"> 

<localRepository>D:/repositories</localRepository> 
 <!--Maven是否需要和用户交互以获得输入。如果Maven需要和用户交互以获得输入，则设置成true，反之则应为false。默认为true。--> 
  <interactiveMode>true</interactiveMode> 
 <!--表示Maven是否需要在离线模式下运行。如果构建系统需要在离线模式下运行，则为true，默认
为false。 --> 
  <offline>false</offline> 
<!--
    当插件的组织Id（groupId）没有显式提供时，供搜寻插件组织Id（groupId）的列表。该元素包含一个      pluginGroup元素列表，每个子元素包含了一个组织Id（groupId）。当我们使用某个插件，
    并且没有在命令行为其提供组织Id（groupId）的时候，Maven就会使用该列表。 
-->
  <pluginGroups> 
    <pluginGroup>org.mortbay.jetty</pluginGroup> 
    <pluginGroup>org.jenkins-ci.tools</pluginGroup> 
  </pluginGroups> 

  <proxies> 
  </proxies> 
<!--配置服务端的一些设置。一些设置如安全证书不应该和pom.xml一起分发。这种类型的信息应该存在于构建服务器上的settings.xml文件中。--> 
  <servers> 
    <server> 
      <!-- server的id必须和pom.xml文件中的仓库id一致 --> 
 <!--这是server的id（注意不是用户登陆的id），该id与distributionManagement中 repository元素的id相匹配。--> 
      <id>nexus-releases</id> 
      <username>deployment</username> 
      <password>deployment123</password> 
    </server> 
    <server>  
      <id>nexus-snapshots</id> 
      <username>deployment</username> 
      <password>deployment123</password> 
    </server> 
  </servers> 
<!--根据环境参数来调整构建配置的列表。--> 
  <profiles> 
    <profile> 
      <id>jdk-1.7</id> 
      <activation> 
        <activeByDefault>true</activeByDefault> 
        <jdk>1.7</jdk> 
      </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> 
    <profile> 
      <id>sxt</id> 
      <activation> 
        <activeByDefault>false</activeByDefault>         <jdk>1.7</jdk> 
      </activation> 
      <repositories> 
        <!-- 私有库配置 --> 
        <repository> 
          <!-- 私有库 id --> 
          <id>nexus</id> 
          <!-- 私有库地址 --> 
          <url>http://192.168.120.158:8081/nexus/content/groups/public/</url> 
          <!-- 私有库是否支持 releases 版本 --> 
          <releases> 
            <enabled>true</enabled> 
          </releases> 
          <!-- 私有库是否支持 snapshots 版本 --> 
          <snapshots> 
            <enabled>true</enabled> 
          </snapshots> 
        </repository> 
      </repositories>       
      <pluginRepositories> 
        <!-- 插件库配置，具体含义私有库配置 --> 
        <pluginRepository> 
          <id>nexus</id> 
          <url>http://192.168.120.158:8081/nexus/content/groups/public/</url> 
          <releases> 
            <enabled>true</enabled> 
          </releases> 
          <snapshots> 
            <enabled>true</enabled> 
          </snapshots> 
        </pluginRepository> 
      </pluginRepositories> 
    </profile> 
  </profiles> 

  <!-- 激活 profile --> 
  <activeProfiles> 
    <!-- 根据 profile 的 id 标签值激活指定的内容 --> 
    <activeProfile>sxt</activeProfile> 
  </activeProfiles> 
</settings>
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/xsd/maven-4.0.0.xsd"> 
  <modelVersion>4.0.0</modelVersion> 
  <groupId>group</groupId> 
  <artifactId>project</artifactId> 
  <version>1.0</version> 

  <distributionManagement> 
    <repository> 
      <id>nexus-releases</id> 
      <name>Nexus Release Repository</name> 
      <url>http://192.168.120.158:8081/nexus/content/repositories/releases/</url> 
    </repository> 
    <snapshotRepository> 
      <id>nexus-snapshots</id> 
      <name>Nexus Snapshot Repository</name> 
      <url>http://192.168.120.158:8081/nexus/content/repositories/snapshots/</url> 
    </snapshotRepository> 
  </distributionManagement> 
  <build> 
    <plugins> 
      <plugin> 
        <groupId>org.apache.maven.plugins</groupId> 
        <artifactId>maven-source-plugin</artifactId> 
        <version>2.1.2</version> 
        <executions> 
          <execution> 
            <id>attach-sources</id> 
            <goals> 
              <goal>jar</goal> 
            </goals> 
          </execution> 
        </executions> 
      </plugin> 
    </plugins> 
  </build> 
</project>
在 Maven 工程的 maven build 中，输入命令 deploy，即可实现发布工程信息到私服。 
如果同版本工程可能多次发布，需要修改 Nexus 配置。
10 Maven 实战
1 需求分析
基于 SSM 框架 的CRUD 案例
2 项目选型
3 项目架构设计
传统项目设计方式 --单体架构
Project
----------com.szxy
-----------------------Controller
------------------------Serviece
------------------------Pojo
------------------------Mapper
Maven项目设计方式
2 创建工程
2.1 建立 pom 父工程
<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>
    <groupId>cn.szy</groupId>
    <artifactId>MavenParent</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>pom</packaging>
    <properties>
        <junit.version>4.12</junit.version>

        <spring.version>4.1.3.RELEASE</spring.version>
        <mybatis.version>3.2.8</mybatis.version>

        <mybatis.spring.version>
            1.2.2
        </mybatis.spring.version>
            <mysql.version>5.1.32</mysql.version>
            <slf4j.version>1.6.4</slf4j.version>
            <druid.version>1.0.9</druid.version>
            <jstl.version>1.2</jstl.version>

            <servlet-api.version>2.5</servlet-api.version>
            <jsp-api.version>2.0</jsp-api.version>
            <tomcat.version>2.2</tomcat.version>
    </properties>
    <!-- jar包的依赖注入 ，由于该工程是一个父工程，所以jar包在该pom文件中只是声明 -->
    <dependencyManagement>
        <dependencies>
            <!-- 单元测试 -->
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>${junit.version}</version>
                <scope>test</scope>
            </dependency>
            <!-- 日志处理 -->
            <dependency>
                <groupId>org.slf4j</groupId>

                <artifactId>slf4j-log4j12</artifactId>
                <version>${slf4j.version}</version>
            </dependency>
            <!-- Mybatis -->
            <dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis</artifactId>
                <version>${mybatis.version}</version>
            </dependency>
            <dependency>
                <groupId>org.mybatis</groupId>

                <artifactId>mybatis-spring</artifactId>

                <version>${mybatis.spring.version}</version>
            </dependency>
            <!-- MySql -->
            <dependency>
                <groupId>mysql</groupId>

                <artifactId>mysql-connector-java</artifactId>
                <version>${mysql.version}</version>
            </dependency>
            <!-- 连接池 -->
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid</artifactId>
                <version>${druid.version}</version>
            </dependency>
            <!-- Spring -->
            <dependency>

                <groupId>org.springframework</groupId>

                <artifactId>spring-context</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>

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

                <groupId>org.springframework</groupId>

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

                <groupId>org.springframework</groupId>

                <artifactId>spring-aspects</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <!-- JSP相关 -->
            <dependency>
                <groupId>jstl</groupId>
                <artifactId>jstl</artifactId>
                <version>${jstl.version}</version>
            </dependency>
            <dependency>
                <groupId>javax.servlet</groupId>
                <artifactId>servlet-api</artifactId>
                <version>${servlet-api.version}</version>
                <scope>provided</scope>
            </dependency>
            <dependency>
                <groupId>javax.servlet</groupId>
                <artifactId>jsp-api</artifactId>
                <version>${jsp-api.version}</version>
                <scope>provided</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <!-- 插件的开启 -->
    <build>
        <!-- tomcat插件，由于子项目不一定每个都是web 项目，所以该插件只是声明，并未开启 -->
        <pluginManagement>
            <plugins>
                <!-- 配置Tomcat插件 -->
                <plugin>
                    <groupId>org.apache.tomcat.maven</groupId>

                    <artifactId>tomcat7-maven-plugin</artifactId>

                    <version>${tomcat.version}</version>
                </plugin>
            </plugins>
        </pluginManagement>

        <!-- maven的编译器插件，该插件主要是决定了当前项目所使用jre版本 。由于无论是jar，还是war项目都需要制定jar的版本，所以该插件不需要生命，应当是开启的。 -->
        <plugins>
            <plugin>

                <groupId>org.apache.maven.plugins</groupId>

                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.2</version>
                <configuration>
                    <source>1.7</source>
                    <target>1.7</target>

                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>
2.2  创建聚合 pom 工程
pom.xml 配置
当前是子模块全部创建后的 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/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
         <groupId>cn.szxy</groupId>
         <artifactId>11-manager-parent</artifactId>
         <version>0.0.1-SNAPSHOT</version>
    </parent>
    <groupId>cn.szxy</groupId>
    <artifactId>11-manager</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>pom</packaging>
    <modules>
        <module>11-manager-pojo</module>
        <module>11-manager-mapper</module>
        <module>11-manger-service</module>
        <module>11-manager-controller</module>
    </modules>
</project>
2.3  创建子模块 pojo 工程
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/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <parent>
    <groupId>cn.szxy</groupId>
    <artifactId>11-manager</artifactId>
    <version>0.0.1-SNAPSHOT</version>
  </parent>
  <artifactId>11-manager-pojo</artifactId>
</project>
2.4 创建子模块 mapper 工程
pom.xml 配置文件
添加 pojo 工程依赖
配置资源插件，复制映射文件到资源目录下
添加关于 mybatis 的 jar 包
<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>
    <parent>
        <groupId>cn.szxy</groupId>
        <artifactId>11-manager</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <artifactId>11-manager-mapper</artifactId>
    <build>
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
            </resource>
        </resources>
    </build>

    <dependencies>
        <dependency>
            <groupId>cn.szxy</groupId>
            <artifactId>11-manager-pojo</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>
        <!-- mybatis 依赖 -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
        </dependency>
        <!-- MySql -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!-- 连接池 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
        </dependency>
    </dependencies>
</project>
2.5 创建子模块 service工程
pom.xml 配置文件
添加 maaper  工程依赖
添加 spring 相关 jar 包
<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>
  <parent>
    <groupId>cn.szxy</groupId>
    <artifactId>11-manager</artifactId>
    <version>0.0.1-SNAPSHOT</version>
  </parent>
  <artifactId>11-manager-service</artifactId>
  <dependencies>
    <dependency>
        <groupId>cn.szxy</groupId>
        <artifactId>11-manager-mapper</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aspects</artifactId>
    </dependency>
  </dependencies>
</project>
2.6  创建子模块 controller 工程
spring 配置
applicationContext-Dao.xml
<?xml version="1.0" encoding="UTF-8"?> 
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:p="http://www.springframework.org/schema/p" 
    xmlns:context="http://www.springframework.org/schema/context"  
    xmlns:mvc="http://www.springframework.org/schema/mvc"  
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
    http://www.springframework.org/schema/beans/spring-beans.xsd 
    http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd 
    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"> 

     <!-- 配置解析properties文件的工具类 --> 
     <context:property-placeholder location="classpath:resource/*.properties"/> 

     <!-- 配置数据源 dataSource 阿里数据源--> 
     <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close"> 
         <property name="url" value="${jdbc.url}"/> 
          <property name="username" value="${jdbc.username}" /> 
          <property name="password" value="${jdbc.password}" /> 
          <property name="driverClassName" value="${jdbc.driver}" /> 
          <property name="maxActive" value="10" /> 
          <property name="minIdle" value="5" /> 
     </bean> 

     <!-- 创建mybatis的上下文对象  --> 
     <bean class="org.mybatis.spring.SqlSessionFactoryBean"> 
          <property name="dataSource"> 
           <ref bean="dataSource"/> 
          </property> 
          <property name="configLocation"> 
                <value>classpath:mybatis/SqlMapperClient.xml</value> 
          </property> 
     </bean> 

     <!-- 扫描mybatis的接口与映射配置文件 --> 
     <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer"> 
        <property name="basePackage" value="com.szxy.mapper"/> 
     </bean> 

</beans>
applicationContext-service.xml
<?xml version="1.0" encoding="UTF-8"?> 
<beans xmlns="http://www.springframework.org/schema/beans"  
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
       xmlns:p="http://www.springframework.org/schema/p"  
       xmlns:context="http://www.springframework.org/schema/context"  
       xmlns:mvc="http://www.springframework.org/schema/mvc"  
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
       http://www.springframework.org/schema/beans/spring-beans.xsd 
       http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd 
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"> 

        <!-- 扫描bean对象 --> 
        <context:component-scan base-package="cn.szxy.service"/> 

</beans>
applicationContext-tx.xml
<?xml version="1.0" encoding="UTF-8"?> 
<beans xmlns="http://www.springframework.org/schema/beans"  
    xmlns:context="http://www.springframework.org/schema/context" 
    xmlns:p="http://www.springframework.org/schema/p"  
    xmlns:aop="http://www.springframework.org/schema/aop" 
    xmlns:tx="http://www.springframework.org/schema/tx"  
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
    http://www.springframework.org/schema/beans/spring-beans-4.0.xsd  
    http://www.springframework.org/schema/context 
    http://www.springframework.org/schema/context/spring-context-4.0.xsd  
    http://www.springframework.org/schema/aop 
    http://www.springframework.org/schema/aop/spring-aop-4.0.xsd 
    http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd  
    http://www.springframework.org/schema/util 
    http://www.springframework.org/schema/util/springutil-4.0.xsd"> 

   <!-- 配置事物管理器的切面 -->  
   <bean id="transactionMananger" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> 
         <property name="dataSource" ref="dataSource"/>    
   </bean>     

   <!-- 配置事物传播行为 ：其实就是那些方法应该受什么样的事物控制--> 
    <tx:advice id="advice" transaction-manager="transactionMananger"> 
        <tx:attributes> 
         <tx:method name="add*" propagation="REQUIRED"/> 
         <tx:method name="modify*" propagation="REQUIRED"/> 
         <tx:method name="update*" propagation="REQUIRED"/> 
         <tx:method name="dorp*" propagation="REQUIRED"/> 
         <tx:method name="del*" propagation="REQUIRED"/> 
         <tx:method name="find*" read-only="true"/> 
        </tx:attributes> 
   </tx:advice> 

   <!-- 那些类下的方法需要参与到当前的事物管理中 。配置切点 --> 
   <aop:config> 
    <aop:advisor advice-ref="advice" 
                 pointcut="execution(* com.bjsxt.service.*.*(..))"/> 
   </aop:config> 

</beans>
springmvc.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
    http://www.springframework.org/schema/beans/spring-beans.xsd 
    http://www.springframework.org/schema/mvc 
    http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd 
    http://www.springframework.org/schema/context 
    http://www.springframework.org/schema/context/spring-context.xsd">

    <!-- 包的扫描器主要是扫描@controller -->
    <context:component-scan  base-package="com.szxy.web.controller" />

    <!-- 注册两个新对象 主要是为了来处理 springmvc中的其他anntation 如：@requestmapping -->
    <mvc:annotation-driven />

    <!-- 视图解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/jsp/" /><!-- jsp所在的前缀 -->
        <property name="suffix" value=".jsp" />
    </bean>
    <!-- 配置静态资源映射 -->
    <mvc:resources location="/WEB-INF/css/" mapping="/css/**" />
    <mvc:resources location="/WEB-INF/js/" mapping="/js/**" />
    <!-- 文件上传处理器 -->
    <!-- <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <property name="defaultEncoding" value="utf-8"></property>
        <property name="maxInMemorySize" value="1024"></property>
        单位字节
        org.springframework.web.multipart.MaxUploadSizeExc eededException
        <property name="maxUploadSize" value="1000000"></property>
    </bean> -->
</beans>
SqlMapperClient.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration
  PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  "http://mybatis.org/dtd/mybatis-3-config.dtd">

 <configuration>
    <!-- 设置分页 -->
</configuration>
db.properties
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql:///test
jdbc.username=root
jdbc.password=root
2.7 开启服务器
clean tocmat7:run

1. Maven的下载与Eclipse的整合
(1) 在Eclipse中整合Maven的步骤是什么？
1. 先去http://maven.apache.org下载想要的版本。
2. 打开eclipse 点击windows下的preferences下的maven下的installations,可以点击add添加下载的maven，点击direcrory选择后finish，OK
3. 指定mavaen的配置文件，继续点击maven下的user setting，选择browser选择setting文件。
2. 什么是Maven仓库
(1) 什么是Maven的远程仓库
       远程仓库指通过各种协议访问其他类型的仓库，这些仓库可能是第三方搭建的真实的远程仓库，用来提供他们的构件下载（如http://repo.maven.apache.org和http://uk.maven.org是Maven的中央仓库）。其他远程仓库可能是你公司拥有的建立在文件或HTTP服务器的内部仓库，用于开发团队之间的共享私有构件和管理发布的。
(2) 什么是Maven的本地仓库？
      本机下载缓存的，包含尚未发布的临时构件。
3. Maven仓库配置
(1) 如何在settings.xml文件中修改本地仓库的位置？ 
     打开setting.xml文件在标签里指定文件夹作为本体仓库。
(2) 如何在settings.xml中将远程仓库的地址改为阿里的镜像地址？
    在mirrors标签里添加marrior标签中指定镜像
4. Maven工程类型
(1) Maven有几种工程类型？
三种，分别为POM工程，JAR工程，WAR工程
(2) 每一种工程类型表示什么含义？
POM工程是逻辑工程，用在父级工程，或聚合工程中，用来做jar包的版本   控制。
JAR工程会打包成jar用作jar包使用。是常见的本地工程。
WAR工程打包成war，发布在服务器上的工程，是常见的网络工程，
5. 创建Maven工程
(1) 通过Eclipse创建Maven工程的步骤？
New下的maven project
(2) Group id、Artifact Id、Version、Packaging分别表示什么含义？
     Group id:公司域名倒写，
     Artifact id ：项目名
     Version：版本
     Packaging:项目类型
6. Maven工程目录介绍
(1) src/main/java目录的作用是什么？ 
     存储java源代码
(2) src/main/resources目录的作用是什么？
     存储资源文件
(3) src/test/java目录的作用是什么？
     存储测试代码
(4) src/test/resources目录的作用是什么？
     存储测试用的资源文件
(5) src目录的作用是什么？
     存放源代码的真实目录，包含了源代码和资源文件以及其他项目相关的文件
(6) target目录的作用是什么？
     存放编译后的文件
(7) pom.xml文件的作用是什么？
     是Maven的基础配置文件，配置项目和项目之间的关系，包含配置依赖关系			  等等。
7. Maven工程关系-依赖关系
(1) 什么是Maven工程的依赖关系？
A工程开发或运行中需要B工程提供支持，
(2) 如何在pom.xml文件中配置工程的依赖关系？
       在项目01maveDemo中的pom.xml文件中的dependencies标签中添加dependency	,添加GAV坐标。
      在项目02mavenDemo中的pom.xml文件中的dependencies标签中添加对01mavenDemo的依赖可以得到jar包。
8. Maven工程关系-继承
(1) 什么是Maven工程的继承关系？
     如果A工程继承了B工程，则A工程依赖B工程的所有资源，且可以应用B工程中定义的所有资源信息，被继承的工程只能是POM工程。
(2) 如何在pom.mxl文件中配置工程的继承关系？
     在父工程pom.xml中的dependencyManagement标签中添加dependencies标签，添加dependency ，GAV坐标。
      子工程创建时填写父工程。子工程的pom.,xml中会有parent标签，在引用依赖时只需要GA坐标，修改版本时只需要在父工程中修改版本号，所有的子工程都会换成对应的版本。
9. Maven工程关系-聚合
(1) 什么是Maven工程的聚合关系？
       当我们开发的工程有两个以上模块时，每个模块都是一个独立的功能集合，开发时每个平台都可以独立编译，测试，运行，这时我们需要一个聚合工程	。
       创建聚合工程的过程中，总的工程必须是一个POM工程，各个子模块可以使任意类型模块，所有的聚合工程必须在同一个组groupid中，，聚合工程可以嵌套。
(2) 创建聚合项目。
然后选中项目创建Maven module。
创建模块完成后聚合项目中的pom.xml文件中会有modules标签，里边为子模块
10.Maven创建war项目
创建war工程 Packaging必须为war。
     创建后的目录需要手动补全web项目的目录结构。在webapp目录下新增文件夹WEB—INFO，在WEB—INFO下新建web.xml。
常见的插件
11. Maven插件-编译器插件
(1) Maven中的编译插件的作用是什么？
     通过编译器插件可以配置使用JDK的版本
(2) 如何在pom.xml文件中配置Maven的编译插件？
     Bulid标签中的plugins标签中添加plugin，然后右击项目，选择Maven，update project，选择要更新的项目。
(3) 如何在settings.xml文件中配置全局的Maven编译插件？
     打开settings.xml找到profiles节点下添加profile
12. Maven插件-Tomcat插件
(1) Maven中的Tomcat插件的作用是什么？
     本地应用。提供tomcat功能，通过Maven的命令完成项目到tomcat的部署和启动tomcat。远程部署。
(2) 如何在pom.xml文件中配置Maven的Tomcat插件？
     pom.xml中build标签，plugins中添加
(3) 如何将启动命令与查看启动日志命令同时执行？
     点击项目run as,选择maven build，输入命令
13. Maven插件-远程热部署
(1) 什么是远程热部署？
       冷部署是指tomcat停止时把war包放到webapp中。
      远程热部署是tomcat容器运行过程中，哪个台实现web工程的部署，重新部署功能，使用maven build功能实现，具体命令为tomcat7:deploy或tomcat7:redeploy，deploy是第一次部署war工程，redeploy代表tomcat容器中已经有了同名应用，重新部署同名war工程。
       实现热部署需要远程访问tomcat容器，所以tomcat容器需要提供合适的访问方式和验证方式。
       实现热部署需要访问tomcat容器提供的原始应用manager，并提供有效有权限的访问用户，所以在tomcat	也需要提供部分配置。
(2) 如何通过Tomcat插件对项目进行远程热部署？
点击manager app管理项目时需要用户名和密码。
如何添加用户名密码？进入conf/tomcat-users.xml文件，添加。
再次启动tomcat进入tomcat主页，点击manage app后登录。
      使用tomcat完成热部署。pom.xml中的puidl标签中的pilugins中添加，把configuration改为图中。
然后使用命令重新部署功能，使用maven build功能实现，具体命令tomcat7:redeploy，redeploy代表tomcat容器中已经有了同名应用，重新部署同名war工程。可以完成远程部署。
14. Maven插件-资源拷贝插件
(1) Maven中的资源拷贝插件的作用是什么？
     Maven打包时默认只将src/main/resources里的配置文件拷贝到项目中并做打包处理，而非resources目录下的文件在打包时不会被添加到项目中。所以要使用插件可以指定资源拷贝到war包中。
(2) 如何在pom.xml文件中配置Maven的资源拷贝插件？
     在build下加resources下加resource，可以打包所有src/main/java下的所有xml文件。
15. Maven常见命令介绍
(1) Install命令的作用是什么？
     本地安装，包含编译，打包，安装到本地仓库，
     编译：javac，
     打包：jar将java代码打包为jar文件
     安装到本地仓库：将打包的jar文件，保存到本地仓库目录中。
(2) Clean命令的作用是什么？
     清理已经编译的信息，删除工程中的target目录。
(3) Compile命令的作用是什么？
     只编译，javac命令。
(4) Deploy命令的作用是什么？
     部署。常见于结合私服使用的命令。
     相当于install+上传jar到私服。
     包含编译，打包，安装到本地仓库，上传到私服。
(5) Package命令的作用是什么？
     打包。包含编译和打包两个功能。

前言： 
    最近工作中遇到了几次跟maven打包相关的问题,每个问题上网查资料解决都花了不少时间，很影响工作进度。既然遇到好几次，每次都能发现知识盲点，干脆总结整理一下，啃掉这个难啃的骨头。
     ps:最近看到了一个很有意思句子：因为今天不想跑步，所以才去跑，这是长距离跑者的思维方式。
转载： 
maven内部运行原理解析
 maven常用插件解析
 maven的三大生命周期
 查看maven插件的源码 
正文： 
    还是首先描述一下最近遇到的几个问题吧：一、初见
 springboot多模块项目mvn打包遇到的问题 - 存在依赖但却无法发现符号
     这个描述跟我遇到的问题差不多，简单说就是AB两个工程是同一个父工程(X)下的子工程,因为A是一个springboot项目,所以父工程X就把parent设置成了：  
<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.1.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
并且在A项目中配置了打包插件：  
<build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <fork>true</fork>
                </configuration>
            </plugin>
        </plugins>
    </build>
然后AB的<parent>都是X。另一个同事开发A,在里边写了一个XXXUtil类。我开发B，为了使用XXXUtil,于是在B的dependency里依赖了A。
     本地测试正常，然后就打算mvn install一下，结果就报错：  
[INFO] ------------------------------------------------------------------------
[ERROR] Failed to execute goal org.apache.maven.plugins:maven-compiler-plugin:3.7.0:compile (default-compile) on project main-jar: Compilation failure: Compilation failure: 
[ERROR] /Users/zhaohui/workspace/Projects/IDEA/packing-test/main-jar/src/main/java/com.zh/Main.java:[3,25] 程序包com.zh.sbt.common不存在
[ERROR] /Users/zhaohui/workspace/Projects/IDEA/packing-test/main-jar/src/main/java/com.zh/Main.java:[8,51] 找不到符号
[ERROR]   符号:   变量 Common2
[ERROR]   位置: 类 com.zh.Main
[ERROR] -> [Help 1]
[ERROR]
    奇怪了，测试的时候明明可以，怎么打包的时候就找不到类了呢？于是就打开A项目打出来打jar包，看一下里边是不是真的没有这个类：
zhaohuideMacBook-Pro:target zhaohui$ jar vtf spring-boot-test-1.0-SNAPSHOT.jar
...//此处省略部分输出
   350 Thu Feb 28 23:15:32 CST 2019 BOOT-INF/classes/com/zh/sbt/common/Common2.class
   347 Thu Feb 28 23:15:32 CST 2019 BOOT-INF/classes/com/zh/sbt/common/Common.class
   822 Thu Feb 28 23:15:32 CST 2019 BOOT-INF/classes/com/zh/sbt/Main.class
...//此处省略部分输出
    发现,包内的文件夹路径跟我项目的文件夹路径不一致，用luyten-0.5.3反编译代码，发现代码里的package行没有变化，所以springboot有可能使用了自定义的类加载器，把类加载器的根目录设置为了BOOT-INF/classes/，而maven打包的时候，使用的类加载器根目录就是项目根路径，所以才找不到类。
     既然是A项目打包的问题，那直接把A项目的<build>标签注释掉不就行了。说干就干，修改完果然可以正常打包了。
     然后就是提交代码，部署，结果A项目启动不起来了，报错如下：  
zhaohuideMacBook-Pro:target zhaohui$ java -jar spring-boot-test-1.0-SNAPSHOT.jar
spring-boot-test-1.0-SNAPSHOT.jar中没有主清单属性
    其实到这里思路已经比较混乱了，为什么spring-boot的打包插件能修改文件路径？为什么不用spring-boot插件就找不到主属性清单？应该用什么打包插件呢？有哪些打包插件呢？每个插件有什么区别呢？今天太累了，我不想跑步了。。。
     面对这么多疑问，大概就是这个感觉。具体怎么解决暂且不表，第一次遇到这个问题，也没有想明白这么多疑问，结果没想到，第二天，又遇到了打包的问题，而且这次的问题更让我郁闷。且听我慢慢道来... ...   
二、重逢 
    接下来就说说我的B项目，因为项目的任务是通过程序往hadoop集群提交一个mr任务，B项目的代码特别简单，就是调用yarn的api提交一个任务。
     本地测试也没有问题，我就想把代码放到线上跑一下。因为jar包需要很多依赖，就想着直接把所有的依赖都打到一个jar文件里，这样就不用上传一堆依赖jar包了。于是我使用了这个打包插件：  
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-shade-plugin</artifactId>
    <version>3.1.1</version>
    <executions>
        <execution>
            <phase>package</phase>
            <goals>
                <goal>shade</goal>
            </goals>
            <configuration>
                <transformers>
                    <transformer
                            implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                        <mainClass>com.zh.Main</mainClass>
                    </transformer>
                </transformers>
            </configuration>
        </execution>
    </executions>
</plugin>
    有了昨天的经验，在plugin里边配置里主类，应该没有问题吧，于是执行了一下jar包，然后就报了一个奇怪的错误：
[WARN ] 2019-02-28 23:59:26 [main] o.a.hadoop.util.NativeCodeLoader - Unable to load native-hadoop library for your platform... using builtin-java classes where applicable
[ERROR] 2019-02-28 23:59:26 [main] c.k.dp.dataexchange.manager.Main - Cannot initialize Cluster. Please check your configuration for mapreduce.framework.name and the correspond server addresses.
java.io.IOException: Cannot initialize Cluster. Please check your configuration for mapreduce.framework.name and the correspond server addresses.
    at org.apache.hadoop.mapreduce.Cluster.initialize(Cluster.java:120)
    at org.apache.hadoop.mapreduce.Cluster.<init>(Cluster.java:82)
    at org.apache.hadoop.mapreduce.Cluster.<init>(Cluster.java:75)
    at org.apache.hadoop.mapreduce.Job$9.run(Job.java:1260)
    at org.apache.hadoop.mapreduce.Job$9.run(Job.java:1256)
    at java.security.AccessController.doPrivileged(Native Method)
    at javax.security.auth.Subject.doAs(Subject.java:422)
    at org.apache.hadoop.security.UserGroupInformation.doAs(UserGroupInformation.java:1657)
    at org.apache.hadoop.mapreduce.Job.connect(Job.java:1255)
    at org.apache.hadoop.mapreduce.Job.submit(Job.java:1284)
    at com.kuaishou.dp.dataexchange.manager.Main.main(Main.java:95)
Exception in thread "main" java.lang.RuntimeException: 集群启动发生异常，异常信息Cannot initialize Cluster. Please check your configuration for mapreduce.framework.name and the correspond server addresses.
    at com.kuaishou.dp.dataexchange.manager.Main.main(Main.java:102)
    这报错信息是什么鬼。。。说明内容一点都不具体，看不懂，只能找到报错的代码：
private void initialize(InetSocketAddress jobTrackAddr, Configuration conf) throws IOException {
        ServiceLoader var3 = frameworkLoader;
        synchronized(frameworkLoader) {
            Iterator i$ = frameworkLoader.iterator();

            while(i$.hasNext()) {
                ClientProtocolProvider provider = (ClientProtocolProvider)i$.next();
                LOG.debug("Trying ClientProtocolProvider : " + provider.getClass().getName());
                ClientProtocol clientProtocol = null;

                try {
                    if (jobTrackAddr == null) {
                        clientProtocol = provider.create(conf);
                    } else {
                        clientProtocol = provider.create(jobTrackAddr, conf);
                    }

                    if (clientProtocol == null) {
                        LOG.debug("Cannot pick " + provider.getClass().getName() + " as the ClientProtocolProvider - returned null protocol");
                    } else {
                        this.clientProtocolProvider = provider;
                        this.client = clientProtocol;
                        LOG.debug("Picked " + provider.getClass().getName() + " as the ClientProtocolProvider");
                        break;
                    }
                } catch (Exception var9) {
                    LOG.info("Failed to use " + provider.getClass().getName() + " due to error: ", var9);
                }
            }
        }

        if (null == this.clientProtocolProvider || null == this.client) {
            throw new IOException("Cannot initialize Cluster. Please check your configuration for mapreduce.framework.name and the correspond server addresses.");
        }
    }
    先是debug，打断点，发现不打包执行没有问题，这就比较蛋疼了，排查问题都不好排查。还好有一些debug的日志可以参考。于是执行参数增加 -Xdebug，logback日志级别改成DEBUG,再次执行jar包，中间细节不再赘述，总之找到出问题的代码在这里：  
//java.util.ServiceLoader<S> line 338 hasNextService()方法
//代码逻辑简单说就是
Enumeration<URL> configs = ClassLoader.getSystemResources("META-INF/services/" + ClientProtocolProvider.class.getName());
//如果不打包，获取到的configs size为2，打印出来就是：
//org.apache.hadoop.mapred.LocalClientProtocolProvider
//org.apache.hadoop.mapred.YarnClientProtocolProvider
//如果打包，获取到的configs size为1，打印出来就是：
//org.apache.hadoop.mapred.LocalClientProtocolProvider
    搞了半天，打包修改了META-INF/services/里的内容，所以才导致了报错。
     ps:吐槽一下hadoop报错信息，完全没有描述出错的问题，导致排查浪费了很多时间。
     说实话，解决这个问题，并没有很开心，一方面花了太多时间，另一方面，这次的问题给我带来了更多的困扰：META-INF里边n多东西都是干什么的？打包的时候如何处理META-INF这个文件夹？
     最让我奇怪的是，我总共就配置了一个plugin，结果target里边打出来了三个包[xxx.jarxxx-shade.jarxxx-source.jar]除了shade以外，其他两个jar为什么会打出来呢？  
三、回首
      打包给自己的工作带来了这么多困扰，归根结底还是不知道maven到底是怎么打包的，所以遇到了具体的问题就不知道该怎么分析解决。所以这次正好整理了一下思路。虽然没有给出上边问题的具体解决方式，但是能够把思路说明白，后续再慢慢分析解决问题吧。  
     思考这个问题的入口其实就是maven的<build>这个标签，具体配置在里边的东西都起到了什么作用呢？很幸运的找到了这篇文章maven内部运行原理解析
      具体细节我就不描述了，看到这里，我的疑问是，文章中提到，每一个plugin，都要有一个<phase>和<goal>表明该插件是在哪个阶段执行的哪个方法。我的pom里边并没有配置这些，插件也照样能生效，那我怎么知道具体每个插件的这两个配置项呢？另外如果我一个plugin都没有配置，也正常打包了，这个时候使用的是什么配置呢？  
     第二个问题在maven内部运行原理解析中有提到：
在maven中，所有的PO都有一个根对象，就是Super POM。Super POM中定义了所有的默认的配置项。Super POM对应的pom.xml文件可以在maven安装目录下lib/maven-model-builder-3.0.3.jar:org/apache/maven/model/pom-4.0.0.xml中找到
     第一个问题我在这个帖子里找到了解决的方法maven常用插件解析 :  
maven-help-plugin
maven-help-plugin是一个小巧的辅助工具。
最简单的help:system可以打印所有可用的环境变量和Java系统属性。
help:effective-pom和help:effective-settings最为有用，它们分别打印项目的有效POM和有效settings，有效POM是指合并了所有父POM（包括Super POM）后的XML，
当你不确定POM的某些信息从何而来时，就可以查看有效POM。
有效settings同理，特别是当你发现自己配置的settings.xml没有生效时，就可以用help:effective-settings来验证。
此外，maven-help-plugin的describe目标可以帮助你描述任何一个Maven插件的信息，还有all-profiles目标和active-profiles目标帮助查看项目的Profile。
     所以执行mvn help:effective-pom就可以列出所有的配置项，我对空项目执行了一下这个命令，把默认的所有插件整理了一下，总结如下：
//知乎怎么还不支持表格
| parse | plugin | goal |
| ------ | ------ | ------ |
| clean | maven-clean-plugin | clean |
| process-test-resources | maven-resources-plugin | testResources |
| process-resources | maven-resources-plugin | resources |
| package | maven-jar-plugin | jar |
| compile | maven-compiler-plugin | compile |
| test-compile | maven-compiler-plugin | test-compile |
| test | maven-surefire-plugin | test |
| install | maven-install-plugin | install |
| deploy | maven-deploy-plugin | deploy |
| site | maven-site-plugin | site |
| site-deploy | maven-site-plugin | deploy |
    这里出现了maven内部运行原理解析中没有提到的几个parse:[clean/site/site-deploy]这几个的含义在这个帖子找到了答案：maven的三大生命周期
    现在知道了具体每个阶段执行的是哪个方法，剩下的只要获取插件的代码就能完整的分析整个打包流程了，代码地址：查看maven插件的源码 
    至此，整个思路就理清楚了。即使没有把这块硬骨头啃下来，至少已经放进锅里了～～
附录：
    最开始查资料的时候，没有搞清楚打包和压缩是两件事，查了一些与压缩相关的内容，其中这个帖子很有意思：RAR和ZIP:压缩大战真相
     向菲利普·卡兹致敬！！
总结： 
    最近工作接触了很多新东西，也遇到了各种个样的问题。天天一边解决问题，还要赶项目进度，每天都要搞到很晚，每当要开始整理一些东西的时候，总是想着：今天太累了，不搞了吧，早点休息养精蓄锐，明天总结。结果天天如此，一拖就是一个月。
     因为今天不想跑步，所以才去跑，这是长距离跑者的思维方式。
     而我想成为长距离跑者！
     以上
    最后，让我们保持独立思考，不卑不亢。长成自己想要的样子！ (引用自 我非常喜欢的B站up主 ”独立菌儿“->猛戳链接<-的口头禅）