Maven项目打包为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命令。如下图：
 
 
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>

IDEA+Maven 打jar包 （包涵依赖jar）
 
最新修改
 以前写的打包方式可能看起来有些繁琐，这里给出进一步简洁的解决方案简单粗暴
 
写在前面：
 
​ 这两天一直在整（gu）理（dao）IDEA 用Maven打jar包，网上的教程是各式各样，但是都不能满足我的需求（或者 还没有找个正确的），因此 综合网上的内容 自己整理了一下（以下内容是在mac系统下 win 可能有一些地方不一样）。
 
软件环境：
 
​ IDEA：2017.1.5
 
​ Maven：3.3.9
 
打jar包：
 
 
IDEA 自带的打包工具使用
 
  
 
打无依赖jar包
 
    
如果工程目录中有以下文件夹 删掉
 
 
 
  
点击工程上方【File】菜单选择【Project Structure】
 
点击【+】 选择【JAR】，【From modules with dependencies】点击【ok】
 
点击【1】选择你要打包的Module，点击【2】选择你的主类（也就是你的程序的入口）然后点击【ok】
点击【ok】
 
【1】是要打的jar包的名字，【2】是jar包的输出路径，【3】是程序所需要的jar依赖，【4】是程序主类的名称。因为这里是打没有依赖的jar包，所以将【3】里面不需要的jar包删掉就行。最后点击【ok】
然后就会生成一个META-INF的文件夹，里面就是一些配置属性
 
  
打包涵依赖jar包
 对以上的方式中的步骤6中 不做任何修改，然后执行步骤7
 
 
 
Maven 打包 
  
 
打无依赖jar包
 
    
 
在pom.xml 文件里加入
 
 <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-jar-plugin</artifactId>
      <version>2.4</version>
      <configuration>
        <archive>
              生成的jar中，不要包含pom.xml和pom.properties这两个文件
          <addMavenDescriptor>false</addMavenDescriptor>
          <manifest>
                是否要把第三方jar放到manifest的classpath中
            <addClasspath>true</addClasspath>
               生成的manifest中classpath的前缀，因为要把第三方jar放到lib目录下，所以classpath的前缀是lib/
            <classpathPrefix>lib/</classpathPrefix>
                应用的main class
            <mainClass>com.yourClass</mainClass>
          </manifest>
        </archive>
            过滤掉不希望包含在jar中的文件
        <excludes>
          <exclude>${project.basedir}/xml/*</exclude>
        </excludes>
     </configuration>
 </plugin> 
 
 
点开Maven管理工具
 
 
 
点击【package】
 
 
 
等运行完以后就会生成jar包了
 
 
​
 
 
 
打包涵依赖jar包
 第一种方法
 1. 在pom.xml文件中写入
 
  <build>
     <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.1</version>
      </plugin>
      <plugin>
        <artifactId>maven-assembly-plugin</artifactId>
        <configuration>
          <archive>
            <manifest>
              <mainClass>com.test.app</mainClass>
            </manifest>
          </archive>
          <descriptorRefs>
            <descriptorRef>jar-with-dependencies</descriptorRef>
          </descriptorRefs>
        </configuration>
        <!--下面是为了使用 mvn package命令，如果不加则使用mvn assembly-->
        <executions>
          <execution>
            <id>make-assemble</id>
            <phase>package</phase>
            <goals>
              <goal>single</goal>
            </goals>
          </execution>
        </executions>
      </plugin>
     </plugins>
  </build>
 
    
然后执行上面【Maven 打无依赖包】步骤2到步骤4
 
第二种方法
 
    
在pom.xml文件中写入
<plugin>
 <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-jar-plugin</artifactId>
  <version>2.4</version>
  <configuration>
    <archive>
         <!-- 生成的jar中，不要包含pom.xml和pom.properties这两个文件-->
      <addMavenDescriptor>false</addMavenDescriptor>
      <manifest>
            <!--是否要把第三方jar放到manifest的classpath中-->
        <addClasspath>true</addClasspath>
           <!--生成的manifest中classpath的前缀，因为要把第三方jar放到lib目录下，所以classpath的前缀是lib/-->
        <classpathPrefix>lib/</classpathPrefix>
           <!-- 应用的main class-->
        <mainClass>com.yourClass</mainClass>
      </manifest>
    </archive>
      <!--  过滤掉不希望包含在jar中的文件-->
    <excludes>
      <exclude>${project.basedir}/xml/*</exclude>
    </excludes>
 </configuration>
</plugin>

<plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-assembly-plugin</artifactId>
      <version>2.4</version>
      <configuration>
        <descriptors>
          <descriptor>src/main/assembly/package.xml</descriptor>
        </descriptors>
      </configuration>
      <executions>
        <execution>
          <id>make-assembly</id>
          <phase>package</phase>
          <goals>
            <goal>single</goal>
          </goals>
        </execution>
      </executions>
    </plugin>
 
创建【src/main/assembly】目录
创建package.xml文件
<assembly>
  <id>bin</id>
  <!-- 最终打包成一个用于发布的zip文件 -->
  <formats>
      <format>zip</format>
  </formats>
  <!-- Adds dependencies to zip package under lib directory -->
  <dependencySets>
      <dependencySet>
          <!--
             不使用项目的artifact，第三方jar不要解压，打包进zip文件的lib目录
         -->
          <useProjectArtifact>false</useProjectArtifact>
          <outputDirectory>lib</outputDirectory>
          <unpack>false</unpack>
      </dependencySet>
  </dependencySets>

  <fileSets>
      <!-- 把项目相关的说明文件，打包进zip文件的根目录 -->
      <fileSet>
          <directory>${project.basedir}</directory>
          <outputDirectory>/</outputDirectory>
          <includes>
              <include>README*</include>
              <include>LICENSE*</include>
              <include>NOTICE*</include>
          </includes>
      </fileSet>

      <!-- 把项目的配置文件，打包进zip文件的config目录 -->
      <fileSet>
          <directory>${project.basedir}/src/main/config</directory>
          <outputDirectory>config</outputDirectory>
          <includes>
              <include>*.xml</include>
              <include>*.properties</include>
          </includes>
      </fileSet>

      <!-- 把项目的脚本文件目录（ src/main/scripts ）中的启动脚本文件，打包进zip文件的跟目录 -->
      <fileSet>
          <directory>${project.build.scriptSourceDirectory}</directory>
          <outputDirectory></outputDirectory>
          <includes>
              <include>startup.*</include>
          </includes>
      </fileSet>

      <!-- 把项目的脚本文件（除了启动脚本文件），打包进zip文件的script目录 -->
      <fileSet>
          <directory>${project.build.scriptSourceDirectory}</directory>
          <outputDirectory></outputDirectory>

          <excludes>
              <exclude>startup.*</exclude>
          </excludes>
      </fileSet>

      <!-- 把项目自己编译出来的jar文件，打包进zip文件的根目录 -->
      <fileSet>
          <directory>${project.build.directory}</directory>
          <outputDirectory></outputDirectory>
          <includes>
              <include>*.jar</include>
          </includes>
      </fileSet>
  </fileSets>
</assembly>
 
将【package.xml】文件放入【assembly】文件夹中
 
然后执行上面【Maven 打无依赖包】步骤2到步骤4
 
 
 
如果要打包scala代码需要添加插件：
 方案一：
 
 <plugin>
     <groupId>net.alchim31.maven</groupId>
     <artifactId>scala-maven-plugin</artifactId>
     <version>3.4.0</version>
     <executions>
         <execution>
             <goals>
                 <goal>compile</goal>
                 <goal>testCompile</goal>
             </goals>
         </execution>
     </executions>
 </plugin>
 
方案二：
 
	<plugin>
		<groupId>org.scala-tools</groupId>
		<artifactId>maven-scala-plugin</artifactId>
 		<version>2.15.2</version>
 		<executions>
         	<execution>
            	 <goals>
                 	<goal>compile</goal>
                 	<goal>testCompile</goal>
            	 </goals>
         	</execution>
     	</executions>
	</plugin>
 
推荐方案一，方案二中的插件最新更新日期是2011年
 
简单粗暴
 将下面的任意一种方案放到pom文件中，并修改成自己项目中的MainClass即可
 
</plugins>
    </build>
     方案一 or 方案二
     <build>
<plugins>
 
方案一：
 
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-shade-plugin</artifactId>
    <version>3.0.0</version>
    <executions>
        <execution>
            <phase>package</phase>
            <goals>
                <goal>shade</goal>
            </goals>
            <configuration>
                <transformers>
                    <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                        <mainClass>com.test.MainClass</mainClass>   <!--带有包路径的MainClass -->
                    </transformer>
                </transformers>
            </configuration>
        </execution>
    </executions>
</plugin>
 
方案二：
 
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-assembly-plugin</artifactId>
    <version>2.4</version>
    <configuration>
        <archive>
            <manifest>
                <mainClass>com.test.MainClass</mainClass>   <!--带有包路径的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>
 
注：
 
本文属于作者原创，如需转载，请注明。
 
内部如果引用的文字，连接，图片等资源存在侵犯原作者的情况，请联系本人，立即删除。
 ​
 
​

下面是阿帕奇官网下载spring相关的jar包链接：
 
http://commons.apache.org/proper/commons-logging/download_logging.cgi
 
如果你是要找 jdbcTemplate 相关jar包，下面是网盘分享。 若是文件里没有你想要的jar包，可以点击上面的链接找到你想要的jar包。
 
链接：https://pan.baidu.com/s/1mYjbTfM4O-8Kz4nbM9r44A 
 提取码：mzym
 
这样就不用花钱 CSDN下载了，哈哈
 
希望对你有帮助！
 同时欢迎访问我的博客：http://www.linblog.tech/

一.直接复制：(不推荐)
 方法：直接将硬盘上的jar包复制粘贴到项目的lib目录下即可。


注意：
 1.对于导入的eclipse项目，该方式添加的jar包没有任何反应，用make编译项目会报错
 2.对于在idea中创建的项目，该方式添加jar包，编译不报错，但是打开Structure会有"...jar ... is missing ..."的提示，需要点击"Fix"或红灯泡解决。

  


二.通过Modules的Dependencies添加：(推荐)
 1.打开 File -> Project Structure （Ctrl + Shift + Alt + S）

  
 2.单击 Modules -> Dependencies -> "+" -> "Jars or directories"

  

  
 3.选择硬盘上的jar包
 4.Apply -> OK


三.通过Libraries添加：(强烈推荐)
 1.打开 File -> Project Structure （Ctrl + Shift + Alt + S）
 

 
 
 
对于新导入的项目，会自动导入lib目录下的相关jar包，我们需要将这些自动添加进来的jar包删除，如图：
 


  

  

  
 2.单击 Libraries  -> "+" -> "Java" -> 选择我们导入的项目主目录，点击OK
 

 


  
 

  
注意：在弹出的方框中点击“Cancel”,取消将其添加到Module中
 


  
 此时，lib目录创建成功，删除目录中添加进来的多余内容，重新添加需要的jar包
 


  

  

  

  
 
到此，Libraries创建成功。
 
 
 
3.回到Modules菜单，选中之前导入的项目，点击“Dependencies”,点击“+” -> “Library”,将刚才创建成功的Library目录加入
 


  

  

  
 
4.将不是项目lib目录下的其他jar包（如：tomcat相关jar包），也通过该方式加入
 


  

  
 
到此，所有jar包添加成功！
 


注意：
 1.图标的区别：
 
   一种是添加项目lib目录下的jar包的图标，像文件夹；
 
   一种是在其他目录添加的jar包，像柱状图。
 
2.以后要添加新的jar包，只要在Library目录中之前创建的项目lib目录下添加进去即可