阻止非阻塞套接字客户端连接

Question

首先，我不是开发人员（并且我只编写了2个星期的代码），所以请随意告诉我我完全误解了这件事（而且，我为自己编写了所有这些内容，所以我确定这是超级不酷）：）。 我想学习并使其正确，所以我很想听听建议或完成重写。

我想以非阻塞模式连接到套接字（我是客户端，而不是服务器）。 我主要需要阅读它，但是有时我也需要写它。 步骤如下：

• 连接插座
• 发送一些初始请求以登录到服务器
• 从套接字读取
• 有时，写一些东西（例如，订阅某些信息）

我的解决方案如下（我正在用Java编写它，因为我已经读过它是一种快速而又好的编程语言，但是我很乐意在需要时进行更改……希望是不需要的！）：

public class SocketClient {

    public static void main(String[] args) {
        new Feed().init();
    }

    private boolean isSocketConnected() {
        return socket != null && socket.isConnected();
    }

    public void init() {
        try {
            if (isSocketConnected()) {
                // What here if I'm in non-blocking mode?
                // Would be good to know if the "close API" request succeeded
                // otherwise next time I won't be able to connect to their socket...

                sendCloseRequestToApi();
                socket.close();
            }

            run();
        } catch (Exception e) {
            if (isSocketConnected()) {
                // Same question as above...
                sendCloseRequestsToApi();
                socket.close();
            }
        }
    }

    public void run() throws IOException {
        System.out.println("Starting connection in blocking mode...");

        SocketChannel channel = SocketChannel.open();
        socket = channel.socket();
        socket.setReceiveBufferSize(RECEIVE_BUFFER_SIZE);
        socket.setSendBufferSize(SEND_BUFFER_SIZE);
        channel.connect(new InetSocketAddress("127.0.0.1", 2121));
        channel.finishConnect();

        System.out.println("Finished connecting in blocking mode");

        // Writes to the socket (user and password)
        initialiseTheApi();

        System.out.println("Sent API requests in blocking mode");
        System.out.println("Now we should probably go non-blocking (I guess)");

        channel.register(selector, SelectionKey.OP_WRITE | SelectionKey.OP_READ);
        selector = Selector.open();
        channel.configureBlocking(false);

        System.out.println("Selector created and switched to non-blocking mode...");

        long timeWithoutData = 0;
        boolean needsReconnection = false;
        while (!needsReconnection) {
            selector.select();
            Iterator < SelectionKey > keys = selector.selectedKeys().iterator();

            while (keys.hasNext()) {
                SelectionKey key = keys.next();
                keys.remove();

                if (!key.isValid()) {
                    continue;
                }

                if (key.isWritable()) {
                    // Execute write...
                    // What if I need to know the result to the write operation?
                }

                if (key.isReadable()) {
                    int dataRead = readDataFromSocket(buffer);

                    buffer.flip();
                    if (buffer.remaining() > 0) {
                        // I process the data read here,
                        // but sometimes the data sent is
                        // "reconnect to API". So I need to close
                        // the connection and start again.

                        // How can I do that if I'm in non-blocking mode?
                        // I mean, I need to make sure when I send that request
                        // (for reconnection).
                        // I need to know that the request got to the server and
                        // was processed OK before moving on and
                        // reading/writing again...
                    }

                    if (dataRead > -1) {
                        timeWithoutData = 0;
                    } else {
                        if (timeWithoutData > 0) {
                            long diffInMillis = System.currentTimeMillis() - timeWithoutData;
                            if (diffInMillis > 2000) {
                                System.out.println("Timeout or something? I need to reconnect I think");
                                needsReconnection = true;
                            }
                        } else {
                            timeWithoutData = System.currentTimeMillis();
                        }
                    }

                    // Do I even need this? Already did it before, right?
                    key.interestOps(SelectionKey.OP_READ | SelectionKey.OP_WRITE);
                }
            }
        }

        if (needsReconnection) {
            // We need full reconnection, go back up and reconnect
            init();
        }
    }
}

为了方便起见，我删除了导入和其他无用的方法，并简化了文章。

正如您在代码中的问题中看到的（加上一些添加的问题）：

• 重新连接：如果我处于非阻止模式，我如何知道我的请求已成功发送到服务器
• 如果我从套接字读取并且消息是“重新连接到API”，如何确保在进行其他任何读/写操作之前发生这种情况？
• 我是否需要一次又一次发送有兴趣的操作？
• 我应该只连接一次插座。 我没有阻止的事实不会改变这一点，对吗？

我已经看到可以使用Netty或其他东西简化所有操作，但是我已经被很多东西blo肿了！ :(

希望我的问题清楚。 否则请让我知道。

非常感谢。

Answer 1

我正在尝试做一些没有意义的事情。 就我而言，我绝对可以使用阻塞连接，而我只是不知道：/。 互联网有时是糟糕的信息来源！ 我一直在这里阅读，不要使用阻塞连接：D。 但是现在，在不同情况下完全可以理解了。 –威尔