JAVA AIO例子

AioServer.java

package aio;

import nio.NioServerHandle;


public class AioServer {
    public static void main(String[] args) {
        new AioServerHandle().start();
        try {
            Thread.sleep(111111111111L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

AioServerHandle.java

package aio;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousServerSocketChannel;
import java.nio.channels.AsynchronousSocketChannel;
import java.nio.channels.CompletionHandler;


public class AioServerHandle extends Thread {

    private AsynchronousServerSocketChannel serverSocketChannel;

    boolean stop = false;

    public AioServerHandle() {
        try {
            serverSocketChannel = AsynchronousServerSocketChannel.open();
            serverSocketChannel.bind(new InetSocketAddress("127.0.0.1", 1986));
            System.out.println("server init ");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
        serverSocketChannel.accept(this, new CompletionHandler<AsynchronousSocketChannel, AioServerHandle>() {
            @Override
            public void completed(final AsynchronousSocketChannel channel, AioServerHandle attachment) {

                attachment.serverSocketChannel.accept(attachment, this);
                System.out.println("server accepted ");

                ByteBuffer readBuffer = ByteBuffer.allocate(1024);
                channel.read(readBuffer, readBuffer, new CompletionHandler<Integer, ByteBuffer>() {
                    @Override
                    public void completed(Integer result, ByteBuffer attachment) {
                        attachment.flip();
                        byte[] bytes = new byte[attachment.remaining()];
                        attachment.get(bytes);
                        System.out.println("server read : " + new String(bytes));

                        String sendMsg = "server ack";
                        ByteBuffer writeBuffer = ByteBuffer.allocate(sendMsg.getBytes().length);
                        writeBuffer.put(sendMsg.getBytes());
                        writeBuffer.flip();
                        channel.write(writeBuffer, writeBuffer, new CompletionHandler<Integer, ByteBuffer>() {
                            @Override
                            public void completed(Integer result, ByteBuffer attachment) {
                                if (attachment.hasRemaining()){
                                    channel.write(attachment, attachment ,this);
                                }
                                System.out.println("server write ");
                            }

                            @Override
                            public void failed(Throwable exc, ByteBuffer attachment) {
                                try {
                                    channel.close();
                                } catch (IOException e) {
                                    e.printStackTrace();
                                }
                            }
                        });

                    }

                    @Override
                    public void failed(Throwable exc, ByteBuffer attachment) {
                        try {
                            serverSocketChannel.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                });
            }

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

            }
        });
        try {
            Thread.sleep(100000000L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

AioClient.java

package aio;


import nio.NioClientHandle;

public class AioClient {


    public static void main(String[] args) {


        try {
            new AioClientHandle().start();

            Thread.sleep(111111111111L);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

AioClientHandle.java

package aio;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.util.Iterator;
import java.util.Set;


public class AioClientHandle extends Thread implements CompletionHandler<Void,AioClientHandle>{

    private AsynchronousSocketChannel socketChannel;

    boolean stop = false;

    public AioClientHandle() {
        try {
            socketChannel = AsynchronousSocketChannel.open();
            System.out.println("client init ");
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    @Override
    public void run() {
        try {
            socketChannel.connect(new InetSocketAddress("127.0.0.1", 1986), this, this);
        } catch (Exception e) {
            e.printStackTrace();
        }
        try {
            Thread.sleep(100000000L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void completed(Void result, AioClientHandle attachment) {

        System.out.println("client connected ");

        String sendMsg = System.currentTimeMillis()+"";
        ByteBuffer writeBuffer = ByteBuffer.allocate(sendMsg.getBytes().length);
        writeBuffer.put(sendMsg.getBytes());
        writeBuffer.flip();

        socketChannel.write(writeBuffer, writeBuffer, new CompletionHandler<Integer, ByteBuffer>() {
            @Override
            public void completed(Integer result, ByteBuffer attachment) {
                if (attachment.hasRemaining()) {
                    socketChannel.write(writeBuffer, attachment, this);
                } else {

                    System.out.println("client write ");

                    ByteBuffer readBuffer = ByteBuffer.allocate(1024);
                    socketChannel.read(readBuffer, readBuffer, new CompletionHandler<Integer, ByteBuffer>() {
                        @Override
                        public void completed(Integer result, ByteBuffer attachment) {
                            readBuffer.flip();
                            byte[] bytes = new byte[readBuffer.remaining()];
                            readBuffer.get(bytes);
                            System.out.println("client read : " + new String(bytes));
                        }

                        @Override
                        public void failed(Throwable exc, ByteBuffer attachment) {
                            try {
                                socketChannel.close();
                            } catch (IOException e) {
                                e.printStackTrace();
                            }
                        }
                    });

                }
            }

            @Override
            public void failed(Throwable exc, ByteBuffer attachment) {
                try {
                    socketChannel.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        });
    }

    @Override
    public void failed(Throwable exc, AioClientHandle attachment) {
        try {
            socketChannel.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }



}