nio原理/netty简单应用

  1 package cn.nio;
  2 
  3 import java.io.IOException;
  4 import java.net.InetSocketAddress;
  5 import java.nio.ByteBuffer;
  6 import java.nio.channels.SelectionKey;
  7 import java.nio.channels.Selector;
  8 import java.nio.channels.ServerSocketChannel;
  9 import java.nio.channels.SocketChannel;
 10 import java.util.Iterator;
 11 
 12 /**
 13  * NIO服务端
 14  * @author 小路
 15  */
 16 public class NIOServer {
 17     //通道管理器
 18     private Selector selector;
 19 
 20     /**
 21      * 获得一个ServerSocket通道，并对该通道做一些初始化的工作
 22      * @param port  绑定的端口号
 23      * @throws IOException
 24      */
 25     public void initServer(int port) throws IOException {
 26         // 获得一个ServerSocket通道
 27         ServerSocketChannel serverChannel = ServerSocketChannel.open();
 28         // 设置通道为非阻塞
 29         serverChannel.configureBlocking(false);
 30         // 将该通道对应的ServerSocket绑定到port端口
 31         serverChannel.socket().bind(new InetSocketAddress(port));
 32         // 获得一个通道管理器
 33         this.selector = Selector.open();
 34         //将通道管理器和该通道绑定，并为该通道注册SelectionKey.OP_ACCEPT事件,注册该事件后，
 35         //当该事件到达时，selector.select()会返回，如果该事件没到达selector.select()会一直阻塞。
 36         serverChannel.register(selector, SelectionKey.OP_ACCEPT);
 37     }
 38 
 39     /**
 40      * 采用轮询的方式监听selector上是否有需要处理的事件，如果有，则进行处理
 41      * @throws IOException
 42      */
 43     @SuppressWarnings("unchecked")
 44     public void listen() throws IOException {
 45         System.out.println("服务端启动成功！");
 46         // 轮询访问selector
 47         while (true) {
 48             //当注册的事件到达时，方法返回；否则,该方法会一直阻塞
 49             selector.select();
 50             // 获得selector中选中的项的迭代器，选中的项为注册的事件
 51             Iterator ite = this.selector.selectedKeys().iterator();
 52             while (ite.hasNext()) {
 53                 SelectionKey key = (SelectionKey) ite.next();
 54                 // 删除已选的key,以防重复处理
 55                 ite.remove();
 56                 // 客户端请求连接事件
 57                 if (key.isAcceptable()) {
 58                     ServerSocketChannel server = (ServerSocketChannel) key
 59                             .channel();
 60                     // 获得和客户端连接的通道
 61                     SocketChannel channel = server.accept();
 62                     // 设置成非阻塞
 63                     channel.configureBlocking(false);
 64 
 65                     //在这里可以给客户端发送信息哦
 66                     channel.write(ByteBuffer.wrap(new String("向客户端发送了一条信息").getBytes()));
 67                     //在和客户端连接成功之后，为了可以接收到客户端的信息，需要给通道设置读的权限。
 68                     channel.register(this.selector, SelectionKey.OP_READ);
 69                     
 70                     // 获得了可读的事件
 71                 } else if (key.isReadable()) {
 72                         read(key);
 73                 }
 74 
 75             }
 76 
 77         }
 78     }
 79     /**
 80      * 处理读取客户端发来的信息 的事件
 81      * @param key
 82      * @throws IOException 
 83      */
 84     public void read(SelectionKey key) throws IOException{
 85         // 服务器可读取消息:得到事件发生的Socket通道
 86         SocketChannel channel = (SocketChannel) key.channel();
 87         // 创建读取的缓冲区
 88         ByteBuffer buffer = ByteBuffer.allocate(10);
 89         channel.read(buffer);
 90         byte[] data = buffer.array();
 91         String msg = new String(data).trim();
 92         System.out.println("服务端收到信息："+msg);
 93         ByteBuffer outBuffer = ByteBuffer.wrap(msg.getBytes());
 94         channel.write(outBuffer);// 将消息回送给客户端
 95     }
 96     
 97     /**
 98      * 启动服务端测试
 99      * @throws IOException 
100      */
101     public static void main(String[] args) throws IOException {
102         NIOServer server = new NIOServer();
103         server.initServer(8000);
104         server.listen();
105     }
106 
107 }

  1 package cn.nio;
  2 
  3 import java.io.IOException;
  4 import java.net.InetSocketAddress;
  5 import java.nio.ByteBuffer;
  6 import java.nio.channels.SelectionKey;
  7 import java.nio.channels.Selector;
  8 import java.nio.channels.SocketChannel;
  9 import java.util.Iterator;
 10 
 11 /**
 12  * NIO客户端
 13  * @author 小路
 14  */
 15 public class NIOClient {
 16     //通道管理器
 17     private Selector selector;
 18 
 19     /**
 20      * 获得一个Socket通道，并对该通道做一些初始化的工作
 21      * @param ip 连接的服务器的ip
 22      * @param port  连接的服务器的端口号         
 23      * @throws IOException
 24      */
 25     public void initClient(String ip,int port) throws IOException {
 26         // 获得一个Socket通道
 27         SocketChannel channel = SocketChannel.open();
 28         // 设置通道为非阻塞
 29         channel.configureBlocking(false);
 30         // 获得一个通道管理器
 31         this.selector = Selector.open();
 32         
 33         // 客户端连接服务器,其实方法执行并没有实现连接，需要在listen（）方法中调
 34         //用channel.finishConnect();才能完成连接
 35         channel.connect(new InetSocketAddress(ip,port));
 36         //将通道管理器和该通道绑定，并为该通道注册SelectionKey.OP_CONNECT事件。
 37         channel.register(selector, SelectionKey.OP_CONNECT);
 38     }
 39 
 40     /**
 41      * 采用轮询的方式监听selector上是否有需要处理的事件，如果有，则进行处理
 42      * @throws IOException
 43      */
 44     @SuppressWarnings("unchecked")
 45     public void listen() throws IOException {
 46         // 轮询访问selector
 47         while (true) {
 48             selector.select();
 49             // 获得selector中选中的项的迭代器
 50             Iterator ite = this.selector.selectedKeys().iterator();
 51             while (ite.hasNext()) {
 52                 SelectionKey key = (SelectionKey) ite.next();
 53                 // 删除已选的key,以防重复处理
 54                 ite.remove();
 55                 // 连接事件发生
 56                 if (key.isConnectable()) {
 57                     SocketChannel channel = (SocketChannel) key
 58                             .channel();
 59                     // 如果正在连接，则完成连接
 60                     if(channel.isConnectionPending()){
 61                         channel.finishConnect();
 62                         
 63                     }
 64                     // 设置成非阻塞
 65                     channel.configureBlocking(false);
 66 
 67                     //在这里可以给服务端发送信息哦
 68                     channel.write(ByteBuffer.wrap(new String("向服务端发送了一条信息").getBytes()));
 69                     //在和服务端连接成功之后，为了可以接收到服务端的信息，需要给通道设置读的权限。
 70                     channel.register(this.selector, SelectionKey.OP_READ);
 71                     
 72                     // 获得了可读的事件
 73                 } else if (key.isReadable()) {
 74                         read(key);
 75                 }
 76 
 77             }
 78 
 79         }
 80     }
 81     /**
 82      * 处理读取服务端发来的信息 的事件
 83      * @param key
 84      * @throws IOException 
 85      */
 86     public void read(SelectionKey key) throws IOException{
 87         //和服务端的read方法一样
 88     }
 89     
 90     
 91     /**
 92      * 启动客户端测试
 93      * @throws IOException 
 94      */
 95     public static void main(String[] args) throws IOException {
 96         NIOClient client = new NIOClient();
 97         client.initClient("localhost",8000);
 98         client.listen();
 99     }
100 
101 }