Java 从springboot服务器运行jar应用程序

我正在运行springboot服务器。 此服务器有一些Web服务。 其中一个服务在收到请求时必须运行外部jar。实际上，服务器是计算引擎（jar）和用户之间的接口。 代码如下：

public class Launcher extends Thread{

@Override
public void run() {
    // TODO Auto-generated method stub
    runJar(this.getJar(), this.getArgs());

}






private void runJar(String jar, String[] args){
    try {
        String[] s = new String[4+args.length];
        s[0] = "nohup";
        s[1] = "java";
        s[2] = "-jar";
        s[3] = jar;
        for(int i = 0; i < args.length; i++){
            s[i+4] = args[i];
        }
        Process p = Runtime.getRuntime().exec(s);

        //Process exec = Runtime.getRuntime().exec(new String[] {"mkdir", "monTest"});


    } catch (IOException e) {
        // TODO Auto-generated catch block
        System.out.println("failed");
        e.printStackTrace();
    } 
}
}

public class Memory {

private ArrayList<Integer> startedIds;

public ArrayList<Integer> getStartedIds() {
    return startedIds;
}

public void setStartedIds(ArrayList<Integer> startedIds) {
    this.startedIds = startedIds;
}

public Memory() {
    this.startedIds = new ArrayList<>();
}

public Memory(ArrayList<Integer> arr) {
    this.startedIds = arr;
}

public int start() {
    int id = this.findAvailableId();
    this.getStartedIds().add(id);
    System.out.println("i'm going to start with a big command!+uhpop");
    String[] args = {"arg1","arg2", "arg3", "&"};
    Launcher launcher = new Launcher("myJar.jar", args);
    launcher.start();


    return id;
}

private int findAvailableId() {
    int id = 0;
    while(this.getStartedIds().contains(id)){
        id++;
    }
    return id;
}

}

几秒钟后它停了下来

我以为这有点像超时，但实际上这不是一个固定的时间。可能是内存问题

我曾尝试在springboot服务器之外运行相同的代码（在一个简单的java项目main上，启动Memory.start（），它运行得很好。所以我认为这是我对spring boot的误解。如果有人知道如何使这个jar独立于springboot服务器运行，请告诉我。

---

谢谢。

我终于找到了解决方案。我不得不放置一个

p.waitFor();

因此启动jar的线程不会停止。然后，jar的输入和输出没有连接到启动线程的输入/输出，然后，我必须创建另一个线程来监视jar的输出（它实际上在主线程中打印）。我在这里找到了这些信息： 我仍然不明白为什么它在springboot服务器之外工作，实际上它不应该运行

如果有人感兴趣，这是我的代码

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;

class AfficheurFlux implements Runnable {

private final InputStream inputStream;

AfficheurFlux(InputStream inputStream) {
    this.inputStream = inputStream;
}

private BufferedReader getBufferedReader(InputStream is) {
    return new BufferedReader(new InputStreamReader(is));
}

@Override
public void run() {
    BufferedReader br = getBufferedReader(inputStream);
    String ligne = "";
    try {
        while ((ligne = br.readLine()) != null) {
            System.out.println(ligne);
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}
}


public class Memory {

private ArrayList<Integer> startedIds;

public ArrayList<Integer> getStartedIds() {
    return startedIds;
}

public void setStartedIds(ArrayList<Integer> startedIds) {
    this.startedIds = startedIds;
}

public Memory() {
    this.startedIds = new ArrayList<>();
}

public Memory(ArrayList<Integer> arr) {
    this.startedIds = arr;
}

public int startJar() {
    int id = this.findAvailableId();
    this.getStartedIds().add(id);
    System.out.println("i'm going to start with a big command!");
    String[] args = {"arg1","arg2", "arg3"};
    Launcher launcher = new Launcher("myJar.jar", args);
    launcher.start();
    return id;
}

private int findAvailableId() {
    int id = 0;
    while(this.getStartedIds().contains(id)){
        id++;
    }
    return id;
}






public class Launcher extends Thread{

private String jar;
private String[] args;

public AntLauncher(String jar, String[] args) {
    super();
    this.jar = jar;
    this.args = args;
}

@Override
public void run() {
    runJar(this.getJar(), this.getArgs());

}

private void runJar(String jar, String[] args){
    try {
        String[] s = new String[3+args.length];
        s[0] = "java";
        s[1] = "-jar";
        s[2] = jar;
        for(int i = 0; i < args.length; i++){
            s[i+3] = args[i];
        }
        Process p = Runtime.getRuntime().exec(s);
         AfficheurFlux fluxSortie = new AfficheurFlux(p.getInputStream());
         AfficheurFlux fluxErreur = new AfficheurFlux(p.getErrorStream());

            new Thread(fluxSortie).start();
            new Thread(fluxErreur).start();

            p.waitFor();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Fin du programme");
        }
    }
}

导入java.io.BufferedReader；
导入java.io.IOException；
导入java.io.InputStream；
导入java.io.InputStreamReader；
类AfficheurFlux实现可运行{
私有最终输入流InputStream；
AfficheurFlux（InputStream InputStream）{
this.inputStream=inputStream；
}
私有BufferedReader getBufferedReader（InputStream为）{
返回新的BufferedReader（新的InputStreamReader（is））；
}
@凌驾
公开募捐{
BufferedReader br=getBufferedReader（inputStream）；
字符串ligne=“”；
试一试{
而（（ligne=br.readLine（））！=null）{
系统输出打印LN（ligne）；
}
}捕获（IOE异常）{
e、 printStackTrace（）；
}
}
}
公共类内存{
私有ArrayList StartedId；
公共ArrayList GetStartedId（）{
返回startedid；
}
公共无效集合开始ID（ArrayList开始ID）{
this.startedIds=startedIds；
}
公共内存（）{
this.startedIds=new ArrayList（）；
}
公共内存（ArrayList arr）{
this.startedIds=arr；
}
公共int startJar（）{
int id=this.findAvailableId（）；
this.getStartedIds（）.add（id）；
System.out.println（“我将从一个大命令开始！”）；
字符串[]args={“arg1”、“arg2”、“arg3”}；
Launcher Launcher=new Launcher（“myJar.jar”，args）；
start（）；
返回id；
}
私有int findAvailableId（）{
int id=0；
而（this.getStartedIds（）.contains（id））{
id++；
}
返回id；
}
公共类启动器扩展线程{
私有字符串jar；
私有字符串[]args；
公共AntLauncher（字符串jar，字符串[]args）{
超级（）；
this.jar=jar；
this.args=args；
}
@凌驾
公开募捐{
runJar（this.getJar（），this.getArgs（））；
}
私有void runJar（字符串jar，字符串[]args）{
试一试{
字符串[]s=新字符串[3+参数长度]；
s[0]=“java”；
s[1]=“-jar”；
s[2]=jar；
对于（int i=0；i

我终于找到了解决方案。我不得不放置一个

p.waitFor();

因此启动jar的线程不会停止。然后，jar的输入和输出没有连接到启动线程的输入/输出，然后，我必须创建另一个线程来监视jar的输出（它实际上在主线程中打印）。我在这里找到了这些信息： 我仍然不明白为什么它在springboot服务器之外工作，实际上它不应该运行

如果有人感兴趣，这是我的代码

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;

class AfficheurFlux implements Runnable {

private final InputStream inputStream;

AfficheurFlux(InputStream inputStream) {
    this.inputStream = inputStream;
}

private BufferedReader getBufferedReader(InputStream is) {
    return new BufferedReader(new InputStreamReader(is));
}

@Override
public void run() {
    BufferedReader br = getBufferedReader(inputStream);
    String ligne = "";
    try {
        while ((ligne = br.readLine()) != null) {
            System.out.println(ligne);
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}
}


public class Memory {

private ArrayList<Integer> startedIds;

public ArrayList<Integer> getStartedIds() {
    return startedIds;
}

public void setStartedIds(ArrayList<Integer> startedIds) {
    this.startedIds = startedIds;
}

public Memory() {
    this.startedIds = new ArrayList<>();
}

public Memory(ArrayList<Integer> arr) {
    this.startedIds = arr;
}

public int startJar() {
    int id = this.findAvailableId();
    this.getStartedIds().add(id);
    System.out.println("i'm going to start with a big command!");
    String[] args = {"arg1","arg2", "arg3"};
    Launcher launcher = new Launcher("myJar.jar", args);
    launcher.start();
    return id;
}

private int findAvailableId() {
    int id = 0;
    while(this.getStartedIds().contains(id)){
        id++;
    }
    return id;
}






public class Launcher extends Thread{

private String jar;
private String[] args;

public AntLauncher(String jar, String[] args) {
    super();
    this.jar = jar;
    this.args = args;
}

@Override
public void run() {
    runJar(this.getJar(), this.getArgs());

}

private void runJar(String jar, String[] args){
    try {
        String[] s = new String[3+args.length];
        s[0] = "java";
        s[1] = "-jar";
        s[2] = jar;
        for(int i = 0; i < args.length; i++){
            s[i+3] = args[i];
        }
        Process p = Runtime.getRuntime().exec(s);
         AfficheurFlux fluxSortie = new AfficheurFlux(p.getInputStream());
         AfficheurFlux fluxErreur = new AfficheurFlux(p.getErrorStream());

            new Thread(fluxSortie).start();
            new Thread(fluxErreur).start();

            p.waitFor();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Fin du programme");
        }
    }
}

导入java.io.BufferedReader；
导入java.io.IOException；
导入java.io.InputStream；
导入java.io.InputStreamReader；
类AfficheurFlux实现可运行{
私有最终输入流InputStream；
AfficheurFlux（InputStream InputStream）{
this.inputStream=inputStream；
}
私有BufferedReader getBufferedReader（InputStream为）{
返回新的BufferedReader（新的InputStreamReader（is））；
}
@凌驾
公开募捐{
BufferedReader br=getBufferedReader（inputStream）；
字符串ligne=“”；
试一试{
而（（ligne=br.readLine（））！=null）{
系统输出打印LN（ligne）；
}
}捕获（IOE异常）{
e、 printStackTrace（）；
}
}
}
公共类内存{
私有ArrayList StartedId；
公共ArrayList GetStartedId（）{
返回startedid；
}
公共无效集合开始ID（ArrayList开始ID）{
this.startedIds=startedIds；
}
公共内存（）{
this.startedIds=new ArrayList（）；
}
公共内存（ArrayList arr）{
this.startedIds=arr；
}
公共int startJar（）{
int id=this.findAvailableId（）；
this.getStartedIds（）.add（id）；
System.out.println（“我将从一个大命令开始！”）；
字符串[]args={“arg1”、“arg2”、“arg3”}；
Launcher Launcher=new Launcher（“myJar.jar”，args）；
start（）；
返回id；
}
私有int findAvailableId（）{
int id=0；
而（this.getStartedIds（）.contains（id））{
id++；
}
返回id；
}
公共类启动器扩展线程{
私有字符串jar；
私有字符串[]args；
公共AntLauncher（字符串jar，字符串[]args）{
超级（）；
this.jar=jar；
this.args=args；
}
@