NIO(二)：Channel通道

一.Channel概述

channel（通道）：进行IO的连接通道，为NIO的几个核心（Buffer，selector，channel）之一，相比于IO的stream具有较高的性能。

IO	单向传输
NIO	异步双向传输

使用时需要和buffer（缓冲区一切使用）,将数据暂存入Buffer中，通过channel通道连接传输buffer以此传输数据。

二.channel继承结构

其中主要的几个实现类如下：

---

• FileChannel: 本地文件传输通道

• SocketChannel: 通过TCP传输通道

• ServerSocketChannel:　　监听新的TCP连接，并创建一个新的SocketChannel，通过.open（）方法进行创建。

• DatagramChannel: 发送和接收UDP数据包的channel

　　通过Buffer的两种传输数据方式:

---

• 非直接缓冲区传输数据 - - >    ByteBuffer.allocate()方法;

• 直接缓冲区传输数据 - - >  ByteBuffer.allocateDriect()方法;

　　几种获取channel的方式：

---

• 本地通过FileInPutStream/FileOutPutStream 使用getChannel（）方法获取；

• 本地FileChannel 的open（）方法获取；

• 本地RandomAccessFile的getChannel（）方法获取；

• 网络socket、ServerSocket、DatagramSocket

三.FileInputStream获取通道方式

非直接缓冲区方式，再程序与本地磁盘中，并不是直接进行数据的交流。而是在用户和内核之间通过复制的形式。每次read 和write 都在中间进行复制。程序可以控制数据。

流程：FileInputStream写入文件  -->   FileOutputStream的getChannel（）获取通道  -->  开辟一个具有一定容量的buffer缓冲区  -->  将缓冲区的内容通过channel传输  -->  关闭流

 //使用非直接缓冲区 传输数据
     //通过流的方式
     @Test
     public void NoDirect(){

         FileInputStream fileInputStream = null;
         FileOutputStream fileOutputStream =null;
         FileChannel fileInputStreamChannel = null;
         FileChannel fileOutputStreamChannel = null;
         long start = 0;

         try {
             //查看耗时
              start = System.currentTimeMillis();

             //写入
             fileInputStream = new FileInputStream("D:/DataTestFile/1.zip");
             //读取到
             fileOutputStream = new FileOutputStream("D:/DataTestFile/2.zip");

             //使用通道进行文件传输
             //在传输前先获取传输通道channel
              fileInputStreamChannel = fileInputStream.getChannel();
              fileOutputStreamChannel = fileOutputStream.getChannel();

             //将数据写入缓冲区 -->   开辟缓冲区容量  --> 后使用通道传输
             ByteBuffer buf = ByteBuffer.allocate(1024);

             //将通道中的数据送入缓冲区  数据为空时跳出循环
             while(fileInputStreamChannel.read(buf) != -1){
                 //切换读写模式
                 buf.flip();
                 //读出缓冲区的数据写入通道中
                 fileOutputStreamChannel.write(buf);
                 //清空缓冲区
                 buf.clear();
             }

         } catch (FileNotFoundException e) {
             e.printStackTrace();
         } catch (IOException e) {
             e.printStackTrace();
         }
         //最终需要执行的步骤 需要关闭流  和通道
         finally {
             //写入流关闭
             if (fileInputStream != null){
                 try {
                     fileInputStream.close();
                 } catch (IOException e) {
                     e.printStackTrace();
                 }
             }
             //读出流关闭
             if (fileOutputStream != null){
                 try {
                     fileOutputStream.close();
                 } catch (IOException e) {
                     e.printStackTrace();
                 }
             }
            if (fileInputStreamChannel != null){
                try {
                    fileInputStreamChannel.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
             //读出通道关闭
             if (fileOutputStreamChannel != null){
                 try {
                     fileOutputStreamChannel.close();
                 } catch (IOException e) {
                     e.printStackTrace();
                 }
             }
             //查看耗时
             long end = System.currentTimeMillis();
             System.out.println("总共耗时："+(end-start));
         }

     }

测试数据大小

使用IO流的方式(FileInPutStream/FileOutPutStream)写入文件或者读取文件，FileInPutStream实现方式：（FileOutPutStream 与之类似）

   public FileInputStream(String name) throws FileNotFoundException {
         this(name != null ? new File(name) : null);
     }

　　//获取本地文件
 public File(String pathname) {
         if (pathname == null) {
             throw new NullPointerException();
         }
         this.path = fs.normalize(pathname);
         this.prefixLength = fs.prefixLength(this.path);
     }

三.FileChannel方式+mapped*ByteBuffer（内存映射文件）传输数据

直接传输方式，在本地形成一个本地映射文件，程序通过本地映射直接传输给物理磁盘，没有复制的操作。在传输速度上优于非直接的传输

但是程序的数据一旦交给映射文件，程序将无法控制数据。

流程： FileChannel.open 获取通道 (写入和读取文件，并规定Read  Or Write ，create等方式) - - > .map(将通道的一个区域映射到内存中)  - - >  将映射文件中的数据存入数组，写入或读出到MappedByteBuffer

  /*
     * 通过直接缓冲区的方式进行传输数据
     * 通过使用映射文件的方式MappedByteBuffer传输
     * */
     @Test
     public void Driect(){

         FileChannel fileInChannel = null;
         FileChannel fileOutChannel = null;
         MappedByteBuffer mappedInByteBuffer = null;
         MappedByteBuffer mappedOutByteBuffer = null;
         long start = 0;

         try {
             //耗时查询
              start = System.currentTimeMillis();

              fileInChannel = FileChannel.open(Paths.get("D:/DataTestFile/1.zip"), StandardOpenOption.READ,StandardOpenOption.WRITE);
              fileOutChannel = FileChannel.open(Paths.get("D:/DataTestFile/2.zip"), StandardOpenOption.READ, StandardOpenOption.WRITE,StandardOpenOption.CREATE);

             //使用内存映射文件 ，杜绝非直接缓存区中的通过用户态 和核心态的相互复制影响性能的问题
             //直接通过本地映射文件。但是一旦传输后，不归程序所管理
              mappedInByteBuffer = fileInChannel.map(FileChannel.MapMode.READ_ONLY, 0, fileInChannel.size());
              mappedOutByteBuffer = fileOutChannel.map(FileChannel.MapMode.READ_WRITE, 0, fileInChannel.size());

             //直接对缓冲区进行读写操作
             //定义一个数组，将映射文件的数据存入其中
             byte[] bt = new byte[mappedInByteBuffer.limit()];
             //先从本地映射文件中读取  后写入传输
             mappedInByteBuffer.get(bt);
             mappedOutByteBuffer.put(bt);

         } catch (IOException e) {
             e.printStackTrace();
         }
         finally {
             if (fileInChannel != null){
                 try {
                     fileInChannel.close();
                 } catch (IOException e) {
                     e.printStackTrace();
                 }
             }
             if (fileOutChannel != null){
                 try {
                     fileOutChannel.close();
                 } catch (IOException e) {
                     e.printStackTrace();
                 }
             }

             //耗时结束查询
             long end = System.currentTimeMillis();
             System.out.println("总共耗时："+(end-start));

         }

相比较于非直接的方式，在相同资源下的第一次传输，性能更高。传输速度更快。

五.分散传输

将一个整体文件，分散成多个部分，使用多缓冲区分别进行分散。

流程：使用RandomAccessFile读取写入文件 - - >  通过RandomAccessFile.getChannel 获取通道 - - >  将两个开辟的缓冲区，存入数组中，并循环读入通道 - - >  转换成可以直观查看的String类型　　

 package com.cllover.nio;

 import org.junit.Test;

 import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.io.RandomAccessFile;
 import java.nio.ByteBuffer;
 import java.nio.channels.FileChannel;

 /*
  * @Author chengpunan
  * @Description //TODO 18609
  * @Date 7:29 PM 7/25/2020
  * @Param
  * @return
  *
  * 分散读写和聚集读写测试类
  * Disperse：分散读写
  * gather： 聚集读写
  **/
 public class DisperseAndGather {

 //    分散读写  将通道中的数据分散到缓冲区中，
     @Test
     public void Disperse(){
         RandomAccessFile randomAccessFile = null;
         FileChannel randomAccessFileChannel = null;

         try {
             //随机访问文件流以RW形式访问某文件
             randomAccessFile = new RandomAccessFile("D:/DataTestFile/1.txt","rw");

             //获取通道
             randomAccessFileChannel = randomAccessFile.getChannel();

             //开辟两个缓冲区
             ByteBuffer byteBuffer100 = ByteBuffer.allocate(100);
             ByteBuffer byteBuffer200 = ByteBuffer.allocate(200);
 
//数值初始化：存入两个缓冲区的数据
41             //分散读取
42             ByteBuffer[] byteBuffer = {byteBuffer100,byteBuffer200};
43
44             //存入读取通道
45             randomAccessFileChannel.read(byteBuffer);
46
47             for (ByteBuffer bf: byteBuffer) {
48                 bf.flip();   //切换读写方式
49             }
             //转换成字符串
             //public String(byte bytes[], int offset, int length)
             System.out.println(new String(byteBuffer[0].array(),0,byteBuffer[0].limit()));
             System.out.println("----------------------------------");
             System.out.println(new String(byteBuffer[1].array(),0,byteBuffer[1].limit()));

         } catch (FileNotFoundException e) {
             e.printStackTrace();
         } catch (IOException e) {
             e.printStackTrace();
         }
         finally {
             if (randomAccessFile != null){
                 try {
                     randomAccessFile.close();
                 } catch (IOException e) {
                     e.printStackTrace();
                 }
             }
             if (randomAccessFileChannel != null){
                 try {
                     randomAccessFileChannel.close();
                 } catch (IOException e) {
                     e.printStackTrace();
                 }
             }
             if (randomAccessFile != null){
                 try {
                     randomAccessFile.close();
                 } catch (IOException e) {
                     e.printStackTrace();
                 }
             }
         }

     }

 }

将单独两个开辟的缓冲区，存入数组之中。存入通道后，用foreach循环遍历index[0]和index[1]缓冲区上的内容，并进行写入。

 //分散读取:数组初始化
             ByteBuffer[] byteBuffer = {byteBuffer100,byteBuffer200};

             //存入读取通道
             randomAccessFileChannel.read(byteBuffer);

             for (ByteBuffer bf: byteBuffer) {
                 bf.flip();   //切换读写方式
             }

资源内容：

运行结果：

聚集写入:

  //聚集写入
             RandomAccessFile randomAccessFile1 = new RandomAccessFile("D:/DataTestFile/2.txt", "rw");
             FileChannel channel = randomAccessFile1.getChannel();
             //将全部内容。将上段代码红色部分，存入数组中的数据直接通过通道写入另一个文件中
             channel.write(byteBuffer);

写入文件后，原本文件中的内容会被覆盖或者丢失。

写入后：

六.总结

channel作为一个连接通道，支持异步传输。

总是基于Buffer缓冲区配合使用。

在传输时，需要在buffer中暂存入数据后开启channel通道，进行读写操作。

下一篇将会写关于网络传输 和 selector的用法。