一、maven-surefire-plugin

  Maven本身并不是一个单元测试框架，Java世界中主流的单元测试框架为JUnit和TestNG。Maven所做的只是在构建执行到特定生命周期阶段的时候，通过插件来执行JUnit或者TestNG的测试用例。这一插件就是maven-surefire-plugin，可以称之为测试运行器（Test Runner），他能很好的兼容JUnit 3、JUnit 4以及TestNG。
我们知道，生命周期阶段需要绑定到某个插件的目标才能完成真正的工作，test阶段正是与maven-surefire-plugin的test目标相绑定了，这是一个内置的绑定。
  在默认情况下，maven-surefire-plugin的test目标会自动执行测试源码路径（默认为src/test/java/）下所有符合一组命名模式的测试类。这组模式为：

**/Test*.java：任何子目录所有命名以Test开头的Java类。
**/*Test.java：任何子目录下所有命名以Test结尾的Java类。
**/*TestCase.java：任何子目录下所有命名以TestCase结尾的Java类。

只要将测试类按上述模式命名，Maven就能自动运行他们，用户也就不再需要定义测试集合（TestSuite）来聚合测试用例（TestCase）。关于模式需要注意的是，以Test结尾的测试类是不会得以自动执行的。

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-surefire-plugin</artifactId>
    <version>2.18.1</version>
    <configuration>
        <!--不执行测试用例-->
        <skipTests>true</skipTests>
    </configuration>
</plugin>

二、maven-javadoc-plugin

生成javadoc文档包的插件 :

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-javadoc-plugin</artifactId>
    <version>2.9.1</version>
</plugin>

三、maven-compiler-plugin

  maven是个项目管理工具，如果我们不告诉它我们的代码要使用什么样的jdk版本编译的话，它就会用maven-compiler-plugin默认的jdk版本来进行处理，这样就容易出现版本不匹配，以至于可能导致编译不通过的问题。
  maven的默认编译使用的jdk版本貌似很低，使用maven-compiler-plugin插件可以指定项目源码的jdk版本，编译后的jdk版本，以及编码。

<plugin>                                                                                                                                      
    <!-- 指定maven编译的jdk版本,如果不指定,maven3默认用jdk 1.5 maven2默认用jdk1.3 -->                                                                           
    <groupId>org.apache.maven.plugins</groupId>                                                                                               
    <artifactId>maven-compiler-plugin</artifactId>                                                                                            
    <version>3.1</version>                                                                                                                    
    <configuration>                                                                                                                           
        <!-- 一般而言，target与source是保持一致的，但是，有时候为了让程序能在其他版本的jdk中运行(对于低版本目标jdk，源代码中不能使用低版本jdk中不支持的语法)，会存在target不同于source的情况 -->                    
        <source>1.8</source> <!-- 源代码使用的JDK版本 -->                                                                                             
        <target>1.8</target> <!-- 需要生成的目标class文件的编译版本 -->                                                                                     
        <encoding>UTF-8</encoding><!-- 字符集编码 -->
        <skipTests>true</skipTests><!-- 跳过测试 -->                                                                             
        <verbose>true</verbose>
        <showWarnings>true</showWarnings>                                                                                                               
        <fork>true</fork><!-- 要使compilerVersion标签生效，还需要将fork设为true，用于明确表示编译版本配置的可用 -->                                                        
        <executable><!-- path-to-javac --></executable><!-- 使用指定的javac命令，例如：<executable>${JAVA_1_4_HOME}/bin/javac</executable> -->           
        <compilerVersion>1.3</compilerVersion><!-- 指定插件将使用的编译器的版本 -->                                                                         
        <meminitial>128m</meminitial><!-- 编译器使用的初始内存 -->                                                                                      
        <maxmem>512m</maxmem><!-- 编译器使用的最大内存 -->                                                                                              
        <compilerArgument>-verbose -bootclasspath ${java.home}\lib\rt.jar</compilerArgument><!-- 这个选项用来传递编译器自身不包含但是却支持的参数选项 -->               
    </configuration>                                                                                                                          
</plugin> 

三、maven-antrun-plugin

拷贝文件：
官网：http://maven.apache.org/plugins/maven-antrun-plugin/

引入依赖(因为要实用if for 等等这样的标签)

<dependency>
   <groupId>ant-contrib</groupId>
   <artifactId>ant-contrib</artifactId>
   <version>1.0b3</version>
</dependency>

引入插件(maven-antrun-plugin)：

<build>
    <plugins>
        <!--spring boot 项目打包插件-->
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
        <!--暂时用作指定jdk版本号-->
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <configuration>
                <source>1.7</source>
                <target>1.7</target>
            </configuration>
        </plugin>
        <!--复制jar包到指定文件目录,连接服务器,复制文件到服务器-->
        <plugin>
            <artifactId>maven-antrun-plugin</artifactId>
            <dependencies>
                <dependency>
                    <groupId>org.apache.ant</groupId>
                    <artifactId>ant-jsch</artifactId>
                    <version>1.8.2</version>
                </dependency>
            </dependencies>
            <executions>
                <execution>
                    <id>copy</id><!--需要唯一-->
                    <phase>package</phase><!--当执行package操作时执行一下任务-->
                    <configuration>
                        <tasks><!--任务-->
                            <echo message="start.................................."/><!--打印-->
                            <echo message="load maven plugin ant-contrib-1.0b3"/>
                            <!--加载plugin ant-contrib的配置文件-->
                            <taskdef resource="net/sf/antcontrib/antlib.xml">
                                <classpath><!--加载jar包,${settings.localRepository}的值是你maven settings文件中配置的本地仓库位置-->
                                    <pathelement location="${settings.localRepository}/ant-contrib/ant-contrib/1.0b3/ant-contrib-1.0b3.jar"/>
                                </classpath>
                            </taskdef>
                            <!--复制jar包-->
                            <if>
                                <equals arg1="${copy.jar}" arg2="true"/><!--是否复制jar包-->
                                <then>
                                    <echo message="Copy jar to your desired path."/>
                                    <copy todir="${copy.jar.dir}/${project.artifactId}" overwrite="true"><!--执行复制操作,todir的值是将要复制jar包到的地方,overwrite是否重写-->
                                        <fileset dir="${project.build.directory}"><!--${project.build.directory}值是你的target目录-->
                                            <include name="*.jar"/><!--target目录下的jar包-->
                                        </fileset>
                                    </copy>
                                </then>
                            </if>
                            <!--打印-->
                            <echo message="pom type:${project.packaging}"/>
                            <echo message="target path:${project.build.directory}"/>
                            <echo message="maven local repository:${settings.localRepository}"/>
                            <echo message="if pom type equals pom,delete ant generate target and antrun folder"/>
                            <echo message="${project.build.finalName}"></echo>
                            <!--
                            因为 maven-antrun-plugin 执行后,会在你的项目中生成一个target/antrun/build-main.xml,
                            在packageing=pom的项目下也会生成一个这样的文件和文件目录,个人觉得很烦,索引引入ant-contrib依赖,
                            如果你觉得不烦,可以不添加ant-contrib依赖,下边的if标签也不能使用.
                            -->
                            <!--删除-->
                            <if><!--if 标签-->
                                <equals arg1="${project.packaging}" arg2="pom"/> <!--判断当前pom文件的packageing是否是pom类型,-->
                                <then><!--如果是pom类型则删除 该项目下的target目录-->
                                    <echo message="delete ${project.build.directory}"/>
                                    <delete dir="${project.build.directory}"/>
                                </then>
                            </if>
                            <!--上传文件
                                file: 文件路径或者文件名称
                                    ${project.build.directory} 指向target目录
                                    ${project.build.finalName} 打包名称
                                todir: 目标服务器ip地址和文件路径
                            -->
                            <scp file="${project.build.directory}\${project.build.finalName}.jar"
                                 todir="username:password@ip:/root/jar_project" trust="true"/>
                            <!--连接虚拟机
                                file: 文件路径或者文件名称
                                    command 执行命令
                            -->
                            <sshexec host="ip"
                                     username="username"
                                     password="password"
                                     command="ls"
                                     trust="true"/>
                            <echo message="end.................................."/>
                        </tasks>
                    </configuration>
                    <goals><!--暂时不知道什么意思,有知道给评论一下-->
                        <goal>run</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

四、maven-dependency-plugin

  maven-dependency-plugin是处理与依赖相关的插件。它有很多可用的goal，大部分是和依赖构建、分析和解决相关的goal，这部分goal可以直接用maven的命令操作，例如：mvn dependency:tree、mvn dependency:analyze 但是我们最常用到的是 dependency:copy dependency:copy-dependencies 及dependency:unpack 　　dependency:unpack-dependencies 这四个。

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-dependency-plugin</artifactId>
    <version>2.8</version>
</plugin>

dependency:copy：将一系列在此插件内列出的artifacts ，将他们copy到一个特殊的地方，重命名或者去除其版本信息。这个可以解决远程仓库存在但是本地仓库不存在的依赖问题，copy操作可以用来将某个（些）maven artifact(s)拷贝到某个目录下。

<build>  
    <plugins>  
        <plugin>  
            <groupId>org.apache.maven.plugins</groupId>  
            <artifactId>maven-dependency-plugin</artifactId>  
            <version>2.8</version>  
            <executions>  
                <execution>  
                    <phase>package</phase>  
                    <goals>  
                        <goal>copy</goal>  
                    </goals>  
                </execution>  
            </executions>  
        </plugin>  
    </plugins>  
</build>

比如把junit拷到libs目录下:

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-dependency-plugin</artifactId>
    <version>2.8</version>
    <executions>
        <execution>
            <phase>package</phase>
            <goals>
                <goal>copy</goal>
            </goals>
            <configuration>
                <artifactItems>
                    <artifactItem>
                        <groupId>junit</groupId>
                        <artifactId>junit</artifactId>
                        <version>4.11</version>
                        <outputDirectory>${project.build.directory}/libs</outputDirectory>
                    </artifactItem>
                </artifactItems>
            </configuration>
        </execution>
    </executions>
</plugin>

执行mvn package打包命令之后，会多出libs目录:

mvn package

dependency:unpack ：unpack和copy类似，只不过它会把拷来的包解开

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-dependency-plugin</artifactId>
    <version>2.8</version>
    <executions>
        <execution>
            <phase>package</phase>
            <goals>
                <goal>unpack</goal>
            </goals>
            <configuration>
                <artifactItems>
                    <artifactItem>
                        <groupId>org.slf4j</groupId>
                        <artifactId>slf4j-log4j12</artifactId>
                        <version>1.7.7</version>
                    </artifactItem>
                    <artifactItem>
                        <groupId>junit</groupId>
                        <artifactId>junit</artifactId>
                        <version>4.11</version>
                        <outputDirectory>${project.build.directory}/libs</outputDirectory>
                    </artifactItem>
                </artifactItems>
                <outputDirectory>lib</outputDirectory>
            </configuration>
        </execution>
    </executions>
</plugin>

执行mvn package打包命令之后,slf4j复制到lib目录下,junit复制到libs目录下:

mvn package

junit和slf4j-log4j12拷完以后，放到lib和libs下的不再是Jar包，还是Jar包里的内容。
copy 和 unpack操作是由要拷某个包，这个包需要具体指定要拷哪个包，与当前工程的依赖没有关系。copy-dependencies和它有点类似，但是它是用来拷当前工程的依赖包的，典型的，例如我们有一个web应用，当打成war包的时候，它所有的依赖也需要被打到应用中。

使用maven-dependency-plugin将EAR文件从我的多模块项目的所有子模块复制到相对于整个项目根目录的目录。

to-deploy/
my-project/
    ear-module-a/
    ear-module-b/
    more-modules-1/
        ear-module-c/
        ear-module-d/
    more-modules-2/
        ear-module-e/
        ear-module-f/
    ...

希望所有的EAR文件都可以从它们各自模块的目标目录中复制到my-project/../to-deploy最终:

to-deploy/
    ear-module-a.ear
    ear-module-b.ear
    ear-module-c.ear
    ear-module-d.ear
    ear-module-e.ear
    ear-module-f.ear
my-project/
    ...

我可以在每个模块中使用相对路径来完成，如下所示：

        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-dependency-plugin</artifactId>
            <executions>
                <execution>
                    <id>copy</id>
                    <phase>install</phase>
                    <goals>
                        <goal>copy</goal>
                    </goals>
                    <configuration>
                        <artifactItems>
                            <artifactItem>
                                <groupId>${project.groupId}</groupId>
                                <artifactId>${project.artifactId}</artifactId>
                                <version>${project.version}</version>
                                <type>ear</type>
                                <outputDirectory>../../to-deploy</outputDirectory>
                            </artifactItem>
                        </artifactItems>
                    </configuration>
                </execution>
            </executions>
        </plugin>

${session.executionRootDirectory}在Maven 3.0.3的pom文件中适用于我。该属性将是您运行的目录，因此运行父项目，并且每个模块都可以获取该根目录的路径。
我把这个属性的插件配置放在父pom中，这样它就被继承了。我在配置文件中使用它，当我知道我要在父项目上运行Maven时，就会使用它。

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-dependency-plugin</artifactId>
    <executions>
        <execution>
            <id>copy-artifact</id>
            <phase>package</phase>
            <goals>
                <goal>copy</goal>
            </goals>
            <configuration>
                <artifactItems>
                    <artifactItem>
                        <groupId>${project.groupId}</groupId>
                        <artifactId>${project.artifactId}</artifactId>
                        <version>${project.version}</version>
                        <type>${project.packaging}</type>
                    </artifactItem>
                </artifactItems>
                <outputDirectory>${session.executionRootDirectory}/target/</outputDirectory>
            </configuration>
        </execution>
    </executions>
</plugin>

五、docker-maven-plugin

用来构建Docker镜像。
docker-maven-plugin有两种使用方式，一种是使用Dockerfile文件，一种是不使用Dockerfile文件。
1.在 POM中指定构建信息(不使用Dockerfile文件)
在pom.xml中引入该插件

<!-- docker-maven-plugin插件(不带Dockerfile文件) -->
<plugin>
    <groupId>com.spotify</groupId>
    <artifactId>docker-maven-plugin</artifactId>
    <version>0.4.13</version>
    <configuration>
        <!--用于指定镜像名称-->
        <imageName>${project.name}:${project.version}</imageName>
        <!--用于指定基础镜像，相当于Dockerfile中的FROM指令-->
        <baseImage>java</baseImage>
        <!--相当于Dockerfile的ENTRYPOINT指令-->
        <entryPoint>["java", "-jar", "/${project.build.finalName}.jar"]</entryPoint>
        <!--是否跳过docker build-->
        <skipDockerBuild>true</skipDockerBuild>
        <resources>
            <resource>
                <targetPath>/</targetPath>
                <!--用于指定需要复制的根目录，${project.build.directory}表示target目录-->
                <directory>${project.build.directory}</directory>
                <!--用于指定需要复制的文件。${project.build.finalName}.jar指的是打包后的jar包文件。-->
                <include>${project.build.finalName}.jar</include>
            </resource>
        </resources>
    </configuration>
</plugin>

默认情况下，该插件通过访问localhost:2375来连接本地docker，可以通过设置DOCKER_HOST 环境变量来连接docker.

DOCKER_HOST=tcp://<host>:2375

2.使用Dockerfile文件
如果使用Dockerfile文件，必须指定dockerDirectory元素，那么 baseImage, maintainer, cmd and entryPoint这些元素也会被忽略。dockerDirectory元素所指定的内容将被复制到${project.build.directory}/docker下，resources元素则会复制除此之外的其它文件，例如项目jar文件。

<!--docker-maven-plugin插件(带Dockerfile文件)-->
<plugin>
    <groupId>com.spotify</groupId>
    <artifactId>docker-maven-plugin</artifactId>
    <version>0.4.13</version>
    <configuration>
        <imageName>${project.name}:${project.version}</imageName>
        <!--Dockerfile文件位置-->
        <dockerDirectory>docker</dockerDirectory>
        <resources>
            <resource>
                <targetPath>/</targetPath>
                <directory>${project.build.directory}</directory>
                <include>${project.build.finalName}.jar</include>
            </resource>
        </resources>
    </configuration>
</plugin>

创建镜像

mvn clean package docker:build

推送镜像到Registry

mvn clean package docker:build -DpushImage

推送指定tag的镜像到Registry

mvn clean package docker:build -DpushImageTag