SpringBoot项目请求不中断动态更新代码的实现

更新时间：2024年09月30日 11:46:21 作者：不掉头发的阿水

在开发中,有时候不停机动态更新代码热部署是一项至关重要的功能,它可以在请求不中断的情况下下更新代码,这种方式不仅提高了开发效率,还能加速测试和调试过程,本文将详细介绍如何在 Spring Boot 项目在Linux系统中实现热部署,特别关注优雅关闭功能的实现

1. 代码概述

我们实现了一个简单的 Spring Boot 应用程序，它可以自动检测端口是否被占用，并在必要时切换到备用端口，然后再将目标端口程序关闭再将备用端口切换为目标端口。具体功能包括：

检查默认端口（8080）是否被占用。
如果被占用，自动切换到备用端口（8086）。
在 Linux 系统下，优雅地关闭占用该端口的进程。
修改Tomcat端口并重启容器。

完整代码

import com.lps.utils.PortUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.embedded.tomcat.TomcatServletWebServerFactory;
import org.springframework.boot.web.server.WebServer;
import org.springframework.boot.web.servlet.ServletContextInitializer;
import org.springframework.boot.web.servlet.server.ServletWebServerFactory;
import org.springframework.context.ConfigurableApplicationContext;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
 
/**
 * @author 阿水
 */
@SpringBootApplication
@Slf4j
public class MybatisDemoApplication {
 
    private static final int DEFAULT_PORT_8080 = 8080;
    private static final int ALTERNATE_PORT_8086 = 8086;
 
    public static void main(String[] args) {
        boolean isNeedChangePort = PortUtil.isPortInUse(DEFAULT_PORT_8080);
        String[] newArgs = Arrays.copyOf(args, args.length + 1);
        if (isNeedChangePort) {
            log.info("端口 {} 正在使用中, 正在尝试端口切换到 {}.", DEFAULT_PORT_8080, ALTERNATE_PORT_8086);
            newArgs[newArgs.length - 1] = "--server.port=" + ALTERNATE_PORT_8086;
        }
        log.info("启动参数: {}", Arrays.toString(newArgs));
        //去除newArgs的null数据
        newArgs = Arrays.stream(newArgs).filter(Objects::nonNull).toArray(String[]::new);
 
        ConfigurableApplicationContext context = SpringApplication.run(MybatisDemoApplication.class, newArgs);
        //判断是否是linux系统，如果是linux系统，则尝试杀死占用8080端口的进程
        System.out.println("是否需要修改端口: "+isNeedChangePort);
        if (isNeedChangePort && isLinuxOS()) {
            changePortAndRestart(context);
        }
    }
 
    /**
     * 如果端口占用，则尝试杀死占用8080端口的进程，并修改端口并重启服务
     *
     * @param context
     */
    private static void changePortAndRestart(ConfigurableApplicationContext context) {
        log.info("尝试杀死占用 8080 端口的进程.");
        killOldServiceInLinux();
        log.info("正在修改端口更改为 {}.", DEFAULT_PORT_8080);
        ServletWebServerFactory webServerFactory = context.getBean(ServletWebServerFactory.class);
        ServletContextInitializer servletContextInitializer = context.getBean(ServletContextInitializer.class);
        WebServer webServer = webServerFactory.getWebServer(servletContextInitializer);
 
        if (webServer != null) {
            log.info("停止旧服务器.");
            webServer.stop();
        }
        //((TomcatServletWebServerFactory) servletContextInitializer).setPort(DEFAULT_PORT_8080);
        ((TomcatServletWebServerFactory) webServerFactory).setPort(DEFAULT_PORT_8080);
        webServer = webServerFactory.getWebServer(servletContextInitializer);
        webServer.start();
        log.info("新服务启动成功.");
    }
 
    /**
     * 杀死占用 8080 端口的进程
     */
    private static void killOldServiceInLinux() {
        try {
            // 查找占用 8080 端口的进程
            String command = "lsof -t -i:" + DEFAULT_PORT_8080;
            log.info("正在执行命令: {}", command);
            Process process = Runtime.getRuntime().exec(command);
            BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
            String pid;
            while ((pid = reader.readLine()) != null) {
                // 发送 SIGINT 信号以优雅关闭
                Runtime.getRuntime().exec("kill -2 " + pid);
                log.info("Killed process: {}", pid);
            }
        } catch (IOException e) {
            log.error("Failed to stop old service", e);
        }
    }
 
    /**
     * 判断是否是linux系统
     *
     * @return
     */
    private static boolean isLinuxOS() {
        return System.getProperty("os.name").toLowerCase().contains("linux");
    }
}

工具类

import java.io.IOException;
import java.net.ServerSocket;
 
/**
 * @author 阿水
 */
public class PortUtil {
    public static boolean isPortInUse(int port) {
        try (ServerSocket ignored = new ServerSocket(port)) {
            // 端口未被占用
            return false;
        } catch (IOException e) {
            // 端口已被占用
            return true;
        }
    }
}

测试效果

2. 主要功能

检测端口状态

通过 PortUtil.isPortInUse() 检查默认端口的使用状态。如果端口被占用，修改启动参数。

import java.io.IOException;
import java.net.ServerSocket;
 
/**
 * @author 阿水
 */
public class PortUtil {
    public static boolean isPortInUse(int port) {
        try (ServerSocket ignored = new ServerSocket(port)) {
            // 端口未被占用
            return false;
        } catch (IOException e) {
            // 端口已被占用
            return true;
        }
    }
}

修改启动参数

当发现端口被占用时，我们动态调整启动参数，以便在启动时使用新的端口。

     if (isNeedChangePort) {
            log.info("端口 {} 正在使用中, 正在尝试端口切换到 {}.", DEFAULT_PORT_8080, ALTERNATE_PORT_8086);
            newArgs[newArgs.length - 1] = "--server.port=" + ALTERNATE_PORT_8086;
        }

优雅关闭

在 Linux 系统中，如果检测到端口被占用，调用 killOldServiceInLinux() 方法，优雅地关闭占用该端口的进程。这是通过发送 SIGINT 信号实现的，允许应用程序进行清理工作并优雅退出。

 /**
     * 杀死占用 8080 端口的进程
     */
    private static void killOldServiceInLinux() {
        try {
            // 查找占用 8080 端口的进程
            String command = "lsof -t -i:" + DEFAULT_PORT_8080;
            log.info("正在执行命令: {}", command);
            Process process = Runtime.getRuntime().exec(command);
            BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
            String pid;
            while ((pid = reader.readLine()) != null) {
                // 发送 SIGINT 信号以优雅关闭
                Runtime.getRuntime().exec("kill -2 " + pid);
                log.info("Killed process: {}", pid);
            }
        } catch (IOException e) {
            log.error("Failed to stop old service", e);
        }
    }

3. 代码实现

代码的核心逻辑在 changePortAndRestart() 方法中实现，主要步骤包括停止当前 Web 服务器并重启。

    /**
     * 如果端口占用，则尝试杀死占用8080端口的进程，并修改端口并重启服务
     *
     * @param context
     */
    private static void changePortAndRestart(ConfigurableApplicationContext context) {
        log.info("尝试杀死占用 8080 端口的进程.");
        killOldServiceInLinux();
        log.info("正在修改端口更改为 {}.", DEFAULT_PORT_8080);
        ServletWebServerFactory webServerFactory = context.getBean(ServletWebServerFactory.class);
        ServletContextInitializer servletContextInitializer = context.getBean(ServletContextInitializer.class);
        WebServer webServer = webServerFactory.getWebServer(servletContextInitializer);
 
        if (webServer != null) {
            log.info("停止旧服务器.");
            webServer.stop();
        }
        //((TomcatServletWebServerFactory) servletContextInitializer).setPort(DEFAULT_PORT_8080);
        ((TomcatServletWebServerFactory) webServerFactory).setPort(DEFAULT_PORT_8080);
        webServer = webServerFactory.getWebServer(servletContextInitializer);
        webServer.start();
        log.info("新服务启动成功.");
    }

4. 配置优雅关闭

在 application.yml 中设置优雅关闭：

server:
  shutdown: graceful

这个配置允许 Spring Boot 在接收到关闭请求时，等待当前请求完成后再停止服务。（因此代码使用的是kill -2命令）

5. 小结

通过以上实现，我们能够灵活应对端口占用问题，并提升开发效率。热部署功能不仅依赖于 Spring Boot 提供的丰富 API，还需要结合操作系统特性，以确保在生产环境中的稳定性和可用性。

附带Window关闭端口程序代码

（Window关闭程序后可能得需要sleep一下，不然还会显示端口占用）

  private static void killOldServiceInWindows() {
            try {
                // 查找占用 8080 端口的进程 ID
                ProcessBuilder builder = new ProcessBuilder("cmd.exe", "/c", "netstat -ano | findstr :8080");
                Process process = builder.start();
                BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
                String line;
                while ((line = reader.readLine()) != null) {
                    String[] parts = line.trim().split("\\s+");
                    if (parts.length > 4) {
                        String pid = parts[parts.length - 1];
                        // 杀死该进程
                        Runtime.getRuntime().exec("taskkill /F /PID " + pid);
                        log.info("Killed process: {}", pid);
                    }
                }
            } catch (IOException e) {
                log.error("Failed to stop old service", e);
            }
        }

以上就是SpringBoot项目请求不中断动态更新代码的实现的详细内容，更多关于SpringBoot不中断更新代码的资料请关注脚本之家其它相关文章！

您可能感兴趣的文章:

JavaSE中Lambda表达式的使用与变量捕获
这篇文章主要介绍了JavaSE中Lambda表达式的使用与变量捕获,Lambda表达式允许你通过表达式来代替功能接口, 就和方法一样,它提供了一个正常的参数列表和一个使用这些参数的主体,下面我们来详细看看,需要的朋友可以参考下
2023-10-10
Java注解(Annotations)的定义和使用详解
Java注解（Annotations）是Java5引入的一种元数据（Metadata）,它提供了一种在源代码中嵌入补充信息的方式,这些信息可以被编译器、JVM或其他工具在编译时、运行时进行处理,注解本身不会直接影响程序的执行,但可以用来指导编译器、JVM或其他工具的行为,从而实现各种功能
2025-03-03
Java8的DateTimeFormatter与SimpleDateFormat的区别详解
这篇文章主要介绍了Java8的DateTimeFormatter与SimpleDateFormat的区别详解，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
2021-03-03
Java关键字this使用方法详细讲解(通俗易懂)
这篇文章主要介绍了Java关键字this使用方法的相关资料,Java关键字this主要用于在方法体内引用当前对象,文中通过代码介绍的非常详细,需要的朋友可以参考下
2025-01-01
SpringBoot处理请求参数中包含特殊符号
今天写代码遇到了一个问题，请求参数是个路径“D:/ExcelFile”，本文就详细的介绍一下该错误的解决方法，感兴趣的可以了解一下
2021-06-06
MyBatis类型处理器TypeHandler的作用及说明
这篇文章主要介绍了MyBatis类型处理器TypeHandler的作用及说明,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教
2025-03-03
Java工程的Resources目录从基础到高级应用深入探索
这篇文章主要介绍了Java工程中的resources目录,从基础概念到高级应用,涵盖了如何创建、使用以及资源文件的加载方法,文中通过代码介绍的非常详细,需要的朋友可以参考下
2025-01-01
Java基于Socket实现多人聊天室
这篇文章主要为大家详细介绍了Java基于Socket实现多人聊天室，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
2022-09-09
java Stream的聚合功能面试精讲
这篇文章主要为大家介绍了java Stream的聚合功能面试精讲,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪
2023-09-09
MyBatis基础支持DataSource实现源码解析
这篇文章主要为大家介绍了MyBatis基础支持DataSource实现源码解析，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪
2023-02-02