Java NIO 与 Nio Socket

最新推荐文章于 2023-02-18 19:34:30 发布

小飞鹤

最新推荐文章于 2023-02-18 19:34:30 发布

阅读量1.2k

点赞数 2

分类专栏： Java高级 Java高级学习

本文链接：https://blog.csdn.net/he90227/article/details/50564092

版权

Java高级同时被 2 个专栏收录

56 篇文章 0 订阅

订阅专栏

Java高级学习

46 篇文章 40 订阅

订阅专栏

Java NIO 目录：

[html]view plaincopy 
   
print?
 package com.xy.nio;  
   
 import java.io.IOException;  
 import java.net.InetSocketAddress;  
 import java.nio.channels.SelectionKey;  
 import java.nio.channels.Selector;  
 import java.nio.channels.ServerSocketChannel;  
 import java.util.Iterator;  
   
 public class TCPServer {  
     // 缓冲区大小  
     private static final int BufferSize = 1024;  
     // 超时时间，单位毫秒  
     private static final int TimeOut = 3000;  
     // 本地监听端口  
     private static final int ListenPort = 1978;  
     public static void main(String[] args) throws IOException {  
         // 创建选择器  
         Selector selector = Selector.open();  
         // 打开监听信道  
         ServerSocketChannel listenerChannel = ServerSocketChannel.open();  
         // 与本地端口绑定  
         listenerChannel.socket().bind(new InetSocketAddress(ListenPort));  
         // 设置为非阻塞模式  
         listenerChannel.configureBlocking(false);  
         // 将选择器绑定到监听信道,只有非阻塞信道才可以注册选择器.并在注册过程中指出该信道可以进行Accept操作  
         listenerChannel.register(selector, SelectionKey.OP_ACCEPT);  
         // 创建一个处理协议的实现类,由它来具体操作  
         TCPProtocol protocol = new TCPProtocolImpl(BufferSize);  
   
         // 反复循环,等待IO  
         while (true) {  
             // 等待某信道就绪(或超时)  
             if (selector.select(TimeOut) == 0) {// 监听注册通道，当其中有注册的 IO  
                                                 // 操作可以进行时，该函数返回，并将对应的  
                                                 // SelectionKey 加入 selected-key  
                                                 // set  
                 System.out.print("独自等待.");  
                 continue;  
             }  
             // 取得迭代器.selectedKeys()中包含了每个准备好某一I/O操作的信道的SelectionKey  
             // Selected-key Iterator 代表了所有通过 select() 方法监测到可以进行 IO 操作的 channel  
             // ，这个集合可以通过 selectedKeys() 拿到  
             Iterator<SelectionKey> keyIter = selector.selectedKeys().iterator();  
             while (keyIter.hasNext()) {  
                 SelectionKey key = keyIter.next();  
                 SelectionKey key1;  
                 if (keyIter.hasNext()) {  
                     key1 = keyIter.next();  
                 }  
                 try {  
                     if (key.isAcceptable()) {  
                         // 有客户端连接请求时  
                         protocol.handleAccept(key);  
                     }  
                     if (key.isReadable()) {// 判断是否有数据发送过来  
                         // 从客户端读取数据  
                         protocol.handleRead(key);  
                     }  
                     if (key.isValid() && key.isWritable()) {// 判断是否有效及可以发送给客户端  
                         // 客户端可写时  
                         protocol.handleWrite(key);  
                     }  
                 } catch (IOException ex) {  
                     // 出现IO异常（如客户端断开连接）时移除处理过的键  
                     keyIter.remove();  
                     continue;  
                 }  
                 // 移除处理过的键  
                 keyIter.remove();  
             }  
         }  
     }  
 }  

TCPProtocol.java读写处理接口

[html]view plaincopy 
   
print?
 package com.xy.nio;  
   
 import java.io.IOException;  
 import java.nio.channels.SelectionKey;  
   
 public interface TCPProtocol{  
    /**  
     * 接收一个SocketChannel的处理  
     * @param key  
     * @throws IOException  
     */  
    void handleAccept(SelectionKey key) throws IOException;  
      
    /**  
     * 从一个SocketChannel读取信息的处理  
     * @param key  
     * @throws IOException  
     */  
    void handleRead(SelectionKey key) throws IOException;  
      
    /**  
     * 向一个SocketChannel写入信息的处理  
     * @param key  
     * @throws IOException  
     */  
    void handleWrite(SelectionKey key) throws IOException;  
  }  

TCPProtocolImpl.java接口实现

[html]view plaincopy 
   
print?
 package com.xy.nio;  
   
 import java.io.IOException;  
 import java.nio.ByteBuffer;  
 import java.nio.channels.SelectionKey;  
 import java.nio.channels.ServerSocketChannel;  
 import java.nio.channels.SocketChannel;  
 import java.nio.charset.Charset;  
 import java.util.Date;  
   
 public class TCPProtocolImpl implements TCPProtocol {  
     private int bufferSize;  
   
     public TCPProtocolImpl(int bufferSize) {  
         this.bufferSize = bufferSize;  
     }  
   
     public void handleAccept(SelectionKey key) throws IOException {  
         // 返回创建此键的通道，接受客户端建立连接的请求，并返回 SocketChannel 对象  
         SocketChannel clientChannel = ((ServerSocketChannel) key.channel())  
                 .accept();  
         // 非阻塞式  
         clientChannel.configureBlocking(false);  
         // 注册到selector  
         clientChannel.register(key.selector(), SelectionKey.OP_READ,  
                 ByteBuffer.allocate(bufferSize));  
     }  
   
     public void handleRead(SelectionKey key) throws IOException {  
         // 获得与客户端通信的信道  
         SocketChannel clientChannel = (SocketChannel) key.channel();  
         // 得到并清空缓冲区  
         ByteBuffer buffer = (ByteBuffer) key.attachment();  
         buffer.clear();  
         // 读取信息获得读取的字节数  
         long bytesRead = clientChannel.read(buffer);  
         if (bytesRead == -1) {  
             // 没有读取到内容的情况  
             clientChannel.close();  
         } else {  
             // 将缓冲区准备为数据传出状态  
             buffer.flip();  
             // 将字节转化为为UTF-16的字符串  
             String receivedString = Charset.forName("UTF-16").newDecoder()  
                     .decode(buffer).toString();  
             // 控制台打印出来  
             System.out.println("接收到来自"  
                     + clientChannel.socket().getRemoteSocketAddress() + "的信息:"  
                     + receivedString);  
             // 准备发送的文本  
             String sendString = "你好,客户端. @" + new Date().toString()  
                     + "，已经收到你的信息" + receivedString;  
             buffer = ByteBuffer.wrap(sendString.getBytes("UTF-16"));  
             clientChannel.write(buffer);  
             // 设置为下一次读取或是写入做准备  
             key.interestOps(SelectionKey.OP_READ | SelectionKey.OP_WRITE);  
         }  
     }  
   
     public void handleWrite(SelectionKey key) throws IOException {  
         // do nothing  
     }  
 }  

TCPClientReadThread.java客户端：

[html]view plaincopy 
   
print?
 package com.xy.nio;  
   
 import java.io.IOException;  
 import java.nio.ByteBuffer;  
 import java.nio.channels.SelectionKey;  
 import java.nio.channels.Selector;  
 import java.nio.channels.SocketChannel;  
 import java.nio.charset.Charset;  
   
 public class TCPClientReadThread implements Runnable {  
     private Selector selector;  
   
     public TCPClientReadThread(Selector selector) {  
         this.selector = selector;  
   
         new Thread(this).start();  
     }  
   
     @SuppressWarnings("static-access")  
     public void run() {  
         try {  
             while (selector.select() > 0) {//select()方法只能使用一次，用了之后就会自动删除,每个连接到服务器的选择器都是独立的  
                 // 遍历每个有可用IO操作Channel对应的SelectionKey  
                 for (SelectionKey sk : selector.selectedKeys()) {  
                     // 如果该SelectionKey对应的Channel中有可读的数据  
                     if (sk.isReadable()) {  
                         // 使用NIO读取Channel中的数据  
                         SocketChannel sc = (SocketChannel) sk.channel();//获取通道信息  
                         ByteBuffer buffer = ByteBuffer.allocate(1024);//分配缓冲区大小  
                         sc.read(buffer);//读取通道里面的数据放在缓冲区内  
                         buffer.flip();// 调用此方法为一系列通道写入或相对获取 操作做好准备  
                         // 将字节转化为为UTF-16的字符串  
                         String receivedString = Charset.forName("UTF-16")  
                                 .newDecoder().decode(buffer).toString();  
                         // 控制台打印出来  
                         System.out.println("接收到来自服务器"  
                                 + sc.socket().getRemoteSocketAddress() + "的信息:"  
                                 + receivedString);  
                         // 为下一次读取作准备  
                         sk.interestOps(SelectionKey.OP_READ);  
                     }  
                     // 删除正在处理的SelectionKey  
                     selector.selectedKeys().remove(sk);  
                 }  
             }  
         } catch (IOException ex) {  
             ex.printStackTrace();  
         }  
     }  
 }  

TCPClient.java

[html]view plaincopy 
   
print?
 package com.xy.nio;  
   
 import java.io.IOException;  
 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.util.Scanner;  
   
 public class TCPClient {  
     // 信道选择器  
     private Selector selector;  
   
     // 与服务器通信的信道  
     SocketChannel socketChannel;  
   
     // 要连接的服务器Ip地址  
     private String hostIp;  
   
     // 要连接的远程服务器在监听的端口  
     private int hostListenningPort;  
   
     public TCPClient(String HostIp, int HostListenningPort) throws IOException {  
         this.hostIp = HostIp;  
         this.hostListenningPort = HostListenningPort;  
   
         initialize();  
     }  
     /**  
      * 初始化  
      *   
      * @throws IOException  
      */  
     private void initialize() throws IOException {  
         // 打开监听信道并设置为非阻塞模式  
         socketChannel = SocketChannel.open(new InetSocketAddress(hostIp,  
                 hostListenningPort));  
         socketChannel.configureBlocking(false);  
   
         // 打开并注册选择器到信道  
         selector = Selector.open();  
         socketChannel.register(selector, SelectionKey.OP_READ);  
   
         // 启动读取线程  
         new TCPClientReadThread(selector);  
     }  
     /**  
      * 发送字符串到服务器  
      *   
      * @param message  
      * @throws IOException  
      */  
     public void sendMsg(String message) throws IOException {  
         ByteBuffer writeBuffer = ByteBuffer.wrap(message.getBytes("UTF-8"));  
         socketChannel.write(writeBuffer);  
     }  
     static TCPClient client;  
     static boolean mFlag = true;  
     public static void main(String[] args) throws IOException {  
         client = new TCPClient("10.81.36.193", 1978);  
         new Thread() {  
             @Override  
             public void run() {  
                 try {  
                     client.sendMsg("你好!Nio!醉里挑灯看剑,梦回吹角连营");  
                     while (mFlag) {  
                         Scanner scan = new Scanner(System.in);//键盘输入数据  
                         String string = scan.next();  
                         client.sendMsg(string);  
                     }  
                 } catch (IOException e) {  
                     mFlag = false;  
                     e.printStackTrace();  
                 } finally {  
                     mFlag = false;  
                 }  
                 super.run();  
             }  
         }.start();  
     }  
 }  

小飞鹤

关注

2
点赞
踩
16

收藏

觉得还不错? 一键收藏
0
评论
Java NIO 与 Nio Socket

Java NIO 目录：Java NIO概述Java NIO ChannelJava NIO BufferJava NIO Scatter / GatherJava NIO 通道之间的数据传输Java NIO SelectorJava NIO FileChannelJava NIO SocketChannelJava NIO ServerSocketChannelJava NIO Da
复制链接

扫一扫

专栏目录