NIO--通道（Channel）

缺乏、安全感 2021-08-26 18:39 516阅读 0赞

### 通道（Channel） ###

由 java.nio.channels 包定义 的。Channel 表示 IO 源与目标打开的连接。 Channel 类似于传统的“流”。只不过 Channel 本身不能直接访问数据，Channel 只能与 Buffer 进行交互。

通道可以用来读取和写入数据，通道类似于之前的输入/输出流，但是程序不会直接操作通道的，所有的内容都是先读到或写入到缓冲区中，再通过缓冲区中取得获写入的。

通道与传统的流操作不同，传统的流操作是分为输入或输出流的，而通道本身是双向操作的，即可以完成输入也可以完成输出。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NvbGRfX19wbGF5_size_16_color_FFFFFF_t_70]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NvbGRfX19wbGF5_size_16_color_FFFFFF_t_70 1]

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

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

### 获取通道 ###

获取通道的一种方式是对支持通道的对象调用 getChannel() 方法。支持通道的类如下:

*  FileInputStream
 *  FileOutputStream
 *  RandomAccessFile
 *  DatagramSocket
 *  Socket
 *  ServerSocket

获取通道的其他方式是使用 Files 类的静态方法 newByteChannel() 获 取字节通道。或者通过通道的静态方法 open() 打开并返回指定通道。

### 通道的数据传输 ###

*  将 Buffer 中数据写入 Channel 例如:

//将Buffer中数据写入Channel中
    int bytesWritten = inChannel.write(buf);

*  从 Channel 读取数据到 Buffer 例如:

//从Channel读取数据到Buffer中
    int bytesRead = inChannel.read(buf);

### 分散（Scatter）和聚集（Gather） ###

分散读取(Scattering Reads)是指从 Channel 中读取的数据“分 散”到多个 Buffer 中。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NvbGRfX19wbGF5_size_16_color_FFFFFF_t_70 2]  
注意:按照缓冲区的顺序，从 Channel 中读取的数据依次将 Buffer 填满。

聚集写入(Gathering Writes)是指将多个 Buffer 中的数据“聚集” 到 Channel。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NvbGRfX19wbGF5_size_16_color_FFFFFF_t_70 3]

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

### transferFrom() ###

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NvbGRfX19wbGF5_size_16_color_FFFFFF_t_70 4]

### transferTo() ###

将数据从源通道传输到其他 Channel 中:  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NvbGRfX19wbGF5_size_16_color_FFFFFF_t_70 5]

### Channel接口定义的方法 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NvbGRfX19wbGF5_size_16_color_FFFFFF_t_70 6]

### FileChannel的常用方法 ###

FileChannel是Channel的子类，可以进行文件的读写操作。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NvbGRfX19wbGF5_size_16_color_FFFFFF_t_70 7]

### 测试 ###

package com.atguigu.nio;
    
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.RandomAccessFile;
    import java.nio.ByteBuffer;
    import java.nio.CharBuffer;
    import java.nio.MappedByteBuffer;
    import java.nio.channels.FileChannel;
    import java.nio.channels.FileChannel.MapMode;
    import java.nio.charset.CharacterCodingException;
    import java.nio.charset.Charset;
    import java.nio.charset.CharsetDecoder;
    import java.nio.charset.CharsetEncoder;
    import java.nio.file.Paths;
    import java.nio.file.StandardOpenOption;
    import java.util.Map;
    import java.util.Map.Entry;
    import java.util.Set;
    
    import org.junit.Test;
    
    /* * 一、通道（Channel）：用于源节点与目标节点的连接。在 Java NIO 中负责缓冲区中数据的传输。Channel 本身不存储数据，因此需要配合缓冲区进行传输。 * * 二、通道的主要实现类 * java.nio.channels.Channel 接口： * |--FileChannel * |--SocketChannel * |--ServerSocketChannel * |--DatagramChannel * * 三、获取通道 * 1. Java 针对支持通道的类提供了 getChannel() 方法 * 本地 IO： * FileInputStream/FileOutputStream * RandomAccessFile * * 网络IO： * Socket * ServerSocket * DatagramSocket * * 2. 在 JDK 1.7 中的 NIO.2 针对各个通道提供了静态方法 open() * 3. 在 JDK 1.7 中的 NIO.2 的 Files 工具类的 newByteChannel() * * 四、通道之间的数据传输 * transferFrom() * transferTo() * * 五、分散(Scatter)与聚集(Gather) * 分散读取（Scattering Reads）：将通道中的数据分散到多个缓冲区中 * 聚集写入（Gathering Writes）：将多个缓冲区中的数据聚集到通道中 * * 六、字符集：Charset * 编码：字符串 -> 字节数组 * 解码：字节数组 -> 字符串 * */
    public class TestChannel { 
    	
    	//字符集
    	@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());
    		}
    	}
    	
    	//分散和聚集
    	@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);
    	}
    	
    	//通道之间的数据传输(直接缓冲区)
    	@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();
    	}
    	
    	//使用直接缓冲区完成文件的复制(内存映射文件)
    	@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));
    	}
    	
    	//利用通道完成文件的复制（非直接缓冲区）
    	@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));
    		
    	}
    
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NvbGRfX19wbGF5_size_16_color_FFFFFF_t_70]: /images/20210813/27331bd3ba9943a09c7cb4943291f3c7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NvbGRfX19wbGF5_size_16_color_FFFFFF_t_70 1]: /images/20210813/109e518b3eb04e7c840db688b7d323f4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NvbGRfX19wbGF5_size_16_color_FFFFFF_t_70 2]: /images/20210813/51ae8e9e6e2d4ab1aaa5e96e380e7616.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NvbGRfX19wbGF5_size_16_color_FFFFFF_t_70 3]: /images/20210813/5a0577218a30424c811103d0b5056f4d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NvbGRfX19wbGF5_size_16_color_FFFFFF_t_70 4]: /images/20210813/d9879f2b06d449c48abd0248f61cd78b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NvbGRfX19wbGF5_size_16_color_FFFFFF_t_70 5]: /images/20210813/e61784f88ad24d9f8e368ee8f44b0e0f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NvbGRfX19wbGF5_size_16_color_FFFFFF_t_70 6]: /images/20210813/9c61d1191ba64fa6bdbb2ed72fe255dc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NvbGRfX19wbGF5_size_16_color_FFFFFF_t_70 7]: /images/20210813/ba105b408d9949589cdf97dd51fd9303.png