Channel就是一个通道，用于传输数据，两端分别是缓冲区和实体（文件或者套接字），通道的特点（也是NIO的特点）：通道中的数据总是要先读到一个缓冲区，或者总是要从一个缓冲区中读入。
1) FileChannel：从文件中读写数据
2) SocketChannel：通过TCP协议读写网络中的数据
3) ServerSocketChannel：在服务器端可以监听新进来的TCP连接，像WEB服务器那样，对每一个新进来的请求创建一个SocketChannel
4) DatagramChannel：通过UDP协议读写网络中的数据
上面众多的分类，是对应了不同的实体，这些通道包括了文件IO、TCP和UDP网络IO。
下面来看看Channel的源码：
public interface Channel extends Closeable {
public boolean isOpen();
public void close() throws IOException;
}
从这里我们可以看到，Channel接口只提供了关闭通道和检测通道是否打开这两个方法，剩下方法的都是由子接口和实现类来定义提供。
aaarticlea/png;base64,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" alt="" />
我们选择其中几个来看看这些接口的源码：
public interface WritableByteChannel
extends Channel
{ public int write(ByteBuffer src) throws IOException; }
public interface ReadableByteChannel extends Channel
{
public int read(ByteBuffer dst) throws IOException; }
public interface ByteChannel
extends ReadableByteChannel, WritableByteChannel
{ }
aaarticlea/png;base64,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" alt="" />
前面我提到过：通道可以只读、只写或者同时读写，因为Channel类可以只实现只读接口ReadableByteChannel或者只实现只写接口WritableByteChannel，而我们常用的Channel类FileChannel、SocketChannel、DatagramChannel是双向通信的， 因为实现了ByteChannel接口。
IO在广义上可以分为：文件IO和网络IO。
文件IO对应的通道为FileChannel，而网络IO对应的通道则有三个：SocketChannel、ServerSoketChannel和DatagramChannel。
一、文件通道
FileChannel对象不能直接创建，只能通过FileInputStream、OutputStream、RandomAccessFile对象的getChannel()来获取，如：
FileInputStream fis = new FileInputStream("c:/in.txt");
FileChannel fic = fis.getChannel();
FileChannel无法设置为非阻塞模式，它总是运行在阻塞模式下。
public class NIOFileReadTest
{
public static void main(String[] args) throws IOException
{
RandomAccessFile raf = new RandomAccessFile("D:/in.txt","rw");
FileChannel fis = raf.getChannel();
ByteBuffer buffer = ByteBuffer.allocate(1024);
fis.read(buffer);
buffer.flip();
while(buffer.hasRemaining())
{
System.out.print((char)buffer.get());
}
buffer.clear();
fis.close();
}
}
执行结果：
FileChannel2）使用通道写入文件
ByteBuffer
SelectorPicked
public class NIOFileWriteTest
{
public static void main(String[] args) throws Exception
{
FileOutputStream fos = new FileOutputStream("d:/out.txt");
FileChannel fc = fos.getChannel();
ByteBuffer buffer = ByteBuffer.allocate(10);
buffer.clear();
String str = "Channel";
buffer.put(str.getBytes());
buffer.flip();
while(buffer.hasRemaining())
{
fc.write(buffer);
}
fc.close();
fos.close();
}
}
在这里总是要记住channel是要关闭的。
ByteBuffer中的方法我在下一章再详细介绍，这里只要注意这点即可：通道只能使用ByteBuffer，不管是读还是写，通道都要对接缓冲区。
position();返回通道的文件位置
position(long newPosition):设置通道的文件位置
将上面读文件的程序修改下，来观察这几个方法：
public class NIOFileReadTest
{
public static void main(String[] args) throws IOException
{
RandomAccessFile raf = new RandomAccessFile("D:/in.txt","rw");
FileChannel fis = raf.getChannel();
System.out.println("此通道文件的总长度:" +fis.size());
//当前通道的文件位置
long position = fis.position();
System.out.println("通道当前的位置:" + position);
//设置新的通道文件位置，从这个位置开始读取
fis.position(position + 8);
ByteBuffer buffer = ByteBuffer.allocate(50);
fis.read(buffer);
buffer.flip();
while(buffer.hasRemaining())
{
System.out.print((char)buffer.get());
}
buffer.clear();
fis.close();
}
}
执行结果：
此通道文件的总长度:33
通道当前的位置:0
nel
ByteBuffer
Selector
FileChannel是线程安全的，可以多个线程在同一个实例上并发 *** 作，但是其中有些方法（改变文件通道位置或者文件大小的方法）必须是单线程 *** 作。
二、网络通道
SocketChannel是一个连接到TCP套接字的通道，获取的方式有两种：
1、打开一个SocketChannel并连接到互联网上某台服务器。
2、一个新连接到达ServerSocketChannel时，会创建一个SocketChannel。
上面这两种模式跟IO的Socket、ServerSocket类似，下面分别来看看客户端和服务器端：
一、SocketChannel
从通道中读取数据
public class SocketChannelTest
{
public static void main(String[] args) throws Exception
{
//获取socket通道
SocketChannel sc = SocketChannel.open();
//设置为非阻塞模式
sc.configureBlocking(false);
//建立连接，非阻塞模式下，该方法可能在连接建立之前就返回了
sc.connect(new InetSocketAddress("wap.cmread.com",80));
//判断连接是否建立
while(!sc.finishConnect())
{
System.out.println("连接未建立");
Thread.sleep(5);
}
ByteBuffer buffer = ByteBuffer.allocate(48);
int byteRead = sc.read(buffer);
System.out.println(byteRead);
sc.close();
buffer.clear();
}
}
执行结果；
连接未建立
连接未建立
0
1、第6、7行是获取一个socket通道，并且设置为非阻塞模式。
2、由于是非阻塞模式，通道在调用方法connect/read/writer这三个方法时，会出现这些情况：连接未建立，connect方法就返回了；尚未读取任何数据时，read方法就返回；尚未写出任何内容时，writer就返回。
3、在12行的循环代码中，是判断连接是否建立，从执行结果来看，循环执行了两次连接才建立（在循环里线程还有休眠）。
4、由于只是建立了连接，通道里面其实没有任何的数据。
5、第18行调用read方法，由于是非阻塞模式，所以在并未读取任何数据的情况下就返回0（尽管通道里面没有数据）。
将数据写入通道
public class SocketChannelTest
{
public static void main(String[] args) throws Exception
{
SocketChannel sc = SocketChannel.open();
String str = "non-blocking socket channel";
ByteBuffer buffer = ByteBuffer.allocate(100);
buffer.put(str.getBytes());
buffer.flip();
while(buffer.hasRemaining())
{
sc.write(buffer);
}
sc.close();
buffer.clear();
}
}
1、SocketChannel.write()方法的调用是在一个while循环中的。
Write()方法无法保证能写多少字节到SocketChannel。
所以，我们重复调用write()直到Buffer没有要写的字节为止。
二、ServerSocketChannel
ServerSocketChannel是一个可以监听新进来的TCP连接的通道。
public class ServerSocketChannelTest
{
public static void main(String[] args) throws Exception
{
ServerSocketChannel ssc = ServerSocketChannel.open();
ssc.socket().bind(new InetSocketAddress(80));
ssc.configureBlocking(false);
while(true)
{
SocketChannel sc = ssc.accept();
if(null != sc)
{
//do something;
}
}
}
}
1、第5、6、7行，获取一个ServerSocketChannel，并且监听80端口，设置为非阻塞模式。
2、通过accept方法监听新接入进来的连接，这个方法会返回一个包含新进来的连接的SocketChannel（服务器端的通道的获取方式）。 如果是阻塞模式，该方法会一直阻塞直到有新的连接进来。 如果是非阻塞模式，则accept方法会立刻返回，返回值是null。
3、第11行，是因为在非阻塞模式下，需要检查SocketChannel是否为null。
三、socket通道与socket
ServerSocketChannel ssc = ServerSocketChannel.open();
ServerSocket socket = ssc.socket();
ServerSocketChannel ssc1 = socket.getChannel();
1、从这代码片段可以大概看到这样一种关系：所有socket通道（SocketChannel/ServerSocketChanne/DatagramSocketChannel）在被实例化之后，都是伴随生成对应的socket对象，就是前面IO章节介绍的java.net类（Socket/ServerSocket/DatagramSocket）。
通过通道类的socket方法来获取。
2、java.net类（Socket/ServerSocket/DatagramSocket）现在可以通过getChannel方法来获取对应的通道。
前提是这些socket对象不是使用传统方式（直接实例化）创建的。
否则它就没有关联的socket通道，调用getChannel方法返回总是null。
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）