Java NIO之Channel详细理解

蔚落 2023-02-17 03:16 214阅读 0赞

介绍

理解：通道是一个连接I/O服务的管道并提供与该服务交互的方法。

Channel类似于传统的”流”，但是Channel不能直接访问数据，需要和缓冲区Buffer进行交互。

通道和传统流的区别：

  1. 通道可以是双向的，既可以读取数据，又可以写数据到通道。但流的读写通常是单项的

  2. 通道可以异步的读写

  3. 通道不能直接访问数据，需要和Buffer进行交互

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NraDIwMTVqYXZh_size_16_color_FFFFFF_t_70

通道可以简单的分为两大类：文件通道和Socket通道

文件通道

  1.    文件通道的主要实现是FileChannel。文件通道总是阻塞的，因此不能被置于非阻塞模式。

FileChannel的创建

  1.     FileChannel对象不能直接创建。一个FileChannel实例只能通过一个打开的file对象(RandomAccessFil、FileInputStraem、FileOutputStream等)上调用getChannel(0方法获取。调用getChannel()方法返回一个连接到相同文件的FileChannel对象且该FileChannel对象具有于file对象相同的访问权限。

创建FileChannel示例：

  1. //创建一个RandomAccessFile（随机访问文件）对象，
  2.   RandomAccessFile raf=new RandomAccessFile("D:\\test.txt", "rw");
  4.   //通过RandomAccessFile对象的getChannel()方法。FileChannel是抽象类。
  5.   FileChannel inChannel=raf.getChannel();

常用方法 

  1.  package java.nio.channels;
  3.     public abstract class FileChannel extends AbstractChannel implements ByteChannel, GatheringByteChannel, ScatteringByteChannel
  5.     {
  7.         // This is a partial API listing
  8.         // All methods listed here can throw java.io.IOException
  9.         //从FileChannel读取数据
  10.         public abstract int read(ByteBuffer dst)
  11.         public abstract int read (ByteBuffer dst, long position);
  13.         //向FileChannel写数据
  14.         public abstract int write(ByteBuffer src)
  15.         public abstract int write (ByteBuffer src, long position);
  17.         //获取文件大小
  18.         public abstract long size();
  20.         //获取位置
  21.         public abstract long position();
  23.         //设置位置
  24.         public abstract void position (long newPosition);
  26.         //用于文件截取
  27.         public abstract void truncate (long size);
  29.         //将通道里尚未写入磁盘的数据强制写到磁盘上
  30.         public abstract void force (boolean metaData);
  32.         //文件锁定，position-开始位置，size-锁定区域的大小，shared-表示锁是否共享(false为独占)，lock()锁定整个文件
  33.         public final FileLock lock();
  34.         public abstract FileLock lock (long position, long size, boolean shared);
  35.         public final FileLock tryLock();
  36.         public abstract FileLock tryLock (long position, long size, boolean shared);
  38.         //内存映射文件
  39.         public abstract MappedByteBuffer map (MapMode mode, long position, long size);
  40.         public static class MapMode;
  41.         public static final MapMode READ_ONLY;
  42.         public static final MapMode READ_WRITE;
  43.         public static final MapMode PRIVATE;
  45.         //用于通道之间的数据传输
  46.         public abstract long transferTo (long position, long count, WritableByteChannel target);
  47.         public abstract long transferFrom (ReadableByteChannel src, long position, long count);
  48.     }

public abstract MappedByteBuffer map (MapMode mode, long position, long size)

  1. 该map()方法可以在一个打开的文件和一个特殊类型的ByteBuffer之间建立虚拟内存映射。
  3.  通过内存映射机制来访问一个文件会比使用常规方法读写高效得多，甚至比使用通道的效率都高。

transferTo()将数据从FileChannel传输到其他的Channel中。

transferFrom()从其他Channel获取数据

transferTo()和transferFrom()方法允许将一个通道交叉连接到另一个通道，而不需要通过一个中间缓存来传递数据。只有FileChannel类有这两个方法。

transferFrom()示例

  1. package test;
  3. import java.io.IOException;
  4. import java.io.RandomAccessFile;
  5. import java.nio.channels.FileChannel;
  8. public class FileChannelTest2 {
  9.     public static void main(String[] args) throws IOException {
  10.         RandomAccessFile aFile = new RandomAccessFile("d:\\ fromFile.txt", "rw");
  11.         FileChannel fromChannel = aFile.getChannel();
  13.         RandomAccessFile bFile = new RandomAccessFile("d:\\ toFile.txt", "rw");
  14.         FileChannel toChannel = bFile.getChannel();
  15.         long position = 0;
  16.         long count = fromChannel.size();
  17.         toChannel.transferFrom(fromChannel, position, count);
  18.         aFile.close();
  19.         bFile.close();
  20.         System.out.println("over!");
  21.     }
  22. }

transferTo()示例

  1. package test;
  4. import java.io.IOException;
  5. import java.io.RandomAccessFile;
  6. import java.nio.channels.FileChannel;
  8. public class FileChannelTest3 {
  9.     public static void main(String[] args) throws IOException {
  10.         RandomAccessFile aFile = new RandomAccessFile("d:\\fromFile.txt", "rw");
  11.         FileChannel fromChannel = aFile.getChannel();
  13.         RandomAccessFile bFile = new RandomAccessFile("d:\\toFile.txt", "rw");
  14.         FileChannel toChannel = bFile.getChannel();
  15.         long position = 0;
  16.         long count = fromChannel.size();
  17.         fromChannel.transferTo(position, count, toChannel);
  18.         aFile.close();
  19.         bFile.close();
  20.         System.out.println("over!");
  21.     }
  23. }

FileChannel示例

  1. package test;
  4. import java.io.IOException;
  5. import java.io.RandomAccessFile;
  6. import java.nio.ByteBuffer;
  7. import java.nio.channels.FileChannel;
  10. public class FileChannelTest {
  13.     public static void main(String[] args) throws IOException {
  14.         RandomAccessFile aFile = new RandomAccessFile("d:\\test.txt", "rw");
  15.         FileChannel inChannel = aFile.getChannel();
  16.         ByteBuffer buf = ByteBuffer.allocate(48);
  17.         int bytesRead = inChannel.read(buf);
  18.         while (bytesRead != -1) {
  19.             System.out.println("Read " + bytesRead);
  20.             buf.flip();
  21.             while (buf.hasRemaining()) {
  22.                 System.out.print((char) buf.get());
  23.             }
  26.             buf.clear();
  27.             bytesRead = inChannel.read(buf);
  28.         }
  29.         aFile.close();
  30.         System.out.println("wan");
  31.     }
  32. }

Socket**通道**

常用的Socket通道

DatagramChannel：用于UDP的数据读写

SocketChannel： 用于TCP的数据读写，一般是客户端实现

ServerSocketChannel: 允许我们监听TCP连接请求，每个请求会创建会一个SocketChannel，一般是服务器实现

以上Channel都继承AbstractSelectableChannel，于是这三个Channel都是可以设置成非阻塞模式的。Socket通道(DatagramChannel、SocketChannel和ServerSocketChannel)在被实例化时都会创建一个对等的socket对象，即我们熟悉的java.net的类型(Socket、ServerSocket和DatagramSocket)。

1.非阻塞模式

Socket通道可以在非阻塞模式下运行，跟非阻塞/阻塞相关的函数（SelecableChannel类下）

//配置是否是阻塞模式（block为true，则为阻塞模式。block为false，则设置为非阻塞模式）

  1. public abstract SelectableChannel configureBlocking(boolean block)
  5. //获取当前是否是阻塞模式
  7.  public abstract boolean isBlocking();
  11.  //获取 configureBlocking和register方法同步的锁
  13.  public abstract Object blockingLock();

2.ServerSocketChannel

ServerSocketChannel用于监听TCP连接请求，常用的API如下：

  1. public abstract class ServerSocketChannel
  2.     extends AbstractSelectableChannel
  3.     implements NetworkChannel
  4. {
  6.  //静态方法，用于创建一个新的ServerSocketChannel对象，后续还需要跟ServerSocket进行绑定操作
  7. public static ServerSocketChannel open()
  9. //获取关联该ServerSocketChannel的server socket
  10. public abstract ServerSocket socket()
  12. //当创建ServerSocketChannel对象并绑定一个ServerSocket关联的通道之后，
  13. //调用该方法可以监听客户端的连接请求
  14. public abstract SocketChannel accept()
  16. //并绑定指定端口的ServerSocket,(jdk1.7以上才有)
  17. public final ServerSocketChannel bind(SocketAddress local)
  19. //同选择器一起使用，获取感兴趣的操作
  20. public final int validOps()
  21. }

静态方法open()用于创建一个新的ServerSocketChannel对象，将会返回一个未绑定的ServerSocket关联的通道。该对等ServerSocket可以通过在返回的ServerSocketChannel上调用socket()方法获取。jdk1.7以前ServerSocketChannel没有bind()方法，因此必须取出对等的socket并使用它来绑定一个端口开始监听连接

  1. ServerSocketChannel ssc = ServerSocketChannel.open();
  2. ServerSocket serverSocket = ssc.socket();
  3. serverSocket.bind(new InetSocketAddress(1234));

jdk1.7以后ServerSocketChannel提供了bind()方法，所以以上可以简化为

  1. ServerSocketChannel ssc = ServerSocketChannel.open().bind(new InetSocketAddress(1234));

简单的ServerSocketChannel示例：

  1. import java.io.IOException;
  2. import java.net.InetSocketAddress;
  3. import java.nio.ByteBuffer;
  4. import java.nio.channels.ServerSocketChannel;
  5. import java.nio.channels.SocketChannel;
  8. public class ServerSocketChannelDemo {
  9.     public static final String GREETING = "Hello I must be going.\r\n";
  12.     public static void main(String[] args) throws IOException, InterruptedException {
  13.         int port = 8088;
  14.         if (args.length > 0){
  15.             port = Integer.parseInt(args[0]);
  16.         }
  17.         ByteBuffer buffer = ByteBuffer.wrap(GREETING.getBytes());
  18.         ServerSocketChannel ssc = ServerSocketChannel.open();
  19.         ssc.socket().bind(new InetSocketAddress(port));
  20.         ssc.configureBlocking(false);
  21.         while (true){
  22.             System.out.println("Waiting for connections");
  23.             SocketChannel sc = ssc.accept();
  24.             if (sc == null){
  25.                 Thread.sleep(2000);
  26.             }else {
  27.                 System.out.println("Incoming connection form:"+sc.socket().getRemoteSocketAddress());
  28.                 buffer.rewind();
  29.                 sc.write(buffer);
  30.                 sc.close();
  31.             }
  32.         }
  33.     }
  34. }

3. SocketChannel

SocketChannel 常见的API如下：

  1. public abstract class SocketChannel extends AbstractSelectableChannel
  2.  implements ByteChannel, ScatteringByteChannel, GatheringByteChannel,NetworkChannel
  3. {
  5.         //静态方法，打开套接字通道(创建SocketChannel实例)
  6.         public static SocketChannel open()
  8.         //静态方法，打开套接字通道并将其连接到远程地址
  9.         public static SocketChannel open(SocketAddress remote)
  11.         //返回一个操作集，标识此通道所支持的操作
  12.         public final int validOps()
  14.         //用于将Socket绑定到一个端口
  15.         public abstract SocketChannel bind(SocketAddress local)
  17.         //获取该SocketChannel关联的Socket(套接字)
  18.         public abstract Socket socket()
  20.         //判断是否已连接此通道的网络套接字
  21.         public abstract boolean isConnected()
  23.         //判断此通道上是否正在进行连接操作。
  24.         public abstract boolean isConnectionPending()
  26.         //用于SocketChannel连接到远程地址
  27.         public abstract boolean connect(SocketAddress remote)
  29.         //从通道中读取数据到缓冲区中
  30.         public abstract int read(ByteBuffer dst)
  31.         public abstract long read(ByteBuffer[] dsts, int offset, int length)
  33.         //将缓冲区的数据写入到通道中
  34.         public abstract int write(ByteBuffer src)
  35.         public abstract long write(ByteBuffer[] srcs, int offset, int length)
  37. }

创建SocketChannel对象并连接到远程地址

  1.    SocketChannel  sc = SocketChannel.open(new InetSocketAddress(ip,port));

等价于

  1.   SocketChannel sc = SocketChannel.open();
  3.    sc.connect(new InetSocketAddress(ip,port));
  5.    线程在连接建立好或超时之前都保持阻塞。
  9.    示例：
  11. import java.io.IOException;
  12. import java.net.InetSocketAddress;
  13. import java.nio.ByteBuffer;
  14. import java.nio.channels.SocketChannel;
  17. public class SocketChannelDemo {
  18.     public static void main(String[] args) {
  19.         int port = 8088;
  20.         String ip = "127.0.0.1";
  21.         ByteBuffer readBuffer = ByteBuffer.allocate(512);
  23.         try {
  24.            SocketChannel socketChannel = SocketChannel.open();//创建一个socketChannel
  25.             socketChannel.connect(new InetSocketAddress(ip,port));
  26.             while (!socketChannel.isConnected()){
  27.                 System.out.println("connecting ...");
  28.                 Thread.sleep(1000);
  29.             }
  30.             System.out.println("connected");
  31.             socketChannel.write(ByteBuffer.wrap("Hello,I am Client".getBytes()));
  32.             while (socketChannel.read(readBuffer) > 0){
  33.                 System.out.println(readBuffer.toString());
  34.                 readBuffer.flip();
  35.             }
  36.         } catch (IOException e) {
  37.             e.printStackTrace();
  38.         } catch (InterruptedException e) {
  39.             e.printStackTrace();
  40.         }
  41.     }
  42. }

4. DatagramChannel

  1.    SocketChannel模拟面向连接的流协议(如TCP/IP)，而DatagramChannel则面向无连接的协议(如UDP/IP)
  3. public abstract class DatagramChannel
  4.     extends AbstractSelectableChannel
  5.     implements ByteChannel, ScatteringByteChannel, GatheringByteChannel, MulticastChannel
  7. {
  8.        //创建DatagramChannel实例
  9.        public static DatagramChannel open()
  10.        public static DatagramChannel open(ProtocolFamily family)
  11.        public final int validOps()
  13.        //将通道的套接字绑定到本地地址
  14.        public abstract DatagramChannel bind(SocketAddress local)
  16.        //获取该DatagramChannel关联的DatagramSocket对象
  17.        public abstract DatagramSocket socket()
  19.        //是否已连接到套接字
  20.        public abstract boolean isConnected()
  22.        //用于DatagramChannel连接到远程地址
  23.        public abstract DatagramChannel connect(SocketAddress remote)
  25.        //通道此DatagramChannel接受到的数据包
  26.        public abstract SocketAddress receive(ByteBuffer dst)
  28.        //通过此DatagramChannel发送数据包
  29.        public abstract int send(ByteBuffer src, SocketAddress target)
  31.        //从此通道读取数据包
  32.        public abstract int read(ByteBuffer dst)
  33.        public abstract long read(ByteBuffer[] dsts, int offset, int length)
  35.        //将数据写入到此通道
  36.        public abstract int write(ByteBuffer src)
  37.        public final long write(ByteBuffer[] srcs) throws IOException
  38. }

打开DatagramChannel

DatagramChannel channel = DatagramChannel.open();

channel.socket().bind(new InetAddress(8088));

DatagramChannel对应的DatagramSocket如果未调用bind()绑定端口号，也是可以通讯的，因为系统默认会动态分配一个端口号

receive()方法，接受数据包

  1. ByteBuffer buffer = ByteBuffer.allocate(48);
  2. buffer.clear();
  3. channel.receive(buffer);

send()方法，发送数据包

  1. String newData = "New String to send,time:" +  System.currentTimeMillis();
  2. ByteBuffer buffer = ByteBuffer.allocate(48);
  3. buffer.clear();
  4. buffer.put(newData.getBytes());
  5. buffer.flip();
  6. int bytesSent = channel.send(buffer, new InetAddress("jenkov.com", 80));

Connecting to a Specific Address

DatagramChannel是可以“连接”到网络上特定地址的。因为UDP是无连接的，所以这种“连接”不是真正像TCP那样的和远程地址建立了一个连接。不如说是它将锁定你的DatagramChannel，以便你只能向一个特定的地址发送和接收数据包。

连接

channel.connect(new InetAddress(“jenkov.com”, 80));

当“连接”建立后，你可以像使用传统的Channel一样调用read()和write()方法。只是对于发送的数据，你不会得到任何关于交付的保证。下面是一些例子：

int bytesRead = channel.read(buffer); //读取数据

int bytesWrite = channel.write(buffer); //写数据

以上内容主要整理自：《Java NIO》

发表评论

表情：
评论列表 （有 0 条评论，214人围观）

还没有评论，来说两句吧...

相关阅读

    相关 java nio channel

    Java NIO 通道类似于流，但又有一下不同： 1、既可以从通道中读取数据，也可以写数据到通道中。java .io 中的流是单向性。 2、通道数据读取可以异步。 3、通

    淩亂°似流年淩亂°似流年/ 0 赞/ 242 阅读

    相关 Java NIO之Selector详细理解

    介绍        Selector一般称为选择器。它是Java NIO核心组件之一，选择器管理着一个被注册的通道集合的信息和它们的就绪状态。通道是和选择器一起被注册的，

    心已赠人心已赠人/ 0 赞/ 136 阅读

    相关 Java NIO之Channel详细理解

    介绍 理解：通道是一个连接I/O服务的管道并提供与该服务交互的方法。 Channel类似于传统的”流”，但是Channel不能直接访问数据，需要和缓冲区Buffer进行

    蔚落蔚落/ 0 赞/ 215 阅读

    相关 Java NIO 之Channel

    定义 用于源节点和目标节点之间的连接。nio中负责缓冲区中数据传输，Channel本地并不存储数据，而是配合缓冲区进行数据传输。你可以把它理解成io中的流。 结

    偏执的太偏执、偏执的太偏执、/ 0 赞/ 401 阅读

    相关 NIO之Channel

    1、基本概念 Java NIO中，channel用于数据的传输，类似于传统BIO中的流（IOStream）的概念。 我们都知道，系统的I/O都分为两个阶段： 等

    快来打我*快来打我*/ 0 赞/ 618 阅读