精华内容
下载资源
问答
  • 用java –jar 命令运行Jar
    千次阅读
    2021-02-28 17:16:29

    摘要

    这个技巧阐明了如何不直接处理清单文件而将一个不能运行jar包转换成一个可以执行的jar包。学会如何写一段转换jar包的程序,将你的jar包转换成你能使用java -jar 命令运行jar包或象在windows系统上那样通过双击来运行jar包。

    你可以很容易地将一个应用的所有的类和资源打包到一个jar文件中去。事实上,这只是打包的一个原因。另一个原因是让用户很容易地执行包中的应用。那么在java的世界里,为什么jar是第二类公民――仅仅用作打包――当他们能成为第一类公民的时候,能和本地执行程序一样吗?

    如果想执行jar文件,可以使用java命令的-jar选项。例如,你有一个可以运行的myjar.jar文件。因为该文件是可以执行的,所以你可以用如下命令执行之:java –jar myjar.jar。此外,安装在windows JRE将会把jar文件和JVM关联起来,以便通过双击来运行jar应用。

    现在的问题是:如何把jar做成可以运行的包?

    清单文件和主类条目

    在大多数jar文件中,在目录META-INF里有个叫MANIFEST.MF的文件。在该文件中,有一个叫Main-Class的特殊条目,它说明了java -jar命令执行的类。

    问题是你必须正确地在清单文件中加入这个特殊的条目――它必须是在特定的位置和特定的格式。可是,好多人不喜欢修改配置文件。

    用API修改改配置

    从java1.2之后,一个叫java.util.jar的包可以操作jar文件(注:它架构在java.util.zip包之上)。Jar包能让你通过Manifest类很容易地操作专门的清单文件。

    让我们使用这些API写一个程序。首先,这个程序必须知道三件事:

    我们想让它执行的jar文件;

    我们想执行的main类(这个文件必须存在于jar包中);

    我们要输出的新jar包的名称,因为不是简单地覆盖原文件;

    编写代码

    上面的列表将组成我们程序的参数。在这里,让我们选择一个合适名字,MakeRunnable咋样?

    检查送入main的参数

    假设我们的main入口是标准的main(String[])方法。我们首先应该检查程序的参数:

    if (args.length != 3) {

    System.out.println("Usage: MakeJarRunnable "

    + "

    ");

    System.exit(0);

    }

    由于对后面的程序执行非常重要,一定要注意这个参数列表是如何解释的。参数的顺序和内容不是一成不变的;如果你改变了它们,记得要修改其它代码。

    存取jar和它的清单文件

    首先,我们必须创建一些知道jar和清单文件的对象:

    //创建JarInputStream对象,获取它的清单

    JarInputStream jarIn = new JarInputStream(new FileInputStream(args[0]));

    Manifest manifest = jarIn.getManifest();

    if (manifest == null) {

    //如果清单不存在

    manifest = new Manifest();

    }

    设置Main类的属性

    我们把Main-Class条目放到清单文件里main属性部分。一旦我们从mainfest对象中得到这个属性集,我们就能设置合适的main类。然而,如果Main-Class属性存在于原始的JAR文件中怎么办?这个程序仅仅打印出一个警告信息并退出。或许,我们可以添加一个命令行参数告诉程序使用新值而不是使用以前的一个:

    Attributes a = manifest.getMainAttributes();

    String oldMainClass = a.putValue("Main-Class", args[1]);

    //如果旧值存取,显示提示信息并退出

    if (oldMainClass != null) {

    System.out.println("Warning: old Main-Class value is: "

    + oldMainClass);

    System.exit(1);

    }

    输出新的JAR包

    我们需要创建一个新的jar文件,因此我们必须使用JarOutputStream类。注意:我们必须确保输出文件和输入文件不相同。作为可选方案,应该考虑如果两个文件同名,程序应该提示用户是否覆盖原始文件。我将这个作为练习留给读者。下面是代码。

    System.out.println("Writing to " + args[2] + "...");

    JarOutputStream jarOut = new JarOutputStream(new FileOutputStream(args[2]),  manifest);

    我们必须将输入jar中每一个条目写到输出jar文件中去,因此,在所有的条目上进行枚举:

    //为了从输入中转移数据而创建读缓存

    byte[] buf = new byte[4096];

    //枚举所有条目

    JarEntry entry;

    while ((entry = jarIn.getNextJarEntry()) != null) {

    //排除旧jar文件中的清单文件

    if ("META-INF/MANIFEST.MF".equals(entry.getName())) continue;

    //把条目写到输出jar文件中去

    jarOut.putNextEntry(entry);

    int read;

    while ((read = jarIn.read(buf)) != -1) {

    jarOut.write(buf, 0, read);

    }

    jarOut.closeEntry();

    }

    //刷新和关闭所有的流

    jarOut.flush();

    jarOut.close();

    jarIn.close();

    完成程序

    当然,我们必须将这些代码放到一个类中的main方法中,以及引入一些需要的包。资源一节提供了完整的程序。

    用法例子

    让我们用一个例子说明如何使用这个程序。假设你有一个main入口在叫做HelloRunnableWorld(类全名)类之中的应用,以及你已经创建了一个叫做myjar.jar的jar包,它包含了整个应用。在这个包上运行MakeJarRunnable,如下所示:

    java MakeJarRunnable myjar.jar HelloRunnableWorld myjar_r.jar

    此外,如前所述,注意我是如何安排参数列表顺序的。如果你忘记了顺序,运行一下这个不带参数的程序,它将会显示一个用法信息。

    试着用java -jar命令运行myjar.jar文件,之后在myjar_r.ja文件上。注意他们的不同!完成之后,研究在每一个jar包中的清单文件(META-INF/MANIFEST.MF)。

    建议:试着将MakeJarRunnable制作成一个可以运行的Jar文件!

    用它处理你想运行的jar包

    通过双击或者使用简单的命令运行一个jar包,总是要比把它放到 gagaghost

    更多相关内容
  • 主要介绍了如何将java打包成可执行的jar,并执行jar包中指定的main方法的相关资料,文中给出了详细的示例代码,对大家具有一定的参考价值,需要的朋友们下面来一起看看吧。
  • 本文通过四种方法给大家介绍java命令执行jar包的方式,每种方法通过实例代码给大家详解,需要的朋友参考下吧
  • 主要介绍了浅谈IDEA2018打包可执行jar包的流程,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 在linux系统中执行jar包,我们需要先杀掉对应端口的进程,然后执行java -jar命令,启动服务
  • 主要给大家介绍了在Linux下用java -jar运行执行jar包的方法教程,文中介绍的非常详细,相信对大家的工作或者学习具有一定的参考学习价值,需要的朋友们下面来一起看看吧。
  • MAVEN打可运行jar

    2019-04-15 01:14:10
    NULL 博文链接:https://gghaomm.iteye.com/blog/1754767
  • 服务器端运行jar包,后台打印日志,解决ctrl+c结束jar进程,后台运行,打印日志,注意需要替换成你的jar包路径,和日志路径,然后给文件附上执行权限最后 ./start.sh
  • Linux运行jar执行文件,内附说明文件,先看说明文件再修改一下执行文件里面的内容需要根据情况而定,通过修改内容后就可在Linux系统下后台运行jar包,并打印日志
  • 主要介绍了centOS6中使用crontab定时运行执行jar程序的脚本,本文给大家介绍的非常详细,具有一定的参考借鉴价值,需要的朋友可以参考下
  • NULL 博文链接:https://hufeng.iteye.com/blog/574339
  • windows运行jar包指定jdk路径的脚本文件。可以不用系统的jdk运行,指定某个文件下的jdk运行jar
  • 执行jar包. 博文链接:https://taiyuan.iteye.com/blog/37494
  • 主要介绍了Maven如何构建可执行jar包(包含依赖jar包) ,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 运行hadoop jar

    2019-04-04 01:18:10
    NULL 博文链接:https://byx5185.iteye.com/blog/1490172
  • 本篇文章主要介绍了shell脚本运行java程序jar的方法,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 主要给大家介绍了关于将java程序打成jar包在cmd命令行下执行的相关资料,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧。
  • maven项目发布生成可运行jar文件,发布到服务器直接运行
  • windows上面运行jar文件1、ctrl+r进入CMD模式2.切换到jar所在的目录 我的XXX.jar在D:\workspace下面3.运行jarjava -jar XXX.jar...

    windows上面运行jar文件

    1、ctrl+r进入CMD模式 

    9dc0cfd6df8ec04e545a0155880e219d.png

    2.切换到jar所在的目录 我的XXX.jar在D:\workspace下面

    3726bee17fa3c5bd6d990bde685626fe.png

    3.运行jar

    java -jar XXX.jar

    Windows服务器后台运行jar包

    一.问题概述

     在windows的服务器中,通过打开一个cmd窗口,执行java --jar xxxx.jar的方式,每一个cmd窗口,相当于一个临时session会话,当cmd窗口关闭之后,启动的java程序就停止了。为了避免这种情况的发生,需要将执行jar包,以后台进程的方式执行jar包,类似linux服务器,以nohup java -jar xxx.jar的方式。

    二.解决办法

    2.1 查看windows服务器上的环境变量

    2.2 自定义程序启动名称

    在环境变量配置jdk路径的bin目录下的javaw.exe,复制一份修改成xxx.exe(名字任意取,原则和jar包的名称保持一致)。

    例如在D:\Program Files (x86)\Web Crawler\JDK\bin 下面将javaw.exe改成pachong-demo.exe,如下图

    2.3 编写执行启动bat脚本

    1.首先需要将jar包放到D:\code-jars下,同时在此目录下新建一个启动脚本:pachong-start-jars.bat,脚本内容如下(注意启动脚本,jar包要放在同一个目录):

    @echo off

    start pachong-demo  -jar  D:\code-jars\pachong-0.0.1-SNAPSHOT.jar >> D:\code-jars\log  &

    exit

    2.内容说明:

    pachong-demo 为上一步2.2 在jdk的bin目录下自定义的文件。

    D:\code-jars\pachong-0.0.1-SNAPSHOT.jar  为jar包存放的绝对路径。

    D:\code-jars\log  &   为log日志存储路径

    2.4 启动脚本

    1.选中脚本,右键,以管理员身份运行,提示输入用户名和密码

     2.通过任务管理器,查看自己的程序进程号:

    3.也可以通过端口号,查看自己程序的进程号:如输入:netstat -ano | findstr  8080,可以看到该程序使用的进程号

    展开全文
  • 自动运行Jar的bat脚本

    热门讨论 2013-08-27 17:15:39
    很简单的一句脚本 将该文件放到文件夹--“启动”中,可以实现jar文件的开机自动运行
  • 运行 jar 文件_如何运行JAR文件

    千次阅读 2020-07-19 04:34:52
    运行jar文件Today we will learn how to run JAR File in java. In last tutorial we learned how to create jar file. Here we will learn how to run jar file from command line and some other aspects of using...

    运行 jar 文件

    Today we will learn how to run JAR File in java. In last tutorial we learned how to create jar file. Here we will learn how to run jar file from command line and some other aspects of using jar file.

    今天,我们将学习如何在Java中运行JAR文件。 在上一个教程中,我们学习了如何创建jar文件 。 在这里,我们将学习如何从命令行运行jar文件以及使用jar文件的其他方面。

    如何运行JAR文件 (How to run JAR File)

    We can run a jar file using java command but it requires Main-Class entry in jar manifest file.

    我们可以使用java命令运行jar文件,但需要jar清单文件中的Main-Class条目。

    Main-Class is the entry point of the jar and used by java command to execute the class. My project structure looks like below image.

    Main-Class是jar的入口点,由java命令用于执行该类。 我的项目结构如下图所示。

    I have to add manifest file in jar file, so I will create a manifest file with below details.

    我必须在jar文件中添加清单文件,因此我将使用以下详细信息创建清单文件。

    manifest.txt

    manifest.txt

    Main-Class: com.journaldev.util.MyUtil

    Now we will use jar command to create jar file with our manifest file data.

    现在,我们将使用jar命令使用清单文件数据创建jar文件。

    pankaj@JD:~/CODE/MyProject/bin$ jar cvfm MyProject.jar manifest.txt com
    added manifest
    adding: com/(in = 0) (out= 0)(stored 0%)
    adding: com/journaldev/(in = 0) (out= 0)(stored 0%)
    adding: com/journaldev/test/(in = 0) (out= 0)(stored 0%)
    adding: com/journaldev/test/MyTest.class(in = 444) (out= 303)(deflated 31%)
    adding: com/journaldev/util/(in = 0) (out= 0)(stored 0%)
    adding: com/journaldev/util/MyUtil.class(in = 444) (out= 304)(deflated 31%)

    Now when I unpack and check the contents of MANIFEST.MF file, it contains following data.

    现在,当我打开包装并检查MANIFEST.MF文件的内容时,它包含以下数据。

    Manifest-Version: 1.0
    Created-By: 1.6.0_37 (Apple Inc.)
    Main-Class: com.journaldev.util.MyUtil

    Manifest-Version and Created-By entries are added by jar command. Now we are ready to run jar file through command line.

    Manifest-Version和Created-By条目由jar命令添加。 现在,我们准备通过命令行运行jar文件。

    从命令行运行Jar文件 (Run Jar File from command line)

    pankaj@JD:~/CODE/MyProject/bin$ java -jar MyProject.jar 
    MyUtil main method

    So it’s executed MyUtil main method. That’s great when we have single class with main method.

    因此它执行了MyUtil main方法。 当我们只有一个带有main方法的类时,这很棒。

    What if my project has multiple entry points and I want to change the entry point without creating the jar again. So we can use the jar command to update the manifest file.

    如果我的项目有多个入口点,并且我想更改入口点而不再次创建jar,该怎么办。 因此,我们可以使用jar命令来更新清单文件。

    For updating a file using jar command, file structure should be similar otherwise it will add new file to another directory. Since manifest file is located at META-INF/MANIFEST.MF. We will rename the manifest.txt to MANIFEST.MF and put it inside META-INF directory. Then run the below command to update the entry point.

    要使用jar命令更新文件,文件结构应相似,否则它将新文件添加到另一个目录。 由于清单文件位于META-INF/MANIFEST.MF 。 我们将manifest.txt重命名为MANIFEST.MF,并将其放入META-INF目录中。 然后运行以下命令更新入口点。

    pankaj@JD:~/CODE/MyProject/bin$ jar uvfm MyProject.jar META-INF/MANIFEST.MF 
    Jan 30, 2013 5:40:27 PM java.util.jar.Attributes read
    WARNING: Duplicate name in Manifest: Main-Class.
    Ensure that the manifest does not have duplicate entries, and
    that blank lines separate individual sections in both your
    manifest and in the META-INF/MANIFEST.MF entry in the jar file.
    updated manifest

    Note that warning is because of duplicate entries and manifest file can have only one entry for each meta property, but it still updates the entry point by updating the manifest file. Now when you will run the jar, it will execute the changed entry class.

    请注意,警告是由于条目重复,清单文件的每个元属性只能有一个条目,但是它仍然通过更新清单文件来更新入口点。 现在,当您运行jar时,它将执行更改后的条目类。

    What if we don’t want to change the entry point but want to execute another class from jar file. It seems confusing but solution is real simple. All you need to do it add the jar to class path and then execute the class like a normal java class with main method.

    如果我们不想更改入口点,但想从jar文件执行另一个类,该怎么办。 似乎令人困惑,但解决方案确实很简单。 您所需要做的就是将jar添加到类路径,然后像使用main方法的普通java类一样执行该类。

    pankaj@JD:~/CODE/MyProject/bin$ java -cp MyProject.jar com.journaldev.util.MyUtil
    MyUtil main method

    That’s all for how to run jar file in java with single entry point, different entry points and without any entry point at all using java classpath.

    这就是如何使用Java类路径在具有单个入口点,不同入口点并且根本没有任何入口点的Java中运行jar文件的全部内容。

    Reference: Oracle Doc

    参考: Oracle文档

    翻译自: https://www.journaldev.com/1344/run-jar-file

    运行 jar 文件

    展开全文
  • 执行 jar 和普通 jar 区别

    千次阅读 2020-10-21 20:20:10
    在我们的项目中使用IDEA可以将项目打包,可以打成可执行jar和普通的jar包,那么这两种jar有什么区别呢? 1.打包插件 Spring Boot 中默认打包成的 jar 叫做 可执行 jar,这种 jar 不同于普通的 jar,普通的 jar 不...

    可执行 jar 和普通 jar 区别

    在我们的项目中使用IDEA可以将项目打包,可以打成可执行jar和普通的jar包,那么这两种jar有什么区别呢?

    1.打包插件

    Spring Boot 中默认打包成的 jar 叫做 可执行 jar,这种 jar 不同于普通的 jar,普通的 jar 不可以通过 java -jar xxx.jar 命令执行,普通的 jar 主要是被其他应用依赖,Spring Boot 打成的 jar 可以执行,但是不可以被其他的应用所依赖,即使强制依赖,也无法获取里边的类。但是可执行 jar 并不是 Spring Boot 独有的,Java 工程本身就可以打包成可执行 jar 。

    既然同样是执行 mvn package 命令进行项目打包,为什么 Spring Boot 项目就打成了可执行 jar ,而普通项目则打包成了不可执行 jar 呢?原因就是两种jar目录结构不同。

    这我们就不得不提 Spring Boot 项目中一个默认的插件配置 spring-boot-maven-plugin ,这个打包插件存在 5 个方面的功能,从插件命令就可以看出:
    在这里插入图片描述

    • build-info:生成项目的构建信息文件 build-info.properties
    • repackage:这个是默认 goal,在 mvn package 执行之后,这个命令再次打包生成可执行的 jar,同时将 mvn package 生成的 jar 重命名为 *.origin
    • run:这个可以用来运行 Spring Boot 应用
    • start:这个在 mvn integration-test 阶段,进行 Spring Boot 应用生命周期的管理
    • stop:这个在 mvn integration-test 阶段,进行 Spring Boot 应用生命周期的管理

    这里功能,默认情况下使用就是 repackage 功能,其他功能要使用,则需要开发者显式配置。

    2.打包

    repackage 功能的 作用,就是在打包的时候,多做一点额外的事情:

    1.首先 mvn package 命令 对项目进行打包,打成一个 jar,这个 jar 就是一个普通的 jar,可以被其他项目依赖,但是不可以被执行。

    2.repackage 命令,对第一步 打包成的 jar 进行再次打包,将之打成一个 可执行 jar ,通过将第一步打成的 jar 重命名为 *.original 文件。

    对任意一个 Spring Boot 项目进行打包,可以执行 mvn package 命令,也可以直接在 IDEA 中点击 package ,如下 :
    在这里插入图片描述
    打包成功之后, target 中的文件如下:
    在这里插入图片描述
    这里有两个文件,第一个 springapplication-0.0.1-SNAPSHOT.jar 表示打包成的可执行 jar ,第二个 springapplication-0.0.1-SNAPSHOT.jar.original 则是在打包过程中 ,被重命名的 jar,这是一个不可执行 jar,但是可以被其他项目依赖的 jar。

    通过对这两个文件的解压,我们可以看出这两者之间的差异。

    3.两种 jar 的比较

    3.1 可执行 jar 解压之后,目录如下:

    在这里插入图片描述
    可以看到,可执行 jar 中,我们自己的代码是存在 于 BOOT-INF/classes/ 目录下,另外,还有一个 META-INF 的目录,该目录下有一个 MANIFEST.MF 文件,打开该文件,内容如下:

    Manifest-Version: 1.0
    Implementation-Title: demo
    Implementation-Version: 0.0.1-SNAPSHOT
    Start-Class: com.allan.demo.DemoApplication
    Spring-Boot-Classes: BOOT-INF/classes/
    Spring-Boot-Lib: BOOT-INF/lib/
    Build-Jdk-Spec: 1.8
    Spring-Boot-Version: 2.1.8.RELEASE
    Created-By: Maven Archiver 3.4.0
    Main-Class: org.springframework.boot.loader.JarLauncher

    可以看到,这里定义了一个 Start-Class,这就是可执行 jar 的入口类,Spring-Boot-Classes 表示我们自己代码编译后的位置,Spring-Boot-Lib 则表示项目依赖的 jar 的位置。

    换句话说,如果自己要打一个可执行 jar 包的话,除了添加相关依赖之外,还需要配置 META-INF/MANIFEST.MF 文件。

    3.2 不可执行 jar 解压之后

    首先将默认的后缀 .original 除去,进行解压,目录如下:
    在这里插入图片描述
    解压后可以看到,不可执行 jar 根目录就相当于我们的 classpath,解压之后,直接就能看到我们的代码,它也有 META-INF/MANIFEST.MF 文件,但是文件中没有定义启动类等。打开该文件,内容如下:

    Manifest-Version: 1.0
    Implementation-Title: demo
    Implementation-Version: 0.0.1-SNAPSHOT
    Build-Jdk-Spec: 1.8
    Created-By: Maven Archiver 3.4.0

    注意:这个不可以执行 jar 也没有将项目的依赖打包进来。

    从这里我们就可以看出,两个 jar ,虽然都是 jar 包,但是内部结构是完全不同的,因此一个可以直接执行,另一个则可以被其他项目依赖。

    4.一次打包两个 jar

    一般来说,Spring Boot 直接打包成可执行 jar 就可以了,不建议将 Spring Boot 作为普通的 jar 被其他的项目所依赖。如果有这种需求,建议将被依赖的部分,单独抽出来做一个普通的 Maven 项目,然后在 Spring Boot 中引用这个 Maven 项目。

    如果非要将 Spring Boot 打包成一个普通 jar 被其他项目依赖,技术上来说,也是可以的,给 spring-boot-maven-plugin 插件添加如下配置:

    	<build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <classifier>exec</classifier>
                </configuration>
            </plugin>
        </plugins>
    </build>
    
      
      
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    配置的 classifier 表示可执行 jar 的名字,配置了这个之后,在插件执行 repackage 命令时,就不会给 mvn package 所打成的 jar 重命名了,所以,打包后的 jar 如下:
    在这里插入图片描述
    第一个 jar 表示可以被其他项目依赖的 jar ,第二个 jar 则表示一个可执行 jar。

    展开全文
  • 如何运行jar文件

    千次阅读 2022-02-18 16:31:16
    //测试运行(关掉窗口即失效) java -jar whai-push.jar --spring.profiles.active=prod tail -f -n 100 (行数) 日志文件 //正式执行命令 nohup java -jar wuhai-push.jar --spring.profiles.active=prod > /...
  • 执行Jar运行原理

    千次阅读 2021-02-26 20:27:09
    本篇博客就来介绍下spring boot可执行jar包的运行原理。1. 打可执行jar包将spring boot应用打成可执行jar包很容易,只需要在pom中加上一个spring boot提供的插件,然后在执行mvn package即可。org.springframework.b...
  • Linux 运行jar包命令如下: 方式一: java -jar shareniu.jar 特点:当前ssh窗口被锁定,可按CTRL + C打断程序运行,或直接关闭窗口,程序退出 那如何让窗口不锁定? 方式二 java -jar shareniu.jar & &代表在后台...
  • docker运行jar

    千次阅读 2022-03-16 10:49:29
    docker run -d -p [宿主机端口]:[容器端口] -v [宿主机路径]:[容器路径] --name [容器名] [镜像] [需运行的命令] docker run -d -p 9000:9000 -v /opt/jar:/usr/jar --name java-test java:8 java -jar java-test....
  • 双击运行 jar 文件

    万次阅读 2022-03-22 10:18:04
    windows 下设置双击运行 jar 文件 大家都知道,项目打包的 jar 文件应该是可以直接运行的,虽然我们也可以用指令 java -jar xxx.jar 运行,但是总归是麻烦些,要是能双击直接打开岂不是很方便,下面我们就来一起看...
  • 在Linux服务器运行jar包并一直处于后台执行: 一、一般情况 jar包在linux的目录为 /jarmanager/xxx.jar 使用在/jarmanager目录下使用 java -jar xxx.jar 命令可以直接运行jar包的项目,运行成功之后使用crtl+c...
  • 全网最全Linux 运行jar包的几种方式

    千次阅读 2022-01-25 17:10:33
    一、Linux 运行jar包的几种方式 方式一: java -jar xxx.jar 最常用的启动jar包命令,特点:当前ssh窗口被锁定,可按CTRL + C打断程序运行,或直接关闭窗口,程序退出 方式二: java -jar xxx.jar & &...
  • 【Linux】nohup执行jar

    2022-02-21 13:20:07
    springboot 项目内嵌tomcat,一般打包成jar 直接使用 idea 执行打包操作,打包完成后在项目目录中就会生成 target 目录 把生成的 jar 包上传到服务器中,配置好对应的数据库信息等 执行命令 java -jar xxx.jar ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 994,051
精华内容 397,620
关键字:

运行jar

友情链接: BusHound+v6.0.1.rar