Java网络编程----NIO编程

古城微笑少年丶 2022-06-01 09:29 451阅读 0赞

一.介绍

有人叫NIO为New IO,有的人把NIO叫做Nonblock IO,这里还是比较倾向于后者,非阻塞IO.NIO有几个重要的基本概念:Buffer(缓冲区),Channel(管道,通道),Selector(选择器,多路复用器).NIO的本质就是避免原始的TCP建立连接使用三次握手的操作,减少连接的开销.模型如下图:

Center

1.1 Buffer

Buffer是一个对象,它包括一些要写入或要读取的数据.在NIO类库中加入Buffer对象,体现了新库与原IO的一个重要区别 .在面向流的IO中,可以将数据直接写入或读取到Stream对象中.在NIO库中,所有数据都是用缓冲区处理的(读写).缓冲区实质上是一个数组,通常它是一个字节数组(ByteBuffer),也可以使用其他类型的数组.这个数组为缓冲区提供了数据的访问读写等操作属性,如位置,容量,上限等概念.

Buffer类型:我们最常用的就是ByteBuffer,实际上每种Java基本类型都对应了一种缓冲区(出了Boolean类型)

ByteBuffer

CharBuffer

ShortBuffer

IntBuffer

LongBuffer

FloatBuffer

DoubleBuffer

  1. package com.east.nio;
  3. import java.nio.IntBuffer;
  5. /**
  6.  * 
  7.  * @author 
  8.  */
  9. public class TestBuffer {
  11.     public static void main(String[] args) {
  12.         // TODO Auto-generated method stub
  13.         //1.基本操作
  15.         //创建指定长度的缓冲区
  16.         IntBuffer buf = IntBuffer.allocate(10);
  17.         buf.put(13);       //往缓冲区放元素
  18.         buf.put(21);
  19.         buf.put(35);
  20.         //把位置复位为0,也就是position位置: 3-->0
  21.         buf.flip();
  22.         System.out.println("使用filp复位: " + buf);
  23.         System.out.println("容量为 : " + buf.capacity());    //容量一旦初始化后不允许改变(Wrap方法包裹数组除外)
  24.         System.out.println("限制为 : " + buf.limit());       //由于只装载了三个元素,所以可读取或者操作的元素为3,即limit = 3
  26.         System.out.println("获取下标为1的元素:" + buf.get(1));
  27.         System.out.println("get(index)方法,position位置不改变:" + buf);
  28.         buf.put(1,4);
  29.         System.out.println("put(index,change)方法,position位置不变: " + buf);
  31.         for(int i=0; i<buf.limit(); i++){
  32.             //调用get方法会使其缓冲区位置(position)向后递增一位
  33.             System.out.println(buf.get() + "\t");
  34.         }
  35.         System.out.println("buf对象遍历之后为:" + buf);
  37.         //2 wrap方法使用
  39.         //wrap方法会包裹一个数组:一般这种用法不会先初始化缓存对象的长度,因为没有意义,最后还会被wrap所包裹的数组覆盖掉
  40.         //并且wrap方法修改缓冲区对象的时候,数组本身也会跟着发生变化
  41.         int [] arr = new int [] {1,2,5};
  42.         IntBuffer buf1 = IntBuffer.wrap(arr);
  43.         System.out.println(buf1);
  45.         IntBuffer buf2 = IntBuffer.wrap(arr, 0, 2);
  46.         //这样使用表示容量为数组arr的长度,但是可操作的元素只有实际进入缓冲区的元素长度
  47.         System.out.println(buf2);
  49.         //3.其他方法
  50.         IntBuffer buf1 = IntBuffer.allocate(10);
  51.         int [] arr = new int []{1,2,5};
  52.         buf1.put(arr);
  53.         System.out.println(buf1);
  55.         //一种复制方法
  56.         IntBuffer buf3 = buf1.duplicate();
  57.         System.out.println(buf3);
  59.         //设置buf1的位置属性
  60.         //buf1.position(0);
  61.         buf1.flip();
  62.         System.out.println(buf1);
  64.         System.out.println("可读数据为: " + buf1.remaining());
  66.         int [] arr2 = new int [buf1.remaining()];
  67.         //将缓冲区数据放入到arr2数组中去
  68.         buf1.get(arr2);
  69.         for(int i : arr2){
  70.             System.out.print(Integer.toString(i) + ",");
  71.         }
  72.     }
  74. }

1.2 Channel

通道(Channel),它就像自来水管道一样,网络数据通过Channel读取和写入,通道与流的不同之处在于通道是双向的,而流只是一个方向上移动(一个流必须是InputStream或者OutputStream的子类),而通道可以用于读,写或者二者同时进行,最关键的是可以与多路复用器结合起来,有多种的状态位,方便多路复用器去识别.事实上通道分为两大类,一类是网络读写(SelectableChannel),一类用于文件操作(FileChannel),我们使用的SocketChannel和ServerSocketChannel都是SelectableChannel的子类

1.3 Selector(一)

多路复用器(Selector),它NIO编程的基础,非常重要.多路复用器提供选择已经就绪的任务的能力.简单地说,就是Selector会不断地轮询注册在其上的通道(Channel),如果某个通道发生了读写操作,这个通道就处于就绪状态,会被Selector轮询出来,然后通过SelectionKey可以取得就绪的Selector集合,从而进行后续的IO操作.

一个多路复用器(Selector)可以负责成千上万的Channel通道,没有上限.这也是JDK使用了epoll代替了传统的select实现,获得连接句柄没有限制.这也意味着我们只要一个线程负责Selector的轮询,就可以接入成千上万的客户端,这也是JDK NIO库的巨大进步.

1.4 Selector(二)

Selector线程就类似一个管理者(Master),管理了成千上万个管道,然后轮询那个管道的数据已经准备好,通知CPU执行IO的读取和写入操作.

Selector模式:当IO事件(管道)注册到选择器以后,Selector会分配给每个管道一个Key值,相当于标签.Selector选择器是以轮询的方式进行查找注册的所有IO事件(管道),当我们的IO事件(管道)准备就绪后,Select就会识别,会通过Key值来找到相应的管道,进行相关的数据处理操作(从管道里读或写数据,写到我们的数据缓冲区中)

每个管道都会对选择器进行注册不同的事件状态,以便选择器查找,

SelectionKey.OP_CONTENT

SelectionKey.OP_ACCEPT

SelectionKey.OP_READ

SelectionKey.OP_WRITE

二.NIO编程示例

  1. package com.east.nio.modou;
  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;
  12. public class Server implements Runnable {
  14.     //1.多路复用器(管理所有的通道)
  15.     private Selector selector;
  16.     //2.建立缓冲区
  17.     private ByteBuffer readBuf = ByteBuffer.allocate(1024);
  18.     //3.
  19.     private ByteBuffer writeBuf = ByteBuffer.allocate(1024);
  21.     public Server(int port) {
  22.         try {
  23.             //1.打开多路复用器
  24.             this.selector = Selector.open();
  25.             //2.打开服务器通道
  26.             ServerSocketChannel ssc = ServerSocketChannel.open();
  27.             //3.设置服务器通道为非阻塞模式
  28.             ssc.configureBlocking(false);
  29.             //4.绑定地址
  30.             ssc.bind(new InetSocketAddress(port));
  31.             //5.把服务器通道注册到多路复用器上,并且监听阻塞事件
  32.             ssc.register(this.selector, SelectionKey.OP_ACCEPT);
  33.             System.out.println("Server Start,Port :" + port);
  34.         } catch (IOException e) {
  35.             // TODO Auto-generated catch block
  36.             e.printStackTrace();
  37.         }
  38.         // TODO Auto-generated constructor stub
  39.     }
  41.     @Override
  42.     public void run() {
  43.         // TODO Auto-generated method stub
  44.        while(true){
  45.            try {
  46.             //1.必须要让多路复用器开始监听
  47.             this.selector.select();
  48.             //2.返回多路复用器已经选择的结果集
  49.             Iterator<SelectionKey> keys = this.selector.selectedKeys().iterator();
  50.             //3.进行遍历
  51.             while(keys.hasNext()){
  52.                 //4.获取一个选择的元素
  53.                 SelectionKey key = keys.next();
  54.                 //5.如果有.则直接从容器中移除
  55.                 keys.remove();
  56.                 //6.如果是有限的
  57.                 if(key.isValid()){
  58.                     //7.如果为阻塞状态
  59.                     if(key.isAcceptable()){
  60.                         this.accept(key);
  61.                     }
  63.                     //8.如果为可读状态
  64.                     if(key.isReadable()){
  65.                         this.read(key);
  66.                     }
  68.                     //9.写数据
  69.                     if(key.isWritable()){
  70.                         //this.write(key);           //ssc
  71.                     }
  72.                 }
  73.             }
  75.         } catch (IOException e) {
  76.             // TODO Auto-generated catch block
  77.             e.printStackTrace();
  78.         }
  80.        }
  81.     }
  83.     private void accept(SelectionKey key){
  84.         try {
  85.             //1.获取服务通道
  86.             ServerSocketChannel ssc = (ServerSocketChannel) key.channel();
  87.             //2.执行阻塞方法(等待客户端的通道)
  88.             SocketChannel sc = ssc.accept();
  89.             //3.设置阻塞模式
  90.             sc.configureBlocking(false);
  91.             //4.注册到多路复用器上,并设置读取标识
  92.             sc.register(this.selector, SelectionKey.OP_READ);
  94.         } catch (IOException e) {
  95.             // TODO Auto-generated catch block
  96.             e.printStackTrace();
  97.         }
  98.     }
  100.     private void read(SelectionKey key){
  101.         try {
  102.             //1.清空缓冲区旧的数据
  103.             this.readBuf.clear();
  104.             //2.获取之前注册的socket通道对象
  105.             SocketChannel sc = (SocketChannel) key.channel();
  106.             //3.读取数据
  107.             int count = sc.read(this.readBuf);
  108.             //4.如果没有数据
  109.             if(count == -1){
  110.                 key.channel().close();
  111.                 key.cancel();
  112.                 return ;
  113.             }
  114.             //5.有数据则进行读取,读取之前需要进行复位方法(把poition和limit进行复位)
  115.             this.readBuf.flip();
  116.             //6.根据缓冲区的数据长度创建相应大小的byte数组,接受缓冲区数据
  117.             byte [] bytes = new byte[this.readBuf.remaining()];
  118.             //7.接受缓冲区数据
  119.             this.readBuf.get(bytes);
  120.             //8.打印结果
  121.             String body = new String(bytes).trim();
  122.             System.out.println("Server :" + body);
  124.             //9.可以给客户端写数据... 
  125.         } catch (Exception e) {
  126.             // TODO Auto-generated catch block
  127.             e.printStackTrace();
  128.         }
  130.     }
  132.     public static void main(String[] args) {
  133.         new Thread(new Server(8765)).start();
  134.     }
  135. }
  140. package com.east.nio.modou;
  142. import java.io.IOException;
  143. import java.net.InetSocketAddress;
  144. import java.nio.ByteBuffer;
  145. import java.nio.channels.SocketChannel;
  147. /**
  148.  * 使用NIO实现一边写数据,一边读数据
  149.  * @author lhy
  150.  *
  151.  */
  152. public class Client {
  153.     //需要一个Selector
  154.     public static void main(String[] args) {
  155.         // TODO Auto-generated method stub
  156.         //创建连接的地址
  157.         InetSocketAddress address = new InetSocketAddress("127.0.0.1", 8765);
  159.         //声明连接通道
  160.         SocketChannel sc = null;
  162.         //建立缓冲区
  163.         ByteBuffer buf = ByteBuffer.allocate(1024);
  165.         try {
  166.             //打开通道
  167.             sc = SocketChannel.open();
  168.             //进行连接
  169.             sc.connect(address);
  171.             while(true){
  172.                 //定义一个字节数组
  173.                 byte [] bytes = new byte [1024];
  174.                 System.in.read(bytes);
  176.                 /*
  177.                  * 关键的步骤
  178.                  */
  179.                 //把数据放到缓冲区中
  180.                 buf.put(bytes);
  181.                 //对缓冲区进行复位
  182.                 buf.flip();
  183.                 //写出数据
  184.                 sc.write(buf);
  185.                 //清空缓冲区数据
  186.                 buf.clear();
  187.              }
  188.         } catch (IOException e) {
  189.             // TODO Auto-generated catch block
  190.             e.printStackTrace();
  191.         } finally {
  192.             if(sc != null){
  193.                 try {
  194.                     sc.close();
  195.                 } catch (IOException e) {
  196.                     // TODO Auto-generated catch block
  197.                     e.printStackTrace();
  198.                 }
  199.             }
  200.         }
  201.     }
  203. }

发表评论

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

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

相关阅读

    相关 网络编程之NIO(二)

    一.NIO定义     Java NIO的非阻塞模式，使一个线程从某通道发送请求读取数据，但是它仅能得到目前可用的数据，如果目前没有数据可用时，就什么都不会获取，而不是保持线

    淡淡的烟草味﹌淡淡的烟草味﹌/ 0 赞/ 379 阅读