linux环境中Java服务通过shell脚本重启(升级)自己

今天遇到一个远程升级的需求，通过接口去触发终端服务的接口，重新拉取最新的jar包，并重启终端服务，这个终端服务是用java写的。 实现该需求，两个步骤，一个是需要一个shell脚本：拉取jar包、kill掉服务、启动服务；还有一个就是java中收到消息去调用shell脚本。

脚本

启动命令：

/root/dtest/upgrade.sh jar-name 端口 jar下载地址 jar存放路径

# !/bin/bash
echo "start upgrade......"
## 判断参数是否正确
########### jar包名称 ############
APPLICATION_NAME=""
if [ ! $1 ]; then
  echo "待执行的jar名称 IS NULL"
  exit 1
else
    APPLICATION_NAME=$1".jar"
fi
SERVER_PORT=""
if [ ! $2 ]; then
  echo "端口 IS NULL"
  exit 1
else
    SERVER_PORT=$2
fi
########### 软件包下载地址 ############
FILE_URL=""
if [ ! $3 ]; then
  echo "软件包下载地址 IS NULL"
  exit 1
else
    FILE_URL=$3
fi
BASE_PATH=""
if [ ! $4 ]; then
  echo "软件包下载地址 IS NULL"
  BASE_PATH="/usr/local/docker"
else
  BASE_PATH=$4
fi
## kill 掉进程
PROCESS=`ps -ef|grep $APPLICATION_NAME|grep -v grep|grep -v PPID|awk '{ print $2}'`
for i in $PROCESS
do
  echo "停止服务:kill the $APPLICATION_NAME process [ $i ]"
  kill -9 $i
done
##备份
rm -rf $APPLICATION_NAME
## 下载应用服务包
echo "download the application package"
echo "升级包下载命令 wget $FILE_URL -O "/root/dtest/"$APPLICATION_NAME"
wget $FILE_URL -O "/root/dtest/"$APPLICATION_NAME
echo "升级包下载完成!!!"
## 启动服务
echo "开始启动 $1 服务"
chmod 777 $APPLICATION_NAME
nohup java -server -jar -XX:MetaspaceSize=256m -XX:MaxMetaspaceSize=256m -Xms256m -Xmx512m -Xmn256m -Xss256k -XX:SurvivorRatio=8 -XX:+UseConcMarkSweepGC $BASE_PATH"/"$APPLICATION_NAME --server.port=$SERVER_PORT   2>&1 &
echo "服务启动命令:java -server -jar -XX:MetaspaceSize=256m -XX:MaxMetaspaceSize=256m -Xms256m -Xmx512m -Xmn256m -Xss256k -XX:SurvivorRatio=8 -XX:+UseConcMarkSweepGC $BASE_PATH"/"$APPLICATION_NAME --server.port=$SERVER_PORT > /dev/null 2>&1 &"
for st in $(seq 1 20)
    do
#        PID=$(netstat -nlp | grep :$EXECUTE_PORT | awk '{print $7}' | awk -F"/" '{ print $1 }');
        PID=$(netstat -nlp | grep :$SERVER_PORT | awk '{print $7}' |sed 's/([0-9]*).*/1/g');
        if [ $st -eq 20 ] && [ -z "$PID" ]; then
            echo "服务启动失败" ### $PID 为空
            break
        fi

        if [ -z "$PID" ]; then
            sleep 2
            echo $st"服务启动中...." ### $PID 为空
        else
            echo "服务名称：$APPLICATION_NAME ,端口号为:$SERVER_PORT ,进程号为：$PID 启动成功 , 耗时：$[$[st-1]*3] seconds！！！"
            break
        fi
    done

Java程序

java调用shell脚本有多种方式，简单粗暴的方式是：Runtime.getRuntime().exec() 

但现实给我上了一课，当kill掉自己服务后，后面的脚本也停止执行了，原因处在，当服务执行自身重启的命令时,父进程关闭导致管道连接中断,将导致子进程也崩溃,从而无法完成后续的启动。

解决方式,

1. 设置子进程IO输出重定向到指定文件
2. 设置属性子进程的I/O源或目标将与当前进程的相同,两者相互独立

上代码：（源码下载）

package com.dzh.boot.demo.controller;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.io.File;
import java.io.IOException;

/**
 * 升级当前服务 --- 拉取最新jar，杀掉当前服务，启动最新的jar
 * @date 2021.4.9
 */
@RestController
public class UpgradeController {

    //脚本的地址
    @Value("${my.test.scriptPath}")
    private String scriptPath;

    /**
     * jar包的名称  去掉.jar
     */
    @Value("${my.test.name}")
    private String applicationName;

    /**
     * 服务启动的端口
     */
    @Value("${server.port}")
    private String port;

    /**
     * 最新jar包的下载地址
     */
    @Value("${my.test.fileUrl}")
    private String fileUrl;

    /**
     * jar包放置的路径
     */
    @Value("${my.test.basePath}")
    private String basePath;

    /**
     * 触发升级
     * @return
     * @throws Exception
     */
    @RequestMapping("run")
    private String run() throws Exception {
        ProcessBuilder sh = new ProcessBuilder("sh", scriptPath, applicationName, port, fileUrl, basePath);
        asynExeLocalComand(null, sh);
        return "成功";
    }

    /**
     * 用来检查服务是否正常
     * @return
     * @throws IOException
     */
    @RequestMapping("getParam")
    private String getParam() throws IOException {
        return scriptPath + "  " + applicationName + "  " + fileUrl + "   " + basePath + "  " + port;
    }



    public static void asynExeLocalComand(File file, ProcessBuilder pb) throws IOException {
        // 不使用Runtime.getRuntime().exec(command)的方式,因为无法设置以下特性
        // Java执行本地命令是启用一个子进程处理,默认情况下子进程与父进程I/O通过管道相连(默认ProcessBuilder.Redirect.PIPE)
        // 当服务执行自身重启的命令时,父进程关闭导致管道连接中断,将导致子进程也崩溃,从而无法完成后续的启动
        // 解决方式,(1)设置子进程IO输出重定向到指定文件;(2)设置属性子进程的I/O源或目标将与当前进程的相同,两者相互独立
        if (file == null || !file.exists()) {
            // 设置属性子进程的I/O源或目标将与当前进程的相同,两者相互独立
            pb.redirectOutput(ProcessBuilder.Redirect.INHERIT);
            pb.redirectError(ProcessBuilder.Redirect.INHERIT);
            pb.redirectInput(ProcessBuilder.Redirect.INHERIT);
        } else {
            // 设置子进程IO输出重定向到指定文件
            // 错误输出与标准输出,输出到一块
            pb.redirectErrorStream(true);
            // 设置输出日志
            pb.redirectOutput(ProcessBuilder.Redirect.appendTo(file));
        }
        // 执行命令进程
        pb.start();
    }

}