maven梳理

常用命令

mvn -v 或者 mvn -version 验证环境变量。
mvn help:system 打印出所有的系统属性和环境变量。
mvn compile编译项目源代码（不会编译test 目录的元代）（会产生target 文件）会去中央仓库下载项目所依赖的jar包,最后将jar 包的依赖添加classpath 路径中。
mvn test运行应用程序中的单元测试。
mvn test-compile 编译测试代码，compile 之后生成的targer 文件夹 主程序编译在classes 文件夹下面，测试程序代码放在test-classes 文件夹下。
mvn clean删除target 文件夹。
mvn install 安装项目依赖的jar 到本地仓库中。
如：mvn install:install-file -Dfile=D:/xuggle-xuggler-5.4.jar -DgroupId=com.xuggle -DartifactId=xuggle-xuggler -Dversion=5.4 -Dpackaging=jar -Dmaven.repo.local=C:/Users/zcAsus/.m2/repository
mvn clean compile test组合使用
mvn clean install

本地仓库路径配置

conf/settings.xml修改：

    <!-- localRepository
   | The path to the local repository maven will use to store artifacts.
   |
   | Default: ${user.home}/.m2/repository
  <localRepository>/path/to/local/repo</localRepository>
  -->

推荐不要去修改maven 安装目录下的conf/settings.xml （全局），建议拷贝settings.xml 到对应的本地仓库目录下面(默认：%USERPROFILE%\.m2/settings.xml)，存放路径： groupId+artifactId(com.cashew.maven+maven-demo1) 即com\cashew\maven\maven-demo1\。

settings.xml详解

远程镜像仓库配置

我们mvn compile的时候maven会去本地仓库查找是否有对应的jar（依赖）,如果没有默认会去maven 中央仓库进行下载,
Downloading:https://repo.maven.apache.org/maven2/junit/junit/xxx
maven 的中央远程仓库地址是 lib/maven-model-builder-3.3.9.jar中pom-4.0.0.xml文件：

  <!--仓库列表-->
  <repositories>
    <repository>
     <!--中央仓库的物理标识-->
      <id>central</id>  
      <!-仓库的名称--->
      <name>Central Repository</name>
      <!-- 链接的url -->
      <url>https://repo.maven.apache.org/maven2</url>
      <!--默认路径-->
      <layout>default</layout>
      <!--禁止下载 snapshot -->
      <snapshots>
        <enabled>false</enabled>
      </snapshots>
    </repository>
  </repositories>

也可以在项目的pom.xml文件中配置其他中央仓库地址:

<repositories>
        <repository>
            <!-- Maven 自带的中央仓库使用的Id为central 如果其他的仓库声明也是用该Id 就会覆盖中央仓库的配置 -->
            <id>mvnrepository</id>
            <name>mvnrepository</name>
            <url>https://mvnrepository.com/</url>
            <layout>default</layout>
            <releases>
                <enabled>true</enabled>
            </releases>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </repository>
    </repositories>

maven中央仓库服务器是在国外的,自己若要配置国内的仓库镜像，在setttings.xml中设置：

  <mirrors>
    <!-- mirror
     | Specifies a repository mirror site to use instead of a given repository. The repository that
     | this mirror serves has an ID that matches the mirrorOf element of this mirror. IDs are used
     | for inheritance and direct lookup purposes, and must be unique across the set of mirrors.
     |
    <mirror>
      <id>mirrorId</id>
      <mirrorOf>repositoryId</mirrorOf>
      <name>Human Readable Name for this Mirror.</name>
      <url>http://my.repository.com/repo/path</url>
    </mirror>
     -->
 <!--配置国内的阿里云服务器镜像-->    
<mirror>
 <id>alimaven</id>
 <name>aliyun maven</name>
  <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
<!-- 代表了一个镜像的替代位置，例如central就表示代替官方的中央库 -->
  <mirrorOf>central</mirrorOf>
 </mirror>
</mirrors>

设置多个镜像只会识别第一个镜像下载jar包。配置的多个mirror可以都放着不影响，选取一个镜像下载比较快的放在第一个就行。

国内其他镜像文件
官网说明

不知道为啥，今天发现这么配置没有起效，然后在项目的pom文件里加上这个，最后才从阿里镜像里下好jar以及插件

    <repositories>
         <repository>
             <id>nexus-aliyun</id>
             <name>Nexus aliyun</name>
             <url>http://maven.aliyun.com/nexus/content/groups/public</url>
         </repository>
     </repositories>
    <pluginRepositories>
        <pluginRepository>
            <id>central</id>
            <url>https://maven.aliyun.com/nexus/content/repositories/central/</url>
        </pluginRepository>
    </pluginRepositories>

通过 mvn -X命令，发现是读取setting.xml文件出错导致配置失效，真是的～

maven常见项目结构

src
       --main
             --java
                   --package
             --resources
       --test
             --java
                   --package
             --resources

pom.xml
src/main/java 项目的源代码所在目录
src/main/resources 项目的资源文件所在的目录
src/test/java 测试代码所在的目录
src/test/resources 测试相关的资源文件所在的目录
pom.xml  项目工程的描述文件
classes文件夹在target里

maven命令创建一个项目

第一种：

mvn archetype:generate

选择817，maven将提供 maven-archetype-quickstart骨架

再输入groupId、artifactId、version、package(与groupId同)
第二种：

mvn archetype:generate -DgroupId=com.cashew.maven -DartifactId=maven-demo -Dversion=1.0.0-SNAPSHOT -Dpackage=com.cashew.maven

第三种：

mvn archetype:crawl

会在本地仓库目录下生成archetype-catalog.xml，移动到.m2目录，配置参数，执行：

mvn archetype:generate -DarchetypeCatalog=local

快速创建一个web工程mvn archetype:generate -DgroupId=org.conan.websocket -DartifactId=websocketServer -DarchetypeArtifactId=maven-archetype-webapp

pom.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<!-- START SNIPPET: superpom -->
<project>
  <!-- 指定当前pom 的版本-->
  <modelVersion>4.0.0</modelVersion>
  <!-- 项目包名: 公司地址名称反写+项目名称-->
  <groupId>com.cashew.maven</groupId>
  <!--项目模块名称：一般为 项目名-模块名 -->
  <artifactId>maven-demo1</artifactId>
  <!-- 
    标识当前项目版本号 
    第一个.号之前的数字标识  表示大版本号
    第二个.号之前的数字标识  表示分支版本号
    第三个.号之前的数字标识  表示小版本号
    
    SNAPSHOT：快照版本
    Release 发布版本
    Alpha :内部测试版本
    GA：正式发布的版本
  -->
  <version>1.0.0SNAPSHOT</version>
  <dependencies>
  <!--
   在maven 的世界中 任何一个依赖、插件以及项目构建的输出都可以成为构件
   而构件又是通过坐标进行唯一标识的。
        官网提供的jar 是不是很多，并且随着版本升级会有不同版本的jar 
     maven 是如何快速的定位获取对于可能给的jar，就是通过坐标的思想来实现的坐标由那些元素构成？
    1. groupId
    2. artifactId
    3. version
    4. packaging: zip war jar (默认)
    5. classifer 
      -->
  
    <!--
      maven 是通过dependency 进行依赖的描述
      dependcy 是通过坐标元素groupId、artifactId、version
      来进行快速定位的，我们同时也知道一个项目会有引用多个依赖（jar）,所以又为dependency指定一个dependencies 的容器
    -->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.9</version>
    </dependency>
  </dependencies>
  
    <build>
        <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <version>2.2</version>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                        <!--指定mvn package时执行tomcat插件-->
                            <goal>run</goal>
                        </goals>
                    </execution>
                </executions> 
          </plugin>
    </build>

</project>
<!-- END SNIPPET: superpom -->

依赖范围

maven 提供三种classpath : 编译、测试、运行这三种classpath 都是有效。
compile:对于编在编测试、运行这三种classpath 都是有效
test: 测试依赖范围有效，在编译和运行项目的时候无法使用此类的依赖（典型的junit）；
provided: 对编译、测试 classpath 有效，对运行时无效（典型的serlvet）；
runtime: 运行时的依赖范围，对测试和运行有效，在编译源代码无效（典型案例：JDBC的驱动实现）；
system: 系统的依赖范围，使用system范围的依赖的时候必须通过systemPath 元素显示指定依赖文件的路径，不依赖于maven仓库解析，所以可能会造成构建不可移植，慎用！

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

依赖传递

employee 依赖manager, manager依赖boss
employee 通过传递 间接也依赖于boss，排除对boss的依赖：

   <dependency>
            <groupId>com.cashew.maven</groupId>
            <artifactId>company-manager</artifactId>
            <version>0.0.1-SNAPSHOT</version>
            <exclusions>
                <exclusion>
                    <groupId>com.cashew.maven</groupId>
                    <artifactId>company-boss</artifactId>
                </exclusion>
            </exclusions>
   </dependency>

依赖冲突

employee --->manager(commons-io 2.0)--->boss(commons-io 2.4)

1.短路优先
A--->B--->C---D(1.0.jar)
A--->B--->C(2.0.jar)
A只会有2.0的包

2.相同路径的时候 先声明先使用
employee--->manager
employee--->boss
manager先声明，则A只会有2.0的包

聚合工程

maven 是以模块的概念进行项目描述的。
现有A、B、C多个模块的过程，需要聚合到一起，可以新建一个聚合工程,在该工程的pom.xml中配置：

<packaging>pom</packaging>

并添加模块依赖列表

     <modules>
          <module>../A</module>
          <module>../B</module>
          <module>../C</module>
      </modules>

直接在聚合项目install或pakeage即可同时打所有的模块项目

父子工程

可以将多个模块工程的一些共性依赖进行向上的抽取，并组成maven父工程。
如：employee 、manager、boss都有junit 依赖，那么可以单独的去定义一个maven项目封装这些共性的依赖，称为父类 maven项目。在该工程的pom.xml中配置：

 <packaging>pom</packaging>

使用dependencyManagement 元素来提供一种管理依赖版本号的方式，让所在在子项目中引用一个依赖而不用显示的列出版本号，maven 会沿着父子层次向上走，直到找到使用dependencyManagement的元素的项目 然后它就会使用dependencyManagement 元素的指定的版本号：

 <dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>${junit.version}</version>
      <scope>test</scope>
    </dependency>
  </dependencies>
  </dependencyManagement>

父工程不需要运行，删除src/test/java
子模块工程要继承父工程，添加：

     <parent>
        <groupId>com.cashew.maven</groupId>
        <artifactId>company-parent</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>

修改对应的依赖：

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
        </dependency>
    <dependencies>

好处：如果有多个子项目都引用都一个依赖，则可避免在每个使用的子项目中都声明一个版本号，当升级或者切换版本的时候，只需要在顶层父容器里更新即可。

build模块里配置文件的配置

• 这种配置文件既出现在jar包里，又在编译文件夹里。filtering标签是开关，可关闭配置的过滤条件。默认maven编译、打包是不会要这些文件的。

        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                    <include>**/*.yml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
        </resources>

• resources下的配置文件会在编译时放到<targetPath>下，但不会出现在jar包里

        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <!-- 将<directory>目录下的文件打包到<targetPath>下，但不会出现在jar包里 -->
                <targetPath>${project.build.directory}</targetPath>
                <excludes>
                    <exclude>**/*.java</exclude>
                </excludes>
            </resource>
        </resources>

• 这种更狠，编译目录target里也没有，适用于将配置文件提取到jar包外进行统一管理的情况

       <resources>
            <resource>
                <directory>src/main/resources</directory>
                <!--打包时排除配置文件-->
                <excludes>
                    <exclude>**/*.properties</exclude>
                    <exclude>**/*.xml</exclude>
                    <exclude>**/*.yml</exclude>
                </excludes>
                <filtering>true</filtering>
            </resource>
        </resources>

  项目启动时通过命令的方式指定项目加载核心配置文件：
  java –jar -Dspring.config.location=xxx/xxx/xxxx.properties xxxx.jar

build模块里依赖包的配置

在plugins标签下（idea都有内置maven插件，没有特殊要求，可不配，不配置是没有依赖包被提出来），但可以写命令使得依赖包打进去：

mvn -DoutputDirectory=./lib 
         -DgroupId=com.cashew
         -DartifactId=myProject 
         -Dversion=1.0-SNAPSHOT 
         dependency:copy-dependencies

• 将项目依赖包复制到<outputDirectory>指定的目录下，jar包里没有
  ${project.build.directory}即target目录。

            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-dependency-plugin</artifactId>
                <executions>
                    <execution>
                        <id>copy-dependencies</id>
                        <phase>package</phase>
                        <goals>
                            <goal>copy-dependencies</goal>
                        </goals>
                        <configuration>
                            <outputDirectory>
                                ${project.build.directory}/lib
                            </outputDirectory>
                        </configuration>
                    </execution>
                </executions>
            </plugin>

• 将项目依赖包的路径（与上一项中的<outputDirectory>对应，和上面的一起使用）添加到classPath中
  并且不把配置文件打入包中

           <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-jar-plugin</artifactId>
                <configuration>
                    <archive>
                        <manifest>
                            <addClasspath>true</addClasspath>
                             <!--指定依赖资源路径前缀-->
                            <classpathPrefix>lib/</classpathPrefix>
                            <mainClass>com.cashew.Test1BasicDesignMode.singleMode.byEnum.T3Test00</mainClass>
                        </manifest>
                        <manifestEntries>
                            <Class-Path>./</Class-Path>
                        </manifestEntries>
                    </archive>
                    <excludes>
                        <exclude>*.properties</exclude>
                        <exclude>*.yml</exclude>
                        <exclude>*.xml</exclude>
                        <exclude>config/**</exclude>
                    </excludes>
                </configuration>
            </plugin>
  

• 使用该插件，打包时会多一个jar-with-dependencies的包，即集成了依赖包的包

            <plugin>
                <artifactId>maven-assembly-plugin</artifactId>
                <configuration>
                    <descriptorRefs>
                        <descriptorRef>jar-with-dependencies</descriptorRef>
                    </descriptorRefs>
                    <archive>
                        <manifest>
                            <mainClass>com.cashew.tricks.Test</mainClass>
                        </manifest>
                    </archive>
                </configuration>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>single</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>

---

Maven profile配置管理及激活profile的几种方式

mybatis逆向工程插件

        <plugin>
            <!-- 命令：mybatis-generator:generate -e -->
            <groupId>org.mybatis.generator</groupId>
            <artifactId>mybatis-generator-maven-plugin</artifactId>
            <version>1.4.0</version>
            <configuration>
                <configurationFile>src/main/resources/generatorConfig.xml</configurationFile>
                <verbose>true</verbose>
                <overwrite>true</overwrite>
            </configuration>
            <dependencies>
        <dependency>
            <groupId>org.mybatis.generator</groupId>
            <artifactId>mybatis-generator-core</artifactId>
            <version>1.4.0</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.37</version>
        </dependency>
         </dependencies>
         <executions>
            <execution>
                 <id>Generate MyBatis Artifacts</id>
                 <phase>deploy</phase>
                 <goals>
                 <goal>generate</goal>
                 </goals>
             </execution>
       </executions>
    </plugin>