Java中使用JSch：如何确认SSH连接或隧道已断开？

Hey there! Let's break down how you can reliably detect if your SSH connection or port forwarding tunnel has dropped in your Java app. Since you're working with SSH in Java, I’m assuming you’re using JSch (the most common library for this use case) — most of these tips are tailored to it, but the core concepts apply to other SSH libraries too.

1. Use JSch’s Built-in Session Status Check #

First off, keep a reference to the initial Session object you created when setting up the connection (store it in a singleton connection manager or dedicated service class). You can use its built-in method to quickly check connectivity:

• Call session.isConnected(): This returns a boolean that reflects the session’s internal state. It’s a fast check, but note that it might not immediately catch sudden network drops (like a router going down) since it only checks the session’s cached status.

2. Enable SSH Keep-Alives for Proactive Detection #

SSH servers often drop idle connections after a set period. Enabling keep-alives does two things: it prevents idle disconnects, and it lets you detect when the connection is unresponsive.
Add this code when initializing your session:

// Send a keep-alive packet every 30 seconds
session.setServerAliveInterval(30000);
// Give up and mark the connection dead after 3 failed attempts
session.setServerAliveCountMax(3);

When the server stops responding to these keep-alive packets, JSch will throw a JSchException that you can catch to trigger reconnection logic or mark the connection as dead.

3. Listen for Disconnect Events Reactively #

JSch lets you register a SessionListener to get notified the moment the session drops, so you don’t have to poll for status. Here’s how to set it up:

session.addSessionListener(new SessionListener() {
    @Override
    public void sessionConnected(Session session) {
        // Log or handle successful connection
    }

    @Override
    public void sessionDisconnected(Session session, int reason, String message) {
        // This fires immediately when the session disconnects!
        System.out.println("SSH tunnel dropped: " + message + " (reason code: " + reason + ")");
        // Here you can trigger reconnection, update your connection status flag, etc.
    }
});

This is perfect for reactive handling — you’ll know right away if the tunnel goes down, instead of waiting for a request to fail.

4. Test the Local Forwarded Port #

Since your app communicates via the local forwarded port, you can also verify if that port is reachable. This ensures the tunnel itself (not just the SSH session) is working:

private boolean isTunnelAlive(int localForwardedPort) {
    try (Socket testSocket = new Socket("localhost", localForwardedPort)) {
        return testSocket.isConnected();
    } catch (IOException e) {
        // Connection failed — tunnel is dead
        return false;
    }
}

Run this check periodically (or before critical requests) to confirm you can reach the local end of the tunnel, which directly ties to the health of your SSH port forwarding.

5. Combine Methods for Maximum Reliability #

For the most robust detection, mix a few of these approaches:

• Use session.isConnected() for quick, lightweight checks.
• Enable keep-alives to prevent idle timeouts and catch silent network drops.
• Register a SessionListener for immediate disconnect notifications.
• Test the local port to ensure the forwarding itself hasn’t failed.

Bonus: Reconnection Logic #

Once you detect a dead connection, make sure your connection manager has a method to:

1. Safely close the old session (if it’s not already closed).
2. Re-authenticate, create a new SSH session, and re-set up the port forwarding.
3. Update your active session reference so subsequent requests use the new tunnel.

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