Java中使用Socket实现双端口连接失败，如何保留流方法解决？

我明白你的痛点——想用NIO的SocketChannel来处理双端口监听，却又离不开BIO里的getInputStream()和getOutputStream()方法，毕竟这俩用起来太顺手了。别担心，其实这两者是可以结合的，下面我给你一步步拆解解决方案：

SocketChannel本身不直接提供流，但它关联的Socket实例可以！你只需要调用socketChannel.socket()就能拿到对应的Socket对象，然后就可以调用getInputStream()和getOutputStream()了。不过有个关键注意点：

• 如果你的SocketChannel设置为非阻塞模式，调用流的方法会直接抛出IllegalBlockingModeException，所以如果要使用流，必须先把SocketChannel切换回阻塞模式：

socketChannel.configureBlocking(true);
Socket socket = socketChannel.socket();
InputStream in = socket.getInputStream();
OutputStream out = socket.getOutputStream();

你的初步代码里已经用到了Selector和线程池，这正好可以用来实现多端口监听。下面是完善后的示例代码，兼顾双端口监听和流操作：

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetSocketAddress;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Set;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ServeurMaitre {
    private Selector selector;
    private ExecutorService pool;
    private boolean isRunning = true;

    public ServeurMaitre(int port1, int port2, int poolSize) throws IOException {
        // 初始化线程池
        this.pool = Executors.newFixedThreadPool(poolSize);
        // 初始化Selector
        this.selector = Selector.open();
        
        // 注册第一个端口的ServerSocketChannel
        registerServerSocket(port1);
        // 注册第二个端口的ServerSocketChannel
        registerServerSocket(port2);
        
        System.out.println("双端口服务器启动，监听端口：" + port1 + " 和 " + port2);
        startListen();
    }

    private void registerServerSocket(int port) throws IOException {
        ServerSocketChannel serverChannel = ServerSocketChannel.open();
        serverChannel.configureBlocking(false); // 非阻塞模式用于监听连接
        serverChannel.socket().bind(new InetSocketAddress(port));
        // 向Selector注册ACCEPT事件
        serverChannel.register(selector, java.nio.channels.SelectionKey.OP_ACCEPT);
    }

    private void startListen() {
        while (isRunning) {
            try {
                // 等待事件触发
                selector.select();
                Set<java.nio.channels.SelectionKey> selectedKeys = selector.selectedKeys();
                Iterator<java.nio.channels.SelectionKey> iterator = selectedKeys.iterator();

                while (iterator.hasNext()) {
                    java.nio.channels.SelectionKey key = iterator.next();
                    iterator.remove(); // 处理完必须移除，避免重复处理

                    if (key.isAcceptable()) {
                        // 处理新连接
                        handleAccept(key);
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    private void handleAccept(java.nio.channels.SelectionKey key) throws IOException {
        ServerSocketChannel serverChannel = (ServerSocketChannel) key.channel();
        SocketChannel socketChannel = serverChannel.accept();
        
        if (socketChannel != null) {
            // 切换为阻塞模式，因为要使用流操作
            socketChannel.configureBlocking(true);
            // 获取Socket和流
            java.net.Socket socket = socketChannel.socket();
            InputStream in = socket.getInputStream();
            OutputStream out = socket.getOutputStream();
            
            // 交给线程池处理具体的读写逻辑
            pool.submit(() -> handleClient(in, out, socket));
        }
    }

    private void handleClient(InputStream in, OutputStream out, java.net.Socket socket) {
        try {
            // 这里写你的业务逻辑，比如读取客户端数据、返回响应
            byte[] buffer = new byte[1024];
            int readLen = in.read(buffer);
            if (readLen > 0) {
                String received = new String(buffer, 0, readLen);
                System.out.println("收到客户端[" + socket.getInetAddress() + "]消息：" + received);
                
                // 示例：返回响应
                String response = "已收到消息：" + received;
                out.write(response.getBytes());
                out.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 关闭资源
            try {
                in.close();
                out.close();
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    public void stop() {
        isRunning = false;
        selector.wakeup(); // 唤醒阻塞的select()
        pool.shutdown();
        try {
            selector.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws IOException {
        new ServeurMaitre(8080, 8081, 15);
    }
}

• 监听阶段：ServerSocketChannel用非阻塞模式，注册到Selector监听ACCEPT事件，这样一个Selector就能同时监听多个端口的连接请求，避免了BIO里每个端口开一个线程的资源浪费。
• 连接处理阶段：一旦有新连接，把SocketChannel切换为阻塞模式，再获取流进行读写——这样你就能继续使用熟悉的流操作，不用切换到NIO的缓冲区API。
• 线程池：用线程池处理每个客户端的读写逻辑，避免单个线程阻塞影响整个服务器的监听能力。

如果你既想保留SocketChannel的非阻塞特性，又不想放弃流操作，可以考虑使用Channels工具类，它能把Channel转换成流：

import java.nio.channels.Channels;

InputStream in = Channels.newInputStream(socketChannel);
OutputStream out = Channels.newOutputStream(socketChannel);

不过这种流是基于Channel的非阻塞特性实现的，读写操作会和Channel的非阻塞行为一致——比如当没有数据可读时，read()会返回-1，而不是阻塞等待。这时候你的业务逻辑需要适配这种非阻塞的流行为，可能会复杂一些，所以如果不是必须用非阻塞，还是第一种方案更简单。

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