NIO

远道学java

2024-05-08 帮助1人

什么是NIO

IO回顾

IO：Input OutPut（输入输出）
IO技术的作用：解决设备和设备之间的数据传输问题
IO的应用场景：图片上传、下载、打印机打印信息表、解析XML…

概念

即 Java New IO
是1个全新的、 JDK 1.4后提供的 IO API
Java API中提供了两套NIO，一套是针对标准输入输出NIO，另一套就是网络编程NIO

作用

NIO和IO有相同的作用和目的，但实现方式不同
可替代标准Java IO 的IO API
IO是以流的方式处理数据，而NIO是以块的方式处理数据。

流与块的比较

NIO和IO最大的区别是数据打包和传输方式。
IO是以流的方式处理数据，而NIO是以块的方式处理数据。
面向流的IO一次一个字节的处理数据，一个输入流产生一个字节，一个输出流就消费一个字节。
面向块的IO系统以块的形式处理数据。每一个操作都在一步中产生或消费一个数据块。按块要比按流快的多

新特性

对比于 Java IO，NIO具备的新特性如下：

IO	NIO
面向流(Stream Oriented)	面向缓冲区(Buffer Oriented)
阻塞IO(Blocking IO)	非阻塞(Non Blocking IO)
/	选择器(Selectors)

可简单认为：IO是面向流的处理，NIO是面向块(缓冲区)的处理

面向流的I/O 系统一次一个字节地处理数据

一个面向块(缓冲区)的I/O系统以块的形式处理数据

核心组件

Java NIO的核心组件包括：

通道（Channel）
缓冲区（Buffer）
选择器（Selector）

在NIO中并不是以流的方式来处理数据的，而是以buffer缓冲区和Channel管道配合使用来处理数据。

Selector是因为NIO可以使用异步的非阻塞模式才加入的东西

简单理解一下：

Channel管道比作成铁路，buffer缓冲区比作成火车(运载着货物)
而我们的NIO就是通过Channel管道运输着存储数据的Buffer缓冲区的来实现数据的处理！
Channel不与数据打交道，它只负责运输数据。与数据打交道的是Buffer缓冲区
相对于传统IO而言，流是单向的。对于NIO而言，有了Channel管道这个概念，我们的读写都是双向的

Buffer缓冲区

Buffer缓冲区概述

作用：缓冲区，用来存放具体要被传输的数据，比如文件、scoket 等。这里将数据装入 Buffer 再通过通道进行传输。

Buffer 就是一个数组，用来保存不同数据类型的数据

在 NIO 中，所有的缓冲区类型都继承于抽象类 Buffer，最常用的就是 ByteBuffer，对于 Java 中的基本类型，基本都有一个具体 Buffer 类型与之相对应，它们之间的继承关系如下图所示
学新通

ByteBuffer：存储字节数据到缓冲区
ShortBuffer：存储字符串数据到缓冲区
CharBuffer：存储字符数据到缓冲区
IntBuffer：存储整数数据到缓冲区
LongBuffer：存储长整型数据到缓冲区
DoubleBuffer：存储小数到缓冲区
FloatBuffer：存储小数到缓冲区

对于 Java 中的基本数据类型，都有一个 Buffer 类型与之相对应，最常用的自然是ByteBuffer 类（二进制数据）

ByteBuffer的创建方式

在堆中创建缓冲区：allocate(int capacity) （最常用）
在系统内存创建缓冲区：allocateDirect(int capacity)
通过普通数组创建缓冲区：wrap(byte[] arr)

import java.nio.ByteBuffer;

public class Demo01Buffer {
    public static void main(String[] args) {
        //在堆中创建缓冲区：allocate(int capacity) (最常用)
        ByteBuffer buffer1 = ByteBuffer.allocate(10);

        //在系统内存创建缓冲区：allocateDirect(int capacity)
        ByteBuffer buffer2 = ByteBuffer.allocateDirect(10);

        //通过普通数组创建缓冲区：wrap(byte[] arr)
        byte[] arr = {97,98,99};
        ByteBuffer buffer3 = ByteBuffer.wrap(arr);
    }

常用方法

拿到一个缓冲区我们往往会做什么？很简单，就是读取缓冲区的数据/写数据到缓冲区中。

所以，缓冲区的核心方法就是:

put(byte b) : 给数组添加元素
get() :获取一个元素

import java.nio.ByteBuffer;
import java.util.Arrays;

public class Demo02Buffer的方法 {
    
    public static void main(String[] args) {
	
    //创建对象
    ByteBuffer buffer = ByteBuffer.allocate(10);

    //put(byte b) : 给数组添加元素
    buffer.put((byte)10);
    buffer.put((byte)20);
    buffer.put((byte)30);

    //把缓冲数组变成普通数组
    byte[] arr = buffer.array();

    //打印
    System.out.println(Arrays.toString(arr));

    //get() :获取一个元素
    byte b = buffer.get(1);
    System.out.println(b);   //20

	}
}

核心变量

Buffer类维护了4个核心变量属性来提供关于其所包含的数组的信息

容量Capacity
缓冲区能够容纳的数据元素的最大数量。容量在缓冲区创建时被设定，并且永远不能被改变。(不能被改变的原因也很简单，底层是数组)
界限Limit
缓冲区中可以操作数据的大小，代表了当前缓冲区中一共有多少数据（从limit开始后面的位置不能操作）。
位置Position
下一个要被读或写的元素的位置。Position会自动由相应的 get( )和 put( )函数更新。
标记Mark
一个备忘位置。用于记录上一次读写的位置。就是读写操作之前的position

byteBuffer.put("百度".getBytes());
System.out.println("第一次put后---->position--->"   byteBuffer.position());

// 做一个标记：记录上一次读写位置 position的值 5
byteBuffer.mark();

byteBuffer.put("zimu".getBytes());
System.out.println("第二次put后---->position--->"   byteBuffer.position());

// 还原到标记位置
byteBuffer.reset();
System.out.println("reset后---->position--->"   byteBuffer.position());

public static void main(String[] args) {

        // 创建一个缓冲区
        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);

        // 看一下初始时4个核心变量的值
        System.out.println("初始时-->limit--->" byteBuffer.limit());
        System.out.println("初始时-->position--->" byteBuffer.position());
        System.out.println("初始时-->capacity--->" byteBuffer.capacity());
        System.out.println("初始时-->mark--->"   byteBuffer.mark());

        System.out.println("--------------------------------------");

        // 添加一些数据到缓冲区中
        String s = "JavaEE";
        byteBuffer.put(s.getBytes());

        // 看一下初始时4个核心变量的值
        System.out.println("put完之后-->limit--->" byteBuffer.limit());
        System.out.println("put完之后-->position--->" byteBuffer.position());
        System.out.println("put完之后-->capacity--->" byteBuffer.capacity());
        System.out.println("put完之后-->mark--->"   byteBuffer.mark());
    }

运行结果：
学新通
现在我想要从缓存区拿数据，怎么拿呀？？NIO给了我们一个flip()方法。这个方法可以改动position和limit的位置！
还是上面的代码，flip()一下后，再看看4个核心属性的值会发生什么变化：

byteBuffer.flip();
System.out.println("flip完之后-->limit--->" byteBuffer.limit());
System.out.println("flip完之后-->position--->" byteBuffer.position());
System.out.println("flip完之后-->capacity--->" byteBuffer.capacity());
System.out.println("flip完之后-->mark--->"   byteBuffer.mark());

运行结果：
学新通

limit变成了position的位置了
而position变成了0
每当要从缓存区的时候读取数据时，就调用filp()“切换成读模式”。

读取缓冲区的数据

// 创建一个limit()大小的字节数组(因为就只有limit这么多个数据可读)
byte[] bytes = new byte[byteBuffer.limit()];

// 将读取的数据装进我们的字节数组中
byteBuffer.get(bytes);

// 输出数据
System.out.println(new String(bytes, 0, bytes.length));

运行结果：学新通
随后输出一下核心变量的值：

读完我们还想写数据到缓冲区，那就使用clear()函数，这个函数会“清空”缓冲区

数据没有真正被清空，只是被遗忘掉了，此时继续执行byteBuffer.get(bytes);还是可以获取到javaEE
学新通

Channel通道

Channel通道概述

通道（Channel）：由 java.nio.channels 包定义的。Channel 表示 IO 源与目标打开的连接。

标准的IO基于字节流和字符流进行操作的，而NIO是基于通道（Channel）和缓冲区（Buffer）进行操作，数据总是从通道读取到缓冲区中，或者从缓冲区写入到通道中（白话: 就是数据传输用的通道，作用是打开到IO设备的连接，文件、套接字都行）

Channel API

学新通

FileChannel：用于读取、写入、映射和操作文件的通道。
DatagramChannel：通过 UDP 读写网络中的数据通道。
SocketChannel：通过 TCP 读写网络中的数据。
ServerSocketChannel：可以监听新进来的 TCP 连接，对每一个新进来的连接都会创建一个 SocketChannel。

FileChannel基本使用

使用FileChannel完成文件的复制

public class CopyTest {
    public static void main(String[] args) throws Exception {
        // 通道依赖于IO流
        FileInputStream fileInputStream = new FileInputStream("D:\\初音未来.jpg");
        FileOutputStream fileOutputStream = new FileOutputStream("D:\\复制.jpg");
        // 使用流获取通道
        FileChannel channel = fileInputStream.getChannel();
        FileChannel channel1 = fileOutputStream.getChannel();
        // 创建缓冲数组
        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
        while (channel.read(byteBuffer) != -1) {
            byteBuffer.flip();
            channel1.write(byteBuffer);
            byteBuffer.clear();
        }
        fileOutputStream.close();
        fileInputStream.close();
    }
}

网络编程收发信息

客户端

public class NIOClient {
    public static void main(String[] args) throws IOException {
        // 创建客户端通道，使用SocketChannel.open()方法
        SocketChannel socketChannel = SocketChannel.open();
        // 指定要连接的服务器地址和端口，使用connect(SocketAddress remote)方法
        // 参数SocketAddress是抽象类，使用其实现类InetSocketAddress构造
        socketChannel.connect(new InetSocketAddress(InetAddress.getLocalHost(), 1080));
        // 缓冲区
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        // 编写数据
        buffer.put("你好，NIO！".getBytes());
        // 调整position和limit，否则写数据的时候有问题
        buffer.flip();
        // 输出数据
        socketChannel.write(buffer);
        // 释放资源
        socketChannel.close();
    }
}

服务器端

public class NIOServer {
    public static void main(String[] args) throws IOException, InterruptedException {
        // 创建服务器通道，使用ServerSocketChannel.open()方法
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        // 绑定端口，使用bind(SocketAddress local)
        // 参数SocketAddress是抽象类，使用其实现类InetSocketAddress构造
        serverSocketChannel.bind(new InetSocketAddress(1080));
        // 设置非阻塞，ttue为阻塞
        serverSocketChannel.configureBlocking(false);
        while (true) {
            // 等待客户端连接
            SocketChannel accept = serverSocketChannel.accept();
            if (accept != null) {
                // 缓冲区
                ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
                // 读取数据，读的是缓冲区中有数据的长度
                int len = accept.read(byteBuffer);
                // 打印，将缓冲区转为数组并转成字符串
                System.out.println(new String(byteBuffer.array(), 0, len));
                break;
            } else {
                System.out.println("做一些别的事");
                Thread.sleep(5000);
            }
        }
    }
}

Selector选择器

多路复用的概念

一个选择器可以同时监听多个服务器端口, 帮多个服务器端口同时等待客户端的访问

Selector的和Channel的关系

选择器（Selector）是 Channel（通道）的多路复用器，Selector 可以同时监控多个通道的 IO（输入输出）状况。

选择器提供选择执行已经就绪的任务的能力。从底层来看，Selector提供了询问通道是否已经准备好执行每个I/O操作的能力。Selector 允许单线程处理多个Channel。仅用单个线程来处理多个Channels的好处是，只需要更少的线程来处理通道。事实上，可以只用一个线程处理所有的通道，这样会大量的减少线程之间上下文切换的开销。

可选择通道(SelectableChannel)

注意：并不是所有的Channel，都是可以被Selector 复用的。比方说，FileChannel就不能被选择器复用。

判断一个Channel 能被Selector 复用，有一个前提：判断他是否继承了一个抽象类SelectableChannel。如果继承了SelectableChannel，则可以被复用，否则不能。

SelectableChannle 的结构如下图：
学新通
SelectableChannel类提供了实现通道的可选择性所需要的公共方法

通道和选择器注册之后，他们是绑定的关系吗？
答:不是。不是一对一的关系。一个通道可以被注册到多个选择器上，但对每个选择器而言只能被注册一次。
通道和选择器之间的关系，使用注册的方式完成。SelectableChannel可以被注册到Selector对象上，在注册的时候，需要指定通道的哪些操作，是Selector感兴趣的。
学新通

Channel注册到Selector

使用Channel.register（Selector sel，int ops）方法，将一个通道注册到一个选择器时。
第一个参数：指定通道要注册的选择器是谁
第二个参数：指定选择器需要查询的通道操作

可以供选择器查询的通道操作，从类型来分，包括以下四种：

（1）可读 : SelectionKey.OP_READ

（2）可写 : SelectionKey.OP_WRITE

（3）连接 : SelectionKey.OP_CONNECT

（4）接收 : SelectionKey.OP_ACCEPT

如果Selector对通道的多操作类型感兴趣，可以用“位或”操作符来实现：
int key = SelectionKey.OP_READ | SelectionKey.OP_WRITE ;

Selector的使用流程

// 1、获取Selector选择器
Selector selector = Selector.open();

// 2、获取通道
ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();

// 3.设置为非阻塞
serverSocketChannel.configureBlocking(false);

// 4、绑定连接
serverSocketChannel.bind(new InetSocketAddress(SystemConfig.SOCKET_SERVER_PORT));

// 5、将通道注册到选择器上,并制定监听事件为：“接收”事件
serverSocketChannel.register(selector，SelectionKey.OP_ACCEPT);

上面通过调用通道的register()方法会将它注册到一个选择器上。

需要注意的是：
与Selector一起使用时，Channel必须处于非阻塞模式下，否则将抛出异常IllegalBlockingModeException

选择键(SelectionKey)

Channel和Selector的关系确定好后，并且一旦通道处于某种就绪的状态，就可以被选择器查询到。这个工作，使用选择器Selector的select()方法完成。select方法的作用，对感兴趣的通道操作，进行就绪状态的查询。

Selector可以不断的查询Channel中发生的操作的就绪状态。并且挑选感兴趣的操作就绪状态。一旦通道有操作的就绪状态达成，并且是Selector感兴趣的操作，就会被Selector选中，放入选择键集合中。

select() :选择器等待客户端连接的方法
阻塞问题:
1.在开始没有客户访问的时候是阻塞的
2.在有客户来访问的时候方法会变成非阻塞的
3.如果客户的访问被处理结束之后,又会恢复成阻塞的
selectedKeys() :选择器会把被连接的服务端对象放在Set集合中,这个方法就是返回一个Set集合

轮询查询就绪操作

通过Selector的 select() 方法，可以查询出已经就绪的通道操作，这些就绪的状态集合，包存在一个元素是SelectionKey对象的Set集合中。

select()方法返回的int值，表示有多少通道已经就绪

而一旦调用select()方法，并且返回值不为0时，下一步工干啥？

通过调用Selector的selectedKeys()方法来访问已选择键集合，然后迭代集合的每一个选择键元素，根据就绪操作的类型，完成对应的操作

NIO 编程实例:
客户端

 public static void main(String[] args) throws IOException {

        //创建客户端
        SocketChannel sc = SocketChannel.open();
        //指定要连接的服务器ip和端口
        sc.connect(new InetSocketAddress("127.0.0.1",9000));

        //创建缓冲输出
        ByteBuffer buffer = ByteBuffer.allocate(1024);

        //给数组添加数据
        buffer.put("百度".getBytes());

        //切换
        buffer.flip();

        //输出数据
        sc.write(buffer);

        //关闭资源
        sc.close();
    }

服务端

public class Selector服务端 {

    public static void main(String[] args) throws IOException {

        // 1、获取Selector选择器
        Selector selector = Selector.open();

        // 2、获取通道
        ServerSocketChannel ssc1 = ServerSocketChannel.open();
        ServerSocketChannel ssc2 = ServerSocketChannel.open();
        ServerSocketChannel ssc3 = ServerSocketChannel.open();

        // 3.设置为非阻塞
        ssc1.configureBlocking(false);
        ssc2.configureBlocking(false);
        ssc3.configureBlocking(false);

        // 4、绑定连接
        ssc1.bind(new InetSocketAddress(8000));
        ssc2.bind(new InetSocketAddress(9000));
        ssc3.bind(new InetSocketAddress(10000));


        // 5、将通道注册到选择器上,并注册的操作为："接收"操作
        ssc1.register(selector, SelectionKey.OP_ACCEPT);
        ssc2.register(selector, SelectionKey.OP_ACCEPT);
        ssc3.register(selector, SelectionKey.OP_ACCEPT);


        // 6、采用轮询的方式，查询获取"准备就绪"的注册过的操作
        while (selector.select() > 0) {
            // 7、获取当前选择器中所有注册的选择键（“已经准备就绪的操作”）
            Iterator<SelectionKey> selectedKeys = selector.selectedKeys().iterator();
            while (selectedKeys.hasNext()) {

                // 8、获取"准备就绪"的事件
                SelectionKey selectedKey = selectedKeys.next();

                    // 9、获取ServerSocketChannel
                ServerSocketChannel serverSocketChannel = (ServerSocketChannel) selectedKey.channel();
                // 10、接受客户端发来的数据
                SocketChannel socketChannel = serverSocketChannel.accept();

                // 11、读取数据
                    ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
                    int length = 0;
                    while ((length = socketChannel.read(byteBuffer)) != -1) {
                        byteBuffer.flip();
                        System.out.println(new String(byteBuffer.array(), 0, length));
                        byteBuffer.clear();
                    }
                    socketChannel.close();
                }
                // 12、移除选择键
                selectedKeys.remove();
            }
        // 13、关闭连接
       	 ssc1.close();
       	 ssc2.close();
      	 ssc3.close();
        }

}

这篇好文章是转载于：学新通技术网

NIO

什么是NIO

IO回顾

概念

作用

流与块的比较

新特性

核心组件

Buffer缓冲区

Buffer缓冲区概述

ByteBuffer的创建方式

常用方法

核心变量

Channel通道

Channel通道概述

Channel API

FileChannel基本使用

网络编程收发信息

Selector选择器

多路复用的概念

Selector的和Channel的关系

可选择通道(SelectableChannel)

Channel注册到Selector

Selector的使用流程

选择键(SelectionKey)

轮询查询就绪操作

photoshop保存的图片太大微信发不了怎么办

word里面弄一个表格后上面的标题会跑到下面怎么办

《学习通》视频自动暂停处理方法

Android 11 保存文件到外部存储，并分享文件

photoshop扩展功能面板显示灰色怎么办

微信公众号没有声音提示怎么办

excel下划线不显示怎么办

excel打印预览压线压字怎么办

TikTok加速器哪个好免费的TK加速器推荐

怎样阻止微信小程序自动打开