3.通道 Channel

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

Channel 类似于传统的 ‘流’。只不过 Channel 本身不能直接访问数据，Channel只能与Buffer进行交互

二、 /*通道的主要实现类*/

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

　　FileChannel：用于读取、写入、映射和操作文件的通道

　　SocketChannel：通过TCP 读写网络中的数据

　　ServerSocketChannel：可以监听新进来的TCP连接，对每一个新进来的连接都会创建一个 SocketChannel

三、 /*如何获取通道*/

获取通道

　　* 1.Java针对 支持通道的类提供了 getChannel()方法

　　　　* 本地IO：

　　　　　　* FileInputStream/FileOutputStream

　　　　　　* RandomAccessFile

　　　　* 网络IO：

　　　　　　* Socket

　　　　　　* ServerSocket

　　　　　　* DatagramSocket

　　2.在 JDK1.7 中 的 NIO.2 针对各个通道提供了静态方法 open()

　　3.在 JDK1.7 中 的 NIO.2 的 File 工具类的newByteChannel()

利用通道进行数据传输

四、 /*通道之间的数据传输*/

　　transferForm() 将数据从源通道 传输到其他 Channel中

　　transferTo() 其他 Channel 从 原通道中 获取数据

　　

五、 /*分散（Scatter） 与 聚集（Gather）*/

　　分散读取（Scattering Reads）：将通道中的数据分散到多个缓冲区

　　聚集写入（Gathering Writes）：将多个缓冲区中的 数据 聚集到通道中

　　
六、 /*字符集：Charset*/

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

　　解码: 字节数组 -> 字符串
　　

 /*
  * 一、通道（Channel）：用于源节点 与目标节点的连接 ，在java nio 中 负责缓冲区中数据的传输。Channel 本身不存储数据，因此需要配合缓冲区进行传输
  *
  * 二、通道的主要实现类
  *     java.nio.channels.Channel 接口
  *         |--FileChannel
  *         |--SocketChannel
  *         |--ServerSocketChannel
  *         |--DatagramChannel
  *
  * 三、获取通道
  * 1.Java针对 支持通道的类提供了 getChannel()方法
  *      本地IO：
  *      FileInputStream/FileOutputStream
  *      RandomAccessFile
  *
  *   网络IO：
  *   Socket
  *   ServerSocket
  *   DatagramSocket
  *
  * 2.在 JDK1.7 中 的 NIO.2 针对各个通道提供了静态方法 open()
  *
  * 3.在 JDK1.7 中 的 NIO.2 的 File 工具类的newByteChannel()
  *
  * 四、通道之间的数据传输
  * transferForm()
  * transferTo()
  *
  * 五、分散（Scatter） 与 聚集（Gather）
  * 分散读取（Scattering Reads）：将通道中的数据分散到多个缓冲区
  * 聚集写入（Gathering Writes）：将多个缓冲区中的 数据 聚集到通道中
  *
  * 六、字符集：Charset
  * 编码：字符串 -> 字节数组
  * 解码: 字节数组 -> 字符串
  *
  * */
 public class TestChannel {

     //使用指定字符集 进行编码 和 解码
     @Test
     public void test6() throws IOException {
         //1.选择字符集
         Charset charset1 = Charset.forName("GBK");

         //2.获取编码器
         CharsetEncoder encoder = charset1.newEncoder();

         //3.获取解码器
         CharsetDecoder decoder = charset1.newDecoder();

         //4.创建字符串缓冲区，放入需要编码的字符串
         CharBuffer charBuffer = CharBuffer.allocate(1024);
         charBuffer.put("迅雷影音");

         //5.对字符串进行编码  （编码：字符串 -> 字节数组）
         charBuffer.flip();    //操作字符串缓冲区，解码字符串之前 需要 flip 一下
         ByteBuffer byteBuffer = encoder.encode(charBuffer);

         // byteBuffer 此时 是 初始状态，即position 是0
         //调用 这个 for ，每 get 一次，position + 1
         //这样才能 在 flip 之后， 解码 需要操作的数据
         for(int i = 0;i<8;i++) {
             System.out.println(byteBuffer.position());
             System.out.println(byteBuffer.get());
         }

         //6.对字节数组进行解码 （解码: 字节数组 -> 字符串）
         byteBuffer.flip();    //操作字节缓冲区，解码字节数组之前 需要 flip 一下
         CharBuffer charBuffer2 = decoder.decode(byteBuffer);

         //打印解码后的数据
         System.out.println(charBuffer2.toString());
     }

     //5.显示所有的字符集
     @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());
         }
     }

     //4.分散和 聚集 （多个缓冲区）
     @Test
     public void test4() throws IOException {
         // "rw" 是指 具有read 和 write 的 权限
         RandomAccessFile raf = new RandomAccessFile("1.txt", "rw");
         //1.获取通道
         FileChannel channel1 = raf.getChannel();

         //2.分配指定大小的缓冲区 (多个)
         ByteBuffer buf1 = ByteBuffer.allocate(100);
         ByteBuffer buf2 = ByteBuffer.allocate(1024);
         ByteBuffer[] bufs = {buf1,buf2};

         //4.聚集写入
         RandomAccessFile raf2 = new RandomAccessFile("2.txt","rw");
         FileChannel channel2 = raf2.getChannel();

         //3.分散读取
         while(channel1.read(bufs)!= -1) {
             for(ByteBuffer buf:bufs) {
                 buf.flip();
             }
             //4.聚集写入
             channel2.write(bufs);

             System.out.println("-----------------缓冲区1---------------");
             System.out.println(new String(bufs[0].array(),0,bufs[0].limit()) );
             System.out.println("-----------------缓冲区1---------------");

             System.out.println("-----------------缓冲区2---------------");
             System.out.println(new String(bufs[1].array(),0,bufs[1].limit()));
             System.out.println("-----------------缓冲区2---------------");

             for(ByteBuffer buf:bufs) {
                 buf.clear();
             }

         }            

     }

     //3.通道之间的数据传输
     @Test
     public void test3() throws Exception {
         FileChannel inChannel = FileChannel.open(Paths.get("1.jpg"), StandardOpenOption.READ);
         FileChannel outChannel = FileChannel.open(Paths.get("2.jpg"), StandardOpenOption.READ,StandardOpenOption.WRITE,StandardOpenOption.CREATE);

         //直接使用transferTo 或者 transferFrom 完成通道之间的数据传输
         inChannel.transferTo(0, inChannel.size(), outChannel);
         outChannel.transferFrom(inChannel, 0, inChannel.size());

         inChannel.close();
         outChannel.close();
     }

     //2.使用直接缓冲区完成文件的复制（内存映射文件）(这种方式效率更高)
     //会出现的问题 ：文件传输已经完成，但是程序仍然没有结束，因为 java 虚拟机无法及时 对 内存映射文件进行  进行释放，必须要等指向映射文件的那个变量被回收
     @Test
     public void test2() {

         long start = System.currentTimeMillis();

         FileChannel inChannel = null;
         FileChannel outChannel = null;
         MappedByteBuffer inMapperBuf = null;
         MappedByteBuffer outMapperBuf = null;

         try {
             //使用 FileChannel 的 open方法 （可以不用创建流就可以得到通道）
             inChannel = FileChannel.open(Paths.get("1.jpg"), StandardOpenOption.READ);
             outChannel = FileChannel.open(Paths.get("2.jpg"), StandardOpenOption.READ,StandardOpenOption.WRITE,StandardOpenOption.CREATE);

             //内存映射文件 (也是一个 缓冲区 ，继承自 ByteBuffer,直接缓冲区也只能使用 ByteBuffer)
             inMapperBuf = inChannel.map(MapMode.READ_ONLY,0 , inChannel.size());
             outMapperBuf = outChannel.map(MapMode.READ_WRITE,0 , inChannel.size());

         } catch (IOException e) {
             e.printStackTrace();
         }  

         //直接对缓冲区进行数据读写操作
         byte[] bytes = new byte[inMapperBuf.limit()];
         inMapperBuf.get(bytes);
         outMapperBuf.put(bytes);

         try {
             if(inChannel != null) {
                 inChannel.close();
             }
             if(outChannel != null) {
                 outChannel.close();
             }
         } catch (IOException e) {
             e.printStackTrace();
         }

         long end = System.currentTimeMillis();
         System.out.println("花费：" +  (end-start));

     }

     //1.利用通道完成文件的复制
     @Test
     public void test1() {
         long start = System.currentTimeMillis();

         FileInputStream fis = null;
         FileOutputStream fos = null;
         try {
             fis = new FileInputStream("1.jpg");
             fos = new FileOutputStream("2.jpg");
         } catch (FileNotFoundException e) {
             e.printStackTrace();
         }

         //1.获取流对应的 通道
         FileChannel inChannel = fis.getChannel();
         FileChannel outChannel = fos.getChannel();

         //2.分配指定大小的缓冲区
         ByteBuffer buffer = ByteBuffer.allocate(1024);

         //3.将通道中的数据存入缓存区
         try {
             //read 方法，从Channel 中读取数据到 ByteBuffer （即往 缓冲区中 put 数据），所以不用 flip
             while(inChannel.read(buffer) != -1) {
                 buffer.flip();  //切换到读取数据模式            

                 //4.将缓存区中的数据写入通道中 （需要get 出 缓冲区中的 数据 ，所以需要 flip）
                 outChannel.write(buffer);
                 buffer.clear();  //清空缓冲区，使其继续循环
             }
         } catch (IOException e) {
             e.printStackTrace();
         } finally {
             if(inChannel != null) {
                 try {
                     inChannel.close();
                 } catch (IOException e) {
                     e.printStackTrace();
                 }
             }
             if(outChannel != null) {
                 try {
                     outChannel.close();
                 } catch (IOException e) {
                     e.printStackTrace();
                 }
             }
             if(fis != null) {
                 try {
                     fis.close();
                 } catch (IOException e) {
                     e.printStackTrace();
                 }
             }
             if(fos != null) {
                 try {
                     fos.close();
                 } catch (IOException e) {
                     e.printStackTrace();
                 }
             }
         }

         long end = System.currentTimeMillis();
         System.out.println("花费：" +  (end-start));
     }

 }