3、nio中的selector使用

通过编写一个客户端和服务器端的例子来熟悉selector的使用

服务端逻辑：

1. 绑定一个端口号
2. channel注册到selector中
3. 用死循环来监听如果有时间发生，遍历selectionKey set
4. 判断发生的事件类型，前面会注册accept事件，如果发生accept事件，那么注册读事件，同时清除selectionKey set 中的当前元素。、
5. 接收事件时，将channel保存下来。
6. 发生读事件时，说明有信息，发过来了，那么将消息，转发给所有的客户端。然后清除自身的事件。

 import java.io.IOException;
 import java.net.InetSocketAddress;
 import java.net.ServerSocket;
 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.*;

 public class NioServer {

     private static HashMap<String, SocketChannel> clientMap = new HashMap<String, SocketChannel>();

     public static void main(String[] args) throws IOException {
         ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
         serverSocketChannel.configureBlocking(false);

         ServerSocket serverSocket = serverSocketChannel.socket();
         serverSocket.bind(new InetSocketAddress(8899));

         Selector selector = Selector.open();

         serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

         while(true) {
             int number = selector.select();
 //            System.out.println("number:" + number);
             Set<SelectionKey> selectionKeySet = selector.selectedKeys();

             Iterator<SelectionKey> iterable = selectionKeySet.iterator();

             if(number > 0 ) {
                 while(iterable.hasNext()) {
                     SelectionKey selectionKey = iterable.next();

                     if(selectionKey.isAcceptable()) {//如果是可接收连接的
                         ServerSocketChannel ssc = (ServerSocketChannel) selectionKey.channel();
                         SocketChannel socketChannel = ssc.accept();
                         socketChannel.configureBlocking(false);

                         socketChannel.register(selector, SelectionKey.OP_READ);//注册读事件

                         clientMap.put(UUID.randomUUID() + "", socketChannel);//保存下channel

                         iterable.remove();
                     } else if(selectionKey.isReadable()){//可读的
                         SocketChannel socketChannel = (SocketChannel) selectionKey.channel();
                         ByteBuffer byteBuffer = ByteBuffer.allocate(1024);

                         int readCount = socketChannel.read(byteBuffer);

                         //这里本该用while
                         if(readCount > 0 ) {//读取到数据，就写回到其他客户端
                             byteBuffer.flip();

                             Charset charset = Charset.forName("UTF-8");
                             String receiveStr = new String(charset.decode(byteBuffer).array());

                             System.out.println(socketChannel + " receive msg :" + receiveStr);

                             String sendKey = "";

                             for(Map.Entry<String, SocketChannel> entry : clientMap.entrySet()) {//第一遍遍历找到发送者
                                 if(socketChannel == entry.getValue()) {
                                     sendKey = entry.getKey();
                                     break;
                                 }
                             }

                             for (Map.Entry<String, SocketChannel> entry: clientMap.entrySet()  ) {//给每个保存的连接，都发送消息
                                 ByteBuffer writeBuffer = ByteBuffer.allocate(1024);
                                 writeBuffer.put((sendKey + ":" +  receiveStr).getBytes());

                                 writeBuffer.flip();
                                 entry.getValue().write(writeBuffer);
                             }
                         }
                         iterable.remove();//这个 删除很关键  每次循环完selectionKeySet ，一定要清楚事件，不然肯定会影响下一次的事件触发，或者直接不触发下次的事件
                     }
                 }
             }

         }
     }
 }

客户端逻辑

1. 建立socketChannel 连接到对应的端口
2. 新建selector对象，然后把socketChannel注册到selector上
3. 建立死循环 ，监听是否有事件发生，若有，则遍历seletionKey set ,
4. 判断发生的事件是什么，
5. 如果是连接事件 ，做对应的连接处理，注册读事件

判断是否在等待连接 ，在进程中
if (channel.isConnectionPending()) {
channel.finishConnect(); 完成连接，这里是阻塞的

6. 如果发生了读事件，读取数据

 import java.io.BufferedReader;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.net.InetSocketAddress;
 import java.nio.ByteBuffer;
 import java.nio.channels.SelectionKey;
 import java.nio.channels.Selector;
 import java.nio.channels.SocketChannel;
 import java.time.LocalDateTime;
 import java.util.Iterator;
 import java.util.Set;
 import java.util.concurrent.Executor;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.ThreadFactory;

 public class NioClient {

     public static void main(String[] args) {
         try{
             SocketChannel socketChannel = SocketChannel.open();
             socketChannel.configureBlocking(false);
             socketChannel.connect(new InetSocketAddress(8899));//服务端就是bind  然后accept  serverSocketChannel

             Selector selector = Selector.open();

             socketChannel.register(selector, SelectionKey.OP_CONNECT);//注册连接事件

             while(true) {
                 int number = selector.select();

                 if(number > 0) {
                     Set<SelectionKey> selectionKeySet =  selector.selectedKeys();

                     Iterator<SelectionKey> iterable = selectionKeySet.iterator();
                     while(iterable.hasNext()) {//有事件发生
                         SelectionKey selectionKey = iterable.next();

                         SocketChannel client = (SocketChannel) selectionKey.channel();
                         if(selectionKey.isConnectable()) {//判断 selectionkey 状态  可连接的
                             if(client.isConnectionPending()) {//是否在准备连接的进程中
                                 client.finishConnect();//这里会阻塞，如果连接未建立，抛异常 ，

                                 ByteBuffer byteBuffer = ByteBuffer.allocate(1024);

                                 byteBuffer.put((LocalDateTime.now() + "，连接成功").getBytes());
                                 byteBuffer.flip();
                                 client.write(byteBuffer);

                                 ExecutorService executorService = Executors.newSingleThreadExecutor(Executors.defaultThreadFactory());

                                 executorService.submit(() -> {//起一个新的线程，去接收控制台的输入 ，不影响其他线程
                                     while(true) {
                                         try{
                                             byteBuffer.clear();
                                             InputStreamReader inputStreamReader = new InputStreamReader(System.in);
                                             BufferedReader bufferedReader = new BufferedReader(inputStreamReader);

                                             byteBuffer.put(bufferedReader.readLine().getBytes());
                                             byteBuffer.flip();
                                             client.write(byteBuffer);

                                         }catch (Exception e) {
                                             e.printStackTrace();
                                         }
                                     }
                                 });
                             }

                             iterable.remove();//这个事件清楚，很关键
                             client.register(selector, SelectionKey.OP_READ);//注册读事件
                         } else if(selectionKey.isReadable()){//可读取
                             SocketChannel socketChannel1 = (SocketChannel) selectionKey.channel();
                             ByteBuffer readBuffer = ByteBuffer.allocate(1024);

                             int readCount = socketChannel.read(readBuffer);
                             if(readCount > 0) {
                                 String receiveMsg = new String(readBuffer.array());
                                 System.out.println("receiveMsg : " + receiveMsg);
                             }

                             iterable.remove();
                         }

                     }
                 }
             }

         }catch (Exception e ) {
             e.printStackTrace();
         }

     }
 }