1. Toy模板网首页
  2. > Toy博客

普通Java工程可执行JAR两种打包方式探讨

8月前 作者：爱码少年 分类：Toy博客 阅读(57) 违法举报

这篇具有很好参考价值的文章主要介绍了普通Java工程可执行JAR两种打包方式探讨。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

一、需求概述

普通Java工程 docker-show 实现了定时打印docker应用信息，现在需要将其打包成可执行Jar部署到服务器端运行。

打包方式分为2种：

  1. 一体化可执行包
  2. 带外部依赖lib的可执行包

二、代码结构

普通Java工程可执行JAR两种打包方式探讨,雕虫小技,Java,java,jar

三、运行结果

此项目使用了线程池定时打印docker应用名，端口信息
普通Java工程可执行JAR两种打包方式探讨,雕虫小技,Java,java,jar
普通Java工程可执行JAR两种打包方式探讨,雕虫小技,Java,java,jar

四、打包设置

1. 一体化可执行包

pom文件中引入 maven-assembly-plugin插件，核心配置

			<!-- 方式一：带dependencies运行包 -->
			<plugin>
				<artifactId>maven-assembly-plugin</artifactId>
				<version>3.5.0</version>
				<configuration>
					<appendAssemblyId>false</appendAssemblyId>
					<archive>
						<manifest>
							<mainClass>com.fly.simple.MainRun</mainClass>
						</manifest>
					</archive>
					<descriptorRefs>
						<!--将所有外部依赖JAR都加入生成的JAR包-->
						<descriptorRef>jar-with-dependencies</descriptorRef>
					</descriptorRefs>
				</configuration>
				<executions>
					<execution><!-- 配置执行器 -->
						<id>make-assembly</id>
						<phase>package</phase><!-- 绑定到package阶段 -->
						<goals>
							<goal>single</goal><!-- 只运行一次 -->
						</goals>
					</execution>
				</executions>
			</plugin>

2. 带外部依赖lib的可执行包

pom文件中引入 maven-dependency-plugin、maven-jar-plugin插件，核心配置

			<!-- 方式二：外部依赖lib目录运行包 -->
			<!-- 将项目依赖包复制到<outputDirectory>指定的目录下 -->
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-dependency-plugin</artifactId>
				<version>3.1.2</version>
				<executions>
					<execution>
						<id>copy-dependencies</id>
						<phase>package</phase>
						<goals>
							<goal>copy-dependencies</goal>
						</goals>
						<configuration>
							<outputDirectory>${project.build.directory}/lib</outputDirectory>
							<excludeArtifactIds>lombok</excludeArtifactIds>
							<includeScope>runtime</includeScope>
							<!-- 默认为test，包含所有依赖 -->
						</configuration>
					</execution>
				</executions>
			</plugin>

			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-jar-plugin</artifactId>
				<version>3.2.0</version>
				<configuration>
					<archive>
						<manifest>
							<addClasspath>true</addClasspath>
							<classpathPrefix>lib</classpathPrefix>
							<mainClass>com.fly.simple.MainRun</mainClass>
						</manifest>
						<manifestEntries>
							<Class-Path>./</Class-Path>
						</manifestEntries>
					</archive>
				</configuration>
			</plugin>

五、打包运行

1. 源码放送

https://gitcode.com/00fly/demo

git clone https://gitcode.com/00fly/demo.git

或者使用下面的备份文件恢复成原始的项目代码

如何恢复，请移步查阅：神奇代码恢复工具

//goto pom-deps.xml
<?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>com.fly</groupId>
	<artifactId>docker-show</artifactId>
	<version>0.0.1</version>
	<name>java-depend</name>
	<url>http://maven.apache.org</url>
	<packaging>jar</packaging>

	<properties>
		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<java.version>1.8</java.version>
	</properties>
	<dependencies>
		<dependency>
			<groupId>org.apache.logging.log4j</groupId>
			<artifactId>log4j-slf4j-impl</artifactId>
			<version>2.12.1</version>
		</dependency>
		<dependency>
			<groupId>org.apache.commons</groupId>
			<artifactId>commons-lang3</artifactId>
			<version>3.5</version>
		</dependency>
		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
			<version>1.18.12</version>
			<scope>provided</scope>
		</dependency>
	</dependencies>
	<build>
		<finalName>${project.artifactId}</finalName>
		<plugins>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-compiler-plugin</artifactId>
				<version>3.8.1</version>
				<configuration>
					<source>1.8</source>
					<target>1.8</target>
				</configuration>
			</plugin>

			<!-- 方式一：带dependencies运行包 -->
			<plugin>
				<artifactId>maven-assembly-plugin</artifactId>
				<version>3.5.0</version>
				<configuration>
					<appendAssemblyId>false</appendAssemblyId>
					<archive>
						<manifest>
							<mainClass>com.fly.simple.MainRun</mainClass>
						</manifest>
					</archive>
					<descriptorRefs>
						<!--将所有外部依赖JAR都加入生成的JAR包-->
						<descriptorRef>jar-with-dependencies</descriptorRef>
					</descriptorRefs>
				</configuration>
				<executions>
					<execution><!-- 配置执行器 -->
						<id>make-assembly</id>
						<phase>package</phase><!-- 绑定到package阶段 -->
						<goals>
							<goal>single</goal><!-- 只运行一次 -->
						</goals>
					</execution>
				</executions>
			</plugin>
		</plugins>
	</build>
</project>
//goto pom-lib.xml
<?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>com.fly</groupId>
	<artifactId>docker-show</artifactId>
	<version>0.0.1</version>
	<name>java-depend</name>
	<url>http://maven.apache.org</url>
	<packaging>jar</packaging>

	<properties>
		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<java.version>1.8</java.version>
	</properties>
	<dependencies>
		<dependency>
			<groupId>org.apache.logging.log4j</groupId>
			<artifactId>log4j-slf4j-impl</artifactId>
			<version>2.12.1</version>
		</dependency>
		<dependency>
			<groupId>org.apache.commons</groupId>
			<artifactId>commons-lang3</artifactId>
			<version>3.5</version>
		</dependency>
		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
			<version>1.18.12</version>
			<scope>provided</scope>
		</dependency>
	</dependencies>
	<build>
		<finalName>${project.artifactId}</finalName>
		<plugins>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-compiler-plugin</artifactId>
				<version>3.8.1</version>
				<configuration>
					<source>1.8</source>
					<target>1.8</target>
				</configuration>
			</plugin>
			
			<!-- 方式二：外部依赖lib目录运行包 -->
			<!-- 将项目依赖包复制到<outputDirectory>指定的目录下 -->
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-dependency-plugin</artifactId>
				<version>3.1.2</version>
				<executions>
					<execution>
						<id>copy-dependencies</id>
						<phase>package</phase>
						<goals>
							<goal>copy-dependencies</goal>
						</goals>
						<configuration>
							<outputDirectory>${project.build.directory}/lib</outputDirectory>
							<excludeArtifactIds>lombok</excludeArtifactIds>
							<includeScope>runtime</includeScope>
							<!-- 默认为test，包含所有依赖 -->
						</configuration>
					</execution>
				</executions>
			</plugin>

			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-jar-plugin</artifactId>
				<version>3.2.0</version>
				<configuration>
					<archive>
						<manifest>
							<addClasspath>true</addClasspath>
							<classpathPrefix>lib</classpathPrefix>
							<mainClass>com.fly.simple.MainRun</mainClass>
						</manifest>
						<manifestEntries>
							<Class-Path>./</Class-Path>
						</manifestEntries>
					</archive>
				</configuration>
			</plugin>
		</plugins>
	</build>
</project>
//goto pom.xml
<?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>com.fly</groupId>
	<artifactId>docker-show</artifactId>
	<version>0.0.1</version>
	<name>java-depend</name>
	<url>http://maven.apache.org</url>
	<packaging>jar</packaging>

	<properties>
		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<java.version>1.8</java.version>
	</properties>
	<dependencies>
		<dependency>
			<groupId>org.apache.logging.log4j</groupId>
			<artifactId>log4j-slf4j-impl</artifactId>
			<version>2.12.1</version>
		</dependency>
		<dependency>
			<groupId>org.apache.commons</groupId>
			<artifactId>commons-lang3</artifactId>
			<version>3.5</version>
		</dependency>
		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
			<version>1.18.12</version>
			<scope>provided</scope>
		</dependency>
	</dependencies>
	<build>
		<finalName>${project.artifactId}</finalName>
		<plugins>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-compiler-plugin</artifactId>
				<version>3.8.1</version>
				<configuration>
					<source>1.8</source>
					<target>1.8</target>
				</configuration>
			</plugin>

			<!-- 方式一：带dependencies运行包 -->
			<plugin>
				<artifactId>maven-assembly-plugin</artifactId>
				<version>3.5.0</version>
				<configuration>
					<appendAssemblyId>true</appendAssemblyId>
					<archive>
						<manifest>
							<mainClass>com.fly.simple.MainRun</mainClass>
						</manifest>
					</archive>
					<descriptorRefs>
						<!--将所有外部依赖JAR都加入生成的JAR包-->
						<descriptorRef>jar-with-dependencies</descriptorRef>
					</descriptorRefs>
				</configuration>
				<executions>
					<execution><!-- 配置执行器 -->
						<id>make-assembly</id>
						<phase>package</phase><!-- 绑定到package阶段 -->
						<goals>
							<goal>single</goal><!-- 只运行一次 -->
						</goals>
					</execution>
				</executions>
			</plugin>


			<!-- 方式二：外部依赖lib目录运行包 -->
			<!-- 将项目依赖包复制到<outputDirectory>指定的目录下 -->
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-dependency-plugin</artifactId>
				<version>3.1.2</version>
				<executions>
					<execution>
						<id>copy-dependencies</id>
						<phase>package</phase>
						<goals>
							<goal>copy-dependencies</goal>
						</goals>
						<configuration>
							<outputDirectory>${project.build.directory}/lib</outputDirectory>
							<excludeArtifactIds>lombok</excludeArtifactIds>
							<includeScope>runtime</includeScope>
							<!-- 默认为test，包含所有依赖 -->
						</configuration>
					</execution>
				</executions>
			</plugin>

			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-jar-plugin</artifactId>
				<version>3.2.0</version>
				<configuration>
					<archive>
						<manifest>
							<addClasspath>true</addClasspath>
							<classpathPrefix>lib</classpathPrefix>
							<mainClass>com.fly.simple.MainRun</mainClass>
						</manifest>
						<manifestEntries>
							<Class-Path>./</Class-Path>
						</manifestEntries>
					</archive>
				</configuration>
			</plugin>
		</plugins>
	</build>
</project>
//goto src\main\java\com\fly\simple\Executor.java
package com.fly.simple;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.SystemUtils;

import lombok.extern.slf4j.Slf4j;

@Slf4j
public class Executor
{
    private static String DOCKER_PS_CMD = "docker ps --format \"{{.Names}} {{.Ports}}\"";
    
    /**
     * execute命令
     * 
     * @param command
     * @throws IOException
     * @see [类、类#方法、类#成员]
     */
    public static List<String> execute(String command)
        throws IOException
    {
        List<String> resultList = new ArrayList<>();
        String[] cmd = SystemUtils.IS_OS_WINDOWS ? new String[] {"cmd", "/c", command} : new String[] {"/bin/sh", "-c", command};
        Process ps = Runtime.getRuntime().exec(cmd);
        try (InputStream in = ps.getInputStream(); BufferedReader br = new BufferedReader(new InputStreamReader(in)))
        {
            String line;
            while ((line = br.readLine()) != null)
            {
                resultList.add(line);
            }
        }
        return resultList;
    }
    
    /**
     * 获取docker相关信息
     * 
     * @throws IOException
     */
    @Deprecated
    public static void printPorts1()
        throws IOException
    {
        Map<String, Set<String>> map = new TreeMap<>();
        for (String line : execute(DOCKER_PS_CMD))
        {
            log.info("{}", line);
            String name = StringUtils.substringBefore(line, " ");
            Set<String> ports =
                Stream.of(StringUtils.substringAfter(line, " ").split(",")).map(p -> StringUtils.substringBetween(p, ":", "->")).filter(StringUtils::isNotBlank).map(p -> p.replace(":", "")).sorted().collect(Collectors.toSet());
            map.put(name, ports);
        }
        log.info("######## {}", map);
    }
    
    /**
     * 获取docker相关信息
     * 
     * @throws IOException
     */
    public static void printPorts()
        throws IOException
    {
        Map<String, Set<String>> map = new TreeMap<>();
        execute(DOCKER_PS_CMD).stream()
            .map(line -> Collections.singletonMap(StringUtils.substringBefore(line, " "),
                Stream.of(StringUtils.substringAfter(line, " ").split(",")).map(p -> StringUtils.substringBetween(p, ":", "->")).filter(StringUtils::isNotBlank).map(p -> p.replace(":", "")).sorted().collect(Collectors.toSet())))
            .forEach(it -> map.putAll(it));
        log.info("######## {}", map);
    }
}
//goto src\main\java\com\fly\simple\MainRun.java
package com.fly.simple;

import java.io.IOException;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class MainRun
{
    /**
     * 线程池保证程序一直运行
     * 
     * @param args
     */
    public static void main(String[] args)
    {
        ScheduledExecutorService service = new ScheduledThreadPoolExecutor(1);
        service.scheduleAtFixedRate(() -> {
            try
            {
                Executor.printPorts();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
        }, 2, 10, TimeUnit.SECONDS);
    }
}
//goto src\main\resources\log4j2.xml
<?xml version="1.0" encoding="UTF-8"?>
<configuration status="off" monitorInterval="0">
	<appenders>
		<console name="Console" target="system_out">
			<patternLayout pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n" />
		</console>
	</appenders>
	<loggers>
		<root level="INFO">
			<appender-ref ref="Console" />
		</root>
	</loggers>
</configuration>

2. 打包执行

#完整打包
mvn clean package

#一体化可执行包
mvn clean package -f pom-deps.xml

#带外部依赖lib的可执行包
mvn clean package -f pom-lib.xml

3. 打包结果

普通Java工程可执行JAR两种打包方式探讨,雕虫小技,Java,java,jar

有任何问题和建议，都可以向我提问讨论,大家一起进步，谢谢!

-over-文章来源地址https://www.toymoban.com/news/detail-846130.html

到了这里，关于普通Java工程可执行JAR两种打包方式探讨的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • IDEA——将Java项目打包成可执行的Jar包

    IDEA——将Java项目打包成可执行的Jar包

    在Java开发中，我们通常会将我们的项目打包成可执行的Jar包，以便于在其他环境中部署和运行。本文将介绍如何使用IDEA集成开发环境将Java项目打包成可执行的Jar包。 步骤一：配置项目的执行入口 在开始之前，确保你的Java项目中已经配置了一个执行入口类（通常是包含mai

    2024年02月16日
    浏览(45)

  • jar命令打包java应用和java打jar包的几种方式详解

    jar是标准的java打包命令，位于JAVA_HOME/bin/目录下面。主要功能是将多个文件打包成一个单独的jar文件。 创建jar文件 jar c[v0Mmfe] [manifest] [jarfile] [entrypoint] [-C dir] inputfiles [-Joption] 更新jar文件 jar u[v0Mmfe] [manifest] [jarfile] [entrypoint] [-C dir] inputfiles [-Joption] 解压jar文件 jar x[vf] [jarfile

    2024年02月17日
    浏览(43)
  • 通过exe4j将 java 项目（jar）打包成exe可执行文件（详细步骤）

    通过exe4j将 java 项目（jar）打包成exe可执行文件（详细步骤）

    通过exe4j将 java 项目（jar）打包成exe可执行文件 文章目录 文章目录 一、下载安装 二、使用步骤 下载链接： ej-technologies - Java APM, Java Profiler, Java Installer Builder  安装只需一直下一步即可。 1.输入注册码“L-g782dn2d-1f1yqxx1rv1sqd”。 2.如下图： 3.如下图： 4.如下图： 5.如下图：

    2024年02月16日
    浏览(48)
  • JAVA工程中引用本地jar的3种常用方式，你用过哪种?

    JAVA工程中引用本地jar的3种常用方式，你用过哪种?

    实际项目过程中咱们经常会碰到需要本地引用jar包到java工程中的场景，本文就介绍一下遇到此场景时如何在IDEA中导入本地jar包到工程中的3种方式，简单却很常用。 IDEA - File - Project Structure - Modules - Dependencies - + - “JARs or Directories” 如果要添加的本地jar文件比较多，可以考虑

    2024年01月25日
    浏览(51)
  • 关于exe4j如何将java jar包打包成windows系统exe可执行文件，并包含JDK环境，超详细教程

    关于exe4j如何将java jar包打包成windows系统exe可执行文件，并包含JDK环境，超详细教程

    最近做了几个javaFX桌面软件，因为是maven项目，最后打包出来的是jar包，windows系统下要运行jar包，首先要安装JDK环境，然后敲命令：java -jar xxx.jar，才能运行程序，这样会显得很麻烦。而且前提是用户已经安装了JDK环境，所以实用性大大降低。这时就需要把jar包转化成exe可执

    2024年04月28日
    浏览(50)
  • Maven工程打包jar

    Maven工程打包jar

    Maven打包一般可以生成两种包一种是可以直接运行的包，一种是依赖包（只是编译包）。Maven默认打包时jar，如果需要修改其他类型。可以修改pom.xml Maven工程默认引入的插件:    生成的jar只是一个编译包，并没有 打包 依赖jar包。 通过控制台的编译日志可以看出来， 方式使用

    2024年02月04日
    浏览(43)

  • maven 模块打包时包含依赖和打包可执行的jar

    maven 模块打包 1）maven 模块打包jar文件时，指定包含依赖（with-dependencies）； 2）maven 模块打包jar文件时，指定入口MainClass、打包生成可执行的jar； vi qftools/common/src/main/java/com/xxx/qftools/common/Main.java package com.xxx.qftools.common; public class Main {     public static void main(String args[]) {    

    2024年02月14日
    浏览(77)

  • idea将普通项目更改为maven项目的两种方式

    今天写demo的时候发现自己建的项目不是maven项目，建时忘记了，demo已经写了很多了，于是找了几种普通项目更改成maven项目的方法。 右键工程文件，新建文件pom.xml，并填写好内容。 在pom.xml 文件上右键 Add as Maven Project。 3.idea自己导入maven。

    2024年02月15日
    浏览(46)

  • springboot项目打包成可执行jar

    spring-boot-maven-plugin是Spring Boot项目专用的构建插件，它可以将项目打包成一个可执行的JAR文件，内置了一个嵌入式的Servlet容器，方便于开发、测试和部署。在pom.xml文件中，你可以配置该插件的信息如下： pom.xml

    2024年02月07日
    浏览(45)

  • Deepin/UOS Linux 配置普通用户 sudo 权限 的两种方式

    Deepin/UOS Linux 配置普通用户 sudo 权限 的两种方式 root 用户下 配置 普通用户 sudo 权限 echo \\\"zhangsan ALL=(ALL:ALL) NOPASSWD: ALL\\\" /etc/sudoers root 用户下 配置 普通用户 到 sudo 组下 vim /etc/sudoers 修改下面这一行 改为 然后修改 /etc/group 改为 也是阔以的 我们下期见，拜拜！

    2024年02月16日
    浏览(46)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包