Maven入门教程（内含实例）

一、 maven介绍

 Maven是一个项目管理工具和构建自动化工具，它包含了一个项目对象模型(Project Object Model)，一组标准集合，一个项目生命周期(Project Lifecycle)，一个依赖管理系统(Dependency Management System)，和用来运行定义在生命周期阶段(phase)中插件(plugin)目标(goal)的逻辑。

maven约定的目录：

二、 maven的生命周期介绍

 Maven强大的一个重要的原因是它有一个十分完善的生命周期模型(lifecycle)，这个生命周期可以从两方面来理解，第一，顾名思义，运行Maven的每个步骤都由它来定义的，这种预定义的默认行为使得我们使用Maven变得简单，相比而言，Ant的每个步骤都要你手工去定义。第二，这个模型是一种标准，在不同的项目中，使用Maven的接口是一样的，这样就不用去仔细理解每个项目的构建了，一般情况下，mvn clean install 这样的命令是通用的。
 Maven有三套相互独立的生命周期，“相互独立”，这三套生命周期分别是：
   Clean Lifecycle 在进行真正的构建之前进行一些清理工作。
   Default Lifecycle 构建的核心部分，编译，测试，打包，部署等等。
   Site Lifecycle 生成项目报告，站点，发布站点。
 你可以仅仅调用clean来清理工作目录，仅仅调用site来生成站点。当然你也可以直接运行 mvn clean install site 运行所有这三套生命周期。每套生命周期都由一组阶段(Phase)组成，我们平时在命令行输入的命令总会对应于一个特定的阶段。比如，运行mvn clean，这个的clean是Clean生命周期的一个阶段。有Clean生命周期，也有clean阶段。Clean生命周期一共包含了三个阶段：
   pre-clean 执行一些需要在clean之前完成的工作
   clean 移除所有上一次构建生成的文件
   post-clean 执行一些需要在clean之后立刻完成的工作
 mvn clean 中的clean就是上面的clean，在一个生命周期中，运行某个阶段的时候，它之前的所有阶段都会被运行，也就是说，mvn clean 等同于 mvn pre-clean clean ，如果我们运行 mvn post-clean ，那么 pre-clean，clean 都会被运行。这是Maven很重要的一个规则，可以大大简化命令行的输入。下面看一下Site生命周期的各个阶段：
   pre-site 执行一些需要在生成站点文档之前完成的工作
   site 生成项目的站点文档
   post-site 执行一些需要在生成站点文档之后完成的工作，并且为部署做准备
   site-deploy 将生成的站点文档部署到特定的服务器上
 这里经常用到的是site阶段和site-deploy阶段，用以生成和发布Maven站点，这可是Maven相当强大的功能，Manager比较喜欢，文档及统计数据自动生成，很好看。
 最后，来看一下Maven的最重要的Default生命周期，绝大部分工作都发生在这个生命周期中，这里，我只解释一些比较重要和常用的阶段：
   validate
   generate-sources
   process-sources
   generate-resources
   process-resources 复制并处理资源文件，至目标目录，准备打包。
   compile 编译项目的源代码。
   process-classes
   generate-test-sources
   process-test-sources
   generate-test-resources
   process-test-resources 复制并处理资源文件，至目标测试目录。
   test-compile编译测试源代码。
   process-test-classes
   test使用合适的单元测试框架运行测试。这些测试代码不会被打包或部署。
   prepare-package
   package接受编译好的代码，打包成可发布的格式，如JAR
   pre-integration-test
   integration-test
   post-integration-test
   verify
   install将包安装至本地仓库，以让其它项目依赖。
   deploy将最终的包复制到远程的仓库，以让其它开发人员与项目共享。
 记住，运行任何一个阶段的时候，它前面的所有阶段都会被运行，这也就是为什么我们运行mvn install的时候，代码会被编译，测试，打包。此外，Maven的插件机制是完全依赖Maven的生命周期的，因此理解生命周期至关重要。

三、 maven的安装

 解压安装包后
 添加两个环境变量M2_HOME，MAVEN_HOME，在Path中加入%M2_HOME%\bin
 验证：mvn –version

四、 settings.xml文件介绍

（1）指定本地仓库

<localRepository>usr/local/maven</localRepository>

（2）设置代理

<proxies>  
        <!--代理元素包含配置代理时需要的信息 -->  
        <proxy>                 
            <!--代理的唯一定义符，用来区分不同的代理元素。 -->  
            <id>myproxy</id>                  
            <!--该代理是否是激活的那个。true则激活代理。当我们声明了一组代理，而某个时候只需要激活一个代理的时候，该元素就可以派上用处。  -->  
            <active>true</active>                  
            <!--代理的协议。 协议://主机名:端口，分隔成离散的元素以方便配置。 -->  
            <protocol>http://…</protocol>                 
            <!--代理的主机名。协议://主机名:端口，分隔成离散的元素以方便配置。   -->  
            <host>proxy.somewhere.com</host>                
            <!--代理的端口。协议://主机名:端口，分隔成离散的元素以方便配置。  -->  
            <port>8080</port>                  
             <!--代理的用户名，用户名和密码表示代理服务器认证的登录名和密码。  -->  
            <username>proxyuser</username>                  
            <!--代理的密码，用户名和密码表示代理服务器认证的登录名和密码。  -->  
            <password>somepassword</password>                 
            <!--不该被代理的主机名列表。该列表的分隔符由代理服务器指定；例子中使用了竖线分隔符，使用逗号分隔也很常见。 -->  
            <nonProxyHosts>*.google.com|ibiblio.org</nonProxyHosts>                  
        </proxy>            
    </proxies>

（3）设置镜像

<mirrors>  
        <!--给定仓库的下载镜像。  -->  
        <mirror>  
            <!--该镜像的唯一标识符。id用来区分不同的mirror元素。  -->  
            <id>planetmirror.com</id>  
            <!--镜像名称  -->  
            <name>PlanetMirror Australia</name>  
<!--该镜像的URL。构建系统会优先考虑使用该URL，而非使用默认的服务器URL -->  
            <url>http://downloads.planetmirror.com/pub/maven2</url>  
<!--被镜像的服务器的id。例如，如果我们要设置了一个Maven中央仓库（http://repo1.maven.org/maven2）的镜像-->  <!--就需要将该元素设置成central。这必须和中央仓库的id central完全一致。 -->  
            <mirrorOf>central</mirrorOf>  
        </mirror>  
    </mirrors>

（4）maven指定远程的仓库，插件的仓库

（5）指定profile特性（pom.xml中介绍）

五、 pom.xml文件介绍

（1）项目的标识

<groupId>...</groupId>
<artifactId>...</artifactId>
<version>...</version>

 通过这个来识别不同的项目，下载jar包的标识

（2）依赖管理

<dependencies>
    <dependency>
      <groupId>org.spark-project.spark</groupId>
      <artifactId>unused</artifactId>
      <version>1.0.0</version>
    </dependency>
</dependencies>
<!--父-->
  <dependencyManagement>
    <dependencies>
      <dependency>
        <groupId>org.apache.spark</groupId>
        <artifactId>spark-tags_${scala.binary.version}</artifactId>
        <version>${project.version}</version>
      </dependency>
</dependencies>
  </dependencyManagement>
<!--子-->
  <dependencies>
      <dependency>
        <groupId>org.apache.spark</groupId>
        <artifactId>spark-tags_${scala.binary.version}</artifactId>
      </dependency>
</dependencies>

 exclusions：如果X需要A,A包含B依赖，那么X可以声明不要B依赖，只要在exclusions中声明exclusion
 scope：是用来指定当前包的依赖范围

（3）build构建

<directory>${basedir}/target</directory>
<finalName>${artifactId}-${version}</finalName>
<resources>…</resources> 资源文件 name=value
targetPath，资源文件的目标路径
filtering，构建过程中是否对资源进行过滤，默认false
directory，资源文件的路径，默认位于${basedir}/src/main/resources/目录下
includes，一组文件名的匹配模式，被匹配的资源文件将被构建过程处理
excludes，一组文件名的匹配模式，被匹配的资源文件将被构建过程忽略。同时被includes和excludes匹配的资源文件，将被忽略
<plugins>…</plugins>插件管理
<pluginManagement>…</pluginManagement>插件管理

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-dependency-plugin</artifactId>
    <version>2.10</version>
    <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>

（4）profile构建

 profile可以让我们定义一系列的配置信息，然后指定其激活条件。这样我们就可以定义多个profile，然后每个profile对应不同的激活条件和配置信息，从而达到不同环境使用不同配置信息的效果。比如说，我们可以通过profile定义在jdk1.5以上使用一套配置信息，在jdk1.5以下使用另外一套配置信息；或者有时候我们可以通过操作系统的不同来使用不同的配置信息，比如windows下是一套信息，linux下又是另外一套信息，等等。profile特性可以在settings中定义也可以在pom中定义。
 profile特性有以下一些属性:

<repositories>
<pluginRepositories>
<dependencies>
<plugins>
<properties>
<dependencyManagement>
<distributionManagement>

 还有build元素下面的子元素，主要包括：

<defaultGoal>
<resources>
<testResources>
<finalName>

 profile的激活方式，Maven给我们提供了多种不同的profile激活方式。比如我们可以使用-P参数显示的激活一个profile，也可以根据环境条件的设置让它自动激活等。

<profiles>  
    <profile>  
         <id>profileTest1</id>  
         <properties>  
                <hello>world</hello>  
         </properties>  
         <activation>  
                <activeByDefault>true</activeByDefault>  
         </activation>  
    </profile>  
    <profile>  
         <id>profileTest2</id>  
         <properties>  
                <hello>andy</hello>  
         </properties>  
    </profile>  
 </profiles>

 我们可以在profile中的activation元素中指定激活条件，当没有指定条件，然后指定activeByDefault为true的时候就表示当没有指定其他profile为激活状态时，该profile就默认会被激活。所以当我们调用mvn package的时候上面的profileTest1将会被激活，但是当我们使用mvn package –P profileTest2的时候将激活profileTest2，而这个时候profileTest1将不会被激活。

<profiles>  
   <profile>  
      <id>profileTest1</id>  
      <jdk>[1.4,1.7)</jdk>  
   </profile>  
<profiles>  

 上面的情况表示在jdk为1.4、1.5和1.6的时候激活profileTest1

<profiles>  
   <profile>  
        <id>profileTest1</id>  
        <activation>  
          <os>  
               <name>Windows XP</name>  
               <family>Windows</family>  
               <arch>x86</arch>  
               <version>5.1.2600</version>  
          </os>  
        </activation>  
   </profile>  
</profiles>

 根据操作系统来激活

六、 常用插件介绍

插件名称	说明
maven-antrun-plugin	maven-antrun-plugin能让用户在Maven项目中运行Ant任务。用户可以直接在该插件的配置以Ant的方式编写Target， 然后交给该插件的run目标去执行。在一些由Ant往Maven迁移的项目中，该插件尤其有用。此外当你发现需要编写一些自定义程度很高的任务，同时又觉 得Maven不够灵活时，也可以以Ant的方式实现之。maven-antrun-plugin的run目标通常与生命周期绑定运行。
maven-archetype-plugin	Archtype指项目的骨架，Maven初学者最开始执行的Maven命令可能就是mvn archetype:generate，这实际上就是让maven-archetype-plugin生成一个很简单的项目骨架，帮助开发者快速上手。可能也有人看到一些文档写了mvn archetype:create， 但实际上create目标已经被弃用了，取而代之的是generate目标，该目标使用交互式的方式提示用户输入必要的信息以创建项目，体验更好。 maven-archetype-plugin还有一些其他目标帮助用户自己定义项目原型，例如你由一个产品需要交付给很多客户进行二次开发，你就可以为 他们提供一个Archtype，帮助他们快速上手。
maven-assembly-plugin	maven-assembly-plugin的用途是制作项目分发包，该分发包可能包含了项目的可执行文件、源代码、readme、平台脚本等等。 maven-assembly-plugin支持各种主流的格式如zip、tar.gz、jar和war等，具体打包哪些文件是高度可控的，例如用户可以 按文件级别的粒度、文件集级别的粒度、模块级别的粒度、以及依赖级别的粒度控制打包，此外，包含和排除配置也是支持的。maven-assembly- plugin要求用户使用一个名为assembly.xml的元数据文件来表述打包，它的single目标可以直接在命令行调用，也可以被绑定至生命周期。
maven-dependency-plugin	maven-dependency-plugin最大的用途是帮助分析项目依赖，dependency:list能够列出项目最终解析到的依赖列表，dependency:tree能进一步的描绘项目依赖树，dependency:analyze可以告诉你项目依赖潜在的问题，如果你有直接使用到的却未声明的依赖，该目标就会发出警告。maven-dependency-plugin还有很多目标帮助你操作依赖文件，例如dependency:copy-dependencies能将项目依赖从本地Maven仓库复制到某个特定的文件夹下面。
maven-enforcer-plugin	在一个稍大一点的组织或团队中，你无法保证所有成员都熟悉Maven，那他们做一些比较愚蠢的事情就会变得很正常，例如给项目引入了外部的 SNAPSHOT依赖而导致构建不稳定，使用了一个与大家不一致的Maven版本而经常抱怨构建出现诡异问题。maven-enforcer- plugin能够帮助你避免之类问题，它允许你创建一系列规则强制大家遵守，包括设定Java版本、设定Maven版本、禁止某些依赖、禁止 SNAPSHOT依赖。只要在一个父POM配置规则，然后让大家继承，当规则遭到破坏的时候，Maven就会报错。除了标准的规则之外，你还可以扩展该插 件，编写自己的规则。maven-enforcer-plugin的enforce目标负责检查规则，它默认绑定到生命周期的validate阶段
maven-release-plugin	maven-release-plugin的用途是帮助自动化项目版本发布，它依赖于POM中的SCM信息。release:prepare用来准备版本发布，具体的工作包括检查是否有未提交代码、检查是否有SNAPSHOT依赖、升级项目的SNAPSHOT版本至RELEASE版本、为项目打标签等等。release:perform则 是签出标签中的RELEASE源码，构建并发布。版本发布是非常琐碎的工作，它涉及了各种检查，而且由于该工作仅仅是偶尔需要，因此手动操作很容易遗漏一 些细节，maven-release-plugin让该工作变得非常快速简便，不易出错。maven-release-plugin的各种目标通常直接在 命令行调用，因为版本发布显然不是日常构建生命周期的一部分。
maven-resources-plugin	为了使项目结构更为清晰，Maven区别对待Java代码文件和资源文件，maven-compiler-plugin用来编译Java代码，maven-resources-plugin则用来处理资源文件。默认的主资源文件目录是src/main/resources，很多用户会需要添加额外的资源文件目录，这个时候就可以通过配置maven-resources-plugin来实现。此外，资源文件过滤也是Maven的一大特性，你可以在资源文件中使用${propertyName}形式的Maven属性，然后配置maven-resources-plugin开启对资源文件的过滤，之后就可以针对不同环境通过命令行或者Profile传入属性的值，以实现更为灵活的构建。
maven-surefire-plugin	可能是由于历史的原因，Maven 2/3中用于执行测试的插件不是maven-test-plugin，而是maven-surefire-plugin。其实大部分时间内，只要你的测试 类遵循通用的命令约定（以Test结尾、以TestCase结尾、或者以Test开头），就几乎不用知晓该插件的存在。然而在当你想要跳过测试、排除某些 测试类、或者使用一些TestNG特性的时候，了解maven-surefire-plugin的一些配置选项就很有用了。例如 mvn test -Dtest=FooTest 这样一条命令的效果是仅运行FooTest测试类，这是通过控制maven-surefire-plugin的test参数实现的
exec-maven-plugin	exec-maven-plugin很好理解，顾名思义，它能让你运行任何本地的系统程序，在某些特定情况下，运行一个Maven外部的程序可能就是最简单的问题解决方案，这就是exec:exec的 用途，当然，该插件还允许你配置相关的程序运行参数。除了exec目标之外，exec-maven-plugin还提供了一个java目标，该目标要求你 提供一个mainClass参数，然后它能够利用当前项目的依赖作为classpath，在同一个JVM中运行该mainClass。有时候，为了简单的 演示一个命令行Java程序，你可以在POM中配置好exec-maven-plugin的相关运行参数，然后直接在命令运行 mvn exec:java 以查看运行效果

七、 创建一个基础工程

（1）使用模板快速生成一下java工程

mvn archetype:generate -DgroupId=com.mycompany.app -DartifactId=my-app -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

（2）添加依赖

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

<dependency>
     <groupId>org.apache.spark</groupId>
  <artifactId>spark-core_2.10</artifactId>
     <version>2.1.0</version>
   </dependency>
 </dependencies>

（3）指定工程编码

<properties>
<!-- 文件拷贝时的编码 -->
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<!-- 编译时的编码 -->
<maven.compiler.encoding>UTF-8</maven.compiler.encoding>
</properties>
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>3.5.1</version>
    <configuration>
        <source>1.8</source>
        <target>1.8</target>
        <encoding>UTF-8</encoding><!-- 指定编码格式，否则在DOS下运行mvn compile命令时会出现莫名的错误，因为系统默认使用GBK编码 -->
    </configuration>
</plugin>

（4）指定java版本

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>3.5.1</version>
    <configuration>
        <source>1.8</source>
        <target>1.8</target>
        <encoding>UTF-8</encoding><!-- 指定编码格式，否则在DOS下运行mvn compile命令时会出现莫名的错误，因为系统默认使用GBK编码 -->
    </configuration>
</plugin>

在settings指定jdk的版本
<profile>
   <id>jdk18</id>
   <activation>
      <activeByDefault>true</activeByDefault>
      <jdk>1.8</jdk>
   </activation>
   <properties>
      <maven.compiler.source>1.8</maven.compiler.source>
      <maven.compiler.target>1.8</maven.compiler.target>
   </properties>
</profile>

 source指定的是源码开发的jdk版本，target指定的时编译的版本，source的版本要高于或等于target的版本，不然编译会出错。settings中的设置会初pom.xml中的覆盖。

（5）打包工程

mvn clean package

 使用maven-jar-plugin插件打包jar包，可指定依赖，添加主函数等

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-jar-plugin</artifactId>
    <version>2.6</version>
    <configuration>
        <archive>
            <manifest>
                <addClasspath>true</addClasspath>
                <classpathPrefix>lib/</classpathPrefix>
                <mainClass>leo.makukin.App</mainClass>
            </manifest>
        </archive>
    </configuration>
</plugin>

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-dependency-plugin</artifactId>
    <version>2.10</version>
    <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>

 使用maven-assembly-plugin插件打包，依赖也会打包到同一个包中

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-assembly-plugin</artifactId>
    <version>2.5.5</version>
    <configuration>
        <archive>
            <manifest>
                <mainClass>leo.makukin.App</mainClass>
            </manifest>
        </archive>
        <descriptorRefs>
            <descriptorRef>jar-with-dependencies</descriptorRef>
        </descriptorRefs>
    </configuration>
    <executions>
        <execution>
            <id>make-assembly</id>
            <phase>package</phase>
            <goals>
                <goal>single</goal>
            </goals>
        </execution>
    </executions>
</plugin>

 结合jar与assembly插件

<plugin>
     <groupId>org.apache.maven.plugins</groupId>
     <artifactId>maven-jar-plugin</artifactId>
     <version>2.6</version>
     <configuration>
         <archive>
             <manifest>
                 <addClasspath>true</addClasspath>
                 <classpathPrefix>lib/</classpathPrefix>
                 <mainClass>leo.makukin.App</mainClass>
             </manifest>
         </archive>
         <includes>
             <include>**\leo\*</include>
         </includes>
     </configuration>
 </plugin>

 <plugin>
     <groupId>org.apache.maven.plugins</groupId>
     <artifactId>maven-assembly-plugin</artifactId>
     <version>2.5.5</version>
     <configuration>
         <finalName>bigdata</finalName>
         <appendAssemblyId>false</appendAssemblyId>
         <archive>
             <manifest>
                 <mainClass>leo.makukin.App</mainClass>
             </manifest>
         </archive>
         <descriptors>
             <descriptor>src/main/assembly.xml</descriptor>
         </descriptors>
     </configuration>
     <executions>
         <execution>
             <id>make-assembly</id>
             <phase>package</phase>
             <goals>
                 <goal>single</goal>
             </goals>
         </execution>
     </executions>
 </plugin>

附录：工程完整的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/maven-v4_0_0.xsd">

  <modelVersion>4.0.0</modelVersion>
  <groupId>leo.makukin</groupId>
  <artifactId>showmaven</artifactId>
  <packaging>jar</packaging>
  <version>1.0-SNAPSHOT</version>
  <name>showmaven</name>
  <url>http://maven.apache.org</url>

  <properties>
   <!-- 文件拷贝时的编码 -->
   <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
   <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
   <!-- 编译时的编码 -->
   <maven.compiler.encoding>UTF-8</maven.compiler.encoding>
  </properties>

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

   <dependency>
      <groupId>org.apache.spark</groupId>
     <artifactId>spark-core_2.10</artifactId>
      <version>2.1.0</version>
    </dependency>
  </dependencies>

  <build>
      <finalName>leo</finalName>
      <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
         <version>3.5.1</version>
            <configuration>
                <source>1.8</source>
                <target>1.8</target>
            </configuration>
        </plugin>

       <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-jar-plugin</artifactId>
            <version>2.6</version>
            <configuration>
                <archive>
                    <manifest>
                        <addClasspath>true</addClasspath>
                        <classpathPrefix>lib/</classpathPrefix>
                        <mainClass>leo.makukin.App</mainClass>
                    </manifest>
                </archive>
                <includes>
                    <include>**\leo\*</include>
                </includes>
            </configuration>
        </plugin>

        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-assembly-plugin</artifactId>
            <version>2.5.5</version>
            <configuration>
                <finalName>bigdata</finalName>
                 <appendAssemblyId>false</appendAssemblyId>
                 <archive>
                     <manifest>
                         <mainClass>leo.makukin.App</mainClass>
                     </manifest>
                 </archive>
                 <!--<descriptorRefs>
                     <descriptorRef>jar-with-dependencies</descriptorRef>
                 </descriptorRefs>-->
                <descriptors>
                    <descriptor>src/main/assembly.xml</descriptor>
                </descriptors>
            </configuration>
            <executions>
                <execution>
                    <id>make-assembly</id>
                    <phase>package</phase>
                    <goals>
                        <goal>single</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
  </build>
</project>

 assembly配置

<assembly xmlns="http://maven.apache.org/ASSEMBLY/2.0.0"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/ASSEMBLY/2.0.0 http://maven.apache.org/xsd/assembly-2.0.0.xsd">
    <id>bin</id>
    <formats>
        <format>zip</format>
    </formats>
    <dependencySets>
        <dependencySet>
            <useProjectArtifact>true</useProjectArtifact>
            <outputDirectory>lib</outputDirectory>
            <!-- 将scope为runtime的依赖包打包到lib目录下。 -->
            <scope>runtime</scope>
        </dependencySet>
    </dependencySets>
    <fileSets>
        <fileSet>
            <directory>${project.basedir}\src\main\scripts</directory>
            <outputDirectory>\bin</outputDirectory>
            <includes>
                <include>test.sh</include>
            </includes>
        </fileSet>
        <fileSet>
            <directory>${project.basedir}\src\main\resources</directory>
            <outputDirectory>\conf</outputDirectory>
        </fileSet>
    </fileSets>
    <files>
        <file>
            <source>${project.basedir}\src\main\README.txt</source>
            <outputDirectory>\</outputDirectory>
            <destName>readme.log</destName>
        </file>
        <file>
            <source>${project.build.directory}\leo.jar</source>
            <outputDirectory>\</outputDirectory>
        </file>
    </files>
</assembly>