NIO基础（菜鸟笔记）

太过爱你忘了你带给我的痛 2024-02-19 21:32 71阅读 0赞

NIO

[git样例源码][git]

### 1 JAVA NIO简介 ###

NIO与原来的IO有同样的作用和目的，但是使用方式完全不同，NIO支持面向缓存区的、基于通道的IO操作。NIO将以更加高效的方式进行文件的读写操作。

### 2 java NIO 与 IO的主要区别 ###

<table> 
 <thead> 
  <tr> 
   <th>IO</th> 
   <th>NIO</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>面向流</td> 
   <td>面向缓存区</td> 
  </tr> 
  <tr> 
   <td>阻塞IO（Blocking IO）</td> 
   <td>非阻塞IO（Non Blocking IO）</td> 
  </tr> 
  <tr> 
   <td>（无）</td> 
   <td>选择器</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td></td> 
  </tr> 
 </tbody> 
</table>

**简而言之**

Channel 负责传输

Buffer 负责存储

### 3 缓存区（Buffer） ###

#### 3.1 依据数据类型不同（boolean除外），提供了相应的缓冲区 ####

注：上述缓存区的管理方式几乎一致，通过allocate()获取缓存区

3.1.1 ByteBuffer

3.1.2 CharBuffer

3.1.3 ShortBuffer

3.1.4 IntBuffer

3.1.5 LongBuffer

3.1.6 FloatBuffer

3.1.7 DoubleBuffer

### 3.2 缓存区存取数据的核心方法 ###

put() 写

get() 读

flip() 切换模式

#### 3.3 缓存区的四个核心属性 ####

private int mark = -1; //标记，表示当前position的位置。可以通过reset()恢复到mark的位置

private int position = 0; //位置，表示缓存区正在操作数据的位置。

private int limit; //界限，表示缓存区可以操作数据的大小。（limit后数据不能进行读写）

private int capacity; //容量，表示缓存区的最大存储数据的容量。一旦声明不能改变。

0 <= mark <= position <= limit <= capacity

#### 3.4 直接缓存区和非直接缓存区 ####

非直接缓存区：allocate()方法分配缓存区，将缓存区建立在JVM的内存中

直接缓存区：allocateDirect()方法分配直接缓存区，将缓存区建立在物理内存中，可以提高效率

#### 3.5 demo ####

package com.learn.buf;
    
    import java.nio.ByteBuffer;
    
    /**
     * NIO
     * 缓存区
     *
     * 1.依据数据类型不同（boolean除外），提供了相应的缓冲区
     * ByteBuffer
     * CharBuffer
     * ShortBuffer
     * IntBuffer
     * LongBuffer
     * FloatBuffer
     * DoubleBuffer
     * 注：上述缓存区的管理方式几乎一致，通过allocate()获取缓存区
     *
     * 2.缓存区存取数据的两个核心方法
     * put() 写
     * get() 读
     * flip() 切换模式
     *
     * 3.缓存区的四个核心属性
     *     private int mark = -1; //标记，表示当前position的位置。可以通过reset()恢复到mark的位置
     *     private int position = 0; //位置，表示缓存区正在操作数据的位置。
     *     private int limit;   //界限，表示缓存区可以操作数据的大小。（limit后数据不能进行读写）
     *     private int capacity; //容量，表示缓存区的最大存储数据的容量。一旦声明不能改变。
     *
     *     0 <= mark <= position <= limit <= capacity
     *
     */
    public class TestBuffer {
        
    
        public static void main(String[] args) {
        
    
            ByteBuffer buffer = ByteBuffer.allocate(1024);
    
            String src = "abcqwe";
    
            buffer.put(src.getBytes());
            System.out.println("------put------");
            System.out.println(buffer.position());
            System.out.println(buffer.limit());
            System.out.println(buffer.capacity());
    
            buffer.flip();
    
            System.out.println("------flip------");
            System.out.println(buffer.position());
            System.out.println(buffer.limit());
            System.out.println(buffer.capacity());
    
            byte[] dst = new byte[buffer.limit()];
            buffer.get(dst);
    
            System.out.println("---------get--------");
            System.out.println(new String(dst));
            System.out.println(buffer.position());
            System.out.println(buffer.limit());
            System.out.println(buffer.capacity());
        }
    }

### 4 通道（Channel） ###

FileChannel

SocketChannel

SockeServerChannel

DatagramChannel

### 5 使用NIO完成网络通信的三个核心 ###

#### 5.1 通道Channel ####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA4Nzk0MjA_size_16_color_FFFFFF_t_70]

#### 5.2 缓存区Buffer ####

负责数据的存储

#### 5.3 选择器Selector ####

是SelectableChannel的多路复用器，用于监控SelectableChannel的状态

### 6 NIO的非阻塞式网络通信 ###

#### 6.1 NIO的阻塞实现 ####

package com.learn;
    
    import java.io.IOException;
    import java.net.InetSocketAddress;
    import java.nio.ByteBuffer;
    import java.nio.channels.FileChannel;
    import java.nio.channels.SocketChannel;
    import java.nio.file.Paths;
    import java.nio.file.StandardOpenOption;
    
    /**
     * 客户端
     */
    public class Client {
        
        public static void main(String[] args) {
        
            SocketChannel sChannel = null;
            FileChannel inChannel = null;
            try {
        
                //1.获取通道
                sChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 9898));
    
                //要获取本地文件缓存
                inChannel = FileChannel.open(Paths.get("d:/1.zip"), StandardOpenOption.READ);
    
                //2.分配指定大小的缓冲区
                ByteBuffer buffer = ByteBuffer.allocate(1024);
    
                //3.读取本地文件，并发送到服务端
                while (inChannel.read(buffer) != -1) {
        
                    buffer.flip();
                    sChannel.write(buffer);
                    buffer.clear();
                }
    
                sChannel.shutdownOutput();
    
                //4.接收服务端的反馈
                while (sChannel.read(buffer) != -1) {
        
                    buffer.flip();
                    System.out.println(new String(buffer.array()));
                    buffer.clear();
                }
    
            } catch (IOException e) {
        
                e.printStackTrace();
            } finally {
        
                try {
        
                    sChannel.close();
                    inChannel.close();
                } catch (IOException e) {
        
                    e.printStackTrace();
                }
            }
        }
    }

package com.learn;
    
    import java.io.IOException;
    import java.net.InetSocketAddress;
    import java.nio.ByteBuffer;
    import java.nio.channels.FileChannel;
    import java.nio.channels.ServerSocketChannel;
    import java.nio.channels.SocketChannel;
    import java.nio.file.Paths;
    
    import static java.nio.file.StandardOpenOption.CREATE;
    import static java.nio.file.StandardOpenOption.WRITE;
    
    /**
     * 服务端
     */
    public class Server {
        
        public static void main(String[] args) {
        
            ServerSocketChannel ssChannel = null;
            FileChannel outChannel = null;
            SocketChannel sChannel = null;
            try {
        
                ssChannel = ServerSocketChannel.open();
                ssChannel.bind(new InetSocketAddress("127.0.0.1", 9898));
                outChannel = FileChannel.open(Paths.get("d:/2.zip"), WRITE, CREATE);
    
                //接收客户端的数据
                sChannel = ssChannel.accept();
    
                ByteBuffer buffer = ByteBuffer.allocate(1024);
                while (sChannel.read(buffer) != -1) {
        
                    buffer.flip();
                    outChannel.write(buffer);
                    buffer.clear();
                }
    
    
                //给客户端返回数据
                buffer.put("数据接收完成".getBytes());
                buffer.flip();
                sChannel.write(buffer);
    
    
            } catch (IOException e) {
        
                e.printStackTrace();
            } finally {
        
                try {
        
                    ssChannel.close();
                    outChannel.close();
                    sChannel.close();
                } catch (IOException e) {
        
                    e.printStackTrace();
                }
            }
        }
    }

#### 6.2 NIO的非阻塞实现 ####

package com.learn;
    
    import java.io.IOException;
    import java.net.InetSocketAddress;
    import java.nio.ByteBuffer;
    import java.nio.channels.SocketChannel;
    import java.util.Date;
    import java.util.Scanner;
    
    /**
     * Hello world!
     */
    public class Client {
        
        public static void main(String[] args) {
        
    
            SocketChannel sChannel = null;
            try {
        
                //1.获取通道
                sChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 9898));
                //2.切换非阻塞模式
                sChannel.configureBlocking(false);
                //3.分配指定大小的缓存区
                ByteBuffer buffer = ByteBuffer.allocate(1024);
                //4.发送数据到服务器
    
                Scanner scanner = new Scanner(System.in);
                while (scanner.hasNext()) {
        
                    final String next = scanner.next();
    
                    buffer.put((new Date().toString() + "\n" + next).getBytes());
                    buffer.flip();
                    sChannel.write(buffer);
                    buffer.clear();
                }
    
    
            } catch (IOException e) {
        
                e.printStackTrace();
            } finally {
        
                try {
        
                    sChannel.close();
                } catch (IOException e) {
        
                    e.printStackTrace();
                }
            }
    
    
        }
    }

package com.learn;
    
    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.ServerSocketChannel;
    import java.nio.channels.SocketChannel;
    import java.util.Iterator;
    
    /**
     * Hello world!
     */
    public class Server {
        
        public static void main(String[] args) {
        
            ServerSocketChannel ssChannel = null;
            try {
        
                //1.获取通道
                ssChannel = ServerSocketChannel.open();
    
                //2.切换非阻塞模式
                ssChannel.configureBlocking(false);
    
                //3.绑定连接
                ssChannel.bind(new InetSocketAddress("127.0.0.1", 9898));
    
                //4.获取选择器
                Selector selector = Selector.open();
    
                //5.将通道注入到选择器上，并且指定“监听接收事件”
                ssChannel.register(selector, SelectionKey.OP_ACCEPT);
    
                //6.轮询获取选择器上已经“准备就绪”的事件
    
                while (selector.select() > 0) {
        
                    //7.
                    final Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
                    while (iterator.hasNext()) {
        
                        //8.获取准备“就绪”的事件
                        final SelectionKey selectionKey = iterator.next();
    
                        //9.判断具体是什么事件
                        if (selectionKey.isAcceptable()) {
        
                            //10.若准备就绪，获取客户端连接
                            final SocketChannel sChannel = ssChannel.accept();
                            //11.设置非阻塞模式
                            sChannel.configureBlocking(false);
                            //12.将该通道注册到选择器上
                            sChannel.register(selector, SelectionKey.OP_READ);
                        } else if (selectionKey.isReadable()) {
        
                            //13.获取当前选择器上“读就绪”状态的通道
                            SocketChannel sChannel = (SocketChannel) selectionKey.channel();
                            //14.读取数据
                            ByteBuffer buffer = ByteBuffer.allocate(1024);
    
                            while (sChannel.read(buffer) != -1) {
        
                                buffer.flip();
                                System.out.println(new String(buffer.array()));
                                buffer.clear();
                            }
    
                        }
                    }
                }
    
            } catch (IOException e) {
        
                e.printStackTrace();
            } finally {
        
                try {
        
                    ssChannel.close();
                } catch (IOException e) {
        
                    e.printStackTrace();
                }
            }
        }
    }

### 7 管道 ###

### 8 java NIO 2 (Path,Paths与Files) ###

[git]: https://github.com/HuaZohar/nio-master
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA4Nzk0MjA_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/29/7e63ffca07204bd9b36328db1592f0c1.png