【网络编程】JAVA中的io之AIO

本文原地址：https://www.dyzhello.club/static/page/readArticle.html?id=15451

原创内容转载请说明

在熟悉了NIO中的几个概念以后我们需要在了解一个接口，来帮助我们理解接下来的代码：

CompletionHandler<V, A> 在java.nio.channels包下,有两个方法需要我们关注：

1. completed() 
2. failed()

顾名思义这两个方法将在某个动作或事件完成时（completed）或者失败（failed）时执行。

接下来我们需要编写服务端代码：

AsyncServer：

public class AsyncServer implements Runnable {
    AsynchronousServerSocketChannel serverSocketChannel;
    public static void main(String[] args) throws IOException {
        AsyncServer server = new AsyncServer();
        server.serverSocketChannel = AsynchronousServerSocketChannel.open();
        server.serverSocketChannel.bind(new InetSocketAddress(9090));
        new Thread(server).start();
    }

    @Override
    public void run() {
        CountDownLatch latch = new CountDownLatch(1);
        serverSocketChannel.accept(this, new AcceptHanler());
        try {
            latch.await();
            serverSocketChannel.close();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

我们在main方法里创建一个AsynchronousServerSocketChannel对象，这个对象类似于BIO里的ServerSocket。用于监听端口接受连接。

随后我们启动一个线程来监听端口。

需要提一下的是CountDownLatch latch = new CountDownLatch(1);。

之所以创建一个CountDownLatch倒数计数器对象(翻译可能不准确，关于该类的详细信息可在java.util.concurrent包中查看）是因为AsynchronousServerSocketChannel是异步的，为了防止程序结束我们要让代码在这停下，在实际生产环境中一般不需要这么处理。

这段代码的关键在于serverSocketChannel.accept(this, new AcceptHanler());这里，accept方法接收两个参数第一个是attachment，第二个是CompletionHandler我们监听端口，我们先来看第二个参数，很显然就是我们开头提到的对事件进程处理的对象，在服务端接受到请求时，会把请求交给该对象处理并将第一个参数attachment一并传递过去。

接下来我们看AcceptHandler的代码

AcceptHandler：

public class AcceptHanler implements CompletionHandler<AsynchronousSocketChannel,AsyncServer > {

    @Override
    public void completed(AsynchronousSocketChannel result, AsyncServer attachment) {
        attachment.serverSocketChannel.accept(attachment, this);
        ByteBuffer buffer = ByteBuffer.allocate(10240);
        result.read(buffer, buffer, new ReadHandler(result));
    }

    @Override
    public void failed(Throwable exc, AsyncServer attachment) {

    }
}

这段代码也很简单首先我们得到上段代码传递过来的attachment之后继续监听，因为我们的代码需要不断的接收客户端的请求，所以要在这里形成循环，由于accept是异步的所以不影响后面代码执行，在后面代码中我们执行read方法将数据读到buffer里，并再次实现CompletionHandler即ReadHandler同时把buffer传递到新的CompletionHandler实现里.

ReadHandler:

public class ReadHandler implements CompletionHandler<Integer, ByteBuffer> {
    AsynchronousSocketChannel channel;
    ReadHandler(AsynchronousSocketChannel channel) {
        this.channel = channel;
    }
    @Override
    public void completed(Integer result, ByteBuffer attachment) {
        System.out.println("read give integer is: " + result);
        attachment.flip();
        byte[] bytes = new byte[attachment.remaining()];
        attachment.get(bytes);
        try {
            String msg = new String(bytes, "utf-8");
            System.out.println(msg);
            ByteBuffer resp = ByteBuffer.allocate(10240);
            resp.put("收到了".getBytes("utf-8"));
            resp.flip();
            channel.write(resp, resp, new WriteHandler(channel));
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        ByteBuffer buffer = ByteBuffer.allocate(10240);
        channel.read(buffer, buffer, this);
    }

    @Override
    public void failed(Throwable exc, ByteBuffer attachment) {

    }
}

在这里我们将buffer中数据读取到字节数组并构造成字符串打印出来，需要注意的是channel.read(buffer, buffer, this);这里。由于我们要不断从channel里读取数据所以也要重新调用read方法。

你可能会注意打这里有channel.write(resp, resp, new WriteHandler(channel));这样一段代码，和前两个CompletionHandler相同这里也实现了该接口，我把代码放出来其余就不再赘述。

WriteHandler:

public class WriteHandler implements CompletionHandler<Integer, ByteBuffer> {
    AsynchronousSocketChannel channel;
    public WriteHandler(AsynchronousSocketChannel channel) {
        this.channel = channel;
    }

    @Override
    public void completed(Integer result, ByteBuffer attachment) {
        if (attachment.hasRemaining()) {
            channel.write(attachment, attachment, this);
        }
    }

    @Override
    public void failed(Throwable exc, ByteBuffer attachment) {

    }
}

到这里我们的服务端代码就编写成功了！

接下来我们来实现客户端代码,y由于和服务端代码比较相似就不再详细解释。

AsyncHandler：

public class ClientReadHandler implements CompletionHandler<Integer, ByteBuffer> {
    AsynchronousSocketChannel channel;
    ClientReadHandler(AsynchronousSocketChannel channel) {
        this.channel = channel;
    }
    @Override
    public void completed(Integer result, ByteBuffer attachment) {
        System.out.println("read completion");
        attachment.flip();
        byte[] bytes = new byte[attachment.remaining()];
        attachment.get(bytes);
        try {
            System.out.println(new String(bytes, "utf-8"));
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        attachment.clear();
        channel.read(attachment,attachment, this);
        
    }

    @Override
    public void failed(Throwable exc, ByteBuffer attachment) {

    }
}

ClientReadHandler：

public class ClientReadHandler implements CompletionHandler<Integer, ByteBuffer> {
    AsynchronousSocketChannel channel;
    ClientReadHandler(AsynchronousSocketChannel channel) {
        this.channel = channel;
    }
    @Override
    public void completed(Integer result, ByteBuffer attachment) {
        System.out.println("read completion");
        attachment.flip();
        byte[] bytes = new byte[attachment.remaining()];
        attachment.get(bytes);
        try {
            System.out.println(new String(bytes, "utf-8"));
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        attachment.clear();
        channel.read(attachment,attachment, this);

    }

    @Override
    public void failed(Throwable exc, ByteBuffer attachment) {

    }
}

ConnectHandler：

public class ConnectHandler implements CompletionHandler<Void, AsynchronousSocketChannel> {
    @Override
    public void completed(Void result, AsynchronousSocketChannel attachment) {
        ByteBuffer buffer = ByteBuffer.allocate(10240);
        try {
//            buffer.put("这是一个请求".getBytes());
//            buffer.flip();
//            attachment.write(buffer, buffer, new WriteHandler(attachment));
            new HeartTask(attachment).work();
            ByteBuffer resp = ByteBuffer.allocate(10240);
            attachment.read(resp, resp, new ClientReadHandler(attachment));
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    @Override
    public void failed(Throwable exc, AsynchronousSocketChannel attachment) {

    }
    class HeartTask {
        AsynchronousSocketChannel channel;
        HeartTask(AsynchronousSocketChannel channel) {
            this.channel = channel;
        }
        public void work() {
            Timer timer = new Timer();
            timer.scheduleAtFixedRate(new TimerTask() {
                @Override
                public void run() {
                    ByteBuffer buffer = ByteBuffer.allocate(1024);
                    buffer.put(new Date().toString().getBytes());
                    buffer.flip();
                    channel.write(buffer, buffer, new WriteHandler(channel));
                }
            }, 300,3000);
        }
    }
}

这里我们和服务端代码不同的是我们创建了HeartTask类来模拟心跳每隔三秒就会发送一次时间，关于心跳检测的详细使用我们将在后续文章中讲到，本文就写到这里。谢谢阅读！