学习——NIO原理概述及聊天示例

NIO编程

1. 概述

java.nio 全称 java non-blocking IO，是指 JDK 提供的新 API。从 JDK1.4 开始，Java 提供了一系列改进的输入/输出的新特性，被统称为 NIO(即 New IO)。新增了许多用于处理输入输出的类，这些类都被放在 java.nio 包及子包下，并且对原 java.io 包中的很多类进行改写，新增了满足 NIO 的功能。
NIO 和 BIO 有着相同的目的和作用，但是它们的实现方式完全不同，BIO 以流的方式处
理数据,而 NIO 以块的方式处理数据,块 I/O 的效率比流 I/O 高很多。另外，NIO 是非阻塞式的，这一点跟 BIO 也很不相同，使用它可以提供非阻塞式的高伸缩性网络。
NIO 主要有三大核心部分：Channel(通道)，Buffer(缓冲区), Selector(选择器)。
传统的 BIO基于字节流和字符流进行操作，而 NIO 基于 Channel(通道)和 Buffer(缓冲区)进行操作，数据总是从通道读取到缓冲区中，或者从缓冲区写入到通道中。通道与流的不同之处在于通道是双向的。而流只是在一个方向上移动(一个流必须是 InputStream 或者 OutputStream 的子类)， 而 通道 可以用于读、写或者同时用于读写。因为它们是双向的，所以通道可以比流更好地反映底层操作系统的真实情况。
Selector(选择区)用于监听多个通道的事件（比如：连接请求，数据到达等），因此使用单个线程就可以监听多个客户端通道。

2. 文件IO

2.1.概述

缓冲区（Buffer）：实际上是一个容器，是一个特殊的数组，缓冲区对象内置了一些机制，能够跟踪和记录缓冲区的状态变化情况。Channel 提供从文件、网络读取数据的渠道，但是读取或写入的数据都必须经由 Buffer，如下图所示：

在 NIO 中，Buffer 是一个顶层父类，它是一个抽象类，常用的 Buffer 子类有：

• ByteBuffer，存储字节数据到缓冲区
• ShortBuffer，存储字符串数据到缓冲区
• CharBuffer，存储字符数据到缓冲区
• IntBuffer，存储整数数据到缓冲区
• LongBuffer，存储长整型数据到缓冲区
• DoubleBuffer，存储小数到缓冲区
• FloatBuffer，存储小数到缓冲区
  对于 Java 中的基本数据类型，都有一个 Buffer 类型与之相对应，最常用的自然是
  ByteBuffer 类（二进制数据），该类的主要方法如下所示：

• public abstract ByteBuffer put(byte[] b); 存储字节数据到缓冲区
• public abstract byte[] get(); 从缓冲区获得字节数据
• public final byte[] array(); 把缓冲区数据转换成字节数组
• public static ByteBuffer allocate(int capacity); 设置缓冲区的初始容量
• public static ByteBuffer wrap(byte[] array); 把一个现成的数组放到缓冲区中使用
• public final Buffer flip(); 翻转缓冲区，重置位置到初始位置
  通道（Channel）：类似于 BIO 中的 stream，例如 FileInputStream 对象，用来建立到目标（文件，网络套接字，硬件设备等）的一个连接，但是需要注意：BIO 中的 stream 是单向的，例如 FileInputStream 对象只能进行读取数据的操作，而 NIO 中的通道(Channel)是双向的，既可以用来进行读操作，也可以用来进行写操作。常用的 Channel 类有：FileChannel、DatagramChannel、ServerSocketChannel 和 SocketChannel。FileChannel 用于文件的数据读写，DatagramChannel 用于 UDP 的数据读写，ServerSocketChannel 和 SocketChannel 用于 TCP 的数据读写。
  这里我们先讲解 FileChannel 类，该类主要用来对本地文件进行 IO 操作，主要方法如下：
• public int read(ByteBuffer dst) ，从通道读取数据并放到缓冲区中
• public int write(ByteBuffer src) ，把缓冲区的数据写到通道中
• public long transferFrom(ReadableByteChannel src, long position, long count)，从目标通道中复制数据到当前通道
• public long transferTo(long position, long count, WritableByteChannel target)，把数据从当前通道复制给目标通道

2.2 示例

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

/**
 * NIO FileChannel Demo
 * 
 * @author Administrator
 *
 */
public class FileChannelDemo {

	/**
	 * NIO 中的通道是从输出流对象里通过 getChannel 方法获取到的，该通道是双向的，既可 以读，又可以写。在往通道里写数据之前，必须通过 put
	 * 方法把数据存到 ByteBuffer 中，然 后通过通道的 write 方法写数据。在 write 之前，需要调用 flip 方法翻转缓冲区，把内部重置
	 * 到初始位置，这样在接下来写数据时才能把所有数据写到通道里
	 * 
	 * @param content  准备写入的内容
	 * @param filePath 写入目标文件路径
	 * @throws IOException
	 */
	public void write(String content, String filePath) throws IOException {
		// 获取输出流
		FileOutputStream fos = new FileOutputStream(filePath);
		// 从输出流获取文件通道
		FileChannel channel = fos.getChannel();
		// 得到ByteBuffer 并设置容量
		ByteBuffer buffer = ByteBuffer.allocate(1024);
		// 将内容放入
		buffer.put(content.getBytes());
		// 翻转
		buffer.flip();
		channel.write(buffer);
		fos.close();
	}

	/**
	 * 从输入流中获得一个通道，然后提供 ByteBuffer 缓冲区，该缓冲区的初始容量 和文件的大小一样，最后通过通道的 read
	 * 方法把数据读取出来并存储到了 ByteBuffer 中
	 * 
	 * @param filePath 读取文件路径
	 * @throws IOException
	 */
	public void read(String filePath) throws IOException {
		// 创建文件对象
		File file = new File(filePath);
		// 获取文件输入流
		FileInputStream fis = new FileInputStream(file);
		// 获取文件通道
		FileChannel channel = fis.getChannel();
		ByteBuffer buffer = ByteBuffer.allocate((int) file.length());
		channel.read(buffer);
		System.out.println("读取到内容：" + new String(buffer.array()));
		fis.close();
	}

	/**
	 * BIO 文件复制功能
	 * 
	 * @param sourceFile 源文件路径
	 * @param targetFile 目标文件路径
	 */
	public void copyByBIO(String sourceFile, String targetFile) throws IOException {
		FileInputStream fis = new FileInputStream(sourceFile);
		FileOutputStream fos = new FileOutputStream(targetFile);
		byte[] b = new byte[1024];
		while (true) {
			int res = fis.read(b);
			if (res == -1) {
				break;
			}
			fos.write(b, 0, res);
		}
		fis.close();
		fos.close();
	}

	/**
	 * NIO 文件复制功能
	 * 
	 * @param sourceFile 源文件路径
	 * @param targetFile 目标文件路径
	 */
	public void copyByNIO(String sourceFile, String targetFile) throws IOException {
		FileInputStream fis = new FileInputStream(sourceFile);
		FileOutputStream fos = new FileOutputStream(targetFile);
		FileChannel sourceChannel = fis.getChannel();
		FileChannel targetChnnel = fos.getChannel();
		// 以下两种方式都可以
		// targetChnnel.transferFrom(sourceChannel, 0, sourceChannel.size());
		sourceChannel.transferTo(0, sourceChannel.size(), targetChnnel);
		sourceChannel.close();
		targetChnnel.close();
		fis.close();
		fos.close();
	}
}

3.网络 IO

3.1 概述

前面在进行文件 IO 时用到的 FileChannel 并不支持非阻塞操作，学习 NIO 主要就是进行
网络 IO，Java NIO 中的网络通道是非阻塞 IO 的实现，基于事件驱动，非常适用于服务器需要维持大量连接，但是数据交换量不大的情况，例如一些即时通信的服务等等…
在 Java 中编写 Socket 服务器，通常有以下几种模式：

• 一个客户端连接用一个线程，优点：程序编写简单；缺点：如果连接非常多，分配的线
  程也会非常多，服务器可能会因为资源耗尽而崩溃。
• 把每一个客户端连接交给一个拥有固定数量线程的连接池，优点：程序编写相对简单，
  可以处理大量的连接。缺点：线程的开销非常大，连接如果非常多，排队现象会比较严
  重。
• 使用 Java 的 NIO，用非阻塞的 IO 方式处理。这种模式可以用一个线程，处理大量的客户端连接。
  [外链图片转存失败(img-RUFGZcu4-1568271699363)(http://img3.imgtn.bdimg.com/it/u=2534199603,674087730&fm=26&gp=0.jpg)]
  Selector(选择器) 能够检测多个注册的通道上是否有事件发生，如果有事件发生，便获取事件然后针对每个事件进行相应的处理。这样就可以只用一个单线程去管理多个通道，也就是管理多个连接。这样使得只有在连接真正有读写事件发生时，才会调用函数来进行读写，就大大地减少了系统开销，并且不必为每个连接都创建一个线程，不用去维护多个线程，并且避免了多线程之间的上下文切换导致的开销。
  该类的常用方法如下所示：
• public static Selector open()，得到一个选择器对象
• public int select(long timeout)，监控所有注册的通道，当其中有 IO 操作可以进行时，将对应的 SelectionKey 加入到内部集合中并返回，参数用来设置超时时间
• public Set selectedKeys()，从内部集合中得到所有的 SelectionKey
  SelectionKey 代表了 Selector 和网络通道的注册关系,一共四种：

• int OP_ACCEPT：有新的网络连接可以 accept，值为 16
• int OP_CONNECT：代表连接已经建立，值为 8
• int OP_READ 和 int OP_WRITE：代表了读、写操作，值为 1 和 4
  该类的常用方法如下所示：

• public abstract Selector selector()，得到与之关联的 Selector 对象
• public abstract SelectableChannel channel()，得到与之关联的通道
• public final Object attachment()，得到与之关联的共享数据
• public abstract SelectionKey interestOps(int ops)，设置或改变监听事件
• public final boolean isAcceptable()，是否可以 accept
• public final boolean isReadable()，是否可以读
• public final boolean isWritable()，是否可以写
  ServerSocketChannel 用来在服务器端监听新的客户端 Socket 连接，常用方法如下所示：
• public static ServerSocketChannel open()，得到一个 ServerSocketChannel 通道
• public final ServerSocketChannel bind(SocketAddress local)，设置服务器端端口号
• public final SelectableChannel configureBlocking(boolean block)，设置阻塞或非阻塞模式，取值 false 表示采用非阻塞模式
• public SocketChannel accept()，接受一个连接，返回代表这个连接的通道对象
• public final SelectionKey register(Selector sel, int ops)，注册一个选择器并设置监听事件
  SocketChannel 网络 IO 通道，具体负责进行读写操作。NIO 总是把缓冲区的数据写入通道，或者把通道里的数据读到缓冲区。常用方法如下所示：
• public static SocketChannel open()，得到一个 SocketChannel 通道
• public final SelectableChannel configureBlocking(boolean block)，设置阻塞或非阻塞模式，取值 false 表示采用非阻塞模式
• public boolean connect(SocketAddress remote)，连接服务器
• public boolean finishConnect()，如果上面的方法连接失败，接下来就要通过该方法完成连接操作
• public int write(ByteBuffer src)，往通道里写数据
• public int read(ByteBuffer dst)，从通道里读数据
• public final SelectionKey register(Selector sel, int ops, Object att)，注册一个选择器并设置监听事件，最后一个参数可以设置共享数据
• public final void close()，关闭通道

3.2. 示例

示例一 服务端客户端通信

import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;

/**
 * NIO 服务端
 * 
 * @author Administrator
 *
 */
public class NIOServer {
	public static void main(String[] args) throws Exception {
		// 获取ServerSocketChannel
		ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
		// 获取Selector对象
		Selector selector = Selector.open();
		// 绑定服务端口
		serverSocketChannel.bind(new InetSocketAddress(666));
		// 设置服务端为非阻塞模式
		serverSocketChannel.configureBlocking(false);
		// 将ServerSocketChannel 注册到Selector
		serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
		while (true) {
			// 监听客户端
			if (selector.select(2000) == 0) {
				System.out.println("NIOServer：暂时没有客户端操。。。");
			}
			// 得到SelectionKey，判断通道事件
			Iterator<SelectionKey> selectionKeys = selector.selectedKeys().iterator();
			while (selectionKeys.hasNext()) {
				SelectionKey selectionKey = selectionKeys.next();
				if (selectionKey.isAcceptable()) {
					// 连接事件
					System.out.println("NIOServer：Client Accept.");
					SocketChannel socketChannel = serverSocketChannel.accept();
					// 设置非阻塞模式并注册到Selector
					socketChannel.configureBlocking(false);
					socketChannel.register(selector,SelectionKey.OP_READ, ByteBuffer.allocate(1024));
				}
				if (selectionKey.isReadable()) {
					// 读取数据事件
					SocketChannel channel = (SocketChannel) selectionKey.channel();
					ByteBuffer attachment = (ByteBuffer) selectionKey.attachment();
					channel.read(attachment);
					System.out.println("NIOClient：" + new String(attachment.array()));
				}
				// 手动从集合中移除当前 key,防止重复处理
				selectionKeys.remove();
			}
		}
	}
}

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;

/**
 * NIO 客户端
 * 
 * @author Administrator
 *
 */
public class NIOClient {
	public static void main(String[] args) throws IOException {

		// 获取 SocketChannel
		SocketChannel socketChannel = SocketChannel.open();
		// 设置非阻塞模式
		socketChannel.configureBlocking(false);
		// 连接服务端
		InetSocketAddress socketAddress = new InetSocketAddress("127.0.0.1", 666);
		if (!socketChannel.connect(socketAddress)) {
			// 连接失败 则使用下面的操作完成连接
			while (!socketChannel.finishConnect()) {
				System.out.println("NIOClient：尝试连接服务端。。。");
			}
		}
		// 准备发送数据
		ByteBuffer buffer = ByteBuffer.wrap("Hello NIOServer".getBytes());
		// 发送数据
		socketChannel.write(buffer);
		System.in.read();
	}
}

示例二 群聊

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.Channel;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;

public class ChatServer {
	private Selector selector;
	private ServerSocketChannel serverSocketChannel;
	private static final int PORT = 666; // 服务端口

	public ChatServer() {
		try {
			// 得到选择器
			selector = Selector.open();
			// 打开监听通道
			serverSocketChannel = ServerSocketChannel.open();
			// 绑定端口
			serverSocketChannel.bind(new InetSocketAddress(PORT));
			// 设置为非阻塞模式
			serverSocketChannel.configureBlocking(false);
			// 将选择器绑定到监听通道并监听 accept 事件
			serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
			System.out.println("ChatServer 已就绪.......");
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	public void start() {
		try {
			while (true) {
				// 监听客户端
				int select = selector.select();
				if (select == 0) {
					System.out.println("ChatServer：暂时没有用户操作。。。");
				}
				// 得到SelectionKey，判断通道事件
				Iterator<SelectionKey> selectionKeys = selector.selectedKeys().iterator();
				while (selectionKeys.hasNext()) {
					SelectionKey selectionKey = selectionKeys.next();
					if (selectionKey.isAcceptable()) {
						// 连接事件
						System.out.println("NIOServer：Client Accept.");
						SocketChannel socketChannel = serverSocketChannel.accept();
						// 设置非阻塞模式并注册到Selector 监听 read
						socketChannel.configureBlocking(false);
						socketChannel.register(selector, SelectionKey.OP_READ);
						System.out.println(socketChannel.getRemoteAddress().toString().substring(1) + "上线了...");
						// 将此对应的 channel 设置为 accept,接着准备接受其他客户端请求
						selectionKey.interestOps(SelectionKey.OP_ACCEPT);
					}
					if (selectionKey.isReadable()) {
						// 读取数据事件
						readMsg(selectionKey);
					}
					// 手动从集合中移除当前 key,防止重复处理
					selectionKeys.remove();
				}
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	/**
	 * 读取 SelectionKey对应通道发送的数据
	 * 
	 * @param key SelectionKey
	 */
	private void readMsg(SelectionKey key) {
		SocketChannel channel = null;
		try {
			// 得到关联的通道
			channel = (SocketChannel) key.channel();
			// 设置 buffer 缓冲区
			ByteBuffer buffer = ByteBuffer.allocate(1024);
			// 从通道中读取数据并存储到缓冲区中
			int count = channel.read(buffer);
			// 如果读取到了数据
			if (count > 0) {
				// 把缓冲区数据转换为字符串
				String msg = new String(buffer.array());
				// 将关联的 channel 设置为 read，继续准备接受数据
				key.interestOps(SelectionKey.OP_READ);
				broadCast(channel, msg); // 向所有客户端广播数据
			}
			buffer.clear();
		} catch (IOException e) {
			try {
				// 当客户端关闭 channel 时，进行异常如理
				System.out.println(channel.getRemoteAddress().toString().substring(1) + "下线了...");
				key.cancel(); // 取消注册
				channel.close(); // 关闭通道
			} catch (IOException e1) {
				e1.printStackTrace();
			}
		}
	}

	public void broadCast(SocketChannel except, String msg) throws IOException {
		// 广播数据到所有的 SocketChannel 中
		for (SelectionKey key : selector.keys()) {
			Channel targetchannel = key.channel();
			// 排除自身
			if (targetchannel instanceof SocketChannel && targetchannel != except) {
				SocketChannel dest = (SocketChannel) targetchannel;
				// 把数据存储到缓冲区中
				ByteBuffer buffer = ByteBuffer.wrap(msg.getBytes());
				// 往通道中写数据
				dest.write(buffer);
			}
		}
	}

	public static void main(String[] args) {
		ChatServer server = new ChatServer();
		server.start();
	}
}

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Scanner;
import java.util.Set;

public class ChatClient {
	private final String HOST = "127.0.0.1"; // 服务器地址
	private int PORT = 666; // 服务器端口
	private Selector selector;
	private SocketChannel socketChannel;
	private String userName;

	public ChatClient() throws IOException {
		// 得到选择器
		selector = Selector.open();
		// 连接远程服务器
		socketChannel = SocketChannel.open(new InetSocketAddress(HOST, PORT));
		// 设置非阻塞
		socketChannel.configureBlocking(false);
		// 注册选择器并设置为 read
		socketChannel.register(selector, SelectionKey.OP_READ);
		// 得到客户端 IP 地址和端口信息，作为聊天用户名使用
		userName = socketChannel.getLocalAddress().toString().substring(1);
		System.out.println("---------------Client(" + userName + ") 就绪------");
	}

	/**
	 * 向服务器端发送数据
	 * 
	 * @param msg 发送的消息
	 * @throws Exception
	 */
	public void sendMsg(String message) throws Exception {
		// 如果控制台输入 bye 就关闭通道，结束聊天
		if (message.equalsIgnoreCase("bye")) {
			socketChannel.close();
			socketChannel = null;
			return;
		}
		message = userName + ": " + message;
		try {
			// 往通道中写数据
			socketChannel.write(ByteBuffer.wrap(message.getBytes()));
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	/**
	 * 从服务器端接收数据
	 */
	public void receiveMsg() {
		try {
			int readyChannels = selector.select();
			if (readyChannels > 0) { // 有可用通道
				Set<?> selectedKeys = selector.selectedKeys();
				Iterator<?> keyIterator = selectedKeys.iterator();
				while (keyIterator.hasNext()) {
					SelectionKey sk = (SelectionKey) keyIterator.next();
					if (sk.isReadable()) {
						// 得到关联的通道
						SocketChannel sc = (SocketChannel) sk.channel();
						// 得到一个缓冲区
						ByteBuffer buff = ByteBuffer.allocate(1024);
						// 读取数据并存储到缓冲区
						sc.read(buff);
						// 把缓冲区数据转换成字符串
						String msg = new String(buff.array());
						System.out.println(msg.trim());
					}
					// 删除当前 SelectionKey，防止重复处理
					keyIterator.remove();
				}
			} else {
				System.out.println("nobady...");
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	public static void main(String[] args) throws Exception {
		// 创建一个聊天客户端对象
		ChatClient chatClient = new ChatClient();
		new Thread() { // 单独开一个线程不断的接收服务器端广播的数据
			public void run() {
				while (true) {
					chatClient.receiveMsg();
					try { // 间隔 1秒
						Thread.sleep(1000);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}
		}.start();
		Scanner scanner = new Scanner(System.in);
		// 在控制台输入数据并发送到服务器端
		while (scanner.hasNextLine()) {
			String msg = scanner.nextLine();
			chatClient.sendMsg(msg);
		}
	}
}