盘一盘 NIO （二）—— Channel解析
Channel是个啥?
Channel，顾名思义，它就是一个通道。NIO中的所有IO都是从 Channel 开始的。
Channel通道和流非常类似，主要有以下几点区别：
1、流是单向的，通道是双向的，可读可写。
2、流读写是阻塞的，通道可以异步读写。
3、流中的数据可以选择性的先读到缓存中，通道的数据总是要先读到一个缓存Buffer中，或从缓存Buffer中写入。
继承关系图
Channel有两种分类方式。一种是按同步Channel和异步Channel划分，还有一种是按功能划分。
后面我们会主要讲解Channel的几个重要实现，如下所示：
FileChannel： 从文件中读写数据
DatagramChannel： 通过UDP读写网络中的
SocketChannel： 通过TCP读写网络中的，一般是客户端实现
ServerSocketChannel: 允许我们监听TCP链接请求，每个请求会创建会一个SocketChannel，一般是服务器实现
接口方法
public interface Channel extends Closeable { // 判断Channel的开关状态 public boolean isOpen(); // 关闭此Channel public void close() throws IOException; }
FileChanel
FileChannel是一个连接到文件的通道，可以通过文件通道读写文件。众所周知文件通道总是阻塞式的，因此FileChannel无法设置为非阻塞模式。
FileChannel中重要方法，read、write通过其实现类FileChannelImpl实现
// 从这个通道读入一个字节序列到给定的缓冲区 public abstract int read(ByteBuffer dst) throws IOException; // 从这个通道读入指定开始位置和长度的字节序列到给定的缓冲区 public abstract long read(ByteBuffer[] dsts, int offset, int length) throws IOException; // 从这个通道读入一个字节序列到给定的缓冲区 public final long read(ByteBuffer[] dsts) throws IOException { return read(dsts, 0, dsts.length); } // 从给定的缓冲区写入字节序列到这个通道 public abstract int write(ByteBuffer src) throws IOException; // 从给定缓冲区的子序列向该信道写入字节序列 public abstract long write(ByteBuffer[] srcs, int offset, int length) throws IOException; // 从给定的缓冲区写入字节序列到这个通道 public final long write(ByteBuffer[] srcs) throws IOException { return write(srcs, 0, srcs.length); }
FileChannelImpl中read、write方法实现
// read 方法实现 public int read(ByteBuffer var1) throws IOException { this.ensureOpen(); if (!this.readable) { throw new NonReadableChannelException(); } else { synchronized(this.positionLock) { int var3 = 0; int var4 = -1; try { this.begin(); var4 = this.threads.add(); if (!this.isOpen()) { byte var12 = 0; return var12; } else { do { var3 = IOUtil.read(this.fd, var1, -1L, this.nd); } while(var3 == -3 && this.isOpen()); int var5 = IOStatus.normalize(var3); return var5; } } finally { this.threads.remove(var4); this.end(var3 > 0); assert IOStatus.check(var3); } } } } // write方法实现 public int write(ByteBuffer var1) throws IOException { this.ensureOpen(); if (!this.writable) { throw new NonWritableChannelException(); } else { synchronized(this.positionLock) { int var3 = 0; int var4 = -1; byte var5; try { this.begin(); var4 = this.threads.add(); if (this.isOpen()) { do { var3 = IOUtil.write(this.fd, var1, -1L, this.nd); } while(var3 == -3 && this.isOpen()); int var12 = IOStatus.normalize(var3); return var12; } var5 = 0; } finally { this.threads.remove(var4); this.end(var3 > 0); assert IOStatus.check(var3); } return var5; } } }
IOUtil中read、write实现：
// read方法实现 static int read(FileDescriptor var0, ByteBuffer var1, long var2, NativeDispatcher var4) throws IOException { if (var1.isReadOnly()) { throw new IllegalArgumentException("Read-only buffer"); } else if (var1 instanceof DirectBuffer) { return readIntoNativeBuffer(var0, var1, var2, var4); } else { // 申请一块和缓存同大小的ByteBuffer var5 ByteBuffer var5 = Util.getTemporaryDirectBuffer(var1.remaining()); int var7; try { // 读取数据到缓存，底层由NativeDispatcher的read实现。 int var6 = readIntoNativeBuffer(var0, var5, var2, var4); var5.flip(); if (var6 > 0) { // 把数据读取到var1（用户定义的缓存，在jvm中分配内存） var1.put(var5); } var7 = var6; } finally { Util.offerFirstTemporaryDirectBuffer(var5); } return var7; } } // write 方法实现 static int write(FileDescriptor var0, ByteBuffer var1, long var2, NativeDispatcher var4) throws IOException { if (var1 instanceof DirectBuffer) { return writeFromNativeBuffer(var0, var1, var2, var4); } else { int var5 = var1.position(); int var6 = var1.limit(); assert var5 <= var6; int var7 = var5 <= var6 ? var6 - var5 : 0; // 申请一块ByteBuffer，大小为byteBuffer中的limit - position ByteBuffer var8 = Util.getTemporaryDirectBuffer(var7); int var10; try { // 复制byteBuffer中的数据 var8.put(var1); var8.flip(); var1.position(var5); // 把数据写入到文件，底层由NativeDispatcher的write实现 int var9 = writeFromNativeBuffer(var0, var8, var2, var4); if (var9 > 0) { var1.position(var5 + var9); } var10 = var9; } finally { Util.offerFirstTemporaryDirectBuffer(var8); } return var10; } }
小结
1、文件通道不能直接创建，只能通过InputStream、OutputStream或RandomAccessFile等创建对应的文件通道
2、文件通道FileChannel从缓冲区中读取数据，使用read方法
3、文件通道FileChannel的read方法只能读ByteBuffer缓冲区
DatagramChannel
DatagramChannel，使用UDP协议来进行传输。由于不需要建立连接，其实没有客户端服务端的概念，为了便于理解，我们定义其中一端为客户端，一端为服务端
客户端
public static void main(String[] args) throws Exception { // 打开DatagramChannel DatagramChannel datagramChannel = DatagramChannel.open(); // 绑定一个端口发送数据 ByteBuffer byteBuffer = ByteBuffer.wrap("A".getBytes()); int byteSent = datagramChannel.send(byteBuffer, new InetSocketAddress("127.0.0.1", 8000)); System.out.println("Byte sent is: " + byteSent); }
服务端
public static void main(String[] args) throws Exception { // 打开DatagramChannel,绑定一个端口 DatagramChannel datagramChannel = DatagramChannel.open(); datagramChannel.socket().bind(new InetSocketAddress(8000)); while (true) { // 接收数据并输出 ByteBuffer byteBuffer = ByteBuffer.allocate(1024); datagramChannel.receive(byteBuffer); byteBuffer.flip(); if(byteBuffer.hasRemaining()) { System.out.print((char) byteBuffer.get()); } } }
ServerSocketChannel和SocketChannel
ServerSocketChannel是一个可以监听新进来的TCP连接的通道。ServerSocketChannel本身不具备传输数据的能力，而只是负责监听传入的连接和创建新的SocketChannel。
SocketChannel是一个连接到TCP网络套接字的通道。通常SocketChannel在客户端向服务器发起连接请求，每个SocketChannel对象创建时都关联一个对等的Socket对象。同样SocketChannel也可以运行在非阻塞模式下。
可以通过以下2种方式创建SocketChannel：
1、打开一个SocketChannel并连接到互联网上的某台服务器
2、一个新连接到达ServerSocketChannel时，会创建一个SocketChannel
服务端
public static void main(String[] args) throws Exception { // 服务端首先打开ServerSocketChannel，然后绑定一个端口 ServerSocketChannel serverSocketChannel = ServerSocketChannel.open(); serverSocketChannel.socket().bind(new InetSocketAddress(8000)); // 服务端ServerSocketChannel收到连接请求时，返回一个SocketChannel对象 SocketChannel socketChannel = serverSocketChannel.accept(); while(true) { // 把数据从channel中读出来，然后写入到buffer中然后打印 ByteBuffer buffer = ByteBuffer.allocate(128); socketChannel.read(buffer); buffer.flip(); if(buffer.hasRemaining()) { System.out.println((char) buffer.get()); } } }
客户端
public static void main(String[] args) throws Exception { // 客户端建立连接的过程，首先打开SocketChannel，然后连接到服务端 SocketChannel socketChannel = SocketChannel.open(); socketChannel.connect(new InetSocketAddress("127.0.0.1", 8000)); //连接是否建立成功 boolean isConnect = socketChannel.isConnected(); while (true) { // 通过buffer，向channel中写入数据 ByteBuffer buffer = ByteBuffer.allocate(128); buffer.clear(); buffer.put(("A").getBytes()); buffer.flip(); socketChannel.write(buffer); Thread.sleep(1000); } }
