基于NIO的同步非阻塞编程完整案例,客户端发送请求,服务端获取数据并返回给客户端数据,客户端获取返回数据
这块还是挺复杂的,挺难理解,但是多练几遍,多看看研究研究其实也就那样,就是一个Selector轮询的过程,这里想要双向通信,客户端和服务端都需要一个Selector,并一直轮询,
直接贴代码:
Server:服务端:
package cn.hou.socket01._03nio01;
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.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
//nio 服务端
public class Server implements Runnable {
//1 多路复用器
private Selector selector;
//2 建立缓冲区
private ByteBuffer readBuf=ByteBuffer.allocate(1024);
private ByteBuffer writeBuf=ByteBuffer.allocate(1024);
//构造函数
public Server(int port){
try {
//1 打开多路复用器
this.selector=Selector.open();
//2 打开服务器通道
ServerSocketChannel ssc = ServerSocketChannel.open();
//3 设置服务器通道为非阻塞方式
ssc.configureBlocking(false);
//4 绑定ip
ssc.bind(new InetSocketAddress(port));
//5 把服务器通道注册到多路复用器上,只有非阻塞信道才可以注册选择器.并在注册过程中指出该信道可以进行Accept操作
ssc.register(this.selector, SelectionKey.OP_ACCEPT);
System.out.println("服务器已经启动.....");
} catch (IOException e) {
e.printStackTrace();
}
}
@Override
public void run() {
while(true){//一直循环
try {
this.selector.select();//多路复用器开始监听
//获取已经注册在多了复用器上的key通道集
Iterator<SelectionKey> keys = this.selector.selectedKeys().iterator();
//遍历
while (keys.hasNext()) {
SelectionKey key = keys.next();//获取key
//如果是有效的
if(key.isValid()){
// 如果为阻塞状态,一般是服务端通道
if(key.isAcceptable()){
this.accept(key);
}
// 如果为可读状态,一般是客户端通道
if(key.isReadable()){
this.read(key);
}
}
//从容器中移除处理过的key
keys.remove();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
//从客户端通道获取数据并进行处理
private void read(SelectionKey key) {
try {
//1 清空缓冲区旧的数据
this.readBuf.clear();
//2 获取之前注册的socket通道对象
SocketChannel sc = (SocketChannel) key.channel();
//3 读取数据
int count = sc.read(this.readBuf);
//4 如果没有数据
if(count == -1){
key.channel().close();
key.cancel();
return;
}
//5 有数据则进行读取 读取之前需要进行复位方法(把position 和limit进行复位)
this.readBuf.flip();
//6 根据缓冲区的数据长度创建相应大小的byte数组，接收缓冲区的数据
byte[] bytes = new byte[this.readBuf.remaining()];
//7 接收缓冲区数据
this.readBuf.get(bytes);
//8 打印结果
String body = new String(bytes).trim();
System.out.println("服务端接受到客户端请求的数据: " + body);
//9 告诉客户端已收到数据
writeBuf.put("你好,客户端,我已收到数据".getBytes());
//对缓冲区进行复位
writeBuf.flip();
//写出数据到服务端
sc.write(writeBuf);
//清空缓冲区数据
writeBuf.clear();
} catch (IOException e) {
e.printStackTrace();
}
}
//接受一个客户端socket进行处理
private void accept(SelectionKey key) {
try {
//1 获取服务通道
ServerSocketChannel ssc = (ServerSocketChannel) key.channel();
//2 执行阻塞方法,当有客户端请求时,返回客户端通信通道
SocketChannel sc = ssc.accept();
//3 设置阻塞模式
sc.configureBlocking(false);
//4 注册到多路复用器上，并设置可读标识
sc.register(this.selector, SelectionKey.OP_READ);
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
//启动服务器
new Thread(new Server(9527)).start();
}
}
Client客户端:
package cn.hou.socket01._03nio01;
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;
//nio 客户端
public class Client{
//客户端信道选择器,轮询读取服务端返回数据
private Selector selector;
//连接信道
private SocketChannel sc;
public Client(){
try {
this.sc=SocketChannel.open();//打开信道
sc.connect(new InetSocketAddress("127.0.0.1",9527));////连接服务端
sc.configureBlocking(false);//设置非阻塞
selector = Selector.open();//必须打开
//将当前客户端注册到多路复用器上,并设置为可读状态
sc.register(this.selector, SelectionKey.OP_READ);
//开启线程,一直轮询
new Thread(()->{
while(true){//一直循环
try {
this.selector.select();//多路复用器开始监听
//获取已经注册在多了复用器上的key通道集
Iterator<SelectionKey> keys = this.selector.selectedKeys().iterator();
//遍历
while (keys.hasNext()) {
SelectionKey key = keys.next();//获取key
//如果是有效的
if(key.isValid()){
// 如果为可读状态,读取服务端返回的数据
if(key.isReadable()){
this.read(key);
}
}
//从容器中移除处理过的key
keys.remove();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}).start();
} catch (IOException e) {
e.printStackTrace();
}
}
//客户端获取服务端返回的数据
private void read(SelectionKey key) {
try {
//建立写缓冲区
ByteBuffer readBuf = ByteBuffer.allocate(1024);
//2 获取之前注册的socket通道对象
SocketChannel sc = (SocketChannel) key.channel();
//3 读取数据
int count = sc.read(readBuf);
//4 如果没有数据
if(count == -1){
key.channel().close();
key.cancel();
return;
}
//5 有数据则进行读取 读取之前需要进行复位方法(把position 和limit进行复位)
readBuf.flip();
//6 根据缓冲区的数据长度创建相应大小的byte数组，接收缓冲区的数据
byte[] bytes = new byte[readBuf.remaining()];
//7 接收缓冲区数据
readBuf.get(bytes);
//8 打印结果
String body = new String(bytes).trim();
System.out.println("客户端已接受到服务端返回的数据: " + body);
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
//建立写缓冲区
ByteBuffer writebuf = ByteBuffer.allocate(1024);
Client client = new Client();
try {
while(true){
//定义一个字节数组，然后使用系统录入功能：
byte[] bytes = new byte[1024];
System.in.read(bytes);
//把数据放到缓冲区中
writebuf.put(bytes);
//对缓冲区进行复位
writebuf.flip();
//写出数据到服务端
client.sc.write(writebuf);
//清空缓冲区数据
writebuf.clear();
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if(client.sc != null){
try {
client.sc.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
,先启动服务端,然后再启动客户端:
效果如下:
Server:
Client:
