在JAVA持续集成构建中，需要从SVN check out的代码编译并打成可执行JAR包，高手告诉我maven命令如何？

我用mvn compile package或mvn jar：jar都能打成jar包，但不能执行
利用HUDSON+MAVEN编译打包java maven工程，打包成可执行的JAR包。在HUDSON中需要填写maven命令。我想知道的是打可执行jar包的maven命令。
我的pom.xml中添加了：
<plugin><artifactId>maven-assembly-plugin</artifactId><configuration><descriptorRefs> <descriptorRef>jar-with-dependencies</descriptorRef></descriptorRefs><archive> <manifest>mainClass>com.ImageViewer.dao.ImageViewer</mainClass></manifest>               </archive></configuration></plugin>

目前的mvn命令是：clean assembly:assembly
但是build时报错：mavenExecutionResult exceptions not empty
org.apache.maven.InternalErrorException: Internal error: ava.lang.NullPointerException
换成jar:jar打成的jar包不能执行。

自动打包java工程
介绍
自动打包java工程，主要功能是什么呢？没错，如标题所言，就是通过命令实现自动打包普通java工程，将java工程打包成一个jar包。
前言
肯定很多人会疑惑，为什么不用IDE直接导出jar呢？还要编写命令？不是多此一举？

答案是：

特殊情况需要，如果需要在服务器中，实现自动生成jar包，而不是在IDE的情况下，就需要该工具实现导出jar包。当然，本地也是可以使用的。

如果，刚好你也有这种需求，需要通过java命令导出jar包的话，可以看下这篇博客。因为，我就是刚好碰到。

因为，我找不到完整的命令，所以，想把这次的调研和开发脚本过程记录下来~

当然，该工具还需要更加完善，如有建议，欢迎留言~
思路

通过javac命令，实现将java格式的文件编译成class文件
将所有的class文件和配置文件，通过jar命令压缩成功一个jar文件

需要解决的问题

如果使用命令javac编译所有java文件？
使用javac编译java文件的过程中，如何让编译的java文件能正确地找到对应依赖的lib和其他包名下的java文件？
如何在压缩class成jar的时候，将其他jar包也压缩到目标jar中呢？

方案如下
–>如何编译所有java文件？
两种情况

一、如果要导出的jar包是有执行主类的，先是查找项目配置文件 MANIFEST.MF 读取出执行的Main类，然后编译Main类，因为Main类在编译的过程中，会通过需要用到的类去寻找编译，这样的话，就可以链式的编译整个项目有需要用到的java文件。

二、导出来的jar包不可以直接执行的，只能作为lib使用的，也就是没有配置文件，那就是通过找出所有包名，然后编译所有包名下的java文件，当然，javac可以一次性编译一个文件夹下的所有java文件。
–>使用javac编译java文件的过程中，如何让编译的java文件能正确地找到对应依赖的lib和其他包名下的java文件？
javac命令中，有一个可选项，-cp（-classpath） 后面带的就是编译时需要用到的依赖jar 和对应的其他依赖库，还有所有包名，但是为了编译的时候能找到对应的包名，必须cd到对应的src目录

例如：
javac -classpath .;../libs/dom4j-2.1.0.jar;compiler;main;utils;vo -encoding utf-8 -d ../classesOutput -Xlint:unchecked -Xlint:deprecation builder/*.java

–>如何在压缩class成jar的时候，将其他jar包也压缩到目标jar中呢？
将用到的jar包复制到编译出的class文件夹中，然后使用jar命令压缩即可
javac命令
javac -classpath .;../libs/dom4j-2.1.0.jar;compiler;main;utils;vo -encoding utf-8 -d ../classesOutput -Xlint:unchecked -Xlint:deprecation builder/*.java
说明：
-classpath 后面带的是编译过程中所需要用到的类，可以为jar包、类保存的文件夹、zip文件等
-encoding 指定编译时的java文件编码格式为utf-8格式
-d 后面带输出的class的路径
-Xlint:unchecked -Xlint:deprecation 避免编译不通过
builder/*.java 编译当前目录下的builder包中的所有Java文件

注意：

1、Windows下和Linux下的命令还有所差异，Windows下，-cp（-classpath）后面接的库需要用’;‘隔开，Linux下的得用’:'隔开

2、在Linux下，使用Java.Runtime.exec命令执行的时候，需要注意，部分命令执行无法达到效果，也就是没执行起来，具体的调用，在Linux下，需要加上两个操作符。

String[] cmds = {“sh”, “-c”, cmd};

process = Runtime.getRuntime().exec(cmds, null, runDir);

3、文件的编码格式最好是utf-8，不然编译会出问题

4、jar包和输出路径可以使用绝对路径，但是包名的应用不能使用绝对路径，不然会找不到对应的包名

5、执行该命令的时候，一定要cd到src目录中，不然包名会找不到！

6、最好添加这两个可选项 -Xlint:unchecked -Xlint:deprecation 不然，当接口废弃或者unchecked的时候，会提示哪些方法是unchecked和deprecation的！
jar命令
jar cvfm C:/Users/37/Desktop/test/test.jar C:/Users/37/Desktop/test/bin/META-INF/MANIFEST.MF -C C:/Users/37/Desktop/test/bin/ .
说明：
jar cvfm 输出的jar包的路径 配置文件的路径 -C 编译的好的class文件夹路径 .
注意：bin/ 表示class的父级文件夹；最后记得要空格加一个"."


写在最后
具体的工具代码实现，最主要的命令就是上面这两个，如果遇到什么问题，欢迎留言~
项目的GitHub地址：ExportJarCommand

一. jar命令用法：
         在cmd命令窗口下输入jar，回车，就会提示改命令的用法：

        

        二.例子（这里介绍的都是生成双击可执行的jar包）：

        1.首先介绍如何在命令行下执行打包程序。
        1.1.没有包结构的最简单的工程。
            (1)在c：盘下新建文件“HelloWorld.java”：
         


1 public class HelloWorld
2 {
3     public static void main(String[] args){
4         System.out.println("Hello world!");
5     }
6 }         (2)在命令行下输入c:/javac HelloWorld.java，在c：盘下编译生成“HelloWorld.class”。

            (3)在c：盘下新建文件“menefest”（没有后缀名）：
           




Main-Class: HelloWorld



注意最后要有一个空行，否则会出现找不到类的错误。

             (4)打包：输入c:/jar cvmf menefest HelloWorld.jar HelloWorld.class,在c：盘下生成“HelloWorld.jar”。

             (5)执行：输入c:/java -jar HelloWolrd.jar。屏幕回显“HelloWorld”。

        1.2.有包结构的java工程。
            (1)在c:/com/gosyl/demo/下新建文件“HelloWorld.java”：
         


package com.gosyl.demo;

public class HelloWorld{
    public static void main(String[] args){
        System.out.println("HelloWorld");
    }
}



            (2)在命令行下输入c:/javac com/gosyl/demo/HelloWorld.java，在c:/com/gosyl/demo/文件夹下编译生成“HelloWorld.class”。

            (3)在c：盘下新建文件“menefest2”（没有后缀名）：
         


Main-Class: com.gosyl.demo.HelloWorld


  
          注意最后要有一个空行，冒号后面要一个空格。否则会出现找不到类的错误。

            (4)打包：输入c:/jar cvmf menefest2 HelloWorld.jar com/,在c：盘下生成“HelloWorld.jar”。

            (5)执行：输入c:/java -jar HelloWorld.jar。屏幕回显“HelloWorld”。

        1.3.引用到外部jar包的java工程。
            (1)在c:/com/gosyl/demo/下新建文件“Car.java”：
              


package com.gosyl.demo;

public class Car
{
    public static void main(String[] args){
        Light.on();        
    }
}



            (2)在c:/com/gosyl/demo/下新建文件“Light.java”：
         


package com.gosyl.demo;

class Light 
{
    public static void on(){
        System.out.println("Light is on!");
    }
}



            (3)打包1：输入c:/jar cvf  Light.jar com/gosyl/demo/Light.class,在c：盘下生成“Light.jar”。
        
            (4)在c：盘下新建文件“menefest-car”（没有后缀名）：
         


Main-Class: com.gosyl.demo.Car
Class-Path: Light.jar



     注意最后要有一个空行，冒号后面要一个空格。否则会出现找不到类的错误。

            (5)打包2：输入c:/jar cvmf  menefest-car Car.jar com/gosyl/demo/Car.class,在c：盘下生成“Car.jar”。
        
            (6)执行：输入c:/java -jar Car.jar。屏幕回显“Light is on”。

    三.总结
        清单文件menifest，对格式要求很高，注意每个冒号后面要有一个空格，文件最后要有一个空行。对于引用到外部jar包的工程，需要在manifest中定义好Class-Path属性。

目录

前言

实现

多模块实现

maven-assembly-plugin插件实现

关于properties标签题外话（maven的内置变量）

前言

有时候我们需要在一个java工程内执行打包命令能生成多个jar包，每个jar包的具体内容都与具体实现类相绑定，这样的好处就是方便。比如我们项目中对外提供了插件扩展，第三方使用者只需要实现我们的插件接口，然后打成jar包上传到我们的项目中便可动态解析，而使用者的需求便是能在一个工程内同时编辑多个业务插件，最终打包时也能生成多个不同的jar包以作不同的用途，因此作为产品方需要给出一个demo供他们直接上手。

 

实现

多模块实现

这个应该很好理解，可以使用多模块的方式实现，每个模块就相当于一个插件，最终打包时直接mvn package便能在不同模块的target目录下输出各自的jar包，实现简单，但是层次上存在一个父子关系，而实际上并不存在，因此不太好。

maven-assembly-plugin插件实现

使用该插件配合描述文件实现，整体项目结构如下图：



pom文件如下：

<?xml version="1.0" encoding="UTF-8"?>
<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>qingcha.test</groupId>
    <artifactId>multiPluginDemo</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <!-- 引入插件目标接口以及相关依赖 -->
        <dependency>
            <artifactId>hornet-web-api</artifactId>
            <groupId>uyun.hornet</groupId>
            <version>2.0.0-SNAPSHOT</version>
            <!-- 表示已提供依赖范围，由于是作为插件jar包运行在主项目中，而主项目中存在该依赖，因此实际运行的时候并不需要maven重复引入一遍，
             因此该依赖范围表示只在测试和编译classpath时有效，在运行时无效，换句话说就是该依赖不会被打进包中-->
            <scope>provided</scope>
        </dependency>

    </dependencies>

    <!-- 在properties标签中定义的值可以通过使用${key}在pom的任何位置访问，其中key为属性值 -->
    <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>
        <project.assembly.directory>src/main/resources/assembly</project.assembly.directory>
    </properties>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-assembly-plugin</artifactId>
                <version>2.6</version>

                 <configuration>
                    <!--该方式会将所有依赖打包到jar，生成的jar包带有jar-with-dependencies后缀 -->
                    <descriptorRefs>
                        <!-- 将依赖一起打包到 JAR -->
                        <descriptorRef>jar-with-dependencies</descriptorRef>
                    </descriptorRefs>

                    <!-- 该标签可以配置主main类，即 使该jar包成为可执行jar包，可在META-INF下的MF文件中找到Main-class一行 -->
                    <archive>
                        <manifest>
                            <mainClass></mainClass>
                        </manifest>
                    </archive>
                </configuration>

                <!-- 配置执行器，若还想增加编写新的插件，在此处新增执行器即可 -->
                <executions>
                    <execution>
                        <!-- 执行器id -->
                        <id>plugin1</id>
                        <!-- 绑定到maven的package生命周期 -->
                        <phase>package</phase>
                        <goals>
                            <!-- 代表只运行一次 -->
                            <goal>single</goal>
                        </goals>
                        <configuration>
                            <descriptors>
                                <!-- 描述文件的地址 -->
                                <descriptor>${project.assembly.directory}/assembly-plugin1.xml</descriptor>
                            </descriptors>
                            <!-- 自定义包名，如果不配置则是 artifactId + version + assemblyId，配置后则为 finalName + assemblyId，当然也可以增加属性去除自动拼接assemblyId值 -->
                            <finalName>multiPluginDemo</finalName>
                        </configuration>
                    </execution>

                    <execution>
                        <id>plugin2</id>
                        <phase>package</phase>
                        <goals>
                            <goal>single</goal>
                        </goals>
                        <configuration>
                            <descriptors>
                                <descriptor>${project.assembly.directory}/assembly-plugin2.xml</descriptor>
                            </descriptors>
                            <finalName>multiPluginDemo</finalName>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

</project>


其中打包脚本之一的assembly-plugin1.xml文件如下：

<assembly
        xmlns="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.2"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.2 http://maven.apache.org/xsd/assembly-1.1.2.xsd">

    <!-- 文件id，与前面保持一致即可 -->
    <id>plugin1</id>
    <!-- 是否生成和压缩包同名的项目和目录 -->
    <includeBaseDirectory>false</includeBaseDirectory>
    <formats>
        <!-- 指定格式 -->
        <format>jar</format>
    </formats>

    <fileSets>
        <fileSet>
            <!-- 文件所在项目中的位置 -->
            <directory>${project.build.outputDirectory}/qingcha/test/common</directory>
            <!-- 打包后的展示路径，必须与包路径保持一致 -->
            <outputDirectory>qingcha/test/common</outputDirectory>
        </fileSet>
        <fileSet>
            <directory>${project.build.outputDirectory}/qingcha/test/plugin1</directory>
            <outputDirectory>qingcha/test/plugin1</outputDirectory>
        </fileSet>
        <fileSet>
            <directory>src/main/resources/plugin1</directory>
            <!-- 由于依赖spi机制，因此这里的输出路径需要满足条件，否则插件便不生效了 -->
            <outputDirectory>META-INF/services</outputDirectory>
        </fileSet>
    </fileSets>
</assembly>


最终直接使用mvn package打包即可，可在target/ 目录下看到最终的jar包，多个plugin会有多个jar包：



如果还要增加一个plugin的话，可依次增加对应的实现类、提供者配置文件、脚本描述文件、执行器

 

关于properties标签题外话（maven的内置变量）

在上面的脚本描述文件中有使用到 ${project.build.outputDirectory} ，然后查看pom文件发现我们并没有定义该key值，因此也能猜到这是maven的内置变量，常用的内置变量如下：

${project.basedir}：这引用了module/project的根文件夹（当前pom.xml文件所在的位置），还可以简化的写法：${basedir}
	
${project.build.directory}：这表示默认的target文件夹。
	
${project.build.outputDirectory}：默认情况下表示target/classes文件夹。
	
${project.build.testOutputDirectory}：这表示默认的target/test-classes文件夹。
	
${project.build.sourceDirectory}：这表示默认情况下src/main/java文件夹。
	
${project.build.testSourceDirectory}：这表示默认情况下src/test/java文件夹。
	
${project.build.finalName}：默认情况下定义为${project.artifactId}-${project.version}。
	
${project.version}：这可以在必须编写文字版本的位置使用，否则，特别是如果您在多模块构建模块间依赖关系。
	
${settings.localRepository}：它引用了本地存储库的位置。这是默认的${home}/.m2/repository。