AIO的特点就是用户程序注册一个事件后就可以做其他事情,当事件被内核执行并得到结果后,我们的CompletionHandler会在I/O回调线程中被自动调用,有点类似观察者模式;因此我们的服务端会有很多个CompletionHandler
为了区别一个Handler是从接收缓冲区读入数据到ByteBuffer,还是将ByteBuffer中的内容写入发送缓冲区,我们定义了两个接口
/**
* server端处理请求的handler
*/
public interface InboundHandler {
/**
* 从通道接收缓冲区读取数据
* @param socketChannel client的channel
* @param in 分配的byteBuffer缓冲
* @return
*/
Object read(AsynchronousSocketChannel socketChannel, ByteBuffer in);
}
/**
* 对外输出的handler
*/
public interface OutboundHandler {
/**
* 向通道写输出的数据
*
* @param socketChannel client对应的channel
* @param out 向通道输出的数据
* @return
*/
Object write(AsynchronousSocketChannel socketChannel, ByteBuffer out);
}
/**
* accept完成时的handler
* deocder: 4 + body
* 前4个字节为一个int,值为body.length,后面紧跟body
* BEFORE DECODE (16 bytes) AFTER DECODE (12 bytes)
* +--------+----------------+ +----------------+
* | Length | Actual Content |----->| Actual Content |
* | 0x000C | "HELLO, WORLD" | | "HELLO, WORLD" |
* +--------+----------------+ +----------------+
* <p/>
* 无论成功还是失败,都要继续使server accept请求
* 不要再AcceptHandler中同步的读取数据
*/
public class ChannelAcceptedHandler implements CompletionHandler<AsynchronousSocketChannel, AsynchronousServerSocketChannel>, InboundHandler {
private final static Logger LOGGER = LoggerFactory.getLogger(ChannelAcceptedHandler.class);
/**
* 仅接受localhost请求
*/
private boolean onlyAcceptLocalhost;
public ChannelAcceptedHandler(boolean onlyAcceptLocalhost) {
this.onlyAcceptLocalhost = onlyAcceptLocalhost;
}
public void completed(AsynchronousSocketChannel socketChannel, AsynchronousServerSocketChannel attachment) {
//继续接受其他客户端的连接
attachment.accept(attachment, this);
try {
InetSocketAddress inetSocketAddress = (InetSocketAddress) socketChannel.getRemoteAddress();
String host = inetSocketAddress.getAddress().getHostAddress();
if (LOGGER.isDebugEnabled()) {
LOGGER.debug("remote host:{}", host);
}
if (onlyAcceptLocalhost && !"127.0.0.1".equals(host)) {
LOGGER.warn("拒绝ip:{}的连接", host);
socketChannel.close();
return;
}
} catch (IOException e) {
e.printStackTrace();
}
//读取前4个字节,也就是body的长度
ByteBuffer buffer = ByteBuffer.allocate(4);
read(socketChannel, buffer);
}
@Override
public Object read(AsynchronousSocketChannel socketChannel, ByteBuffer in) {
//开始监听读头部buffer
socketChannel.read(in, in, new ChannelReadHeadHandler(socketChannel));
return null;
}
public void failed(Throwable exc, AsynchronousServerSocketChannel attachment) {
attachment.accept(attachment, this);
LOGGER.error("连接错误", exc);
}
}
ChannelAcceptedHandler实现了InboundHandler,表明它是接收请求信息的CompletionHandler
onlyAcceptLocalhost是用来进行ip过滤的,是否只接受127.0.0.1的连接,如果连接应该被拒绝,则将socketChannel.close()调,不再向下继续处理
attachment.accept(attachment, this);
我们在AsyncServer执行了serverChannel.accept方法,为什么这里要继续执行呢?
答:执行serverChannel.accept仅注册了一次监听连接的事件,当服务端在accept完一个连接后,如果不继续注册,则服务端就无法继续接受请求了
需要非常注意的是,很多人只知道accept方法需要在每次accept成功后都要接着调用一次,却忽略了在accept失败时也需要继续调用。试想如果一个客户端在connect到server后,立即将连接close掉,而这个时候,server正准备处理这个尝试建立连接的请求,却发现已经不能用了,此时会触发failed方法,而非completed方法。网络情况是及其复杂的,这样的情况不可谓不常见。在实际测试中,我有过这样的测试用例,这也是在被坑后才注意到的。
如果继续网下面讲,就需要聊到协议了。通过查看socketChannel.read方法,你会发现AIO是先声明一个ByteBuffer,让内核往里面读入对应个数的byte,也就是说,需要先确定缓冲区大小,再调用read方法,注册回调事件。
纳尼,为什么不让我有机会先知道一下总的长度呢,例如Http协议有一个请求头,可以通过请求头中的信息,知道整个请求的大小。
这也是AIO看似编码简单,但是却很麻烦的地方。
我们采用了一个极其简单的协议:int(4 byte) + realbody的协议,也就是说先读到4个字节,解析成int类型,就知道后面的realbody有多少个字节,和客户端提前约定好;
ByteBuffer buffer = ByteBuffer.allocate(4);
read(socketChannel, buffer);
先分配4个字节到buffer中,再继续注册read事件
socketChannel.read(in, in, new ChannelReadHeadHandler(socketChannel));
ChannelReadHeadHandler将会成功读到4个字节,从而获取body的长度
/**
* 读取请求的内容,业务处理,取前4个字节,获取body的具体长度
*/
public class ChannelReadHeadHandler implements CompletionHandler<Integer, ByteBuffer>, InboundHandler {
private final static Logger LOGGER = LoggerFactory.getLogger(ChannelReadHeadHandler.class);
private AsynchronousSocketChannel channel;
private static int BODY_PAYLOAD = Constants.MB_1;
static {
String maxBodySize = System.getProperty("max_body_size");
if (maxBodySize != null && maxBodySize.trim().equals("")) {
try {
BODY_PAYLOAD = Integer.valueOf(maxBodySize);
} catch (Exception e) {
LOGGER.warn("环境变量max_body_size转换int失败:{}", maxBodySize);
}
}
if (BODY_PAYLOAD < 1) {
BODY_PAYLOAD = Constants.MB_1;
}
LOGGER.info("body-payload:{}", BODY_PAYLOAD);
}
public ChannelReadHeadHandler(AsynchronousSocketChannel channel) {
this.channel = channel;
}
public void completed(Integer result, ByteBuffer attachment) {
//如果条件成立,说明客户端主动终止了TCP套接字,这时服务端终止就可以了
if (result == -1 || result < 4) {
System.out.println("remote is close");
try {
channel.close();
} catch (IOException e) {
e.printStackTrace();
}
return;
}
attachment.flip();
//获取实际body的长度
Integer bodyLen = attachment.getInt();
LOGGER.info("bodyLen:" + bodyLen);
if (bodyLen > BODY_PAYLOAD) {
LOGGER.warn("请求体过大,直接丢弃,currentBodyLen:{}, maxLen:{}", bodyLen, BODY_PAYLOAD);
// result.read()
releaseConnection(channel);
return;
}
//为body生成一个buffer
ByteBuffer bodyBuffer = ByteBuffer.allocate(bodyLen);
read(channel, bodyBuffer);
}
@Override
public Object read(AsynchronousSocketChannel socketChannel, ByteBuffer in) {
//开始监听读buffer
socketChannel.read(in, in, new ChannelServerHandler(socketChannel));
return null;
}
public void failed(Throwable exc, ByteBuffer attachment) {
releaseConnection(this.channel);
}
private void releaseConnection(Channel channel) {
try {
channel.close();
LOGGER.warn("server close client channle");
} catch (IOException e) {
e.printStackTrace();
}
}
}
约定一个body的最大长度,我们的服务端不可能接受无止境的body,一定需要设置一个最大长度,超过这个长度的,就直接拒绝,如1MB
//如果条件成立,说明客户端主动终止了TCP套接字,这时服务端终止就可以了
if (result == -1 || result < 4) {
System.out.println("remote is close");
try {
channel.close();
} catch (IOException e) {
e.printStackTrace();
}
return;
}
result是成功读取到的byte个数
attachment.flip();
//获取实际body的长度
Integer bodyLen = attachment.getInt();
LOGGER.info("bodyLen:" + bodyLen);
if (bodyLen > BODY_PAYLOAD) {
LOGGER.warn("请求体过大,直接丢弃,currentBodyLen:{}, maxLen:{}", bodyLen, BODY_PAYLOAD);
releaseConnection(channel);
return;
}
ByteBuffer的常规操作,要读时先调用flip()方法,切换为读模式
attachment.getInt()从buffer中读出一个int,此处一共4个字节,恰好可以读到一个int,也就是body的长度,成功获取长度后立即判断长度是否过大
socketChannel.read(in, in, new ChannelServerHandler(socketChannel));
既然已经确定了长度,那么我们可以分配指定长度大小的Buffer继续从通道里面取数据了
下一节将讲解具体处理请求Handler
手机扫一扫
移动阅读更方便
你可能感兴趣的文章