基于Servlet接收程序B数据并实时展示的技术问题咨询

AI 小北

2026-5-25

嘿，我之前刚好处理过类似的进程监控+实时Web展示的需求，结合你的场景（只能改程序b，还得应对b频繁被a重启的情况），给你梳理几个可行的思路和之前方案失败的排查点：

核心问题拆解

你的痛点在于：b频繁重启导致日志收集不稳定，且只能修改b，还要实现Web端实时展示b的输出/错误信息。关键要解决两个问题：b重启后能自动重新连接日志收集服务，以及Web端能实时感知到新的日志数据。

可行解决方案

方案1：让b主动推送日志到WebSocket（最推荐，实时性高）

既然只能改b，那让b启动时就和Servlet建立WebSocket长连接，把自身的输出和错误信息实时推给Servlet，再由Servlet广播给前端页面。这样b每次重启后，只要重新建立WebSocket连接，就能继续推送日志，完全适配频繁重启的场景。

代码示例（伪代码）

b程序端（假设是Java）：

// b启动时初始化WebSocket客户端，连接到你的Servlet端点
WebSocketContainer container = ContainerProvider.getWebSocketContainer();
try {
    Session wsSession = container.connectToServer(new Endpoint() {
        @Override
        public void onOpen(Session session, EndpointConfig config) {
            // 重定向System.out和System.err到WebSocket，把日志实时发出去
            System.setOut(new PrintStream(new OutputStream() {
                @Override
                public void write(int b) throws IOException {
                    if (session.isOpen()) {
                        session.getBasicRemote().sendText(String.valueOf((char) b));
                    }
                }
            }));
            // 同理处理System.err，收集错误信息
            System.setErr(new PrintStream(new OutputStream() {
                @Override
                public void write(int b) throws IOException {
                    if (session.isOpen()) {
                        session.getBasicRemote().sendText("[ERROR] " + String.valueOf((char) b));
                    }
                }
            }));
        }
    }, URI.create("ws://你的服务器地址:端口/log-ws"));
    // 可以把wsSession存起来，b退出前关闭连接
    Runtime.getRuntime().addShutdownHook(new Thread(() -> {
        try {
            wsSession.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }));
} catch (Exception e) {
    e.printStackTrace();
}

Servlet端的WebSocket端点：

@ServerEndpoint("/log-ws")
public class LogWebSocketEndpoint {
    // 用线程安全的集合保存所有前端连接的会话
    private static final Set<Session> clientSessions = Collections.synchronizedSet(new HashSet<>());

    @OnOpen
    public void onClientConnect(Session session) {
        clientSessions.add(session);
        // 可以给新连接的前端发送历史日志（如果有存储的话）
    }

    @OnMessage
    public void onLogReceived(String logMsg, Session bSession) {
        // 收到b的日志，广播给所有在线的前端页面
        Iterator<Session> iterator = clientSessions.iterator();
        while (iterator.hasNext()) {
            Session clientSession = iterator.next();
            if (clientSession.isOpen()) {
                try {
                    clientSession.getBasicRemote().sendText(logMsg);
                } catch (IOException e) {
                    // 连接失效，移除会话
                    iterator.remove();
                }
            } else {
                iterator.remove();
            }
        }
    }

    @OnClose
    public void onClientDisconnect(Session session) {
        clientSessions.remove(session);
    }
}

前端页面（JavaScript）：

<div id="log-area" style="height: 400px; overflow-y: scroll; border: 1px solid #ccc; padding: 10px;"></div>
<script>
    const ws = new WebSocket('ws://你的服务器地址:端口/log-ws');
    const logArea = document.getElementById('log-area');
    
    ws.onmessage = function(event) {
        // 把收到的日志追加到页面
        logArea.textContent += event.data;
        // 自动滚动到最新日志
        logArea.scrollTop = logArea.scrollHeight;
    };
    
    ws.onclose = function() {
        // 连接断开可以尝试重连
        setTimeout(() => window.location.reload(), 3000);
    };
</script>

方案2：用HTTP POST+SSE（兼容老浏览器）

如果不想用WebSocket，也可以让b把日志通过HTTP POST提交到Servlet，Servlet把日志存在线程安全的容器里，再用SSE（Server-Sent Events）给前端实时推送新日志。

代码示例

b程序端（POST日志）：

// 可以封装一个工具方法，把日志行POST到Servlet
private static void sendLogToServlet(String logLine) {
    try {
        URL url = new URL("http://你的服务器地址:端口/submit-log");
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setRequestMethod("POST");
        conn.setDoOutput(true);
        conn.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
        
        String postData = "log=" + URLEncoder.encode(logLine, "UTF-8");
        try (OutputStream os = conn.getOutputStream()) {
            os.write(postData.getBytes());
        }
        
        // 可以忽略响应，或者处理状态码
        conn.getResponseCode();
        conn.disconnect();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

// 重定向System.out来调用这个方法
System.setOut(new PrintStream(new OutputStream() {
    @Override
    public void write(int b) throws IOException {
        sendLogToServlet(String.valueOf((char) b));
    }
}));

接收日志的Servlet：

@WebServlet("/submit-log")
public class LogSubmitServlet extends HttpServlet {
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String logLine = req.getParameter("log");
        if (logLine == null || logLine.isEmpty()) {
            resp.setStatus(HttpServletResponse.SC_BAD_REQUEST);
            return;
        }
        
        // 把日志存在ServletContext的线程安全列表里
        List<String> logList = (List<String>) getServletContext().getAttribute("systemLogs");
        if (logList == null) {
            logList = Collections.synchronizedList(new ArrayList<>());
            getServletContext().setAttribute("systemLogs", logList);
        }
        logList.add(logLine);
        
        // 限制日志数量，避免内存溢出
        if (logList.size() > 2000) {
            logList.remove(0);
        }
        
        resp.setStatus(HttpServletResponse.SC_OK);
    }
}

SSE推送Servlet：

@WebServlet("/log-sse")
public class LogSseServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.setContentType("text/event-stream");
        resp.setCharacterEncoding("UTF-8");
        resp.setHeader("Cache-Control", "no-cache");
        resp.setHeader("Connection", "keep-alive");
        
        PrintWriter out = resp.getWriter();
        List<String> currentLogs = (List<String>) getServletContext().getAttribute("systemLogs");
        
        // 先发送已有的历史日志
        if (currentLogs != null) {
            for (String line : currentLogs) {
                out.write("data: " + line + "\n\n");
                out.flush();
            }
        }
        
        // 定时检查新日志，实时推送
        int lastLogCount = currentLogs != null ? currentLogs.size() : 0;
        while (!req.isRequestedSessionIdValid()) {
            List<String> updatedLogs = (List<String>) getServletContext().getAttribute("systemLogs");
            if (updatedLogs != null && updatedLogs.size() > lastLogCount) {
                // 发送新增的日志
                for (int i = lastLogCount; i < updatedLogs.size(); i++) {
                    out.write("data: " + updatedLogs.get(i) + "\n\n");
                    out.flush();
                }
                lastLogCount = updatedLogs.size();
            }
            // 每秒检查一次
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                break;
            }
        }
        out.close();
    }
}

前端页面：

<div id="log-area" style="height: 400px; overflow-y: scroll; border: 1px solid #ccc; padding: 10px;"></div>
<script>
    const eventSource = new EventSource('/log-sse');
    const logArea = document.getElementById('log-area');
    
    eventSource.onmessage = function(event) {
        logArea.textContent += event.data;
        logArea.scrollTop = logArea.scrollHeight;
    };
    
    eventSource.onerror = function() {
        eventSource.close();
        // 重连
        setTimeout(() => window.location.reload(), 3000);
    };
</script>

之前失败方案的排查点

并行线程接收数据共享：
- 大概率是线程安全问题：如果用普通的List/变量存储日志，多个线程读写会出现数据丢失或错乱，必须用ConcurrentLinkedQueue、Collections.synchronizedList这类线程安全的集合。
- 另外，b每次重启后，新的b进程需要重新启动日志收集线程，不然新的日志根本不会被收集到。
客户端接收数据到ServletContext：
- 核心问题是实时感知：ServletContext的数据变化后，前端不会主动知道，必须用轮询、SSE或WebSocket来主动获取更新，不然页面只会显示初始数据，不会实时刷新。

内容的提问来源于stack exchange，提问作者gobbo