Java NIO网络编程

我不是女神ヾ 2023-06-22 13:59 88阅读 0赞

BIO

BIO：传统的网络通讯模型，同步阻塞IO。服务端创建一个ServerSocket， 客户端用Socket去连接服务端的ServerSocket， ServerSocket接收到了一个的连接请求就会创建一个Socket和一个线程去跟那个Socket进行通讯。接着客户端和服务端就进行阻塞式的通信：
阻塞式具体体现在：
①服务端等待连接请求
②创建一个线程跟客户端进行和通信阻塞等待客户端发送的数据。
③客户端阻塞等待服务器端处理后返回响应，在响应返回前，客户端那边就阻塞等待，什么事都做不了。
缺点：
①每次一个客户端接入，都需要创建一个线程来服务这个客户端。当客户端过多时，就会造成服务端的线程数量可能达到了几千几万，这样就可能会造成服务端过载过高，最后宕机
②阻塞时什么事都做不了，只能阻塞等待，浪费资源。

服务器代码会在A行代码中阻塞，一直等待客户端连接。一旦有客户端连接就能得到一个Socket连接，接着就会继续往下阻塞等待客户端的输入信息（一下代码在正式使用时会增加线程池，当有连接时，从线程池获得一个线程执行操作）
服务端代码样例

  1. public class TCPServer { 
  2.     public static void main(String[] args) { 
  3.         ServerSocket serverSocket = null;
  4.         Socket sc = null;
  5.         try { 
  6.              serverSocket = new ServerSocket(9999);
  7.         } catch (IOException e) { 
  8.             e.printStackTrace();
  9.         }
  10.         while (true){ 
  11.             try { 
  12.                 sc = serverSocket.accept(); //A
  13.                 String ip = sc.getInetAddress().getHostAddress();
  14.                 System.out.println(ip+"已连接");
  15.                 InputStream is = sc.getInputStream();//B
  16.                 byte[] b = new byte[1024];
  17.                 is.read(b);
  18.                 System.out.println(ip+":"+new String(b));
  19.                 OutputStream outputStream = sc.getOutputStream();
  20.                 outputStream.write("知道了".getBytes());
  21.             } catch (IOException e) { 
  22.                 e.printStackTrace();
  23.             }finally { 
  24.                 try { 
  25.                     sc.close();
  26.                 } catch (IOException e) { 
  27.                     e.printStackTrace();
  28.                 }
  29.             }
  30.         }
  31.     }
  32. }

客户端代码样例
C行代码会一直阻塞直到服务器端做出响应

  1. public class TCPClient { 
  2.     public static void main(String[] args) { 
  3.         while (true){ 
  4.             try { 
  5.                 Socket s = new Socket("127.0.0.1",9999);
  6.                 OutputStream outputStream = s.getOutputStream();
  7.                 System.out.println("请输入");
  8.                 Scanner scanner = new Scanner(System.in);
  9.                 String msg = scanner.nextLine();
  10.                 outputStream.write(msg.getBytes());
  11.                 InputStream inputStream = s.getInputStream();//C
  12.                 byte[] b = new byte[1024];
  13.                 inputStream.read(b);
  14.                 System.out.println("服务器:"+new String(b));
  15.             } catch (IOException e) { 
  16.                 e.printStackTrace();
  17.             }
  18.         }
  19.     }
  20. }

NIO

核心组件

  • 通道（Channel）
    首先说一下Channel，“通道/连接”。Stream是单向的，譬如：InputStream, OutputStream是单向的而Channel是双向的，既可以用来进行读操作，又可以用来进行写操作。网络NIO中的Channel也是双向的，可以从另一端获得数据也可以向另一端写入数据。
    1）FileChannel（文件IO）
    2）DatagramChannel（UDP）
    3）SocketChannel（ClientTCP）
    4）ServerSocketChannel（ClientTCP）
  • 缓冲区（Buffer）
    NIO中的关键Buffer实现有
    ByteBuffer
    CharBuffer
    DoubleBuffer
    FloatBuffer
    IntBuffer
    LongBuffer,
    ShortBuffer
  • 选择器（Selectors）
    Selectors(选择器)能够检测一到多个NIO通道，并能够知道连接是否做好准备的组件。一个单独的线程就可以管理多个channel，从而管理多个网络连接。要使用Selector, 得向Selector注册Channel。轮询一个或多个NIO Channel的状态是否有事件发生。有相应事件发生则执行相应逻辑。这样既可实现了利用一个线程无管理多数连接。不用再一个客户端一个连接。避免了多个线程的切换与维护。在这里插入图片描述
  • selectionKey：代表socket与Select之间发生的事件关系。
    OP_ACCEPT:有新的网络连接可以建立（accept），值为16
    OP_CONNECT:连接已经建立,值为8
    OP_READ/OP_WRITE 读写操作 值为1，4

服务端代码样例

  1. public class ChatServer { 
  2.     private ServerSocketChannel serverSocketChannel;
  3.     private Selector selector;
  4.     private static final int PORT = 9999;
  6.     public ChatServer() { 
  7.         try { 
  8.             //得到ServerSocketChannel
  9.             serverSocketChannel = ServerSocketChannel.open();
  10.             //得到selector
  11.             selector = Selector.open();
  12.             //绑定端口号
  13.             serverSocketChannel.bind(new InetSocketAddress(PORT));
  14.             //设置非阻塞方式
  15.             serverSocketChannel.configureBlocking(false);
  16.             //设置selector给ServerSocketChannel
  17.             serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
  18.             System.out.println("server reday");
  19.         } catch (IOException e) { 
  20.             e.printStackTrace();
  21.         }
  22.     }
  24.     public void start() throws IOException { 
  25.         //准备执行任务
  26.         while (true) { 
  27.             //每四秒监控一下客户端，返回值为就绪的channel连接数量
  28.             if (selector.select(4000) == 0) { 
  29.                 //非阻塞式，可以执行其他的事务
  30.                 System.out.println("没有准备就绪的连接，或已注册的连接");
  31.                 continue;
  32.             }
  33.             //有连接就绪了，得到selectionKey判断事件
  34.             //得到所有的发生事件
  35.             Iterator<SelectionKey> selectionKeyIterable = selector.selectedKeys().iterator();
  36.             while (selectionKeyIterable.hasNext()) { 
  37.                 SelectionKey selectionKey = selectionKeyIterable.next();
  39.                 if (selectionKey.isAcceptable()) { 
  40.                     System.out.println("isAcceptable");
  41.                     SocketChannel socketChannel = null;
  43.                     //客户端连接事件
  44.                     socketChannel = serverSocketChannel.accept();
  45.                     //设置非阻塞方式
  46.                     socketChannel.configureBlocking(false);
  47.                     //将该通道注册到监控器中，注重监听读事件
  48.                     socketChannel.register(selector, SelectionKey.OP_READ);
  49.                     System.out.println(socketChannel.getRemoteAddress());
  50.                 } else if (selectionKey.isReadable()) { 
  51.                     readMsg(selectionKey);
  52.                 }
  53.                 selectionKeyIterable.remove();
  54.             }
  55.         }
  56.     }
  58.     /** * 收到消息，并且广播 * * @param selectionKey */
  59.     private void readMsg(SelectionKey selectionKey) throws IOException { 
  60.         //获得通道
  61.         Channel channel = selectionKey.channel();
  62.         ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
  64.         int count = ((SocketChannel) channel).read(byteBuffer);
  65.         if (count > 0) { 
  66.             String msg = new String(byteBuffer.array());
  67.             System.out.println(msg);
  68.             //发送广播
  69.             broadCast(msg, channel);
  70.         }
  71.     }
  73.     /** * 给所有的连接发送消息 * * @param msg * @param expect */
  74.     private void broadCast(String msg, Channel expect) throws IOException { 
  75.         for (SelectionKey key : selector.keys()) { 
  76.             Channel channel = key.channel();
  77.             if (channel instanceof SocketChannel && channel != expect) { 
  78.                 ByteBuffer byteBuffer = ByteBuffer.wrap(msg.getBytes());
  79.                 ((SocketChannel) channel).write(byteBuffer);
  80.             }
  81.         }
  82.     }
  84.     public static void main(String[] args) { 
  85.         ChatServer chatServer = new ChatServer();
  86.         try { 
  87.             chatServer.start();
  88.         } catch (IOException e) { 
  89.             e.printStackTrace();
  90.         }
  91.     }
  92. }

客户端样例代码

  1. public class ChatClient { 
  2.     private String userName;
  3.     private final static String HOST="127.0.0.1";
  4.     private int port=9999;
  5.     private SocketChannel socketChannel;
  7.     public ChatClient() { 
  9.         try { 
  10.             //得到一个网络连接
  11.             socketChannel = SocketChannel.open();
  12.             //设置阻塞方式
  13.             socketChannel.configureBlocking(false);
  14.             //封装连接地址
  15.             InetSocketAddress address = new InetSocketAddress(HOST,port);
  16.             //使连接连上客户端
  17.             if (!socketChannel.connect(address)){ 
  18.                 //连接失败
  19.                 while (!socketChannel.finishConnect()){ 
  20.                     //未连接上，持续连接，在连接过程中非阻塞
  21.                     System.out.println("正在连接服务器....");
  22.                 }
  23.             }
  24.             userName = socketChannel.getLocalAddress().toString();
  25.         } catch (IOException e) { 
  26.             e.printStackTrace();
  27.         }
  28.     }
  30.     public void sendMsg(String msg) throws IOException { 
  31.         if (msg.equals("bye")){ 
  32.             socketChannel.close();
  33.             return;
  34.         }
  35.         ByteBuffer byteBuffer = ByteBuffer.wrap((userName+":"+msg).getBytes());
  36.         socketChannel.write(byteBuffer);
  37.     }
  39.     public void receiveMsg() throws IOException { 
  40.         ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
  41.         int count = socketChannel.read(byteBuffer);
  42.         if (count > 0) { 
  43.             String msg = new String(byteBuffer.array());
  44.             System.out.println(msg.trim());
  45.         }
  46.     }
  48.     public static void main(String[] args) { 
  49.         ChatClient chatClient = new ChatClient();
  51.         new Thread(){ 
  52.             @Override
  53.             public void run() { 
  54.                 while (true){ 
  55.                     try { 
  56.                         chatClient.receiveMsg();
  57.                         Thread.sleep(2000);
  58.                     } catch (IOException e) { 
  59.                         e.printStackTrace();
  60.                     } catch (InterruptedException e) { 
  61.                         e.printStackTrace();
  62.                     }
  63.                 }
  64.             }
  65.         }.start();
  67.         Scanner scanner = new Scanner(System.in);
  68.         while (scanner.hasNext()){ 
  69.             String msg = scanner.nextLine();
  70.             try { 
  71.                 chatClient.sendMsg(msg);
  72.             } catch (IOException e) { 
  73.                 e.printStackTrace();
  74.             }
  75.         }
  76.     }
  77. }

发表评论

表情：
评论列表 （有 0 条评论，88人围观）

还没有评论，来说两句吧...

相关阅读