Java微服务无损发布生产实战案例及验证

#!/bin/bash
# stop.sh - 优雅停机脚本

APP_NAME="provider"
APP_PORT=8082
NACOS_SERVER="127.0.0.1:8848"

echo "开始优雅停止 $APP_NAME..."

# 1. 获取服务ip
get_nacos_registered_ip() {
    
    # 调用Nacos查询接口
    local response=$(curl -s "http://${NACOS_SERVER}/nacos/v1/ns/instance/list?serviceName=${APP_NAME}")
    
    if [ $? -ne 0 ] || [ -z "$response" ]; then
        echo "查询Nacos服务失败" >&2
        return 1
    fi
    
    # 解析JSON获取IP（需要jq工具）
    if command -v jq >/dev/null 2>&1; then
        local ip=$(echo "$response" | jq -r '.hosts[0].ip' 2>/dev/null)
        if [ "$ip" != "null" ] && [ -n "$ip" ]; then
            echo $ip
            return 0
        fi
    fi
    
    # 如果没有jq，使用grep/awk解析
    local ip=$(echo "$response" | grep -o '"ip":"[^"]*' | cut -d'"' -f4 | head -1)
    if [ -n "$ip" ]; then
        echo $ip
        return 0
    fi
    
    echo "无法从Nacos响应中解析IP" >&2
    return 1
}

LOCAL_IP=$(get_nacos_registered_ip)
echo "检测到服务注册IP: $LOCAL_IP"

# 2. 从Nacos下线服务
echo "从Nacos注销服务..."
curl -X DELETE "${NACOS_SERVER}/nacos/v1/ns/instance?serviceName=${APP_NAME}&ip=${LOCAL_IP}&port=${APP_PORT}"

# 3. 等待流量切换
echo "等待流量切换(15秒)..."
sleep 15

# 4. 根据jar名称查找应用进程，比如provider2
echo "查找应用进程..."
# 更精确的进程查找方式
APP_PID=$(ps aux | grep "[j]ava.*provider2" | awk '{print $2}')

if [ -n "$APP_PID" ]; then
    echo "找到应用进程，PID: $APP_PID"
    
    # 5. 发送优雅停止信号
    echo "发送优雅停止信号..."
    kill -15 $APP_PID
    
    # 6. 等待进程停止，最多30秒
    for i in {1..30}; do
        if kill -0 $APP_PID 2>/dev/null; then
            echo "等待应用停止...($i/30)"
            sleep 1
        else
            echo "应用已优雅停止"
            exit 0
        fi
    done
    
    # 7. 强制停止
    echo "优雅停止超时，强制停止"
    kill -9 $APP_PID
else
    echo "应用未运行"
fi

echo "停止脚本执行完成"

server:
  shutdown: graceful

package com.example.provider;

import com.alibaba.cloud.nacos.registry.NacosRegistration;
import com.alibaba.cloud.nacos.registry.NacosServiceRegistry;
import org.apache.catalina.connector.Connector;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.web.embedded.tomcat.TomcatConnectorCustomizer;
import org.springframework.context.ApplicationListener;
import org.springframework.context.annotation.Lazy;
import org.springframework.context.event.ContextClosedEvent;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.util.concurrent.Executor;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

@Component
public class TomcatNacosGracefulShutdown implements TomcatConnectorCustomizer,
        ApplicationListener<ContextClosedEvent> {

    private static final Logger logger = LoggerFactory.getLogger(TomcatNacosGracefulShutdown.class);

    private volatile Connector connector;

    @Lazy
    @Resource
    private NacosServiceRegistry nacosServiceRegistry;

    @Lazy
    @Resource
    private NacosRegistration nacosRegistration;

    @Override
    public void customize(Connector connector) {
        this.connector = connector;
        logger.info("Tomcat连接器自定义配置完成");
    }

    @Override
    public void onApplicationEvent(ContextClosedEvent event) {
        logger.info("=== 开始Tomcat+Nacos优雅停机 ===");
        startGracefulShutdown();
    }

    public void startGracefulShutdown() {
        try {
            // 步骤1: Nacos注销
            deregisterFromNacos();

            // 步骤2: 等待注册中心传播
            waitForRegistryPropagation();

            // 步骤3: 暂停Tomcat接收新请求
            pauseTomcat();

            // 步骤4: 等待活跃请求完成
            waitForActiveRequests();

            logger.info("=== Tomcat+Nacos优雅停机完成 ===");

        } catch (Exception e) {
            logger.error("优雅停机失败", e);
        }
    }

    private void deregisterFromNacos() {
        if (nacosServiceRegistry != null && nacosRegistration != null) {
            try {
                logger.info("从Nacos注销服务实例...");
                nacosServiceRegistry.deregister(nacosRegistration);
                logger.info("Nacos注销成功: {}", nacosRegistration.getServiceId());
            } catch (Exception e) {
                logger.error("Nacos注销失败", e);
            }
        } else {
            logger.warn("Nacos注册组件未找到，跳过注销");
        }
    }

    private void waitForRegistryPropagation() {
        try {
            long waitTime = 15000;
            logger.info("等待注册中心传播: {}ms", waitTime);
            Thread.sleep(waitTime);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            logger.warn("等待过程被中断");
        }
    }

    private void pauseTomcat() {
        if (connector != null) {
            logger.info("暂停Tomcat连接器，停止接收新请求");
            connector.pause();
        } else {
            logger.warn("Tomcat连接器未找到，无法暂停");
        }
    }

    private void waitForActiveRequests() {
        if (connector == null) {
            logger.warn("Tomcat连接器未找到，跳过等待");
            return;
        }

        Executor executor = connector.getProtocolHandler().getExecutor();
        if (executor instanceof ThreadPoolExecutor) {
            ThreadPoolExecutor threadPool = (ThreadPoolExecutor) executor;

            logger.info("等待活跃请求完成...");
            threadPool.shutdown();

            try {
                long maxWaitTime = 30000;
                if (!threadPool.awaitTermination(maxWaitTime, TimeUnit.MILLISECONDS)) {
                    logger.warn("等待请求超时，强制关闭线程池");
                    threadPool.shutdownNow();

                    if (!threadPool.awaitTermination(5000, TimeUnit.MILLISECONDS)) {
                        logger.error("线程池未能正常终止");
                    }
                } else {
                    logger.info("所有活跃请求处理完成");
                }
            } catch (InterruptedException e) {
                threadPool.shutdownNow();
                Thread.currentThread().interrupt();
                logger.warn("等待过程被中断");
            }
        } else {
            logger.warn("无法获取Tomcat线程池，跳过等待");
        }
    }

}