1. 背景
 
工程中免不了要通过maven打包。
 
2. maven三种打包插件
 
plugin
 
function
 
site
 
maven-jar-plugin
 
maven 默认打包插件，用来创建 project jar
 
maven-shade-plugin
 
用来打可执行包，executable(fat) jar
 
http://maven.apache.org/plugins/maven-shade-plugin/
 
maven-assembly-plugin
 
支持定制化打包方式，例如，apache 项目的打包方式
 
http://maven.apache.org/components/plugins/maven-assembly-plugin/
 
我们主要打zip包，也就是使用maven-assembly-plugin。
 
3. maven assembly plugin
 
maven assembly plugin允许用户将依赖项、模块、文档和其他文件聚合到一个可发布的归档文件中。
 
我们可以通过预制的描述文件打包文件，这些描述可以处理常见操作，比如打包工程包和文件到一个zip文件里面。
 
其实我们也可以自定义描述文件对依赖包，模块，file-sets和单个文件更高级别的控制。
 
当前支持如下格式的文件打包：
 
zip
 
tar
 
tar.gz (or tgz)
 
tar.bz2 (or tbz2)
 
tar.snappy
 
tar.xz (or txz)
 
jar
 
dir
 
war
 
and any other format that the ArchiveManager has been configured for
 
假如你想把工程打包成一个uber-jar，可以参考Maven Shade Plugin，不在本文讨论范围。
 
使用maven assembly plugin的步骤如下：
 
在工程的pom.xml文件里面配置assembly plugin
 
运行mvn assembly:single命令
 
4. 实例
 
首先给个官方的demo地址
 
4.1 创建一个maven工程mvnassembly
 

 
为了演示创建lib文件夹，放入随意两个jar包，创建资源目录src/main/resources，并随机放入一个文件。
 
创建完之后目录结构如下：
 

 
4.2 自定义assembly描述文件-assembly.xml
 
assembly.xml文件与pom.xml同级，内容如下：
 
描述文件格式请参考：http://maven.apache.org/components/plugins/maven-assembly-plugin/assembly.html
 
myzip
 
zip
 
lib
 
lib
 
src/main/resources
 
.
 
lib
 
false
 
runtime
 
4.3 在工程的pom.xml文件里面配置assembly plugin
 
4.0.0
 
com.lujiango
 
mvnassembly
 
0.0.1-SNAPSHOT
 
jar
 
mvnassembly
 
http://maven.apache.org
 
UTF-8
 
junit
 
junit
 
3.8.1
 
test
 
org.apache.commons
 
commons-collections4
 
4.0
 
org.apache.maven.plugins
 
maven-assembly-plugin
 
2.2
 
assembly.xml
 
make-assembly
 
package
 
single
 
4.4 打包
 
因为我使用的是eclipse，所以我直接通过右击工程->Run As-> Maven clean，然后在右击工程->Run As->Maven install，就可以打包了。
 
4.5 检查zip包
 
打出的包为mvnassembly-0.0.1-SNAPSHOT-myzip.zip，符合artifactId-version-id.zip命名格式。
 
打开zip包，是一个文件夹：
 

 
点击进入：
 

 
进入lib目录：
 

 
验证是OK。

 
“打包“这个词听起来比较土，比较正式的说法应该是”构建项目软件包“，具体说就是将项目中的各种文件，比如源代码、编译生成的字节码、配置文件、文档，按照规范的格式生成归档，最常见的当然就是JAR包和WAR包了，复杂点的例子是，它有自定义的格式，方便用户直接解压后就在命令行使用。作为一款”打包工具“，Maven自然有义务帮助用户创建各种各样的包，规范的JAR包和WAR包自然不再话下，略微复杂的自定义打包格式也必须支持，本文就介绍一些常用的打包案例以及相关的实现方式，除了前面提到的一些包以外，你还能看到如何生成源码包、Javadoc包、以及从命令行可直接运行的CLI包。
 
Packaging的含义
 
任何一个Maven项目都需要定义POM元素packaging(如果不写则默认值为jar)。顾名思义，该元素决定了项目的打包方式。实际的情形中，如果你不声明该元素，Maven会帮你生成一个JAR包；如果你定义该元素的值为war，那你会得到一个WAR包；如果定义其值为POM(比如是一个父模块)，那什么包都不会生成。除此之外，Maven默认还支持一些其他的流行打包格式，例如ejb3和ear。你不需要了解具体的打包细节，你所需要做的就是告诉Maven，”我是个什么类型的项目“，这就是约定优于配置的力量。
 
为了更好的理解Maven的默认打包方式，我们不妨来看看简单的声明背后发生了什么，对一个jar项目执行mvn package操作，会看到如下的输出：
 
[INFO] --- maven-jar-plugin:2.3.1:jar (default-jar) @ git-demo ---
 
[INFO] Building jar: /home/juven/git_juven/git-demo/target/git-demo-1.2-SNAPSHOT.jar
 
相比之下，对一个war项目执行mvn package操作，输出是这样的：
 
[INFO] --- maven-war-plugin:2.1:war (default-war) @ webapp-demo ---
 
[INFO] Packaging webapp
 
[INFO] Assembling webapp [webapp-demo] in [/home/juven/git_juven/webapp-demo/target/webapp-demo-1.0-SNAPSHOT]
 
[INFO] Processing war project
 
[INFO] Copying webapp resources [/home/juven/git_juven/webapp-demo/src/main/webapp]
 
[INFO] Webapp assembled in [90 msecs]
 
[INFO] Building war: /home/juven/git_juven/webapp-demo/target/webapp-demo-1.0-SNAPSHOT.war
 
对应于同样的package生命周期阶段，Maven为jar项目调用了maven-jar-plugin，为war项目调用了maven-war-plugin，换言之，packaging直接影响Maven的构建生命周期。了解这一点非常重要，特别是当你需要自定义打包行为的时候，你就必须知道去配置哪个插件。一个常见的例子就是在打包war项目的时候排除某些web资源文件，这时就应该配置maven-war-plugin如下：
 
org.apache.maven.plugins
 
maven-war-plugin
 
2.1.1
 
src/main/webapp
 
**/*.jpg
 
源码包和Javadoc包
 
本专栏的《坐标规划》一文中曾解释过，一个Maven项目只生成一个主构件，当需要生成其他附属构件的时候，就需要用上classifier。源码包和Javadoc包就是附属构件的极佳例子。它们有着广泛的用途，尤其是源码包，当你使用一个第三方依赖的时候，有时候会希望在IDE中直接进入该依赖的源码查看其实现的细节，如果该依赖将源码包发布到了Maven仓库，那么像Eclipse就能通过m2eclipse插件解析下载源码包并关联到你的项目中，十分方便。由于生成源码包是极其常见的需求，因此Maven官方提供了一个插件来帮助用户完成这个任务：
 
org.apache.maven.plugins
 
maven-source-plugin
 
2.1.2
 
attach-sources
 
verify
 
jar-no-fork
 
类似的，生成Javadoc包只需要配置插件如下：
 
org.apache.maven.plugins
 
maven-javadoc-plugin
 
2.7
 
attach-javadocs
 
jar
 
为了帮助所有Maven用户更方便的使用Maven中央库中海量的资源，中央仓库的维护者强制要求开源项目提交构件的时候同时提供源码包和Javadoc包。这是个很好的实践，读者也可以尝试在自己所处的公司内部实行，以促进不同项目之间的交流。
 
可执行CLI包
 
除了前面提到了常规JAR包、WAR包，源码包和Javadoc包，另一种常被用到的包是在命令行可直接运行的CLI(Command Line)包。默认Maven生成的JAR包只包含了编译生成的.class文件和项目资源文件，而要得到一个可以直接在命令行通过java命令运行的JAR文件，还要满足两个条件：
 
JAR包中的/META-INF/MANIFEST.MF元数据文件必须包含Main-Class信息。
 
项目所有的依赖都必须在Classpath中。
 
Maven有好几个插件能帮助用户完成上述任务，不过用起来最方便的还是maven-shade-plugin，它可以让用户配置Main-Class的值，然后在打包的时候将值填入/META-INF/MANIFEST.MF文件。关于项目的依赖，它很聪明地将依赖JAR文件全部解压后，再将得到的.class文件连同当前项目的.class文件一起合并到最终的CLI包中，这样，在执行CLI JAR文件的时候，所有需要的类就都在Classpath中了。下面是一个配置样例：
 
org.apache.maven.plugins
 
maven-shade-plugin
 
1.4
 
package
 
shade
 
com.juvenxu.mavenbook.HelloWorldCli
 
上述例子中的，我的Main-Class是com.juvenxu.mavenbook.HelloWorldCli，构建完成后，对应于一个常规的hello-world-1.0.jar文件，我还得到了一个hello-world-1.0-cli.jar文件。细心的读者可能已经注意到了，这里用的是cli这个classifier。最后，我可以通过java -jar hello-world-1.0-cli.jar命令运行程序。
 
自定义格式包
 
实际的软件项目常常会有更复杂的打包需求，例如我们可能需要为客户提供一份产品的分发包，这个包不仅仅包含项目的字节码文件，还得包含依赖以及相关脚本文件以方便客户解压后就能运行，此外分发包还得包含一些必要的文档。这时项目的源码目录结构大致是这样的：
 
pom.xml
 
src/main/java/
 
src/main/resources/
 
src/test/java/
 
src/test/resources/
 
src/main/scripts/
 
src/main/assembly/
 
README.txt
 
除了基本的pom.xml和一般Maven目录之外，这里还有一个src/main/scripts/目录，该目录会包含一些脚本文件如run.sh和run.bat，src/main/assembly/会包含一个assembly.xml，这是打包的描述文件，稍后介绍，最后的README.txt是份简单的文档。
 
我们希望最终生成一个zip格式的分发包，它包含如下的一个结构：
 
bin/
 
lib/
 
README.txt
 
其中bin/目录包含了可执行脚本run.sh和run.bat，lib/目录包含了项目JAR包和所有依赖JAR，README.txt就是前面提到的文档。
 
描述清楚需求后，我们就要搬出Maven最强大的打包插件：maven-assembly-plugin。它支持各种打包文件格式，包括zip、tar.gz、tar.bz2等等，通过一个打包描述文件(该例中是src/main/assembly.xml)，它能够帮助用户选择具体打包哪些文件集合、依赖、模块、和甚至本地仓库文件，每个项的具体打包路径用户也能自由控制。如下就是对应上述需求的打包描述文件src/main/assembly.xml：
 
bin
 
zip
 
true
 
lib
 
/
 
README.txt
 
src/main/scripts
 
/bin
 
run.sh
 
run.bat
 
首先这个assembly.xml文件的id对应了其最终生成文件的classifier。
 
其次formats定义打包生成的文件格式，这里是zip。因此结合id我们会得到一个名为hello-world-1.0-bin.zip的文件。(假设artifactId为hello-world，version为1.0)
 
dependencySets用来定义选择依赖并定义最终打包到什么目录，这里我们声明的一个depenencySet默认包含所有所有依赖，而useProjectArtifact表示将项目本身生成的构件也包含在内，最终打包至输出包内的lib路径下(由outputDirectory指定)。
 
fileSets允许用户通过文件或目录的粒度来控制打包。这里的第一个fileSet打包README.txt文件至包的根目录下，第二个fileSet则将src/main/scripts下的run.sh和run.bat文件打包至输出包的bin目录下。
 
打包描述文件所支持的配置远超出本文所能覆盖的范围，为了避免读者被过多细节扰乱思维，这里不再展开，读者若有需要可以去参考这份文档。
 
最后，我们需要配置maven-assembly-plugin使用打包描述文件，并绑定生命周期阶段使其自动执行打包操作：
 
org.apache.maven.plugins
 
maven-assembly-plugin
 
2.2.1
 
src/main/assembly/assembly.xml
 
make-assembly
 
package
 
single
 
运行mvn clean package之后，我们就能在target/目录下得到名为hello-world-1.0-bin.zip的分发包了。
 
小结
 
打包是项目构建最重要的组成部分之一，本文介绍了主流Maven打包技巧，包括默认打包方式的原理、如何制作源码包和Javadoc包、如何制作命令行可运行的CLI包、以及进一步的，如何基于个性化需求自定义打包格式。这其中涉及了很多的Maven插件，当然最重要，也是最为复杂和强大的打包插件就是maven-assembly-plugin。事实上Maven本身的分发包就是通过maven-assembly-plugin制作的，感兴趣的读者可以直接查看源码一窥究竟。
 
=====================================================================
 
将一个带有main函数的example.java打包成JAR(java文件必须带有main函数，这样打包成的JAR才能双击直接运行)
 
一、编译example.java，得到example.class文件
 
二、准备一个清单文件manifest.mf，此文件和example.class在同一目录里
 
可以先建一个mainfest.txt文件，然后再把扩展名改成.mf
 
用记事本打开manifest.mf，在里面输入
 
main-class: example
 
(注意冒号后有一个空格，而且example后必须有一个换行)
 
三、打开命令提示符(前提是系统的path路径和classpath路径都已经设置好了)，在里面输入
 
jar cvfm example.jar manifest.mf example.class
 
(c:新建一个JAR文件
 
v:输出打包结果
 
f:JAR文件名
 
m:清单文件名)
 
四、如果example.java编译后得到多个class文件，例如：example1.class、example2.class
 
则在CMD里输入
 
jar cvfm example.jar manifest.mf example1.class example2.class
 
五、若得到多个编译文件，也可以将这些class文件全部移入一个新的文件夹(例如classes文件夹，classes文件夹和manifest.mf文件在同一目录)
 
然后在CMD里输入：
 
jar cvfm example.jar manifest.mf -C classses/ .
 
(/和.之间有一个空格)

maven 打包详解
 
Maven可以使用mvn package指令对项目进行打包。
 
可能会遇见的问题
 
如果使用Java -jar xxx.jar执行运行jar文件，会出现"no main manifest attribute, in xxx.jar"（没有设置Main-Class）、ClassNotFoundException（找不到依赖包）、”没有主清单属性“ 等错误。
 
要想jar包能直接通过java -jar xxx.jar运行，需要满足：
 
1、在jar包中的META-INF/MANIFEST.MF中指定Main-Class，这样才能确定程序的入口在哪里；
 
2、要能加载到依赖包。
 
使用Maven有以下几种方法可以生成能直接运行的jar包，可以根据需要选择一种合适的方法。
 
方法一：使用maven-jar-plugin和maven-dependency-plugin插件打包
 
这种方式生成jar包有个缺点，就是生成的jar包太多不便于管理，其它两种方式只生成一个jar文件，包含项目本身的代码、资源以及所有的依赖包。
 
<build>
        <plugins>
            <!--      配置打包，并配置MainClass， 但不将依赖包打包，会出现找不到依赖的异常    -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-jar-plugin</artifactId>
                <configuration>
                    <archive>
                        <manifest>
                            <addClasspath>true</addClasspath>
                            <!--   MANIFEST.MF 中 Class-Path -->
                            <classpathPrefix>lib/</classpathPrefix>
                            <mainClass>cn.zoom.wqz.filter.Application</mainClass>
                        </manifest>
                    </archive>
                </configuration>
            </plugin>
            <!--      配置依赖包      -->
            <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>
                            <!--              将依赖包打包至target下的lib目录              -->
                            <outputDirectory>${project.build.directory}/lib</outputDirectory>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
 
方法二：使用maven-assembly-plugin插件打包
 
打包方式：
 
mvn package assembly:single  
 
配置方式：
 
<plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-assembly-plugin</artifactId>
        <configuration>
            <archive>
                <manifest>
                    <mainClass>cn.zoom.wqz.filter.Application</mainClass>
                </manifest>
            </archive>
            <descriptorRefs>
                <descriptorRef>jar-with-dependencies</descriptorRef>
            </descriptorRefs>
        </configuration>
    </plugin>
 
打包后会在target目录下生成一个xxx-jar-with-dependencies.jar文件，这个文件不但包含了自己项目中的代码和资源，还包含了所有依赖包的内容。所以可以直接通过java -jar来运行。
 
此外还可以直接通过mvn package来打包，无需assembly:single，不过需要加上一些配置：
 
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-assembly-plugin</artifactId>
                <configuration>
                    <archive>
                        <manifest>
                            <mainClass>cn.zoom.wqz.filter.Application</mainClass>
                        </manifest>
                    </archive>
                    <descriptorRefs>
                        <descriptorRef>jar-with-dependencies</descriptorRef>
                    </descriptorRefs>
                </configuration>
                <!-- 其中<phase>package</phase>、<goal>single</goal>即表示在执行package打包时，执行assembly:single -->
                <executions>
                    <execution>
                        <id>make-assembly</id>
                        <phase>package</phase>
                        <goals>
                            <goal>single</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
 
不过，如果项目中用到spring Framework，用这种方式打出来的包运行时会出错，使用下面的方法三可以处理。
 
方法三：使用maven-shade-plugin插件打包
 
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                        <configuration>
                            <transformers>
                                <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                    <mainClass>cn.zoom.wqz.filter.Application</mainClass>
                                </transformer>
                            </transformers>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
 
配置完成后，执行mvn package即可打包。在target目录下会生成两个jar包，注意不是original-xxx.jar文件，而是另外一个。和maven-assembly-plugin一样，生成的jar文件包含了所有依赖，所以可以直接运行。
 
如果项目中用到了Spring Framework，将依赖打到一个jar包中，运行时会出现读取XML schema文件出错。原因是Spring Framework的多个jar包中包含相同的文件spring.handlers和spring.schemas，如果生成一个jar包会互相覆盖。为了避免互相影响，可以使用AppendingTransformer来对文件内容追加合并：
 
<plugin>
        <groupid>org.apache.maven.plugins</groupid>
        <artifactid>maven-shade-plugin</artifactid>
        <executions>
            <execution>
                <phase>package</phase>
                <goals>
                    <goal>shade</goal>
                </goals>
                <configuration>
                    <transformers>
                        <transformer implementation="org.apache.maven.plugins.shade.resource.manifestresourcetransformer">
                            <mainclass>cn.zoom.wqz.filter.application</mainclass>
                        </transformer>
                        <transformer implementation="org.apache.maven.plugins.shade.resource.appendingtransformer">
                            <resource>meta-inf/spring.handlers</resource>
                        </transformer>
                        <transformer implementation="org.apache.maven.plugins.shade.resource.appendingtransformer">
                            <resource>meta-inf/spring.schemas</resource>
                        </transformer>
                    </transformers>
                </configuration>
            </execution>
        </executions>
    </plugin>
 
如果不是springboot 但是想要运行指定的main方法入口的时候，需要在pom文件中指定，打包的时候才能写入。以上的方法有提到使用maven-assembly-plugin插件来打包的时候会生成两个jar，使用是后缀为xxxx-jar-with-dependencies.jar 这个包
 希望本篇文章能够对你有所帮助，我因为这个找不到main入口，花费了大量的时间。

 

 
Maven打包,包含第三方依赖失败
 
目标 1. 将依赖第三方jar包都打进去2. 将工程java 目录下所有文件夹和配置文件，包括资源文件都打入jar包，根据目录来3. 打出jar文件可直接运行方法：采用 maven-assembly-plugin环境：IDEA 14.1.5 JDK 1.8其中**/*写法，是为了保证各级子目录下的资源文件被打包，svn相关文件排除。
 
pom.xml 写法src/main/java**/***/.svn/*falseorg.apache.maven.pluginsmaven-compiler-plugin2.3.21.8
 
java maven 打包怎么只带部分依赖
 
addClasspath>javamaven-war-pluginorg.apache;artifactId>goals>copy-dependenciesmainClass>com.xx;outputDirectory>/artifactId>encoding>build>maven打包的时候有些jar包是不在mavencenter的。
 
需要在pom中引入相关的本地jar包；execution>copyexecution>maven-jar-plugin/source>1.5&lt.apache.maven.pluginsUTF-8&lt。
 
当然也是可以打包其他的文件的，诸如xml,properties等的；systemPath>/artifactId>org;manifest>/configuration>configuration>true&lt，可以使用plugin，默认将lib下的所有jar文件打包到WEB-INF/lib下.ik-analyzerplugin>artifactId>dependency>configuration>phase>installsystemorg.apache;/plugin>maven-dependency-plugin1.5/goal>version>2.3/archive>configuration>/configuration>/addClasspath>${project;warName>lib/WEB-INF/lib**/*.jar;groupId>ik-analyzermaven-compiler-pluginsourceDirectory>src/main/outputDirectory>${project.build.directory}3;/scope>${project;artifactId>
 
maven provided jar 包也会打进去怎么解决
 
注意scope标签，compile和runtime两种依赖打包时会打进去，provided、system、test都不会打进去。
 
如果不想打包时将依赖包含进去，可以按实际情况选择后面的方式。
 
maven本身引用时，在没有打包前，这些jar都是存储在maven的repository里面给所有项目共享的，这也是maven的目标之一。
 
如下图，请看jar包的路径。
 
用maven打包jar项目其中很多模块引用了相同jar包,如何把它些jar公...
 
注意scope标签，compile和runtime两种依赖打包时会打进去，provided、system、test都不会打进去。
 
如果不想打包时将依赖包含进去，可以按实际情况选择后面的方式。
 
maven本身引用时，在没有打包前，这些jar都是存储在maven的repository里面给所有项目共享的，这也是maven的目标之一。
 
如下图，请看jar包的路径。
 
Maven依赖管理的jar文件在打包后可部署文件中的位置？
 
使用maven-assembly-plugin，配合assembly.xml:org.apache.maven.pluginsmaven-assembly-plugin2.4truefalsesrc/main/assembly/assembly.xmltruejp.co.nec.nhm.df.entrance.Entrancemake-assemblypackageassembly
 
怎么使用maven package命令
 
此命令包含一系列过程：validate-->compile-->test-->package;Maven根据pom文件里packaging的配置，决定是生成jar文件还是war文件，并放到target目录下。
 
(注：此命令需要在项目的根目录(也就是pom.xml文件所在的目录)下运行，Maven才知道打包哪个项目。
 
)如何用maven打包可执行的jar方法一：将项目及所依赖的所有jar包打包成一个jar。
 
1、pom.xml添加assembly插件 2、执行mvn assembly:assembly3、生成如文件4、执行java -jar quickstart-1.0.0-jar-with-dependencies.jar 备注：第2步的命令也可以改成mvn package，但需要更改pom.xml：方法二：将项目依赖的jar复制到一个目录中并在MANIFEST文件中添加Class-Path和Main-Class。
 
1、在pom.xml中添加jar和dependency插件 2、执行mvn package 3、生成文件4、执行java -jar quickstart-1.0.0.jar...
 
maven activebydefault不生效怎么办
 
1.Java-maven异常-cannot be cast to javax.servlet.Filter 报错tomcat 启动后先将tomcat/lib目录下的jar包全部读入内存，如果webapps目录里的应用程序中WEB-INF/lib目录下有相同的包，将无法加载，报错的Filter实现了javax.servlet.Filter接口，Filter是在servlet-api.jar里。
 
解决这个问题的方法就是对于servlet-ap.jar 使用 标签，编译的时候用到servlet-api和jsp-api，但在打包的时候不用这两个依赖。
 
javax.servletservlet-api2.5provided中，它主要管理依赖的部署。
 
目前可以使用5个值：* compile，缺省值，适用于所有阶段，会随着项目一起发布。
 
* provided，类似compile，期望JDK、容器或使用者会提供这个依赖。
 
如servlet.jar。
 
* runtime，只在运行时使用，如JDBC驱动，适用运行和测试阶段。
 
* test，只在测试时使用，用于编译和运行测试代码。
 
不会随项目发布。
 
*system，类似provided，需要显式提供包含依赖的jar,Maven不会在Repository中查找它。
 
解决SpringBoot 不继承父 parent 打包不包含依赖的问题
 
创建两个项目1. cdai_codebase_parent：其他项目的Maven配置都继承这个项目中pom.xml的定义。
 
2. cdai_codebase_ssh：一个SSH示例项目，继承parent项目中的配置。
 
首先看cdai_codebase_parent中pom.xml的内容：通过将packaging属性定义为pom来说明当前pom.xml是用来被继承的。
 
之后在parent的pom.xml中，我们可以定义一些统一的版本号(Spring等第三方包的)，依赖项(所有项目都会用的JUnit)，以及通用的打包配置等。
 
现在，我们就可以在cdai_codebase_ssh中，通过项目的相对路径引用这个parent的pom.xml文件了。
 
附：在父pom.xml中dependencyManagement中定义需要被继承的依赖，然后在子pom.xml中可以直接指定groupId和artifactId来引入，就不需要版本号了。