打jar包的几种方式

测试用类
public class Hello {
    public static void main(String[] args) {
        System.out.println("hello world");
    }
}
一般的jar包
生成class文件
javac Hello.java

如果有中文，报 编码GBK的不可映射字符 的错误，执行下面的命令。
javac -encoding UTF-8 Hello.java

打包
jar cvf hello.jar Hello.class
可运行的jar包

需要借助 manifest.mf 配置文件
manifest.mf

Manifest-Version: 1.0
Class-Path: .
Main-Class: Hello
这里有几个点，需要注意一下：
    key和value之间，必须有一个空格。
    最后必须预留一个空行
    Class-Path设置为 . 是为了声明从当前目录开始查找
    Main-Class是包含main函数的入口类，如果有包名，需要填写完成的类名。

打包
jar cvfm hello.jar manifest.mf Hello.class

验证打包结果
java -jar hello.jar

Maven项目打包为jar的几种方式
直接打包，不打包依赖包
直接打包，不打包依赖包，仅打包出项目中的代码到JAR包中。在POM中添加如下plugin即可，随后执行maven install
　　<plugin>
      　　 <groupId>org.apache.maven.plugins</groupId>
      　　 <artifactId>maven-compiler-plugin</artifactId>
       　　<configuration>
            　　<source>1.8</source>
            　　<target>1.8</target>
       　　</configuration>
　　</plugin>

将依赖JAR包输出到lib目录方式
将项目中的JAR包的依赖包输出到指定的目录下,修改outputDirectory配置，如下面的${project.build.directory}/lib。如想将打包好的JAR包可以通过命令直接运行，如java -jar xx.jar，还需要制定manifest配置的classpathPrefix与上面配置的相对应,如上面把依赖JAR包输出到了lib，则这里的classpathPrefix也应指定为lib/；同时，并指定出程序的入口类，在配置mainClass节点中配好入口类的全类名。
这种打包方式对于JAVA项目是通用的，不管是不是springBoot的项目还是传统的JAVA项目，都可行。
        <plugins>
            <!-- java编译插件 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.7</source>
                    <target>1.7</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-jar-plugin</artifactId>
                <configuration>
                    <archive>
                        <manifest>
                            <addClasspath>true</addClasspath>
                            <classpathPrefix>lib/</classpathPrefix>
                            <mainClass>com.yourpakagename.mainClassName</mainClass>
                        </manifest>
                    </archive>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-dependency-plugin</artifactId>
                <executions>
                    <execution>
                        <id>copy</id>
                        <phase>install</phase>
                        <goals>
                            <goal>copy-dependencies</goal>
                        </goals>
                        <configuration>
                            <outputDirectory>${project.build.directory}/lib</outputDirectory>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
有时为了方便，可以把classpath初在当前目录上，默认的classpath会在jar包内,可以在Main方法配置后加上manifestEntries配置，指定classpath,如:
           <plugin>  
                <groupId>org.apache.maven.plugins</groupId>  
                <artifactId>maven-jar-plugin</artifactId>  
                <configuration>  
                    <classesDirectory>target/classes/</classesDirectory>  
                    <archive>  
                        <manifest>  
                            <!-- 主函数的入口 -->  
                            <mainClass>com.yourpakagename.mainClassName</mainClass>  
                            <!-- 打包时 MANIFEST.MF文件不记录的时间戳版本 -->  
                            <useUniqueVersions>false</useUniqueVersions>  
                            <addClasspath>true</addClasspath>  
                            <classpathPrefix>lib/</classpathPrefix>  
                        </manifest>  
                        <manifestEntries>  
                            <Class-Path>.</Class-Path>  
                        </manifestEntries>  
                    </archive>  
                </configuration>  
            </plugin>
将项目依赖包和项目打为一个包
这种方式打包会将项目中的依赖包和项目代码都打为一个JAR包，其配置如下：
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>  
            <artifactId>maven-assembly-plugin</artifactId>  
            <version>2.5.5</version>  
            <configuration>  
                <archive>  
                    <manifest>  
                        <mainClass>com.xxg.Main</mainClass>  
                    </manifest>  
                </archive>  
                <descriptorRefs>  
                    <descriptorRef>jar-with-dependencies</descriptorRef>  
                </descriptorRefs>  
            </configuration>  
        </plugin>
但此种方式对于传统的JAVA项目打包没问题，如是打有spring框架的JAR包就不可以了。可以采用maven-shade-plugin的插件来打包，来实现spring框架的打包
有好几位朋友说不能在使用此配置时无法将项目的依赖也打到一个JAR包中，通过追溯发现由于是执行的package命令导致发。此处应执行插件的assembly命令。如下图：
assembly打包插件说明
springBoot项目打包

springBoot项目打包最常用且最简单的方式是用springBoot的打包plugin
　　<plugin>
   　　<groupId>org.springframework.boot</groupId>
   　　<artifactId>spring-boot-maven-plugin</artifactId>
　　</plugin>
在POM中加入此插件，再点击maven [install]或[repackge]就会把当前项目里所有依赖包和当前项目的源码都打成一个JAR包，同时还会将没有依赖包的JAR包也打出来，以.original的就是了
groovy项目打包
如果项目中包含groovy代码，默认采用MAVEN打包时不会将groovy代码进行打包，需要加入如下配置
            <plugin>
                <groupId>org.codehaus.gmavenplus</groupId>
                <artifactId>gmavenplus-plugin</artifactId>
                <version>1.2</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>addSources</goal>
                            <goal>addStubSources</goal>
                            <goal>compile</goal>
                            <goal>execute</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>