精华内容
下载资源
问答
  • Java NIO

    2012-03-25 16:06:13
    Java NIO 书籍,讲述new io特性 裴小星 译
  • java nio

    2013-10-23 10:54:18
    Java NIO非堵塞应用通常适用用在I/O读写等方面,我们知道,系统运行的性能瓶颈通常在I/O读写,包括对端口和文件的操作上,过去,在打开一个I/O通道后,read()将一直等待在端口一边读取字节内容,如果没有内容进来,...
    Java NIO非堵塞应用通常适用用在I/O读写等方面,我们知道,系统运行的性能瓶颈通常在I/O读写,包括对端口和文件的操作上,过去,在打开一个I/O通道后,read()将一直等待在端口一边读取字节内容,如果没有内容进来,read()也是傻傻的等,这会影响我们程序继续做其他事情,那么改进做法就是开设线程,让线程去等待,但是这样做也是相当耗费资源的。
    

    Java NIO非堵塞技术实际是采取Reactor模式,或者说是Observer模式为我们监察I/O端口,如果有内容进来,会自动通知我们。

    package com.java.xiong.file15;
    
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.nio.CharBuffer;
    import java.nio.MappedByteBuffer;
    import java.nio.channels.FileChannel;
    import java.nio.charset.Charset;
    import java.nio.charset.CharsetDecoder;
    
    public class FileChanelTest {
    	private static FileInputStream fileInputStream;
    	private static FileOutputStream fileOutputStream;
    
    	public static void main(String[] args) {
    
    		File files = new File("src/com/java/xiong/file15/FileChanelTest.java");
    		File filess = new File("1.txt");
    		try {
    
    			fileInputStream = new FileInputStream(files);
    			FileChannel filein = fileInputStream.getChannel();
    			fileOutputStream = new FileOutputStream(filess);
    			FileChannel fileout = fileOutputStream.getChannel();
    			MappedByteBuffer mapin = filein.map(FileChannel.MapMode.READ_ONLY,
    					0, files.length());
    			// 使用GBK来创建解码
    			Charset cset = Charset.forName("GBK");
    			fileout.write(mapin);
    			// 将Buffer 界限和位置复原
    			mapin.clear();
    			// 创建解码对象
    			CharsetDecoder chard = cset.newDecoder();
    			// byteBuffer转换成charBuffer
    			CharBuffer charc = chard.decode(mapin);
    			System.out.println(charc.toString());
    
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    	}
    
    }
    


    展开全文
  • Java NIO系列教程(一) Java NIO 概述
  • java NIO

    万次阅读 2016-09-01 10:26:27
     NIO 的创建目的是为了让 Java 程序员可以实现高速 I/O 而无需编写自定义的本机代码。NIO 将最耗时的 I/O 操作(即填充和提取缓冲区)转移回操作系统,因而可以极大地提高速度。  原来的 I/O 库(在 java.io.*中) 与...

    为什么要使用 NIO?

        NIO 的创建目的是为了让 Java 程序员可以实现高速 I/O 而无需编写自定义的本机代码。NIO 将最耗时的 I/O 操作(即填充和提取缓冲区)转移回操作系统,因而可以极大地提高速度。

       原来的 I/O 库(在 java.io.*中) 与 NIO 最重要的区别是数据打包和传输的方式。原来的 I/O 以流的方式处理数据,而 NIO 以块的方式处理数据。

        面向流 的 I/O 系统一次一个字节地处理数据。一个输入流产生一个字节的数据,一个输出流消费一个字节的数据。为流式数据创建过滤器非常容易。链接几个过滤器,以便每个过滤器只负责单个复杂处理机制的一部分,这样也是相对简单的。不利的一面是,面向流的 I/O 通常相当慢。

        一个 面向块 的 I/O 系统以块的形式处理数据。每一个操作都在一步中产生或者消费一个数据块。按块处理数据比按(流式的)字节处理数据要快得多。但是面向块的 I/O 缺少一些面向流的 I/O 所具有的优雅性和简单性。

        在 JDK 1.4 中原来的 I/O 包和 NIO 已经很好地集成了。 java.io.* 已经以 NIO 为基础重新实现了,所以现在它可以利用 NIO 的一些特性。例如, java.io.* 包中的一些类包含以块的形式读写数据的方法,这使得即使在更面向流的系统中,处理速度也会更快。

        也可以用 NIO 库实现标准 I/O 功能。例如,可以容易地使用块 I/O 一次一个字节地移动数据。但是正如您会看到的,NIO 还提供了原 I/O 包中所没有的许多好处。

    在网络通信方面:传统的并发型服务器设计是利用阻塞型网络I/O 以多线程的模式来实现的,然而由于系统常常在进行网络读写时处于阻塞状态,会大大影响系统的性能;自Java1. 4 开始引入了NIO(新I/O) API,通过使用非阻塞型I/O,实现流畅的网络读写操作,为开发高性能并发型服务器程序提供了一个很好的解决方案,这就是java nio。

    Java NIO:
    Java NIO中比较核心的三个概念是:通道(Channel)、缓冲区(Buffer)、选择器(Selector)

    什么是通道?

    Channel是一个对象,可以通过它读取和写入数据。拿 NIO 与原来的 I/O 做个比较,通道就像是流。

    所有数据都通过 Buffer 对象来处理。您永远不会将字节直接写入通道中,相反,您是将数据写入包含一个或者多个字节的缓冲区。同样,您不会直接从通道中读取字节,而是将数据从通道读入缓冲区,再从缓冲区获取这个字节。

    通道与流的不同之处在于通道是双向的。而流只是在一个方向上移动(一个流必须是 InputStream 或者 OutputStream 的子类), 而 通道 可以用于读、写或者同时用于读写。

    因为它们是双向的,所以通道可以比流更好地反映底层操作系统的真实情况。特别是在 UNIX 模型中,底层操作系统通道是双向的。

    常用的有以下几种通道:
    • FileChannel  --从文件读或者向文件写入数据
    • SocketChanel   --以TCP来向网络连接的两端读写数据
    • ServerSocketChannel   --服务器端通过ServerSocketChanel能够监听客户端发起的TCP连接,并为每个TCP连接创建一个新的SocketChannel来进行数据读写
    • DatagramChannel   --以UDP协议来向网络连接的两端读写数据

    什么是缓冲区?

    Buffer 是一个对象, 它包含一些要写入或者刚读出的数据。 在 NIO 中加入 Buffer 对象,体现了新库与原 I/O 的一个重要区别。在面向流的 I/O 中,您将数据直接写入或者将数据直接读到 Stream 对象中。

    在 NIO 库中,所有数据都是用缓冲区处理的。在读取数据时,它是直接读到缓冲区中的。在写入数据时,它是写入到缓冲区中的。任何时候访问 NIO 中的数据,您都是将它放到缓冲区中。

    Buffer实际上是一个容器,是一个连续数组。Channel提供从文件、网络读取数据的渠道,使用Java NIO时,所有数据处理(读取或写入)必须经由Buffer。即读入数据时,先通过通道Channel获取数据渠道,然后将数据写入到缓冲区Buffer中,往外写数据时,先把内存中的数据放到Buffer中,然后再从Buffer送往通道中。如下图所示:

    最常用的缓冲区类型是 ByteBuffer。一个 ByteBuffer 可以在其底层字节数组上进行 get/set 操作(即字节的获取和设置)。

    ByteBuffer 不是 NIO 中唯一的缓冲区类型。事实上,对于每一种基本 Java 类型都有一种缓冲区类型:

    • ByteBuffer
    • CharBuffer
    • ShortBuffer
    • IntBuffer
    • LongBuffer
    • FloatBuffer
    • DoubleBuffer

    每一个 Buffer 类都是 Buffer 接口的一个实例。 除了 ByteBuffer,每一个 Buffer 类都有完全一样的操作,只是它们所处理的数据类型不一样。因为大多数标准 I/O 操作都使用 ByteBuffer,所以它具有所有共享的缓冲区操作以及一些特有的操作。

    一个传统IO读写数据的例子:     
    [java]  view plain  copy
      在CODE上查看代码片 派生到我的代码片
    1. public static String readFromStream(InputStream is) throws IOException{  
    2.         ByteArrayOutputStream baos = new ByteArrayOutputStream();  
    3.         byte[] buffer = new byte[1024];  
    4.         int len = 0;  
    5.         while((len = is.read(buffer))!=-1){  
    6.             baos.write(buffer, 0, len);  
    7.         }  
    8.         is.close();  
    9.         String result = baos.toString();  
    10.         baos.close();  
    11.         return result;  
    12.     }  
    传统IO在读取数据时,直接从InputStream中读入到byte[]数组中,如is.read(buffer),在写数据时,直接将内存数据写到输出流中,如baos.write(buffer,0,len);

    使用NIO读取数据:按照上图,读取数据时,从通道中将数据读入到Buffer中,写数据时,将内存数据先写到Buffer,再送入通道。
        NIO 读取数据:         
    [java]  view plain  copy
      在CODE上查看代码片 派生到我的代码片
    1. FileInputStream in = new FileInputStream("e:\\lly.txt");  
    2.         FileChannel fileChannel = in.getChannel();  
    3.         //创建一个ByteBuffer缓冲区  
    4.         ByteBuffer buffer = ByteBuffer.allocate(10);  
    5.         //从通道读入数据到缓冲区  
    6.         fileChannel.read(buffer);  
    7.         //重设此缓冲区,将限制设置为当前位置,然后将当前位置设置为0    
    8.         buffer.flip();  
    9.   
    10.         while(buffer.hasRemaining()){  
    11.             byte b = buffer.get();//从缓冲区中取数据到内存中  
    12.             System.out.print(((char)b));  
    13.         }  
    14.         in.close();  
        NIO写数据:        
    [java]  view plain  copy
      在CODE上查看代码片 派生到我的代码片
    1. //模拟数据  
    2.    byte[] data = { 8311110910132,    
    3.            9812111610111546};  
    4.    FileOutputStream out = new FileOutputStream("e:\\lly.txt");  
    5.    FileChannel fileChannel = out.getChannel();  
    6.    //创建一个ByteBuffer缓冲区  
    7.    ByteBuffer buffer = ByteBuffer.allocate(20);  
    8.    //先将数据写入到Buffer中  
    9.    for(int i = 0; i < data.length; i++){  
    10.        buffer.put(data[i]);  
    11.    }  
    12.    //重设此缓冲区,将限制设置为当前位置,然后将当前位置设置为0   
    13.    buffer.flip();  
    14.    //把buffer中的数据送入到通道中  
    15.    fileChannel.write(buffer);  
    16.    out.close();  
    可以看到,Java NIO在数据处理方面需要通过Buffer来缓存,与传统IO处理方式相比,NIO相当于是数据块处理,传统IO是一个一个字节处理。其实,在传统IO后面出现了BufferInputStream、BufferOutputStream这种也是缓存数据块的处理方式。
    同时,我们看到在读或写时都调用了Buffer的buffer.flip();这个方法非常重要,它是用来设置缓冲对象的一些状态信息,在读get()和写put()之前,都需要调用buffer.flip();来设置状态。


    缓冲区内部细节

    NIO 中两个重要的缓冲区组件:状态变量和访问方法 (accessor)。

    每一个读/写操作都会改变缓冲区的状态。通过记录和跟踪这些变化,缓冲区就可能够内部地管理自己的资源。

    在从通道读取数据时,数据被放入到缓冲区。在有些情况下,可以将这个缓冲区直接写入另一个通道,但是在一般情况下,您还需要查看数据。这是使用 访问方法 get() 来完成的。同样,如果要将原始数据放入缓冲区中,就要使用访问方法 put()。

    状态变量:

    可以用三个值指定缓冲区在任意时刻的状态:

    • position
    • limit
    • capacity

    这三个变量一起可以跟踪缓冲区的状态和它所包含的数据。接下来将详细分析每一个变量,还要介绍它们如何适应典型的读/写(输入/输出)进程。在这个例子中,我们假定要将数据从一个输入通道拷贝到一个输出通道。

    position:指定了下一个将要被写入或者读取的元素索引,它的值由get()/put()方法自动更新,在新创建一个Buffer对象时,position被初始化为0。

    limit:指定还有多少数据需要取出(在从缓冲区写入通道时),或者还有多少空间可以放入数据(在从通道读入缓冲区时)。

    capacity:指定了可以存储在缓冲区中的最大数据容量,实际上,它指定了底层数组的大小,或者至少是指定了准许我们使用的底层数组的容量。

    以上四个属性值之间有一些相对大小的关系:0 <= position <= limit <= capacity


    我们首先观察一个新创建的缓冲区。出于本例子的需要,我们假设这个缓冲区的 总容量 为8个字节。 Buffer 的状态如下所示:


    Buffer state 

    limit 决不能大于 capacity,此例中这两个值都被设置为 8。我们通过将它们指向数组的尾部之后(如果有第8个槽,则是第8个槽所在的位置)来说明这点。


    Array 

    position 设置为0。如果我们读一些数据到缓冲区中,那么下一个读取的数据就进入 slot 0 。如果我们从缓冲区写一些数据,从缓冲区读取的下一个字节就来自 slot 0 。 position 设置如下所示:


    Position setting 

    由于 capacity 不会改变,所以我们在下面的讨论中可以忽略。

    第一次读取:

    现在我们可以开始在新创建的缓冲区上进行读/写操作。首先从输入通道中读一些数据到缓冲区中。第一次读取得到三个字节。它们被放到数组中从 position 开始的位置,这时 position 被设置为 0。读完之后,position 就增加到 3,如下所示:


    Position increased to 3 

    limit 没有改变。

    第二次读取

    在第二次读取时,我们从输入通道读取另外两个字节到缓冲区中。这两个字节储存在由 position 所指定的位置上, position 因而增加 2:


    Position increased by 2 

    limit 没有改变。

    flip()方法

    现在我们要将数据写到输出通道中。在这之前,我们必须调用 flip() 方法。这个方法做两件非常重要的事:

    1. 它将 limit 设置为当前 position。
    2. 它将 position 设置为 0。

    buffer.flip()该方法是用于将缓冲区从写模式切换到读模式,这是一种固定写法,该方法的源码如下:
    public final Buffer flip() {
        limit = position;
        position = 0;
        mark = -1;
        return this;
    }

    前一小节中的图显示了在 flip 之前缓冲区的情况。下面是在 flip 之后的缓冲区:


    Buffer after the flip 

    我们现在可以将数据从缓冲区写入通道了。 position 被设置为 0,这意味着我们得到的下一个字节是第一个字节。 limit 已被设置为原来的 position,这意味着它包括以前读到的所有字节,并且一个字节也不多。

    第一次写入:

    在第一次写入时,我们从缓冲区中取四个字节并将它们写入输出通道。这使得 position 增加到 4,而 limit 不变,如下所示:


    Position advanced to 4, limit unchanged 

    第二次写入:

    我们只剩下一个字节可写了。 limit在我们调用 flip() 时被设置为 5,并且 position 不能超过 limit。所以最后一次写入操作从缓冲区取出一个字节并将它写入输出通道。这使得 position 增加到 5,并保持 limit 不变,如下所示:


    Position advanced to 5, limit unchanged 

    clear()方法

    最后一步是调用缓冲区的 clear() 方法。这个方法重设缓冲区以便接收更多的字节。 Clear 做两种非常重要的事情:

    1. 它将 limit 设置为与 capacity 相同。
    2. 它设置 position 为 0。

     public final Buffer clear() {
        position = 0;
         limit = capacity;
         mark = -1;
         return this;
    }

    1、一旦完成对buffer中数据的读取,需要让buffer做好再次被写入的准备,这时候可以调用clear方法来完成。

    2、clear方法将position设置为0,limit设置为容量的值,也就意味着buffer被清空了,但是这个清空的概念是写入数据可以从缓冲区的指定位置开始,但buffer里面的数据并没有        删除。

    3、如果buffer里面还有数据没有被读取,这个时候调用clear方法会导致那些数据被“遗忘”,因为没有标记告诉你哪些是读取过哪些没有被读取。


    下图显示了在调用 clear() 后缓冲区的状态:


    State of the buffer after clear() has been called 

    缓冲区现在可以接收新的数据了。


    选择器(Selector)
        Selector类是NIO的核心类,Selector能够检测多个注册的通道上是否有事件发生,如果有事件发生,便获取事件然后针对每个事件进行相应的响应处理。这样一来,只是用一个单线程就可以管理多个通道,也就是管理多个连接。这样使得只有在连接真正有读写事件发生时,才会调用函数来进行读写,就大大地减少了系统开销,并且不必为每个连接都创建一个线程,不用去维护多个线程,并且避免了多线程之间的上下文切换导致的开销。如下如所示:
    要使用Selector,得向Selector注册Channel,然后调用它的select()方法。这个方法会一直阻塞到某个注册的通道有事件就绪。一旦这个方法返回,线程就可以处理这些事件,事件的例子有如新连接进来,数据接收等。

    JAVA NIO socket用法

    传统的阻塞型网络 I/O的不足:
        Java 平台传统的I/O 系统都是基于Byte(字节)和Stream(数据流)的,相应的I/O 操作都是阻塞型的,所以服务器程序也采用阻塞型I/O 进行数据的读、写操作。
        这种模式的优点是简单、实用、易管理;然而缺点也是显而易见的:由于是为每一个客户端分配一个线程来处理输入、输出数据,其线程与客户机的比例近似为1:1,随着线程数量的不断增加,服务器启动了大量的并发线程,会大大加大系统对线程的管理开销,这将成为吞吐量瓶颈的主要原因;其次由于底层的I/O 操作采用的同步模式,I/O 操作的阻塞管理粒度是以服务于请求的线程为单位的,有可能大量的线程会闲置,处于盲等状态,造成I/O资源利用率不高,影响整个系统的性能。

       对于并发型服务器,系统用在阻塞型I/O 等待和线程间切换的时间远远多于CPU 在内存中处理数据的时间,因此传统的阻塞型I/O 已经成为制约系统性能的瓶颈。Java1.4 版本后推出的NIO 工具包,提供了非阻塞型I/O 的异步输入输出机制,为提高系统的性能提供了可实现的基础机制。

    NIO 包及工作原理

        针对传统I/O 工作模式的不足,NIO 工具包提出了基于Buffer(缓冲区)、Channel(通道)、Selector(选择器)的新模式;Selector(选择器)、可选择的Channel(通道)SelectionKey(选择键)配合起来使用,可以实现并发的非阻塞型I/O 能力。

    NIO 工具包的成员

    • Buffer(缓冲器)
      Buffer 类是一个抽象类,它有7 个子类分别对应于七种基本的数据类型:ByteBuffer、CharBuffer、DoubleBuffer、FloatBuffer、IntBuffer、LongBuffer 和ShortBuffer。每一个Buffer对象相当于一个数据容器,可以把它看作内存中的一个大的数组,用来存储和提取所有基本类型(boolean 型除外)的数据。Buffer 类的核心是一块内存区,可以直接对其执行与内存有关的操作,利用操作系统特性和能力提高和改善Java 传统I/O 的性能。
    • Channel(通道)
      Channel 被认为是NIO 工具包的一大创新点,是(Buffer)缓冲器和I/O 服务之间的通道,具有双向性,既可以读入也可以写出,可以更高效的传递数据。我们这里主要讨论的是ServerSocketChannel 和SocketChannel,它们都继承了SelectableChannel,是可选择的通道,分别可以工作在同步和异步两种方式下(这里的可选择不是指可以选择两种工作方式,而是指可以有选择的注册自己感兴趣的事件)。当通道工作在同步方式时,它的功能和编程方法与传统的ServerSocket、Socket 对象相似;当通道工作在异步工作方式时,进行输入输出处理不必等到输入输出完毕才返回,并且可以将其感兴趣的(如:接受操作、连接操作、读出操作、写入操作)事件注册到Selector 对象上,与Selector 对象协同工作可以更有效率的支持和管理并发的网络套接字连接。
    • Selector(选择器)
      各类 Buffer 是数据的容器对象;各类Channel 实现在各类Buffer 与各类I/O 服务间传输数据。Selector 是实现并发型非阻塞I/O 的核心,各种可选择的通道将其感兴趣的事件注册到Selector 对象上,Selector 在一个循环中不断轮循监视这各些注册在其上的Socket 通道。为ServerSocketChannel 监控接收客户端连接就绪事件,为 SocketChannel 监控连接服务器就绪,读就绪和写就绪事件。
    • ServerSocketChannel
      ServerSocket 的替代类,支持阻塞通信与非阻塞通信。
    • SocketChannel
      Socket 的替代类,支持阻塞通信与非阻塞通信。
    • SelectionKey
          SelectionKey 类则封装了SelectableChannel 对象在Selector 中的注册信息。当Selector 监测到在某个注册的SelectableChannel 上发生了感兴趣的事件时,自动激活产生一个SelectionKey对象,这个对象中记录了哪一个SelectableChannel 上发生了哪种事件,通过对被激活的SelectionKey 的分析,外界可以知道每个SelectableChannel 发生的具体事件类型,进行相应的处理。当一个 SelectionKey 对象位于Selector 对象的 selected-keys 集合中时,就表示与这个 SelectionKey 对象相关的事件发生了。
    • 在SelectionKey 类中几个静态常量
      SelectionKey.OP_ACCEPT     ->   客户端连接就绪事件 等于监听serversocket.accept()返回一个socket
      SelectionKey.OP_CONNECT  ->   准备连接服务器就绪 跟上面类似,只不过是对于socket的 相当于监听了 socket.connect()
      SelectionKey.OP_READ        ->   读就绪事件, 表示输入流中已经有了可读数据, 可以执行读操作了
      SelectionKey.OP_WRITE       ->   写就绪事件

     

        在使用传统的ServerSocket和Socket的时候 很多时候程序是会阻塞的。比如 serversocket.accept() , socket.getInputStream().read() 的时候都会阻塞 。

        accept()方法除非等到客户端socket的连接或者被异常中断 否则会一直等待下去,read()方法也是如此 除非在输入流中有了足够的数据,否则该方法也会一直等待下去知道数据的到来。在ServerSocket与Socket的方式中 服务器端往往要为每一个客户端(socket)分配一个线程,而每一个线程都有可能处于长时间的阻塞状态中.而过多的线程也会影响服务器的性能,在JDK1.4引入了非阻塞的通信方式,这样使得服务器端只需要一个线程就能处理所有客户端socket的请求。

    NIO 工作原理

        通过上面的讨论,我们可以看出在并发型服务器程序中使用NIO,实际上是通过网络事件驱动模型实现的。我们应用Select 机制,不用为每一个客户端连接新启线程处理,而是将其注册到特定的Selector 对象上,这就可以在单线程中利用Selector 对象管理大量并发的网络连接,更好的利用了系统资源;采用非阻塞I/O 的通信方式,不要求阻塞等待I/O 操作完成即可返回,从而减少了管理I/O 连接导致的系统开销,大幅度提高了系统性能。

       当有读或写等任何注册的事件发生时,可以从Selector 中获得相应的SelectionKey , 从SelectionKey 中可以找到发生的事件和该事件所发生的具体的SelectableChannel,以获得客户端发送过来的数据。由于在非阻塞网络I/O 中采用了事件触发机制,处理程序可以得到系统的主动通知,从而可以实现底层网络I/O 无阻塞、流畅地读写,而不像在原来的阻塞模式下处理程序需要不断循环等待。使用NIO,可以编写出性能更好、更易扩展的并发型服务器程序。

    并发型服务器程序的实现代码

        应用 NIO 工具包,基于非阻塞网络I/O 设计的并发型服务器程序与以往基于阻塞I/O 的实现程序有很大不同,在使用非阻塞网络I/O 的情况下,程序读取数据和写入数据的时机不是由程序员控制的,而是Selector 决定的。下面便给出基于非阻塞网络I/O 的并发型服务器程序的核心代码片段:

    <span style="font-size:14px;"><span style="font-size:14px;">import java.io.IOException;
    import java.net.InetSocketAddress;
    import java.net.ServerSocket;
    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;
    import java.util.Set;
    
    public class NIOServer {
    
        /*标识数字*/
        private int flag = 0;
        /*缓冲区大小*/
        private int BLOCK = 4096;
        /*接受数据缓冲区*/
        private ByteBuffer sendbuffer = ByteBuffer.allocate(BLOCK);
        /*发送数据缓冲区*/
        private ByteBuffer receivebuffer = ByteBuffer.allocate(BLOCK);
        private Selector selector;
    
        public NIOServer(int port) throws IOException {
            // 打开服务器套接字通道  
            ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
            // 服务器配置为非阻塞  
            serverSocketChannel.configureBlocking(false);
            // 检索与此通道关联的服务器套接字  
            ServerSocket serverSocket = serverSocketChannel.socket();
            // 进行服务的绑定  
            serverSocket.bind(new InetSocketAddress(port));
            // 通过open()方法找到Selector  
            selector = Selector.open();
            // 注册到selector,等待连接  
            serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
            System.out.println("Server Start----8888:");
        }
    
        // 监听  
        private void listen() throws IOException {
            while (true) {
                // 应用Select机制轮循是否有用户感兴趣的新的网络事件发生,当没有新的网络事件发生时,此方法会阻塞,直到有新的网络事件发生为止。
                selector.select();
                // 返回此选择器的已选择键集。  
                Set<SelectionKey> selectionKeys = selector.selectedKeys();
                Iterator<SelectionKey> iterator = selectionKeys.iterator();
                System.out.println("selectionKeys size -> " + selectionKeys.size());
                while (iterator.hasNext()) {
                    SelectionKey selectionKey = iterator.next();
                    iterator.remove();
                    handleKey(selectionKey);
                }
            }
        }
    
        // 处理请求  
        private void handleKey(SelectionKey selectionKey) throws IOException {
            // 接受请求  
            ServerSocketChannel server = null;
            SocketChannel client = null;
            String receiveText;
            String sendText;
            int count = 0;
            // 测试此键的通道是否已准备好接受新的套接字连接。  
            if (selectionKey.isAcceptable()) {
                System.out.println("------------- isAcceptable");
                // 返回为之创建此键的通道。  
                server = (ServerSocketChannel) selectionKey.channel();
                // 接受到此通道套接字的连接。  
                // 此方法返回的套接字通道(如果有)将处于阻塞模式。  
                client = server.accept();
                // 配置为非阻塞  
                client.configureBlocking(false);
                //在和客户端连接成功之后,为了可以接收到客户端的信息,需要给通道设置读的权限。
                client.register(selector, SelectionKey.OP_READ);
            }
            else if (selectionKey.isReadable()) {
                System.out.println("------------- isReadable");
                // 返回为之创建此键的通道。  
                client = (SocketChannel) selectionKey.channel();
                //将缓冲区清空以备下次读取  
                receivebuffer.clear();
                //读取服务器发送来的数据到缓冲区中  
                count = client.read(receivebuffer);
                if (count > 0) {
                    receiveText = new String(receivebuffer.array(), 0, count);
                    System.out.println("服务器端接受客户端数据--:" + receiveText);
                    client.register(selector, SelectionKey.OP_WRITE);
                }
            }
            else if (selectionKey.isWritable()) {
                System.out.println("------------- isWritable");
                //将缓冲区清空以备下次写入  
                sendbuffer.clear();
                // 返回为之创建此键的通道。  
                client = (SocketChannel) selectionKey.channel();
                sendText = "message from server--" + flag++;
                //向缓冲区中输入数据  
                sendbuffer.put(sendText.getBytes());
                //将缓冲区各标志复位,因为向里面put了数据标志被改变要想从中读取数据发向服务器,就要复位  
                sendbuffer.flip();
                //输出到通道  
                client.write(sendbuffer);
                System.out.println("服务器端向客户端发送数据--:" + sendText);
                client.register(selector, SelectionKey.OP_READ);
            }
        }
    
        /** 
         * @param args 
         * @throws IOException 
         */
        public static void main(String[] args) throws IOException {
            // TODO Auto-generated method stub  
            int port = 8888;
            NIOServer server = new NIOServer(port);
            server.listen();
        }
    }</span></span>


    <span style="font-size:14px;"><span style="font-size:14px;">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.Iterator;
    import java.util.Set;
    
    public class NIOClient {
    
        /*标识数字*/
        private static int flag = 0;
        /*缓冲区大小*/
        private static int BLOCK = 4096;
        /*接受数据缓冲区*/
        private static ByteBuffer sendbuffer = ByteBuffer.allocate(BLOCK);
        /*发送数据缓冲区*/
        private static ByteBuffer receivebuffer = ByteBuffer.allocate(BLOCK);
        /*服务器端地址*/
        private final static InetSocketAddress SERVER_ADDRESS = new InetSocketAddress("localhost", 8888);
    
        public static void main(String[] args) throws IOException {
            // TODO Auto-generated method stub  
            // 打开socket通道  
            SocketChannel socketChannel = SocketChannel.open();
            // 设置为非阻塞方式  
            socketChannel.configureBlocking(false);
            // 打开选择器  
            Selector selector = Selector.open();
            // 注册连接服务端socket动作  
            socketChannel.register(selector, SelectionKey.OP_CONNECT);
            // 连接  
            socketChannel.connect(SERVER_ADDRESS);
            // 分配缓冲区大小内存  
    
            Set<SelectionKey> selectionKeys;
            Iterator<SelectionKey> iterator;
            SelectionKey selectionKey;
            SocketChannel client;
            String receiveText;
            String sendText;
            int count = 0;
    
            while (true) {
                //选择一组键,其相应的通道已为 I/O 操作准备就绪。  
                //此方法执行处于阻塞模式的选择操作。  
                selector.select();
                //返回此选择器的已选择键集。  
                selectionKeys = selector.selectedKeys();
                //System.out.println(selectionKeys.size());  
                iterator = selectionKeys.iterator();
                while (iterator.hasNext()) {
                    selectionKey = iterator.next();
                    if (selectionKey.isConnectable()) {
                        System.out.println("client connect");
                        client = (SocketChannel) selectionKey.channel();
                        // 判断此通道上是否正在进行连接操作。  
                        // 完成套接字通道的连接过程。  
                        if (client.isConnectionPending()) {
                            client.finishConnect();
                            System.out.println("完成连接!");
                            sendbuffer.clear();
                            sendbuffer.put("Hello,Server".getBytes());
                            sendbuffer.flip();
                            client.write(sendbuffer);
                        }
                        client.register(selector, SelectionKey.OP_READ);
                    }
                    else if (selectionKey.isReadable()) {
                        client = (SocketChannel) selectionKey.channel();
                        //将缓冲区清空以备下次读取  
                        receivebuffer.clear();
                        //读取服务器发送来的数据到缓冲区中  
                        count = client.read(receivebuffer);
                        if (count > 0) {
                            receiveText = new String(receivebuffer.array(), 0, count);
                            System.out.println("客户端接受服务器端数据--:" + receiveText);
                            client.register(selector, SelectionKey.OP_WRITE);
                        }
    
                    }
                    else if (selectionKey.isWritable()) {
                        sendbuffer.clear();
                        client = (SocketChannel) selectionKey.channel();
                        sendText = "message from client--" + (flag++);
                        sendbuffer.put(sendText.getBytes());
                        //将缓冲区各标志复位,因为向里面put了数据标志被改变要想从中读取数据发向服务器,就要复位  
                        sendbuffer.flip();
                        client.write(sendbuffer);
                        System.out.println("客户端向服务器端发送数据--:" + sendText);
                        client.register(selector, SelectionKey.OP_READ);
                    }
                }
                selectionKeys.clear();
            }
        }
    }</span></span>

    从上面对代码可以看出,使用非阻塞性I/O进行并发型服务器程序设计分三个部分:

    1. 向Selector对象注册感兴趣的事件。
    2. 从Selector中获取所感兴趣的事件。
    3. 根据不同的事件进行相应的处理。

    结语

        通过使用NIO 工具包进行并发型服务器程序设计,一个或者很少几个Socket 线程就可以处理成千上万个活动的Socket 连接,大大降低了服务器端程序的开销;同时网络I/O 采取非阻塞模式,线程不再在读或写时阻塞,操作系统可以更流畅的读写数据并可以更有效地向CPU 传递数据进行处理,以便更有效地提高系统的性能。






    展开全文
  • java NIO文档

    2017-12-20 12:26:12
    Java NIO大学课堂文档 Java NIO大学课堂文档Java NIO大学课堂文档Java NIO大学课堂文档Java NIO大学课堂文档Java NIO大学课堂文档Java NIO大学课堂文档Java NIO大学课堂文档Java NIO大学课堂文档Java NIO大学课堂...
  • java nio入门知识 java nio详细介绍总结
  • java nio.pdf

    2017-10-26 17:20:20
    java nio.pdfjava nio.pdfjava nio.pdfjava nio.pdfjava nio.pdfjava nio.pdfjava nio.pdfjava nio.pdfjava nio.pdfjava nio.pdfjava nio.pdfjava nio.pdfjava nio.pdfjava nio.pdfjava nio.pdfjava nio.pdfjava ...
  • java NIO 详解

    2020-09-04 01:55:26
    Java NIO(New IO)是从Java 1.4版本开始引入的一个新的IO API,可以替代标准的Java IO API。本系列教程将有助于你学习和理解Java NIO
  • Java NIO 主要类,包含类和函数,没有函数说明,类有简要说明
  • java nio ppt

    2019-01-23 13:06:57
    java nio 相关 ppt,介绍了 java nio 的基本概念以及和其他 io 的区别
  • Java NIO pdf

    2018-12-12 20:18:05
    Java NIO pdf
  • Java NIO(新IO)对于Java是一个交替、可供选择的IO API(从Java 1.4版本开始),意味着可替代标准Java IO和Java网络的API。Java NIO跟标准IO的API相比较是提供了一种使用IO工作的不同方式。 Java NIO:通道和...
    

    最后更新时间:2014-06-25


    Java NIO(新IO)对于Java是一个交替、可供选择的IO API(从Java 1.4版本开始),意味着可替代标准Java IO和Java网络的API。Java NIO跟标准IO的API相比较是提供了一种使用IO工作的不同方式。


    Java NIO:通道和缓冲区


    在标准IO的API中,你使用字节流和字符流的方式工作。而在NIO中你使用通道和缓冲区工作。数据总是从一个通道读到缓冲区,或者从一个缓冲区写到通道。


    Java NIO:非阻塞IO


    Java NIO可以让你使用非阻塞的IO。例如,一个线程可以询问请求一个通道去读数据进入到一个缓冲区。当这个通道读数据进入到缓冲区的时候,这个线程可以做其他的一些事情。一旦数据读进了缓冲区中,这个线程可以再处理它。从缓冲区写数据到通道也是一样的。


    Java NIO:选择器


    Java NIO包含了一个“选择器”的一个概念。一个选择器是一个对象,他可以监控多个通道的多个事件(像:连接打开,数据到达等等事件)。而且,一个单独的线程可以监控多个通道的多个数据事件。


    所有的这些是如何工作的,在这个系列中的下面的文章里有更详细的说明--Java NIO综述


    翻译地址:http://tutorials.jenkov.com/java-nio/index.html


    下一章:Java NIO综述


    展开全文
  • java NIO 中文版

    2018-12-01 20:09:01
    讲解了 JavaIO 与 JAVA NIO区别,JAVA NIO设计理念,以及JDK中java NIO中语法的使用
  • Java Nio 十六、Java NIO Files

    千次阅读 2016-07-03 16:25:26
    这个Java NIO的Files类(java.nio.file.Files)提供了数个方法中文件系统中操作文件。这个Java NIO的Files类教程将会覆盖这些方法的大部分通用方法的使用。这个类包含了许多的方法,所以也可以核对这个JavaDoc,如果...

    最后更新:2015-04-15

    这个Java NIO的Files类(java.nio.file.Files)提供了数个方法中文件系统中操作文件。这个Java NIO的Files类教程将会覆盖这些方法的大部分通用方法的使用。这个类包含了许多的方法,所以也可以核对这个JavaDoc,如果你需要一个没有在这里描述的方法。这个Files类只是可能为了它仍然有一个方法。

    这个java.nio.file.Files类同java.nio.file.Path实例一起工作,以至于你在同Files类工作之前需要理解这个Path类。

    Files.exists()

    这个方法检查给予的这个路径是否在这个文件中。

    去创建一个在文件系统不存在的Path实例是可能的。例如,如果你计划创建一个新的目录,你将会首先创建相应的Path实例,然后创建这个目录。

    因为Path实例可能指向或者可能没有指向存在这个文件系统的路径,你可以使用Files.exists()方法去决定是否他们是(一旦你需要检查那个)。

    这里有一个Java的Files.exists()实例:

    Path path = Paths.get("data/logging.properties");
    
    boolean pathExists =
            Files.exists(path,
                new LinkOption[]{ LinkOption.NOFOLLOW_LINKS});

    这个例子首先创建一个指向这个路径的一个Path实例,我们去检查他是否存在。第二,这个例子使用Path实例作为第一个参数,调用这个Files.exists()方法。

    注意Files.exists的第二个参数。这个参数是一个数组选项,它影响着这个Files.exists是怎么决定文件路径是否存在。在上面的这个例子中,这个数组包括这个LinkOption.NOFOLLOW_LINKS,这个意味着这个Files.exists方法应该不会跟随这个文件系统的符号链接去决定路径是否存在。

    Files.createDirectory()

    这个方法创建一个来自于Path实例的一个新的目录。这里有一个例子:

    Path path = Paths.get("data/subdir");
    
    try {
        Path newDir = Files.createDirectory(path);
    } catch(FileAlreadyExistsException e){
        // the directory already exists.
    } catch (IOException e) {
        //something else went wrong
        e.printStackTrace();
    }


    第一行创建了一个将会去创建的一个目录的Path实例。在try-catch块内部的这个Files.createDirectory()方法使用这个path作为一个参数被调用。如果创建一个目录成功,一个执行这个新创建的路径的Path实例被返回。

    如果这个目录已经存在了,一个java.nio.file.FileAlreadyEXistsException将会抛出。如果其他的出现错误的话,一个IOException可能会抛出,例如,如果所期望的上级目录,新目录不存在的话,一个IOException会抛出。这个上级目录是你想创建的那个新的目录。因此,它意味着这个新目录的上级目录。

    Files.copy()

    这个方法拷贝一个文件从一个路径到另外一个。这里有一个例子:

    Path sourcePath      = Paths.get("data/logging.properties");
    Path destinationPath = Paths.get("data/logging-copy.properties");
    
    try {
        Files.copy(sourcePath, destinationPath);
    } catch(FileAlreadyExistsException e) {
        //destination file already exists
    } catch (IOException e) {
        //something else went wrong
        e.printStackTrace();
    }

    首先,这个例子创建了一个源和目的的Path实例。然后这个例子调用了Files.copy()方法,通过这两个Path实例作为参数。这个将会导致通过源路径的文件引用被拷贝到被目录路径的文件引用中。

    如果这个目的文件已经存在,一个java.nio.file.FileAlreadyEXistsException将会抛出。如果其他的事情出现错误,一个IOException会抛出。例如,如果拷贝文件的这个目录不存在,将会抛出一个IOException。

    覆盖已经存在的文件

    强制的Files.copy()去覆盖已经存在的文件是可能的。这里有一个例子展示怎样通过Files.copy()方法去覆盖已经存在的文件:

    Path sourcePath      = Paths.get("data/logging.properties");
    Path destinationPath = Paths.get("data/logging-copy.properties");
    
    try {
        Files.copy(sourcePath, destinationPath,
                StandardCopyOption.REPLACE_EXISTING);
    } catch(FileAlreadyExistsException e) {
        //destination file already exists
    } catch (IOException e) {
        //something else went wrong
        e.printStackTrace();
    }

    注意Files.copy()方法中的第三个参数。这个参数指明如果目的文件已经存在将会覆盖。

    Files.move()

    这个Java NIO类也包含了一个这样的函数,移动一个文件从一个路径到另外一个路径。移动一个文件就像重命名它一样,移动一个文件既可以移动到不同的目录,还可以同时改变他的名字。是的,这个java.io.File类的renameTo()方法也可以做这个事情,但是现在你也可以在java.nio.file.Files类中做文件移动的功能。

    这里有一个例子:

    Path sourcePath      = Paths.get("data/logging-copy.properties");
    Path destinationPath = Paths.get("data/subdir/logging-moved.properties");
    
    try {
        Files.move(sourcePath, destinationPath,
                StandardCopyOption.REPLACE_EXISTING);
    } catch (IOException e) {
        //moving file failed.
        e.printStackTrace();
    }

    首先源路径和目的路径被创建。这个源路径指向了将要移动的文件,以及整个目的路径指向了这个文件将要移动的目的地。然后Files.move方法被调用了。这个就会导致这个文件将会被移动。

    注意这个方法里面的第三个参数,这个参数告诉这个方法将会覆盖目的路径中任何存在的文件。这个参数实际上是可选择的。

    如果移动文件失败可能会抛出IOException异常。例如,如果一个文件已经存在目的路径中,并且你遗漏了StandardCopyOption.REPLACE_EXISTING这个选项,或者将要移动的这个文件不存在等等。

    Files.delete()

    这个方法可以删除一个文件或者一个目录。这里有一个例子:

    Path path = Paths.get("data/subdir/logging-moved.properties");
    
    try {
        Files.delete(path);
    } catch (IOException e) {
        //deleting file failed
        e.printStackTrace();
    }

    首先创建一个指向要删除的文件的Path实例。然后调用这个删除的方法。如果因为一些原因(例如文件或者目录不存在)删除失败,一个IOException将会抛出。

    Files.walkFileTree()

    这个方法包含了可以递归遍历一个目录树的功能。这个方法携带着一个Path实例和FileVisitor作为参数。这个Path实例指向了你想要遍历的目录。这个FileVisitor是中遍历期间被调用。

    在我解释这个遍历是如何工作的之前,这里首先有一个FileVisitor接口:

    public interface FileVisitor {
    
        public FileVisitResult preVisitDirectory(
            Path dir, BasicFileAttributes attrs) throws IOException;
    
        public FileVisitResult visitFile(
            Path file, BasicFileAttributes attrs) throws IOException;
    
        public FileVisitResult visitFileFailed(
            Path file, IOException exc) throws IOException;
    
        public FileVisitResult postVisitDirectory(
            Path dir, IOException exc) throws IOException {
    
    }

    你不得不自己去实现FileVisitor接口,以及传递你实现的一个实例到walkFileTree方法中。你的FileVisitor实现的每一个方法中目录遍历期间的不同时间将会被调用。如果你不想去实现这些所有的方法,你可以继承SimpleFileVisitor类,这个类里面包含了FileVisitor接口所有方法的默认实现。

    这里有一个walkFileTree的例子:

    Files.walkFileTree(path, new FileVisitor<Path>() {
      @Override
      public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOException {
        System.out.println("pre visit dir:" + dir);
        return FileVisitResult.CONTINUE;
      }
    
      @Override
      public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
        System.out.println("visit file: " + file);
        return FileVisitResult.CONTINUE;
      }
    
      @Override
      public FileVisitResult visitFileFailed(Path file, IOException exc) throws IOException {
        System.out.println("visit file failed: " + file);
        return FileVisitResult.CONTINUE;
      }
    
      @Override
      public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException {
        System.out.println("post visit directory: " + dir);
        return FileVisitResult.CONTINUE;
      }
    });

    在FileVisitor实现的每一个方法中目录遍历期间的不同时间将会被调用:

    这个preVisitDirectory() 方法将会中访问任何目录之前会被调用。这个 postVisitDirectory()方法是中访问目录之后被调用。

    这个visitFile()方法是中每一个文件访问期间会被调用,它对于目录是不会被调用的--只是相对文件。这个visitFileFailed()方法一旦访问文件失败将会被调用。例如,如果你没有正确的权限,或者是其他事情出错了。

    四个方法中的每一个都返回了一个FileVisitResult 枚举实例。这个枚举实例包含下面四个选项:

    • CONTINUE
    • TERMINATE
    • SKIP_SIBLINGS
    • SKIP_SUBTREE
    通过返回的值去决定接下来这个方法应该怎么走。
    CONTINUE意味着意味着这个文件将会正常的继续访问下去。
    TERMINATE意味着这个文件的访问现在将会终止。
    SKIP_SIBLINGS意味着这个文件的访问将会继续,但是不会访问这个文件或者目录的兄弟节点。
    SKIP_SUBTREE意味着这个文件的访问将会继续,但是不会访问这个目录的条目。这个值只是如果从 preVisitDirectory()  返回就会有这个功能。如果从其他任何方法返回,他将会作为一个CONTINUE被解释使用。

    搜索文件
    这里有一个walkFileTree方法,它继承了 SimpleFileVisitor  去寻找README.txt的文件:
    Path rootPath = Paths.get("data");
    String fileToFind = File.separator + "README.txt";
    
    try {
      Files.walkFileTree(rootPath, new SimpleFileVisitor<Path>() {
        
        @Override
        public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
          String fileString = file.toAbsolutePath().toString();
          //System.out.println("pathString = " + fileString);
    
          if(fileString.endsWith(fileToFind)){
            System.out.println("file found at path: " + file.toAbsolutePath());
            return FileVisitResult.TERMINATE;
          }
          return FileVisitResult.CONTINUE;
        }
      });
    } catch(IOException e){
        e.printStackTrace();
    }

    递归的删除目录
    walkFileTree方法也可以用来删除所有文件的一个目录以及它里面的子目录。如果它是空的,这个Files.delete()方法将只是删除一个目录。通过穿行所有的目录以及删除所有的文件(在visitFile()里面)在每一个目录中,并且删除目录本身之后(在 postVisitDirectory()里面),你可以删除一个带有所有子目录和文件的一个目录。这里有一个递归删除目录的一个例子:
    Path rootPath = Paths.get("data/to-delete");
    
    try {
      Files.walkFileTree(rootPath, new SimpleFileVisitor<Path>() {
        @Override
        public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
          System.out.println("delete file: " + file.toString());
          Files.delete(file);
          return FileVisitResult.CONTINUE;
        }
    
        @Override
        public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException {
          Files.delete(dir);
          System.out.println("delete dir: " + dir.toString());
          return FileVisitResult.CONTINUE;
        }
      });
    } catch(IOException e){
      e.printStackTrace();
    }

    在Files类里面的额外的方法
    这个java.nio.file.Files类包含了很多其他有用的功能,例如像创建符号链接的功能,决定文件大小的功能,设置文件权限的功能等等。你可以去查看这个类的Java文档去获取这些方法的更多信息。

    翻译地址:http://tutorials.jenkov.com/java-nio/files.html

    展开全文
  • nio_javanio_NIO_源码

    2021-09-30 09:09:31
    java nio 方面知识,适合对nio感兴趣的开发人员
  • Java NIO系列教程(十二) Java NIO与IO

    千次阅读 2017-07-20 10:38:32
    转载自并发编程网 – ifeve.com本文链接地址: Java NIO系列教程(十二) Java NIO与IO当学习了Java NIO和IO的API后,一个问题马上涌入脑海:我应该何时使用IO,何时使用NIO呢?在本文中,我会尽量清晰地解析Java NIO...
  • JavaNIO chm帮助文档

    2017-10-09 17:20:10
    Java NIO系列教程(一) Java NIO 概述 Java NIO系列教程(二) Channel Java NIO系列教程(三) Buffer Java NIO系列教程(四) Scatter/Gather Java NIO系列教程(五) 通道之间的数据传输 Java NIO系列教程(六)...
  • Java nio源码

    2016-10-07 17:32:56
    Java nio源码
  • Java Nio 十五、Java NIO Path

    千次阅读 2016-06-26 16:54:18
    这个Java Path接口是中Java 6或者Java 7中Java NIO 2更新的一部分。这个Java Path接口中Java 7中被添加到了Java NIO中。这个Path接口被放置到了java.nio.file包中,以至于这个Java Path的完整定义名称是:java.nio....
  • Java NIO系列教程

    2017-11-19 13:27:16
    Java NIO系列教程 Java NIO Channel Buffer Selector SocketChannel
  • JavaNIO教程高清

    2018-04-07 23:29:22
    JavaNIO能够让读者快速的学习JavaNIO相关知识,讲解详细
  • java NIO教程

    2018-09-28 10:05:03
    java NIO高清电子书,新的,无阻塞的IO,主要面向缓冲区的。
  • Java NIO总结

    2018-05-05 15:12:27
    Java NIO的总结, 对于新人入门理解很好, 使用Markdown编写

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 202,342
精华内容 80,936
关键字:

javanio

java 订阅