NIO
java.nio 全称 javanon-blockingIO，是指 JDK 提供的新 API。从 JDK1.4 开始，Java 提供了 一系列改进的输入/输出的新特性，被统称为 NIO(即 NewIO)。新增了许多用于处理输入输出的类，这些类都被放在 java.nio 包及子包下，并且对原 java.io 包中的很多类进行改写，新增 了满足 NIO 的功能。
NIO 和 BIO 有着相同的目的和作用，但是它们的实现方式完全不同，BIO 以流的方式处 理数据,而 NIO 以块的方式处理数据,块 I/O 的效率比流 I/O 高很多。另外， NIO 是非阻塞式的，这一点跟 BIO 也很不相同，使用它可以提供非阻塞式的高伸缩性网络。 NIO 主要有三大核心部分：Channel(通道)，Buffer(缓冲区),Selector(选择器)。传统的 BIO 基于字节流和字符流进行操作，而 NIO 基于 Channel(通道)和 Buffer(缓冲区)进行操作，数据总是从通道读取到缓冲区中，或者从缓冲区写入到通道中。Selector(选择区)用于监听多个通道的事件（比如：连接请求，数据到达等），因此使用单个线程就可以监听多个客户端通道。
Buffer
缓冲区（Buffer）：实际上是一个容器，是一个特殊的数组，缓冲区对象内置了一些机制，能够跟踪和记录缓冲区的状态变化情况。Channel 提供从文件、网络读取数据的渠道， 但是读取或写入的数据都必须经由 Buffer。
在 NIO 中，Buffer 是一个顶层父类，它是一个抽象类，常用的 Buffer 子类有：
- ByteBuffer，存储字节数据到缓冲区
- ShortBuffer，存储字符串数据到缓冲区
- CharBuffer，存储字符数据到缓冲区
- IntBuffer，存储整数数据到缓冲区
- LongBuffer，存储长整型数据到缓冲区
- DoubleBuffer，存储小数到缓冲区
- FloatBuffer，存储小数到缓冲区
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 finalBuffer flip(); 翻转缓冲区，重置位置到初始位置
通道（Channel）
类似于 BIO 中的 stream，例如 FileInputStream 对象，用来建立到目 标（文件，网络套接字，硬件设备等）的一个连接，但是需要注意：BIO 中的 stream 是单向 的，例如 FileInputStream 对象只能进行读取数据的操作，而 NIO 中的通道(Channel)是双向的， 既可以用来进行读操作，也可以用来进行写操作。常用的 Channel 类有：FileChannel、 DatagramChannel、ServerSocketChannel 和 SocketChannel。FileChannel 用于文件的数据读写， DatagramChannel 用于 UDP 的数据读写，ServerSocketChannel 和 SocketChannel 用于 TCP 的 数据读写。
网络IO
JavaNIO 中的网络通道是非阻塞 IO 的实现，基于事件驱动，非常适用于服务器需要维持大量连接，但是数据交换量不大的情况
Selector
Selector(选择器)，能够检测多个注册的通道上是否有事件发生，如果有事件发生，便获 取事件然后针对每个事件进行相应的处理。这样就可以只用一个单线程去管理多个通道，也 就是管理多个连接。这样使得只有在连接真正有读写事件发生时，才会调用函数来进行读写， 就大大地减少了系统开销，并且不必为每个连接都创建一个线程，不用去维护多个线程，并 且避免了多线程之间的上下文切换导致的开销。
常用方法
- public static Selector open()，得到一个选择器对象
- public int select (long timeout)，监控所有注册的通道，当其中有 IO 操作可以进行时，将 对应的 SelectionKey 加入到内部集合中并返回，参数用来设置超时时间
- public Set selectedKeys()，从内部集合中得到所有的 SelectionKey
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
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
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()，关闭通道
网络聊天室
ChatServer
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.text.SimpleDateFormat;
import java.util.*;
//聊天程序服务器端
public class ChatServer {
private ServerSocketChannel listenerChannel; //监听通道
private Selector selector;//选择器对象
private static final int PORT = 9999; //服务器端口
public ChatServer() {
try {
// 1. 得到监听通道
listenerChannel = ServerSocketChannel.open();
// 2. 得到选择器
selector = Selector.open();
// 3. 绑定端口
listenerChannel.bind(new InetSocketAddress(PORT));
// 4. 设置为非阻塞模式
listenerChannel.configureBlocking(false);
// 5. 将选择器绑定到监听通道并监听accept事件
listenerChannel.register(selector, SelectionKey.OP_ACCEPT);
printInfo("Chat Server is ready.......");
} catch (IOException e) {
e.printStackTrace();
}
}
public void start() throws Exception{
try {
while (true) { //不停监控
if (selector.select(1000) == 0) {
//此处可编写服务器空闲时的业务代码
continue;
}
Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
while (iterator.hasNext()) {
SelectionKey key = iterator.next();
if (key.isAcceptable()) { //连接请求事件
SocketChannel sc=listenerChannel.accept();
sc.configureBlocking(false);
sc.register(selector,SelectionKey.OP_READ);
System.out.println(sc.getRemoteAddress().toString().substring(1)+"上线了...");
}
if (key.isReadable()) { //读取数据事件
readMsg(key);
}
//一定要把当前key删掉，防止重复处理
iterator.remove();
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
//读取客户端发来的消息并广播出去
public void readMsg(SelectionKey key) throws Exception{
SocketChannel channel=null;
try {
//得到关联的通道
channel = (SocketChannel)key.channel();
ByteBuffer buffer=ByteBuffer.allocate(1024);
int count=channel.read(buffer);
if(count>0){
String msg=new String(buffer.array());
printInfo(msg);
//发广播
broadCast(channel,msg);
}
} catch(IOException e){
try {
printInfo(channel.getRemoteAddress().toString().substring(1)+"下线了...");
key.cancel();//取消注册
channel.close();//关闭通道
}catch (IOException e1)
{
e1.printStackTrace();
}
}
}
//给所有的客户端发广播
public void broadCast(SocketChannel except,String msg) throws Exception{
System.out.println("服务器发送了广播...");
for(SelectionKey key:selector.keys()){
Channel targetChannel=key.channel();
if(targetChannel instanceof SocketChannel && targetChannel!=except){
SocketChannel destChannel=(SocketChannel)targetChannel;
ByteBuffer buffer=ByteBuffer.wrap(msg.getBytes());
destChannel.write(buffer);
}
}
}
private void printInfo(String str) { //往控制台打印消息
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
System.out.println("[" + sdf.format(new Date()) + "] -> " + str);
}
public static void main(String[] args) throws Exception {
new ChatServer().start();
}
}
ChatClient
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
//聊天程序客户端
public class ChatClient {
private final String HOST = "127.0.0.1"; //服务器地址
private int PORT = 9999; //服务器端口
private SocketChannel socketChannel; //网络通道
private String userName; //聊天用户名
public ChatClient() throws IOException {
//1. 得到一个网络通道
socketChannel=SocketChannel.open();
//2. 设置非阻塞方式
socketChannel.configureBlocking(false);
//3. 提供服务器端的IP地址和端口号
InetSocketAddress address=new InetSocketAddress(HOST,PORT);
//4. 连接服务器端
if(!socketChannel.connect(address)){
while(!socketChannel.finishConnect()){ //nio非阻塞式
//此处可编写等待连接时的业务代码
}
}
//5. 得到客户端IP地址和端口信息，作为聊天用户名使用
userName = socketChannel.getLocalAddress().toString().substring(1);
System.out.println("---------------Client(" + userName + ") is ready---------------");
}
//向服务器端发送数据
public void sendMsg(String msg) throws Exception{
if(msg.equalsIgnoreCase("bye")){
socketChannel.close();
return;
}
msg = userName + "-> "+ msg;
ByteBuffer buffer=ByteBuffer.wrap(msg.getBytes());
socketChannel.write(buffer);
}
//从服务器端接收数据
public void receiveMsg() throws Exception{
ByteBuffer buffer = ByteBuffer.allocate(1024);
int size=socketChannel.read(buffer);
if(size>0){
String msg=new String(buffer.array());
System.out.println(msg.trim());
}
}
}
开启线程启动聊天客户端
import java.util.Scanner;
//启动聊天程序客户端
public class TestChat {
public static void main(String[] args) throws Exception {
ChatClient chatClient=new ChatClient();
new Thread(){
public void run(){
while(true){
try {
chatClient.receiveMsg();
Thread.sleep(2000);
}catch (Exception e){
e.printStackTrace();
}
}
}
}.start();
Scanner scanner=new Scanner(System.in);
while (scanner.hasNextLine()){
String msg=scanner.nextLine();
chatClient.sendMsg(msg);
}
}
}
上述代码运行了聊天程序的客户端，并在主线程中发送数据，在另一个线程中不断接收服务 器端的广播数据，该代码运行一次就是一个聊天客户端，可以同时运行多个聊天客户端，聊天效果如下图所示：
571
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
