如何检查Websocket连接是否处于活动状态

问题描述 投票：0回答：3

我有一个到服务器的 websocket 连接：

import javax.websocket.*;
import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;

@ClientEndpoint
public class WebsocketExample {

    private Session userSession;

    private void connect() {

        try {
            WebSocketContainer container = ContainerProvider.getWebSocketContainer();
            container.connectToServer(this, new URI("someaddress"));
        } catch (DeploymentException | URISyntaxException | IOException e) {
            e.printStackTrace();
        }
    }

    @OnOpen
    public void onOpen(Session userSession) {
        // Set the user session
        this.userSession = userSession;
        System.out.println("Open");
    }

    @OnClose
    public void onClose(Session userSession, CloseReason reason) {
        this.userSession = null;
        System.out.println("Close");
    }

    @OnMessage
    public void onMessage(String message) {
        // Do something with the message
        System.out.println(message);
    }
}

一段时间后，我似乎没有再收到来自服务器的消息，但 onClose 方法还没有被调用。

我想要一种计时器，如果我在最后五分钟内没有收到任何消息，它至少会记录一个错误（并且最多尝试重新连接）。当我收到新消息时，计时器将被重置。

我该怎么做？

java websocket java-websocket
3个回答
8
投票

这就是我所做的。我通过jetty更改了javax.websocket并实现了ping调用：

import org.eclipse.jetty.util.ssl.SslContextFactory;
import org.eclipse.jetty.websocket.api.Session;
import org.eclipse.jetty.websocket.api.annotations.OnWebSocketClose;
import org.eclipse.jetty.websocket.api.annotations.OnWebSocketConnect;
import org.eclipse.jetty.websocket.api.annotations.OnWebSocketMessage;
import org.eclipse.jetty.websocket.api.annotations.WebSocket;
import org.eclipse.jetty.websocket.client.WebSocketClient;

import java.io.IOException;
import java.net.URI;
import java.nio.ByteBuffer;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

@WebSocket
public class WebsocketExample {

    private Session userSession;
    private final ScheduledExecutorService executorService = Executors.newScheduledThreadPool(1);

    private void connect() {
        try {
            SslContextFactory sslContextFactory = new SslContextFactory();
            WebSocketClient client = new WebSocketClient(sslContextFactory);
            client.start();
            client.connect(this, new URI("Someaddress"));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @OnWebSocketConnect
    public void onOpen(Session userSession) {
        // Set the user session
        this.userSession = userSession;
        System.out.println("Open");

        executorService.scheduleAtFixedRate(() -> {
                    try {
                        String data = "Ping";
                        ByteBuffer payload = ByteBuffer.wrap(data.getBytes());
                        userSession.getRemote().sendPing(payload);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                },
                5, 5, TimeUnit.MINUTES);
    }

    @OnWebSocketClose
    public void onClose(int code, String reason) {
        this.userSession = null;
        System.out.println("Close");
    }

    @OnWebSocketMessage
    public void onMessage(String message) {
        // Do something with the message
        System.out.println(message);
    }
}

编辑：这只是一个 ping 示例...我不知道是否所有服务器都应该通过 pong 应答...

Edit2：下面是如何处理pong消息。诀窍不是监听字符串消息，而是监听帧消息：

@OnWebSocketFrame
@SuppressWarnings("unused")
public void onFrame(Frame pong) {
    if (pong instanceof PongFrame) {
        lastPong = Instant.now();
    }
}

为了管理服务器超时，我修改了计划任务如下：

scheduledFutures.add(executorService.scheduleAtFixedRate(() -> {
                    try {
                        String data = "Ping";
                        ByteBuffer payload = ByteBuffer.wrap(data.getBytes());
                        userSession.getRemote().sendPing(payload);

                        if (lastPong != null
                                && Instant.now().getEpochSecond() - lastPong.getEpochSecond() > 60) {
                            userSession.close(1000, "Timeout manually closing dead connection.");
                        }

                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                },
                10, 10, TimeUnit.SECONDS));

...并在onClose方法中处理重新连接

0
投票

您应该通过实施一个心跳系统来解决这个问题，该系统一侧发送 

ping
，另一侧用 
pong
应答。几乎每个 websocket 客户端和服务器（据我所知）内部都支持此功能。该 ping/pong 帧可以从双方发送。我通常在服务器端实现它，因为我通常知道它比客户端有更好的机会保持活力（我的观点）。如果客户端长时间不发回 pong，我就知道连接已断开。在客户端，我检查相同的内容：如果服务器很长一段时间没有发送 ping 消息，我就知道连接已断开。

如果 ping/pong 没有在你使用的库中实现（我认为 javax websocket 有它），你可以为此制定自己的协议。

0
投票

接受的答案使用 Jetty 特定的 API。为此有一个标准 API：

发送 ping：session.getAsyncRemote().sendPing(data)

发送pong（只是保持活动状态，没有应答）session.getAsyncRemote().sendPong(data)

对 pong 做出反应 session.addMessageHandler(handler) 其中 

handler
实现 MessageHandler.Whole<PongMessage> 或创建一个用 
@OnMessage
注释并具有 
PongMessage
参数的方法：

@OnMessage
public void onMessage(PongMessage pong) {
    // check if the pong has the same payload as ping that was sent etc...
}

可以使用 ScheduledExecutorService 来安排定期 ping/keep-alive 发送，就像接受的答案一样，但必须适当注意同步：如果使用 

session.getBasicRemote()
，则需要同步对远程的所有调用。如果出现 
session.getAsyncRemote()
，可能除 Tomcat 之外的所有容器都会自动处理同步：请参阅 此错误报告中的讨论。
最后，重要的是取消 
ScheduledFuture
中的 ping 任务（从 
executor.scheduleAtFixedRate(...)
获得
onClose(...)
）。

我开发了一个简单的 WebsocketPingerService 来简化事情（可在 mavencentral 中使用）。创建一个实例并将其作为静态变量存储在某处：

public Class WhicheverClassInYourApp {
    public static WebsocketPingerService pingerService = new WebsocketPingerService();

    // more code here...
}

您可以通过将参数传递给构造函数来配置 ping 间隔、ping 大小、应关闭会话的失败限制等。

之后，在 

onOpen(...)
中注册您的端点以进行 ping 操作，并在 
onClose(...)
中取消注册：

@ClientEndpoint  // or @ServerEndpoint -> pinging can be done from both ends
public class WebsocketExample {
    private Session userSession;

    @OnOpen
    public void onOpen(Session userSession) {
        this.userSession = userSession;
        WhicheverClassInYourApp.pingerService.addConnection(userSession);
    }

    @OnClose
    public void onClose(Session userSession, CloseReason reason) {
        WhicheverClassInYourApp.pingerService.removeConnection(userSession);
    }

    // other methods here
}
最新问题
© www.soinside.com 2019 - 2024. All rights reserved.