Java网络编程（三）：NIO核心组件Channel通道详解

Channel (interface)
├── ReadableByteChannel (interface)
│   └── ScatteringByteChannel (interface)
├── WritableByteChannel (interface)
│   └── GatheringByteChannel (interface)
├── ByteChannel (interface) 
│   └── SeekableByteChannel (interface)
└── InterruptibleChannel (interface)
    └── SelectableChannel (abstract class)
        ├── AbstractSelectableChannel (abstract class)
        │   ├── SocketChannel
        │   ├── ServerSocketChannel
        │   ├── DatagramChannel
        │   └── Pipe.SinkChannel/SourceChannel
        └── ...

// 创建ServerSocketChannel
ServerSocketChannel serverChannel = ServerSocketChannel.open();

// 绑定端口，就像给门牌号
serverChannel.bind(new InetSocketAddress(8080));

// 设置为非阻塞模式，这是关键
serverChannel.configureBlocking(false);

// 如果需要，还能拿到传统的ServerSocket
ServerSocket serverSocket = serverChannel.socket();

// 创建SocketChannel
SocketChannel socketChannel = SocketChannel.open();

// 设置为非阻塞模式
socketChannel.configureBlocking(false);

// 尝试连接服务器
boolean connected = socketChannel.connect(new InetSocketAddress("localhost", 8080));

// 非阻塞模式下，connect可能还没连上就返回了
if (!connected) {
    // 需要等连接真正建立
    while (!socketChannel.finishConnect()) {
        // 这期间可以干点别的事
        Thread.sleep(100);
    }
}

System.out.println("连接成功！");

// 设置为非阻塞模式
channel.configureBlocking(false);

// 设置为阻塞模式
channel.configureBlocking(true);

// 检查当前是什么模式
boolean isBlocking = channel.isBlocking();

// 阻塞模式的例子
ServerSocketChannel serverChannel = ServerSocketChannel.open();
serverChannel.bind(new InetSocketAddress(8888));
// 程序会卡在这里等连接
SocketChannel socketChannel = serverChannel.accept();

// 非阻塞模式的例子
ServerSocketChannel serverChannel = ServerSocketChannel.open();
serverChannel.bind(new InetSocketAddress(8888));
serverChannel.configureBlocking(false);
// 立即返回，可能是null
SocketChannel socketChannel = serverChannel.accept();
if (socketChannel != null) {
    // 有新连接，处理一下
}

// 创建服务器通道，相当于开了个门店
ServerSocketChannel serverChannel = ServerSocketChannel.open();
serverChannel.bind(new InetSocketAddress(8888));  // 选个门牌号
serverChannel.configureBlocking(false);           // 设置成非阻塞，不傻等

// 找个管家（Selector）来帮忙看门
Selector selector = Selector.open();
serverChannel.register(selector, SelectionKey.OP_ACCEPT);  // 告诉管家关注新客户

// 开始营业，无限循环处理客户
while (true) {
    if (selector.select() > 0) {  // 管家检查有没有事情要处理
        Iterator<SelectionKey> keyIterator = selector.selectedKeys().iterator();
        while (keyIterator.hasNext()) {
            SelectionKey key = keyIterator.next();
            keyIterator.remove();  // 处理完就移除，避免重复处理
            
            if (key.isAcceptable()) {  // 有新客户要进门
                ServerSocketChannel server = (ServerSocketChannel) key.channel();
                SocketChannel clientChannel = server.accept();  // 接待新客户
                clientChannel.configureBlocking(false);         // 客户也设置成非阻塞
                clientChannel.register(selector, SelectionKey.OP_READ);  // 关注客户的消息
                System.out.println("新客户来了: " + clientChannel.getRemoteAddress());
            }
            // 处理其他事件...
        }
    }
}

// 创建客户端通道，准备去连接服务器
SocketChannel socketChannel = SocketChannel.open();
socketChannel.configureBlocking(false);  // 设置非阻塞，连接时不等待

// 也找个管家来帮忙
Selector selector = Selector.open();
socketChannel.register(selector, SelectionKey.OP_CONNECT);  // 关注连接事件

// 开始尝试连接
socketChannel.connect(new InetSocketAddress("localhost", 8888));

// 等待连接结果
while (true) {
    if (selector.select() > 0) {  // 检查有没有事件发生
        Iterator<SelectionKey> keyIterator = selector.selectedKeys().iterator();
        while (keyIterator.hasNext()) {
            SelectionKey key = keyIterator.next();
            keyIterator.remove();
            
            if (key.isConnectable()) {  // 连接有结果了
                SocketChannel channel = (SocketChannel) key.channel();
                if (channel.isConnectionPending()) {  // 连接还在进行中
                    channel.finishConnect();  // 完成连接
                    System.out.println("连上服务器了！");
                    // 现在可以关注读事件了
                    channel.register(selector, SelectionKey.OP_READ);
                    // 先打个招呼
                    ByteBuffer buffer = ByteBuffer.wrap("Hello Server".getBytes());
                    channel.write(buffer);
                }
            }
            // 处理其他事件...
        }
    }
}

// 准备一个盘子（缓冲区）来装数据
ByteBuffer buffer = ByteBuffer.allocate(1024);

// 从通道读数据到盘子里
int bytesRead = socketChannel.read(buffer);

if (bytesRead > 0) {
    // 翻转盘子，准备取数据（从写模式切换到读模式）
    buffer.flip();
    
    // 把盘子里的数据倒出来
    byte[] data = new byte[buffer.remaining()];
    buffer.get(data);
    String message = new String(data);
    System.out.println("收到消息: " + message);
    
    // 洗干净盘子，准备下次用
    buffer.clear();
} else if (bytesRead == -1) {
    // 对方挂断了连接
    socketChannel.close();
}

// 准备要发送的消息
String message = "Hello Client";
ByteBuffer buffer = ByteBuffer.wrap(message.getBytes());

// 把数据写到通道里，可能需要多次写入
while (buffer.hasRemaining()) {
    socketChannel.write(buffer);
}

// 更安全的写法，防止写不完
int totalWritten = 0;
int bytesWritten;
while (totalWritten < message.length()) {
    bytesWritten = socketChannel.write(buffer);
    if (bytesWritten <= 0) {
        // 对方接收缓冲区满了，暂时写不进去
        break;
    }
    totalWritten += bytesWritten;
}

// 分散读取：一次读取分别放到不同的Buffer里
ByteBuffer header = ByteBuffer.allocate(128);   // 消息头的盘子
ByteBuffer body = ByteBuffer.allocate(1024);    // 消息体的盘子
ByteBuffer[] buffers = {header, body};
long bytesRead = socketChannel.read(buffers);   // 一次性读到两个盘子里

// 聚集写入：把多个Buffer的数据一次性写出去
ByteBuffer header = ByteBuffer.allocate(128);
ByteBuffer body = ByteBuffer.allocate(1024);
// 往两个盘子里装数据...
ByteBuffer[] buffers = {header, body};
long bytesWritten = socketChannel.write(buffers);  // 一次性把两个盘子的数据都发出去

try {
    // 使用Channel做各种操作
    // ...
} finally {
    if (socketChannel != null && socketChannel.isOpen()) {
        socketChannel.close();  // 手动关门
    }
}

// 更简单的写法，自动关闭
try (SocketChannel socketChannel = SocketChannel.open()) {
    // 使用Channel做各种操作
    // ...
} // Java会自动帮你关门

try {
    SocketChannel socketChannel = SocketChannel.open();
    socketChannel.connect(new InetSocketAddress("localhost", 8080));
    
    ByteBuffer buffer = ByteBuffer.allocate(1024);
    int bytesRead = socketChannel.read(buffer);
    
} catch (ConnectException e) {
    System.err.println("连不上服务器: " + e.getMessage());
} catch (SocketTimeoutException e) {
    System.err.println("连接等太久了: " + e.getMessage());
} catch (IOException e) {
    System.err.println("网络出问题了: " + e.getMessage());
} catch (Exception e) {
    System.err.println("出了其他问题: " + e.getMessage());
} finally {
    // 不管怎样都要清理资源
    if (socketChannel != null && socketChannel.isOpen()) {
        try {
            socketChannel.close();
        } catch (IOException e) {
            System.err.println("关闭连接时又出错了: " + e.getMessage());
        }
    }
}