java maven项目创建可执行jar的6种方法,可以用于任何JAVA项目包含spring, springboot项目

已于 2024-03-21 21:09:42 修改
阅读量1.3k 收藏 32
点赞数 28
分类专栏： java springboot 文章标签： java spring maven 可运行jar打包方法 jar MAVEN插件使用
于 2024-03-21 20:47:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tekin_cn/article/details/136920305
版权

JAVA项目创建可运行的jar文件其实就是在jar文件中构建清单文件META-INF/MANIFEST.MF, 在这个前端文件中需要指定入口类 main-class, 还有打包相关的依赖项目等.
第6种方法依赖的额外包最少,文件也最小, 第五种方法生成的jar文件最大, 但是他启动的是一个tomcat服务,通常用于web项目的部署.
其他几种方法没有内置服务,适合于控制台应用的jar打包, Spring Boot Maven Plugin这个和springboot是无缝集成的,常用于springboot项目, 以下是对各种插件生成可执行jar的配置方法和各自的优缺点的总结和对比.

1. 使用maven-jar-plugin和maven-dependency-plugin插件

优点: 处理过程透明，我们可以自定义每个步骤
不足: 手动; 依赖项不在最终的jar中，这意味着只有当libs文件夹对jar是可访问和可见的时，我们的可执行jar才会运行

  • 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>cn.tekin</groupId>
    <artifactId>spring_demo</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <spring.version>5.3.29</spring.version>
    </properties>
    <dependencies>
        <!-- https://mavenlibs.com/maven/dependency/org.springframework/spring-core -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- https://mavenlibs.com/maven/dependency/org.springframework/spring-context -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>

    </dependencies>

    <build>
        <finalName>${project.name}</finalName>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-dependency-plugin</artifactId>
                <executions>
                    <execution>
                        <id>copy-dependencies</id>
                        <phase>prepare-package</phase>
                        <goals>
                            <goal>copy-dependencies</goal>
                        </goals>
                        <configuration>
                            <!-- 指定所有依赖的jar包的输出路径 -->
                            <outputDirectory>
                                ${project.build.directory}/libs
                            </outputDirectory>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-jar-plugin</artifactId>
                <configuration>
                    <archive>
                        <manifest>
                            <addClasspath>true</addClasspath>
                            <classpathPrefix>libs/</classpathPrefix>
                            <!-- 这里写入你的可执行Class的Reference 即包含main入口类的Reference -->
                            <mainClass>cn.tekin.MyApp</mainClass>
                        </manifest>
                    </archive>
                </configuration>
            </plugin>
        </plugins>
    </build>


</project>
  • 构建jar命令
    这里构建的jar文件是不包含依赖文件的, 所有的依赖文件全部位于libs目录下
mvn package
  • jar包中的清单文件 META-INF/MANIFEST.MF
    生成的MANIFEST.MF内容如下
Manifest-Version: 1.0
Archiver-Version: Plexus Archiver
Built-By: Tekin
Class-Path: libs/spring-core-5.3.29.jar libs/spring-jcl-5.3.29.jar lib
 s/spring-context-5.3.29.jar libs/spring-aop-5.3.29.jar libs/spring-be
 ans-5.3.29.jar libs/spring-expression-5.3.29.jar
Created-By: Apache Maven 3.6.3
Build-Jdk: 1.8.0_362
Main-Class: cn.tekin.MyApp
  • 执行jar
    java -jar target/spring_demo.jar

2. 使用Apache Maven Assembly Plugin插件

优点: 依赖包含在jar文件中
不足: 只能对制品进行基础控制, 如没有类重定位的支持

这个配置默认会生成2个jar文件, 一个包含配置清单和依赖的jar包 xxx-jar-with-dependencies.jar, 另外一个是不包含依赖且没有清单的jar包.

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-assembly-plugin</artifactId>
    <executions>
        <execution>
            <phase>package</phase>
            <goals>
                <goal>single</goal>
            </goals>
            <configuration>
                <archive>
                <manifest>
                    <mainClass>
                        cn.tekin.MyApp
                    </mainClass>
                </manifest>
                </archive>
                <descriptorRefs>
                    <descriptorRef>jar-with-dependencies</descriptorRef>
                </descriptorRefs>
            </configuration>
        </execution>
    </executions>
</plugin>

注意这里省略的其他配置,其他配置见1;

  • 生成jar文件
    mvn package

  • 清单文件

Manifest-Version: 1.0
Archiver-Version: Plexus Archiver
Created-By: Apache Maven
Built-By: Tekin
Build-Jdk: 1.8.0_362
Main-Class: cn.tekin.MyApp
  • 运行:
    这里生成的可执行jar是包含依赖包的jar文件.
    java -jar target/spring_demo-jar-with-dependencies.jar

3. Apache Maven Shade Plugin

优点: 依赖包含在jar文件中, 可对我们的jar制品进行高级控制, 可对依赖的类进行重命名和重新定位.
不足: 我们想使用高级功能时配置较为复杂, 生成的jar文件大小比上面2种稍大.

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-shade-plugin</artifactId>
    <executions>
        <execution>
            <goals>
                <goal>shade</goal>
            </goals>
            <configuration>
                <shadedArtifactAttached>true</shadedArtifactAttached>
                <transformers>
                    <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                        <mainClass>cn.tekin.MyApp</mainClass>
                </transformer>
            </transformers>
        </configuration>
        </execution>
    </executions>
</plugin>
  • 清单文件
Manifest-Version: 1.0
Archiver-Version: Plexus Archiver
Built-By: Tekin
Created-By: Apache Maven 3.6.3
Build-Jdk: 1.8.0_362
Main-Class: cn.tekin.MyApp

4. Spring Boot Maven Plugin

优点: 依赖项包含在jar文件中，我们可以在每个可访问的位置运行它，可对打包制品进行高级控制，排除jar文件的依赖项等，还可以打包war文件

不足: 添加可能不必要的Spring和Spring Boot相关类, 生成的jar文件大小比方法3稍大

 <build>
        <finalName>${project.name}</finalName>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <!-- 注意这里如果项目是1.8需要指定对应的版本号 否则默认会自动依赖最新版本 从而导致版本不一致而编译失败 -->
                <version>2.3.12.RELEASE</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                        <configuration>
                            <classifier>spring-boot</classifier>
                            <mainClass>
                                cn.tekin.MyApp
                            </mainClass>
                        </configuration>
                    </execution>
                </executions>
            </plugin>

        </plugins>
    </build>
  • 清单文件
Manifest-Version: 1.0
Spring-Boot-Classpath-Index: BOOT-INF/classpath.idx
Archiver-Version: Plexus Archiver
Built-By: Tekin
Start-Class: cn.tekin.MyApp
Spring-Boot-Classes: BOOT-INF/classes/
Spring-Boot-Lib: BOOT-INF/lib/
Spring-Boot-Version: 2.3.12.RELEASE
Created-By: Apache Maven 3.6.3
Build-Jdk: 1.8.0_362
Main-Class: org.springframework.boot.loader.JarLauncher

5. Web Application With Executable Tomcat

优点: 依赖项包含在jar文件中，容易部署和运行

不足: 很多年未发行新版本, 且因为在内置的war文件中打包了一个内置的tomcat发行包, 所以jar文件比较大.

 	<dependencies>
 	<!-- 其他依赖..... -->

 	<!-- servlet-api依赖 -->
	  <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>4.0.1</version>
            <scope>provided</scope>
        </dependency>

    </dependencies>

	<build>
        <finalName>${project.name}</finalName>
        <plugins>
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <version>2.2</version>
                <executions>
                    <execution>
                        <id>tomcat-run</id>
                        <goals>
                            <goal>exec-war-only</goal>
                        </goals>
                        <phase>package</phase>
                        <configuration>
                            <path>/</path>
                            <enableNaming>false</enableNaming>
                            <finalName>webapp.jar</finalName>
                            <charset>utf-8</charset>
                        </configuration>
                    </execution>
                </executions>
            </plugin>

        </plugins>
    </build>
  • 清单文件
Manifest-Version: 1.0
Main-Class: org.apache.tomcat.maven.runner.Tomcat7RunnerCli

6. One Jar Maven Plugin

优点: 干净的委托模型，允许类处于OneJar的顶级，支持外部Jar，并且可以支持Native库, 在jar文件中包含了one-jar的源码,可以自己扩展
不足: 停止维护很多年了.


<?xml version="1.0" encoding="UTF-8"?>
<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xmlns="http://maven.apache.org/POM/4.0.0"
         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>cn.tekin</groupId>
    <artifactId>spring_demo</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <spring.version>5.3.29</spring.version>
    </properties>

    <dependencies>
        <!-- https://mavenlibs.com/maven/dependency/org.springframework/spring-core -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- https://mavenlibs.com/maven/dependency/org.springframework/spring-context -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>


    </dependencies>

    <build>
        <finalName>${project.name}</finalName>
        <plugins>

            <plugin>
                <groupId>com.jolira</groupId>
                <artifactId>onejar-maven-plugin</artifactId>
                <executions>
                    <execution>
                        <configuration>
                            <mainClass>cn.tekin.MyApp</mainClass>
                            <attachToBuild>true</attachToBuild>
                            <classifier>Tekin</classifier>
                            <!--注意 在JDK1.8中, 使用filename 这个属性会导致 Unexpected end of ZLIB input stream异常-->
                        </configuration>
                        <goals>
                            <goal>one-jar</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>

        </plugins>
    </build>

</project>
  • 清单文件
Manifest-Version: 1.0
ImplementationVersion: 1.0-SNAPSHOT
Main-Class: com.simontuffs.onejar.Boot
One-Jar-Main-Class: cn.tekin.MyApp

总结

同一项目不同的插件生成的jar可执行文件文件大小比较:

  1. maven-jar-plugin 4.2M + 5kb
  2. Apache Maven Assembly Plugin 4.1M
  3. Apache Maven Shade Plugin 4.2M
  4. Spring Boot Maven Plugin 4.3M
  5. Web Application With Executable Tomcat 9.2M
  6. One Jar Maven Plugin 3.8M

完整示例git地址
https://gitee.com/tekintian/java-maven-executable-jar
https://github.com/tekintian/java-maven-executable-jar

tekin
关注
  • 28
    点赞
  • 踩
  • 32
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
java -jar 工作原理_可执行Jar包运行原理
weixin_35261775的博客
02-13 3764
spring boot有一个很方便的功能就是可以将应用打成可执行的jar。那么大家有没想过这个jar是怎么运行起来的呢？本篇博客就来介绍下spring boot可执行jar包的运行原理。1. 打可执行jar包将spring boot应用打成可执行jar包很容易，只需要在pom中加上一个spring boot提供的插件，然后在执行mvn package即可。org.springframework.b...
总结：利用JDK原生命令，制作可执行jar包与依赖jar包
weixin_48033662的博客
11-12 1845
JAR（Java Archive）是Java开发中常用的一种文件格式。它是一种归档文件，用于将多个Java类文件、资源文件和元数据打包成一个单独的文件。JAR文件通常用于分发和部署Java应用程序和库。JAR包可以包含编译后的Java类文件（.class文件）、配置文件、图像、音频文件等资源，以及描述这些文件的元数据信息。JAR包还可以包含清单文件（Manifest），用于指定JAR包的属性和配置信息。JAR包具有压缩功能，可以将多个文件压缩成一个较小的文件，以便更方便地传输和存储。
maven生成可执行jar命令
08-17
maven项目发布生成可运行的jar文件，发布到服务器直接运行
IDEA——将Java项目打包成可执行的Jar包
热门推荐
yzc775210的博客
07-04 4万+
在Java开发中，我们通常会将我们的项目打包成可执行的Jar包，以便于在其他环境中部署和运行。本文将介绍如何使用IDEA集成开发环境将Java项目打包成可执行的Jar包。
maven工程打包 把本地jar包、远程jar包和工程代码打包成一个jar包
最新发布
九二战歌的博客
05-07 757
如标题所言，本篇博客讲解一下maven打包如何把依赖包和工程代码打成一个jar包并且可以正常使用（因为有些方式打出来虽然是一个jar包，但是运行时候找不到对应的依赖）。从上面打包后的jar包内部结构图可以看到方式2的结构和方式1差别还是很大的，方式2是把对应jar包的class都拷贝进去，这种方式可能会导致有些需要证书认证的jar包无法使用。
Maven 打包可运行jar包
【设计改变世界】github地址：https://github.com/guochunyang2004
09-28 1万+
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，这样才能确定程序的入口在哪里；
Maven打包可执行jar包方法大全（史上最全）
weixin_49613823的博客
03-26 1万+
如果为true，则会在manifest文件中添加classpath，这样在启动的时候就不用再手动指定classpath了。打成的最终jar包中没有所依赖的jar包。如上面的manifest文件中，Class-Path的值中，每个jar包的前缀都是。后，会在target文件夹下生成两个jar包，一个是不带依赖的jar包，一个是后缀有。后，会在target文件夹下生成两个jar包，一个是不带依赖的jar包，一个是后缀有。本质上，这个配置的值是所依赖jar包所在的文件夹。可以将所有的东西都打包到一个jar包中。
Maven工程打包jar
myli92的博客
03-31 5739
Maven打包一般可以生成两种包一种是可以直接运行的包，一种是依赖包（只是编译包）。Maven默认打包时jar，如果需要修改其他类型。
生成可运行jar
09-03
生成可运行的jar包步骤，包含项目中有第三方包的时候该怎么处理，生成jar可以做到完全跨平台，而不是生成exe，若要生成exe，请参看鄙人生成exe资源
用Maven打成可执行jar,包含maven依赖,本地依赖的操作
08-18
主要介绍了用Maven打成可执行jar,包含maven依赖,本地依赖的操作，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
idea将maven项目改成Spring boot项目的方法步骤
09-07
添加`spring-boot-maven-plugin`，这个插件能够将Spring Boot应用打包成可执行的JAR或WAR文件： ```xml <groupId>org.springframework.boot <artifactId>spring-boot-maven-plugin ``` 5. **创建...
Spring Boot Maven 打包可执行Jar文件的实现方法
08-28
Spring Boot Maven 打包可执行Jar文件的实现方法 Spring Boot 框架是基于 Java 语言的开源框架，提供了一个简洁的方式来构建基于 Spring 框架的应用程序。Maven 是一个流行的项目管理工具，提供了项目构建、依赖...
Spring Boot创建可执行jar包的实例教程
08-28
Spring Boot创建可执行jar包是指将 Spring Boot 应用程序打包成一个可以独立运行的jar文件，从而不需要依赖 Tomcat 或其他应用服务器。下面是 Spring Boot 创建可执行jar包的实例教程。 首先，在 pom.xml 文件中...
spring boot打包成可执行jar包
08-29
maven-compiler-plugin 用于编译 Java 代码，而 spring-boot-maven-plugin 用于将 Spring Boot 应用程序打包成可执行 JAR 包。 在 spring-boot-maven-plugin 中，我们指定了 mainClass 属性，指向了应用程序的主类...
maven-springboot-electron：仅使用Maven将Java Web应用程序与Electron + OpenJDK打包
02-04
这个项目是用电子作为本机可执行文件包装任何Java Web应用程序（使用Springboot的fe）的起点。 对于构建过程，仅使用maven。 该项目包含所有必要的配置和一些占位符文件，以帮助您入门。 该项目的灵感来自 ，但有...
idea将Java项目打包Jar包，并生成exe可执行文件，并在无环境的电脑上运行
weixin_50667675的博客
04-03 3419
现在输出编译文件输出地址，一会儿要执行这个文件，然后是安装文件名称，最后是安装文件图标。第一步：打开Project Structure设置界面，点击Artifacts。这样我们就完成了java程序的打包工作，你只需要把安装文件发给其他人运行就可以了。现在需要打包的exe文件，在添加需要打包的所有文件。最后会执行编译文件进行打包，生成安装文件。第二步：然后继续添加modle，如下。首先，先删除文件夹中的jar。点击文件->新建->下一步。选择项目类型点击下一步。然后一直下一步就可以了。界面设置，DPI设置。
maven创建springboot项目
04-23
好的，我可以为您提供关于如何使用Maven创建Spring Boot项目的步骤： 1. 打开您的Maven控制台或命令行工具。 2. 输入以下命令来创建一个新的Maven项目：mvn archetype:generate -DgroupId=com.example -DartifactId=my-springboot-app -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false 3. 确保您已经安装了Spring Boot插件，在pom.xml文件中添加以下内容： ```xml <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> ``` 4. 运行mvn package命令来生成一个可执行的JAR文件：mvn package 5. 运行应用程序：java -jar target/my-springboot-app-0.0.1-SNAPSHOT.jar 这就是创建一个简单的Spring Boot应用程序的基本步骤，希望对您有所帮助。如果您有任何其他问题，请随时向我提问。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值