netty（二）：NIO——处理可写事件-Toy模板网

这篇具有很好参考价值的文章主要介绍了netty（二）：NIO——处理可写事件。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

处理可写事件

什么情况下需要注册可写事件？

在服务端一次性无法把数据发送完的情况下，需要注册可写事件
- 服务端一次性是否能够把数据全部发送完成取决于服务端的缓冲区大小，该缓冲区不受程序控制

注册可写事件的步骤

判断ByteBuffer是否仍有剩余，如果有剩余注册可写事件

ByteBuffer bf = "hello client,welcome";
SocketChannel sc = (SocketChannel) selectionKey.channel();
sc.write(bf);
if(bf.hasRemaining){
    selectionKey.interestOps(SelectionKey.OP_READ + SelectionKey.OP_WRITE);
    selectionKey.attachment(bf);
}

监听可写事件，判断数据是否写完，数据写完需要

if (key.isWritable()){
    // 监听可写事件
    SocketChannel channel = (SocketChannel) key.channel();
    ByteBuffer byteBuffer = (ByteBuffer) key.attachment();
    channel.write(byteBuffer);
    if (!byteBuffer.hasRemaining()) {
        // 判断数据是否写完
        // 数据写完，解除对buffer的引用
        key.attach(null);
        // 数据写完，不再关注可写事件
        key.interestOps(key.interestOps() - SelectionKey.OP_WRITE);
    }
}

代码示例

客户端

package com.ysf;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
import java.nio.charset.Charset;

public class Client {

    public static void main(String[] args) throws IOException {
        SocketChannel sc = SocketChannel.open();
        sc.connect(new InetSocketAddress("127.0.0.1",11027));
        sc.write(Charset.defaultCharset().encode("123456\n223456\nhello server\n"));
        while (true){
            ByteBuffer allocate = ByteBuffer.allocate(16);
            sc.read(allocate);
            allocate.flip();
            System.out.println(Charset.defaultCharset().decode(allocate));
        }
    }
}

服务端文章来源地址https://www.toymoban.com/news/detail-673294.html

package com.ysf;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.nio.charset.Charset;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

public class WriterSelectorServer {

    public static void handleContent(ByteBuffer byteBuffer){
        byteBuffer.flip();
        for (int i = 0;i < byteBuffer.limit();i++){
            if (byteBuffer.get(i) == '\n'){
                int length = i + 1 - byteBuffer.position();
                ByteBuffer allocate = ByteBuffer.allocate(length);
                for (int j = 0;j<length;j++){
                    allocate.put(byteBuffer.get());
                }
                allocate.flip();
                System.out.println(Charset.defaultCharset().decode(allocate));
            }
        }
        byteBuffer.compact();
    }

    public static void main(String[] args) throws IOException {
        Selector selector = Selector.open();

        ServerSocketChannel ssc = ServerSocketChannel.open();
        ssc.configureBlocking(false);
        ssc.bind(new InetSocketAddress(11027));
        SelectionKey sscKey = ssc.register(selector, 0, null);
        sscKey.interestOps(SelectionKey.OP_ACCEPT);

        while (true){
            selector.select();
            Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
            while (iterator.hasNext()){
                SelectionKey key = iterator.next();
                iterator.remove();
                if (key.isAcceptable()){
                    ServerSocketChannel serverSocketChannel = (ServerSocketChannel) key.channel();
                    SocketChannel sc = serverSocketChannel.accept();
                    sc.configureBlocking(false);
                    ByteBuffer welcome = Charset.defaultCharset().encode("welcome");
                    sc.write(welcome);
                    Map<String,ByteBuffer> attach = new HashMap<>();
                    ByteBuffer readBuffer = ByteBuffer.allocate(16);
                    attach.put("read",readBuffer);
                    SelectionKey scKey = sc.register(selector, 0, attach);
                    if (welcome.hasRemaining()){
                        attach.put("write",welcome);
                        scKey.interestOps(SelectionKey.OP_READ + SelectionKey.OP_WRITE);
                    }else {
                        scKey.interestOps(SelectionKey.OP_READ);
                    }
                }else if (key.isReadable()){
                    SocketChannel channel = (SocketChannel) key.channel();
                    Map<String, ByteBuffer> attachment = ((Map<String,ByteBuffer>) key.attachment());
                    ByteBuffer readBuffer = attachment.get("read");
                    int read;
                    try {
                        read = channel.read(readBuffer);
                    } catch (IOException e) {
                        e.printStackTrace();
                        key.cancel();
                        continue;
                    }
                    if (read == -1){
                        key.cancel();
                    }else {
                        handleContent(readBuffer);
                        if (readBuffer.position() == readBuffer.limit()){
                            ByteBuffer newAttachment = ByteBuffer.allocate(readBuffer.capacity() * 2);
                            readBuffer.flip();
                            newAttachment.put(readBuffer);
                            attachment.put("read",newAttachment);
                        }
                    }
                }else if (key.isWritable()){
                    SocketChannel channel = (SocketChannel) key.channel();
                    Map<String, ByteBuffer> attachment = (Map<String, ByteBuffer>) key.attachment();
                    ByteBuffer byteBuffer = attachment.get("write");
                    channel.write(byteBuffer);
                    if (!byteBuffer.hasRemaining()) {
                        attachment.remove("write");
                        key.interestOps(key.interestOps() - SelectionKey.OP_WRITE);
                    }
                }
            }
        }
    }
}