Java NIO Channels

In Java NIO, the channel is a medium used to transports the data efficiently between the entity and byte buffers. It reads the data from an entity and places it inside buffer blocks for consumption.

Channels act as gateway provided by java NIO to access the I/O mechanism. Usually channels have one-to-one relationship with operating system file descriptor for providing the platform independence operational feature.

Let's see the class hierarchy for java.nio.channels:

The above channel can be used in a blocking or a non-blocking mode, but we mainly focus on using the channel in non blocking mode.

NIO Channel Basics

Channel implementation uses the native code to perform actual work. The channel interface allows us to gain access to low-level I/O services in a portable and controlled way.

At the top of hierarchy, the Channel interface is used as given below:

package java.nio.channels;
 public interface Channel{
    public boolean isclose();
    public void Open() throws IOException;
}

As we can see in above channel interface, there are only two operations common to all the channels:

Checking to see if a channel is close (isclose())
Opening the close channel (close())

Channel Implementations

In Java NIO the primary Channels used are given below:

FileChannel: The file channel is used for reading the data from the files. It's object can be created only by calling the getChannel() method. We cannot create FileChannel object directly.

Let's see the example to create the object of FileChannel:

FileInputStream fis = new FileInputStream("D:\\testin.txt"); // Path of Input text file
ReadableByteChannel rbc = fis.getChannel();

DatagramChannel: The datagram channel can read and write the data over the network via UDP (User Datagram Protocol). It uses the factory methods for creating the new object.

The syntax used for opening the DatagramChannel:

The syntax used for closing the DatagramChannel:

SocketChannel: The datagram channel can read and write the data over the network via TCP (Transmission Control Protocol). It also uses the factory methods for creating the new object.

The syntax used for opening the SocketChannel:

SocketChannel ch = SocketChannel.open();
ch.connect(new InetSocketAddress("somehost", someport));

SocketChannel ch = SocketChannel.close();
ch.connect(new InetSocketAddress("somehost", someport));

ServerSocketChannel: The ServerSocketChannel allows user to listen the incoming TCP connections, same as a web server. For every incoming connection a SocketChannel is created.

The syntax used for opening the ServerSocketChannel:

ServerSocketChannel ch = ServerSocketChannel.open();
ch.socket().bind (new InetSocketAddress (somelocalport));

The syntax used for closing the ServerSocketChannel:

ServerSocketChannel ch = ServerSocketChannel.close();
ch.socket().bind (new InetSocketAddress (somelocalport));

Basic Channel Example

Let's see the example of copy the data from one channel to another channel or from one file to another file:

package com.javatpoint;
 
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.ReadableByteChannel;
import java.nio.channels.WritableByteChannel;
 public class Index {
    public static void main(String args[]) throws IOException {
    FileInputStream input = new FileInputStream ("D:\\testin.txt"); // Path of Input text file
        ReadableByteChannel source = input.getChannel();
    FileOutputStream output = new FileOutputStream ("D:\\testout.txt"); // Path of Output text file
        WritableByteChannel destination = output.getChannel();
  copyData(source, destination);
  source.close();
        destination.close();
    }
 private static void copyData(ReadableByteChannel src, WritableByteChannel dest) throws IOException 
    {
        ByteBuffer buffer = ByteBuffer.allocateDirect(20 * 1024);
   while (src.read(buffer) != -1) 
        {
            // The buffer is used to drained
            buffer.flip();
            // keep sure that buffer was fully drained
            while (buffer.hasRemaining()) 
            {
                dest.write(buffer);
            }
            buffer.clear(); // Now the buffer is empty, ready for the filling
        }
    }
}

Output:

The above program copies the content of text file testin.txt to another text file testout.txt.

Next TopicJava NIO Buffers

← prev next →