首页 > 编程语言> > NIO编程---通道（Channel）

NIO编程---通道（Channel）

2019-02-15 14:48:44 作者：互联网

**版权声明：本文为小斑马伟原创文章，转载请注明出处！
通道（Channel）：由java.nio.channels 包定义的。Channel 表示IO 源与目标打开的连接。Channel 类似于传统的“流”。只不过Channel 本身不能直接访问数据，Channel 只能与Buffer 进行交互。

Java 为Channel 接口提供的最主要实现类如下：

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

获取通道
获取通道的一种方式是对支持通道的对象调用getChannel() 方法。支持通道的类如下：
FileInputStream
FileOutputStream
RandomAccessFile
DatagramSocket
Socket
ServerSocket
获取通道的其他方式是使用Files 类的静态方newByteChannel() 获取字节通道。或者通过通道的静态方法open() 打开并返回指定通道。
将Buffer 中数据写入Channel

从Channel 读取数据到Buffer

//利用通道完成文件的复制（非直接缓冲区）

@Test
public void test1(){//10874-10953
    long start = System.currentTimeMillis();
    
    FileInputStream fis = null;
    FileOutputStream fos = null;
    //①获取通道
    FileChannel inChannel = null;
    FileChannel outChannel = null;
    try {
        fis = new FileInputStream("d:/1.mkv");
        fos = new FileOutputStream("d:/2.mkv");
        
        inChannel = fis.getChannel();
        outChannel = fos.getChannel();
        
        //②分配指定大小的缓冲区
        ByteBuffer buf = ByteBuffer.allocate(1024);
        
        //③将通道中的数据存入缓冲区中
        while(inChannel.read(buf) != -1){
            buf.flip(); //切换读取数据的模式
            //④将缓冲区中的数据写入通道中
            outChannel.write(buf);
            buf.clear(); //清空缓冲区
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if(outChannel != null){
            try {
                outChannel.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        
        if(inChannel != null){
            try {
                inChannel.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        
        if(fos != null){
            try {
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        
        if(fis != null){
            try {
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    
    long end = System.currentTimeMillis();
    System.out.println("耗费时间为：" + (end - start));
    
}

//使用直接缓冲区完成文件的复制(内存映射文件)
@Test
public void test2() throws IOException{//2127-1902-1777
    long start = System.currentTimeMillis();
    
    FileChannel inChannel = FileChannel.open(Paths.get("d:/1.mkv"), StandardOpenOption.READ);
    FileChannel outChannel = FileChannel.open(Paths.get("d:/2.mkv"), StandardOpenOption.WRITE, StandardOpenOption.READ, StandardOpenOption.CREATE);
    
    //内存映射文件
    MappedByteBuffer inMappedBuf = inChannel.map(MapMode.READ_ONLY, 0, inChannel.size());
    MappedByteBuffer outMappedBuf = outChannel.map(MapMode.READ_WRITE, 0, inChannel.size());
    
    //直接对缓冲区进行数据的读写操作
    byte[] dst = new byte[inMappedBuf.limit()];
    inMappedBuf.get(dst);
    outMappedBuf.put(dst);
    
    inChannel.close();
    outChannel.close();
    
    long end = System.currentTimeMillis();
    System.out.println("耗费时间为：" + (end - start));
}

分散(Scatter)和聚集(Gather)
分散读取（Scattering Reads）是指从Channel 中读取的数据“分散”到多个Buffer 中。

注意：按照缓冲区的顺序，从Channel 中读取的数据依次将Buffer 填满。
聚集写入（Gathering Writes）是指将多个Buffer 中的数据“聚集”到Channel。

注意：按照缓冲区的顺序，写入position 和limit 之间的数据到Channel 。

//分散和聚集
@Test
public void test4() throws IOException{
    RandomAccessFile raf1 = new RandomAccessFile("1.txt", "rw");
    
    //1. 获取通道
    FileChannel channel1 = raf1.getChannel();
    
    //2. 分配指定大小的缓冲区
    ByteBuffer buf1 = ByteBuffer.allocate(100);
    ByteBuffer buf2 = ByteBuffer.allocate(1024);
    
    //3. 分散读取
    ByteBuffer[] bufs = {buf1, buf2};
    channel1.read(bufs);
    
    for (ByteBuffer byteBuffer : bufs) {
        byteBuffer.flip();
    }
    
    System.out.println(new String(bufs[0].array(), 0, bufs[0].limit()));
    System.out.println("-----------------");
    System.out.println(new String(bufs[1].array(), 0, bufs[1].limit()));
    
    //4. 聚集写入
    RandomAccessFile raf2 = new RandomAccessFile("2.txt", "rw");
    FileChannel channel2 = raf2.getChannel();
    
    channel2.write(bufs);
}

将数据从源通道传输到其他Channel 中：

//通道之间的数据传输(直接缓冲区)

 @Test
public void test3() throws IOException{
    FileChannel inChannel = FileChannel.open(Paths.get("d:/1.mkv"), StandardOpenOption.READ);
    FileChannel outChannel = FileChannel.open(Paths.get("d:/2.mkv"), StandardOpenOption.WRITE, StandardOpenOption.READ, StandardOpenOption.CREATE);
    
    //inChannel.transferTo(0, inChannel.size(), outChannel);
    outChannel.transferFrom(inChannel, 0, inChannel.size());
    
    inChannel.close();
    outChannel.close();
}

FileChannel 的常用方法

字符集：Charset

1 编码：字符串 -> 字节数组

2解码：字节数组 -> 字符串

 //字符集
@Test
public void test6() throws IOException{
 Charset cs1 = Charset.forName("GBK");
 
 //获取编码器
 CharsetEncoder ce = cs1.newEncoder();
 
 //获取解码器
 CharsetDecoder cd = cs1.newDecoder();
 
 CharBuffer cBuf = CharBuffer.allocate(1024);
 cBuf.put("尚硅谷威武！");
 cBuf.flip();
 
 //编码
 ByteBuffer bBuf = ce.encode(cBuf);
 
 for (int i = 0; i < 12; i++) {
     System.out.println(bBuf.get());
 }
 
 //解码
 bBuf.flip();
 CharBuffer cBuf2 = cd.decode(bBuf);
 System.out.println(cBuf2.toString());
 
 System.out.println("------------------------------------------------------");
 
 Charset cs2 = Charset.forName("GBK");
 bBuf.flip();
 CharBuffer cBuf3 = cs2.decode(bBuf);
 System.out.println(cBuf3.toString());
}

@Test
public void test5(){
    Map<String, Charset> map = Charset.availableCharsets();
 
    Set<Entry<String, Charset>> set = map.entrySet();
 
    for (Entry<String, Charset> entry : set) {
        System.out.println(entry.getKey() + "=" + entry.getValue());
 }
}

作者：ZebraWei
链接：https://www.jianshu.com/p/fe526297e659
來源：简书
简书著作权归作者所有，任何形式的转载都请联系作者获得授权并注明出处。

标签：NIO,outChannel,编程,System,FileChannel,inChannel,缓冲区,Channel
来源： https://www.cnblogs.com/kakaisgood/p/10383599.html