Netty基础：NIO三大组件

最新推荐文章于 2023-07-21 18:45:01 发布
最新推荐文章于 2023-07-21 18:45:01 发布
阅读量173 收藏
点赞数
分类专栏： java 后端 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/web18484626332/article/details/123496185
版权
java 同时被 2 个专栏收录
331 篇文章 13 订阅
订阅专栏
后端
20 篇文章 0 订阅
订阅专栏

一、NIO三大核心原理关系：

Selector、Channel和Buffer之间的关系图（简单版）：

关系图说明：

  1. 每个channel都对应一个Buffer
  2. Selector对应一个线程，一个线程对应多个channel（连接）
  3. 上图反应了有三个channel注册到该Selector
  4. 程序切换到哪个channel，是由**事件(Event)**决定的
  5. Selector会根据不同的事件，在各个通道上切换
  6. Buffer本质上就是一个内存块，底层是一个数组
  7. 数据的读取或写入是通过Buffer进行的，这个特性和BIO有本质区别，BIO中要么是输入流，或者是输出流，不能双向。但是NIO的Buffer是可以读也可以写，只是需要flip()方法切换。
  8. channel是双向的，可以返回底层操作系统的情况。

二、缓冲区Buffer

缓冲区Buffer，缓冲区本质上是一个可以读写数据的内存块，可以理解为是一个容器对象（含数组），该对象提供一组方法，****可以轻松的使用内存块。**缓冲区对象内置了一些机制，能够跟踪和记录缓冲区的状态变化情况。Channel提供从文件、网络读取数据的通道 ，但是读取或写入数据都必须经由Buffer**，如下图所示：

2.1 Buffer类及其子类

1. 在NIO中，Buffet是一个顶层父类，是一个抽象类，类的层级关系如下图所示，最常用的是ByteBuffer。

2. Buffer类定义了所有缓冲区都具有的四个属性，来提供关于其所包含的数据元素的信息：

// Invariants: mark <= position <= limit <= capacity
private int mark = -1;
private int position = 0;
private int limit;
private int capacity;

属性

描述

capacity

容量，即可以容纳的最大数据量，在缓冲区创建时被设定并且不能改变。

limit

表示缓冲区的当前终点，不能对缓冲区超过极限的位置进行读写操作。且极限是可以修改的。

position

位置，下一个要被读或写的元素的索引，每次读写缓冲区数据时都会改变值，为下次读写准备。

mark

标记

示意图如下：

我们使用 IntBuffer intBuffer = IntBuffer.allocate(5); 语句，创建一个Buffer对象，其本质是在内存中创建一个容量为5的空间，且buffer刚创建时，capacity属性为5，limit属性也为5，position位置指向0。

刚创建时，capacity为5是因为该buffer本身创建时容量是5，而limit为5，是因为接下来的操作，也就是向Buffer写入数据的操作，不能超出容量5。我们接着向Buffer中写入数据，每写入一个数据，position指针自动+1向后移动一位，直到position与limit的值相等，无法继续操作。

**当我们要从Buffer中读取数据的时候，首先要使用flip()函数，将buffer转换，进行读写切换，**flip()函数执行的操作如下所示：

public final Buffer flip(){

????????//flip反转之后进行的操作不能超过上次的操作范围。如我们通过flip()函数，要读Buffer
????????//中的数据，那么读取的边界就是之前写入数据的边界，之前数据写到哪里了呢
? ? ? ? //position指明了位置
? ? ? ? limit = position;?

? ? ? ? position = 0;

? ? ? ? mark = -1;

????????return this;
}

2.2 Buffer类相关方法：

2.3 ByteBuffer

java的基本数据类型中，除了boolean之外，都有一个Buffer类型与之对应，但是，最常用的是ByteBuffer类，该类的主要方法如下：

三、通道Channel

3.1 基本介绍

**1）**NIO的通道类似于流，但是有一些区别：

  • 通道是双向的，可以同时进行读写，而流只能读或者只能写
  • 通道可以实现异步读写数据
  • 通道可以从缓冲读数据，也可以从缓冲写数据

**2）**BIO中的 Stream是单向的，例如 FileInputStream 对象只能进行读取数据的操作，而 NIO 中的通道（Channel）是双向的，可以读操作，也可以写操作。

3)****Channel 在 NIO 中是一个接口 public interface Channel extends Closeable{}

4) 常用的Channel类有、FileChannel、DatagramChannel、ServerSocketChannel和SocketChannel。

5) FileChannel用于文件的数据读写，DatagramChannel用于UDP的数据读写，ServerSocketChannel和SocketChannel用于Tcp的数据读写。

无论再怎么想象，那些从来没有发生过的事情也总是无法深入，更何况，从来不敢想象你会回来！

3.2 FileChannel类

FileChannel类主要用来对本地文件进行IO操作，创建的方法如下：

  • public int read(ByteBuffer dst), 从通道读取数据并放到缓冲区中
  • public int write(ByteBuffer src), 把缓冲区中的数据写入到通道中
  • public long transferFrom(ReadableByteChannel src, long position, long count)，从目标通道中复制数据到当前通道
  • _public long transferTo(long position, long count, WriteableByteChannel target)，_把数据从当前通道复制给目标通道。

案例1：本地文件写数据

    public static void main(String[] args) throws IOException {
        String str = "wangy";
        //创建一个输出流 ->用于获取到一个channel
        FileOutputStream fileOutputStream = new FileOutputStream("d:\file01.txt");

        //通过fileOutputStream获取对应的FileChannel
        //这里体现了多态，此处fileChannel真是类型是FileChannelImpl, FileChannel是一个抽象类
        FileChannel fileChannel = fileOutputStream.getChannel();

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

        //将str数据放入到ByteBuffer中
        byteBuffer.put(str.getBytes(StandardCharsets.UTF_8));

        //将byteBuffer中的数据写入到channel中（该操作对byteBuffer来说是将数据读出来，对fileChannel通道来说，是将缓冲区读出的数据写入到通道）
        byteBuffer.flip(); // 反转缓冲区，由写变为读
        fileChannel.write(byteBuffer);

        //关闭流
        fileOutputStream.close();
    }

案例2：本地文件读数据

    public static void main(String[] args) throws IOException {
        //创建文件输入流
        File file = new File("d:\file01.txt");
        FileInputStream fileInputStream = new FileInputStream(file);

        //通过fileInputStream 获取到对应的FileChannel ->实际类型为FileChannelImpl
        FileChannel fileChannel = fileInputStream.getChannel();

        //创建ByteBuffer缓冲区
        ByteBuffer byteBuffer = ByteBuffer.allocate((int)file.length());

        //将通道的数据读入到Buffer
        fileChannel.read(byteBuffer);

        //将byteBuffer的字节数据转为string
        System.out.println(new String(byteBuffer.array()));

        //关闭流
        fileInputStream.close();
    }

案例三：使用一个Buffer完成文件拷贝

/**
 * 拷贝
 */
public class NIOFileChannel03 {
    public static void main(String[] args) throws IOException {
        //文件对象
        File file1= new File("d:\file01.txt");
        FileInputStream fileInputStream = new FileInputStream(file1);
        FileChannel fileChannel01 = fileInputStream.getChannel(); //由输入流获取Channel通道

        //创建缓冲对象
        ByteBuffer byteBuffer = ByteBuffer.allocate((int)file1.length());

        //创建文件输出流对象
        File file2 = new File("d:\file02.txt");
        FileOutputStream fileOutputStream = new FileOutputStream(file2);
        FileChannel fileChannel2 = fileOutputStream.getChannel(); //由输出流获取Channel通道
        //循环读取
        while(true){
            /**
             *     public Buffer clear() {
             *         position = 0;
             *         limit = capacity;
             *         mark = -1;
             *         return this;
             *     }
             */
            byteBuffer.clear(); //清空buffer,复位，非常重要
            //从通道读取数据，放入到缓冲区
            int read = fileChannel01.read(byteBuffer);
            if(read == -1){ //读完所有数据
                break;
            }
            //将buffer中的数据写入到fileChannel02,即写入到文件file02.txt
            byteBuffer.flip();
            fileChannel2.write(byteBuffer);
        }

        //关闭流
        fileInputStream.close();
        fileOutputStream.close();
    }
}

案例四：transferFrom方法拷贝文件

使用FileChannel(通道)和方法transferFrom,完成文件的拷贝。

public class NIOFileChannel04 {

    public static void main(String[] args) throws IOException {
        //创建相关的流
        File file1= new File("D:\星空.jpg");
        FileInputStream fileInputStream = new FileInputStream(file1);
        File file2 = new File("D:\星空2.jpg");
        FileOutputStream fileOutputStream = new FileOutputStream(file2);

        //获取各个流对应的filechannel
        FileChannel sourceChannel = fileInputStream.getChannel();
        FileChannel destChannel = fileOutputStream.getChannel();

        //使用trans
        destChannel.transferFrom(sourceChannel,0,sourceChannel.size());

        //关闭相关流
        sourceChannel.close();;
        destChannel.close();
        fileInputStream.close();
        fileOutputStream.close();
    }
}

3.3 Buffer和Channel的注意事项和细节

  • ByteBuffer支持类型化的put和get, put放入的是什么数据类型，get就应该使用相应的数据类型来取出，负责可能有BufferUnderflowExceptiion异常。

    public class NIOByteBufferPutGet {
    public static void main(String[] args) {
    //创建一个Budder
    ByteBuffer buffer = ByteBuffer.allocate(64);

        //以类型化方式放入数据
    buffer.putInt(100);
    buffer.putLong(9L);
    buffer.putChar('w');
    buffer.putShort((short)4);

    //取出数据
    buffer.flip();
    System.out.println(buffer.getInt());
    System.out.println(buffer.getLong());
    System.out.println(buffer.getChar());
    System.out.println(buffer.getShort());
}

    }

  • 可以将一个普通Buffer转成只读Buffer

    public class ReadOnlyBuffer {
    public static void main(String[] args) {
    //创建一个Buffer
    ByteBuffer buffer = ByteBuffer.allocate(64);

        for(int i=0;i<64;i++){
        buffer.put((byte)i);
    }

    //读取
    buffer.flip();
    //得到一个只读的Buffer
    ByteBuffer readOnlyBuffer = buffer.asReadOnlyBuffer(); //由ByteBuffer获取一个只读的Buffer
    while(readOnlyBuffer.hasRemaining()){
        System.out.println(readOnlyBuffer.get());
    }

    readOnlyBuffer.put((byte)100); //抛出异常，ReadOnlyBufferException
}

    }

  • NIO提供MappedByteBuffer,可以让文件直接在内存（堆外的内存）中进行修改（不用拷贝），而如何同步到文件，由NIO来完成。

    /**

    • 说明：
    •  MappedByteBuffer可以让文件直接在内存（堆外内存）中修改，操作系统不需要拷贝文件

    /
    public class MappedByteBufferTest {
    public static void main(String[] args) throws IOException {
    //准备文件
    RandomAccessFile randomAccessFile = new RandomAccessFile(“D:\a.txt”,“rw”);
    //获取对应的通道
    FileChannel channel = randomAccessFile.getChannel();
    /    *
    * 参数1：FileChannel.MapMode.READ_WRITE 使用读写模式
    * 参数2： 0， 可以直接修改的起始位置
    * 参数3： 5， 映射到内存的大小（不是索引位置），即将a。txt的多少个字节映射到内存，可以直接修改的范围就是0-5(最多修改5个字节，索引到4)
    *
    * MappedByteBuffer是一个抽象类，此处实际类型是DirectByteBuffer
    */
    MappedByteBuffer mappedByteBuffer = channel.map(FileChannel.MapMode.READ_WRITE,0,5);

        mappedByteBuffer.put(0,(byte) 'H');
    mappedByteBuffer.put(3,(byte)'5');

    randomAccessFile.close();
}

    }

  • 前面的读写操作，都是通过一个Buffer完成的，NIO还支持多个Budder(即Buffer数组)完成读写操作，即Scattering和Gathering。

    /**

    • Scattering:将数据写入到buffer时，可以采用Buffer数组，依次写入

    • Gathering: 从Buffer读取数据时，可以采用Buffer数组，依次读
      */
      public class ScatteringAndGatheringTest {
      public static void main(String[] args) throws IOException {
      //使用ServerSocketChannel和SocketChannel
      ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
      InetSocketAddress inetSocketAddress = new InetSocketAddress(7000);

       //绑定端口到Socket，并启动
 serverSocketChannel.socket().bind(inetSocketAddress);

 //创建Buffer数组
 ByteBuffer[] byteBuffers = new ByteBuffer[2];
 byteBuffers[0] = ByteBuffer.allocate(5);
 byteBuffers[1] = ByteBuffer.allocate(3);

 //等待客户端的连接
 SocketChannel socketChannel = serverSocketChannel.accept();

 int messageLength = 8; //假定从客户端接收8个字节
 //循环读取数据
 while(true){
     int byteRead = 0;
     while(byteRead<messageLength){
         long l = socketChannel.read(byteBuffers);
         byteRead+=l; //累计读取到的字节数
         System.out.println("byteRead="+byteRead);
         //使用流打印，看看当前的buffer的position和limit
         Arrays.asList(byteBuffers).stream().map(buffer->"position="+buffer.position()+",Limit="+buffer.limit()).forEach(System.out::println);
     }

     //将所有的Budder进行flip反转
     Arrays.asList(byteBuffers).forEach(buffer-> buffer.flip());

     //将数据读出，显示到客户端
     long byteWrite = 0;
     while(byteWrite<messageLength){
         long l = socketChannel.write(byteBuffers);
         byteWrite+=l;
     }

     //将所有的buffer进行复位
     Arrays.asList(byteBuffers).forEach(buffer->buffer.clear());
     System.out.println("byteRead:="+byteRead+" byteWrite="+byteWrite+", MessageLength"+messageLength);
 }

      }
      }

四、Selecter选择器

Java NIO，是非阻塞的IO,可以使用一个线程，处理多个客户端连接，其就是通过Selector(选择器实现的)。Selector选择器特性如下：

  • **Selector能够检测多个注册的通道上是否有事件发生,如果有事件发生，**便获取事件，然后针对每个事件进行相应的处理。这样就可以只用一个单线程去管理多个通道，也就是管理多个连接和请求。
  • 只有在连接/通道真正有读写事件发生时，才会进行读写，这大大减少了系统开销，并且不必 为每个连接都创建一个线程，不用去维护多个线程。避免了多线程之间的上下文切换导致的开销。

4.1 Selector示意图和特点说明

Nonblocking I/O

特点说明如下：

  • Netty的IO线程NioEventLoop聚合了Selector（选择器，也叫多路复用器），可以同时并发处理成百上千个客户端连接。
  • 当线程从某客户端Socket通道进行读写数据时，若没有数据可用时，该线程可以进行其他任务。
  • 线程通常将非阻塞IO的空闲时间用于在其他通道上执行I/O操作，所以单个线程可以管理多个输入和输出通道。
  • 由于读写操作都是非阻塞的，这就可以充分提升IO线程的运行效率，避免由于频繁I/O阻塞导致的线程挂起
  • 一个I/O线程可以并发处理N个客户端连接和读写操作，这从根本上解决了传统同步阻塞I/O一连接一线程模型，架构的性能、弹性伸缩能力和可靠性都得到了极大的提升。

4.2 Selector 类相关方法

Selector类是一个抽象类，常用方法及说明如下：

注意事项：

  1. NIO中的ServerSocketChannel功能类似ServerSocket，ServerChannel功能类似Socket。
  2. Selector相关方法说明
    1. selector.selector() //阻塞
    2. selector.select(1000) //阻塞1000毫秒，在1000毫秒后返回
    3. selector.wakeup(); //唤醒selevctor
    4. selector.selectNow() //不阻塞，立马返回

4.3NIO 非阻塞网络编程原理分析图

NIO非阻塞网络编程相关的 Selector、SelectionKey、ServerSocketChannel、及SocketChannel关系梳理图**：**

上图说明：

  1. 当客户端请求连接时，会通过ServerSocketChannel得到SocketChannel；
  2. 然后，将SocketChannel注册到Selector上；通过函数**register(Selector sel, int ops)**注册。一个selector上可以注册多个SocketChannel；
  3. SocketChannel注册到Selector上，会返回一个SelectionKey，会和该Selector关联；
  4. Selector通过_select()_方法，返回有事件发生的通道的个数，并进一步得到有事件发生的SelectionKey；
  5. 在获取到有事件发生的SelectionKey之后，通过_channel()_可以反向获取到SocketChannel；
  6. 最终，可以通过获取到的有事件发生的SocketChannel，完成相关的业务处理。
web18484626332
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java文件NIO读取的本质——FileInputStream与FileChannel对比
infant09的专栏
04-22 5882
本文连接：https://blog.csdn.net/infant09/article/details/80044868 首发连接：https://www.jianshu.com/p/a23ca155f949 本文作者：gks09@qq.com 仓促成文，还请指正。 FileInputStream典型代码 public static void main(String[...
05【NIO核心组件之Channel】
緑水長流*z
06-24 645
Java NIO的通道类似流，都是用于传输数据的。但通过又与流有些不同；流的数据走向是单向的，分为输入流（只能读取数据），输出流（只能写出数据），但NIO中的通道不一样，通道既可以写数据到Buffer，又可以从Buffer中读取数据；另外流的操作对象是数组，而通道的操作对象是Buffer；FileChannel是用于文件I/O编程的管道类；通过FileInputStream和FileOutputStream可以获取一个关联文件的Channel，即FileChannel；示例代码： 我们可以读取Channel
不惑JAVA之JAVA基础 - NIO （一）
happy_85的专栏
05-13 4098
JAVA中最可以大书特书的我觉得至少有两个：一个是NIO，另外一个就是JVM了。这也就是为什么一直我没有去写这两个知识点的原因，因为我一直找不出来一个可以在一篇博文中全部覆盖这个知识点的总结。这两天翻了一下了JAVA中的圣经《think in java》和《Java核心技术》，虽然写的很好，但感觉写的也不是太符合我想一篇博文覆盖NIO知识点的要求。由于NIO本来就是技术难点，并且java对IO的设计
三 NIO-文件编程
qq_37119960的博客
07-15 174
3.1 FileChannel ⚠️ FileChannel 工作模式 FileChannel 只能工作在阻塞模式下 获取 不能直接打开 FileChannel，必须通过 FileInputStream、FileOutputStream 或者 RandomAccessFile 来获取 FileChannel，它们都有 getChannel 方法 通过 FileInputStream 获取的 channel 只能读 通过 FileOutputStream 获取的 channel 只能写 通过 Rando
简述NIO，BIO的区别
weixin_41758726的博客
03-01 420
BIO就是我们传统意义上的Inputstream，Outputstream。这个东西是同步阻塞的，效率不高，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，当然可以通过线程池机制改善。 NIO 随着分布式的如火如荼，为了提高访问效率，引进了NIO，同步非阻塞式IO，服务器实现模式为一个请求一个线程，即客户端发...
io:nio netty等
05-18
- NIO的核心组件有：通道（Channels）、缓冲区（Buffers）、选择器（Selectors）。通道负责连接到I/O设备，缓冲区存储数据，选择器监控多个通道的状态，以便于异步读写。 - NIO适用于需要处理大量并发连接的网络...
Netty初探：掌握高性能网络通信框架，提升Java网络编程技能
最新发布
01-05
Netty 在互联网行业的应用广泛，例如在分布式服务框架 Dubbo 中，Netty 作为基础通信组件，用于实现节点间的RPC通信。RocketMQ，一个流行的消息中间件，同样依赖Netty进行低延迟、高并发的消息传输。在游戏行业中，...
Netty由浅到深_第三章_NIO模型3大组件详细介绍
12-22
NIO三大核心原理示意图 每个channel（通道）都会对应一个buffer（缓冲区） Selector（选择器）对应一个线程，一个线程对应多个channel（连接) 程序切换到那个channel是由事件决定的，==Event(事件)==是一个非常重要...
nettyrpc:netty4
05-15
其异步模型基于Java NIO（非阻塞I/O），允许Netty处理大量并发连接，从而在高负载下表现出色。 接下来是Protocol Buffers，它是Google开发的一种数据序列化协议。protobuf通过定义消息格式，可以将结构化数据序列化...
NettyDemo:运动净值
04-09
1. **异步非阻塞 I/O**：Netty 使用 NIO（非阻塞 I/O）模型，通过事件驱动架构实现了高并发能力。当数据准备就绪时，事件会被触发，而不是一直等待数据的读写操作完成。这提高了系统的资源利用率和响应速度。 2. **...
【Netty】NIO详解：NIO三大组件概述
qq_50675319的博客
09-15 365
NIO是一种同步非阻塞IO，其核心在于。若需要使用 NIO ，其中的Channel 有一点类似于 Stream，它是读写数据的，可以从 Channel 将数据读入 Buffer，也可以将 Buffer 的数据写入 Channel，Channel 比 Stream 更为底层，selector 的作用是配合一个线程来管理多个 channel，获取这些 channel 上发生的事件，这些 channel 工作在非阻塞模式下，当一个channel中没有执行任务时，可以去执行其他channel中的任务。适合连接数多，
netty(二)--NIO及Nio三大组件详解
zisuu的博客
05-03 470
NIO三大组件的关系: 三大组件:selector,channel,buffer 一个Select对应一个线程,一个线程对应多个channel 程序切换到那个channel是由事件决定的 Selector会根据不同的事件,在各个通道上切换 Buffer是一个内存块,底层是一个数据 数据的读取写入是通过Buffer.在传统Bio中要么是输入流,要么是输出流,不能是双向,但是N...
选择器selector
chonger_feifei的博客
03-08 583
CSS选择器
多路复用--Selector选择器
JAVA大猩猩的博客
02-06 684
多路复用的概念 选择器Selector是NIO中的重要技术之一。它与SelectableChannel联合使用实现了非阻塞的多路复用。 使用它可以节省CPU资源，提高程序的运行效率。 "多路"是指：服务器端同时监听多个“端口”的情况。每个端口都要监听多个客户端的连接。 服务器端的非多路复用效果 服务器端的多路复用效果 选择器Selector Selector被称为：选择器，也被称为：多路复用器...
8.JAVA NIO核心之选择器(Selector)
qq_30635523的博客
07-21 333
highlight: arduino-light 选择器(Selector)概述 选择器Selector是 SelectableChannle 对象的多路复用器，Selector 可以同时监控多个SelectableChannel的 IO 状况，也就是说，利用 Selector可使一个单独的线程管理多个 Channel。Selector 是非阻塞 IO 的核心 Java 的 NIO...
关于微信小程序picker之multiSelector多列选择器
m0_55545985的博客
03-24 4724
关于微信小程序picker之multiSelector多列选择器 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。 新的改变 我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能，帮助你用它写博客： 全新的界面设计 ，将会带来全新的写作体验； 在创作中心设置你喜爱的代码高亮样式，Ma
【NIO】Selector（选择器）
yhl_jxy的博客
02-17 5892
前言 Github：GitHub - yihonglei/jdk-source-code-reading: JDK source code reading（java-nio） 一 Selector (选择器)概述 Selector(选择器)是 Java NIO 中能够检测到一到多个 NIO 通道，并能够知道通道是否为读写 事件做好准备。这样，一个单独的线程可以管理多个 Channel，从而管理多个网络连接。 仅用单个线程来处理多个 Channel的好处是，只需要更少的线程来处理通道。事实上， .
Java文件读写IO/NIO及性能比较总结
热门推荐
Java我人生的技术博客
03-11 2万+
干Java这么久，一直在做WEB相关的项目，一些基础类差不多都已经忘记。经常想得捡起，但总是因为一些原因，不能如愿。 其实不是没有时间，只是有些时候疲于总结，今得空，下定决心将丢掉的都给捡起来。 文件读写是一个在项目中经常遇到的工作，有些时候是因为维护，有些时候是新功能开发。我们的任务总是很重，工作节奏很快，快到我们不能停下脚步去总结。 文件读写有以下几种常用的方法 1、字节读写（Inpu
java nio 实现文件的读取和输出
破浪行
12-27 1802
1、读取文件流     File f= new File("**");     FileInputStream in=new FileInputStream(f);     //获取输入管道     FileChannel inChannel=in.getChannel(); 2、获得输出流     FileOutputStream out=new FileOu
Netty实战：NIO架构的网络应用开发指南（Manning早期访问版）
《Netty in Action》是一本由Manning Publications在2014年发行的英文版书籍，专注于介绍Netty框架，这是一个强大的NIO（Non-blocking I/O）客户端服务器开发框架，特别适用于构建网络应用，如协议服务器和客户端。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值