@Override
public NextAction handleWrite(FilterChainContext context) throws IOException {
Connection<?> connection = context.getConnection();
GrizzlyChannel channel = GrizzlyChannel.getOrAddChannel(connection, url, handler);
try {
UnsafeByteArrayOutputStream output = new UnsafeByteArrayOutputStream(1024); // 不需要关闭
if (!(context.getMessage() instanceof Response)) {
downstreamCodec.encode(channel, output, context.getMessage());
} else {
upstreamCodec.encode(channel, output, context.getMessage());
}
GrizzlyChannel.removeChannelIfDisconnectd(connection);
byte[] bytes = output.toByteArray();
Buffer buffer = connection.getTransport().getMemoryManager().allocate(bytes.length);
buffer.put(bytes);
buffer.flip();
buffer.allowBufferDispose(true);
context.setMessage(buffer);
} finally {
GrizzlyChannel.removeChannelIfDisconnectd(connection);
}
return context.getInvokeAction();
}
@Override
public NextAction handleRead(final FilterChainContext ctx) throws IOException {
String message = (String) ctx.getMessage();
logger.log(Level.INFO, "First chunk come: {0}", message);
intermResultQueue.add(message);
Connection connection = ctx.getConnection();
connection.setBlockingReadTimeout(10, TimeUnit.SECONDS);
try {
for (int i = 0; i < clientMsgs - 1; i++) {
final ReadResult rr = ctx.read();
final String blckMsg = (String) rr.getMessage();
rr.recycle();
logger.log(Level.INFO, "Blocking chunk come: {0}", blckMsg);
intermResultQueue.add(blckMsg);
message += blckMsg;
}
} catch (Exception e) {
intermResultQueue.add(e);
return ctx.getStopAction();
}
ctx.setMessage(message);
return ctx.getInvokeAction();
}
/*
* 接收
*
* @param context 上下文
* @param channel 通道
* @param buffer 缓存
* @param readable 缓存可读
* @param bytes 输入缓存
* @param offset 指向已读数据的偏移量，off之前的数据都是已用过的
* @param limit 有效长度，limit之后的长度是空白或无效数据，off到limit之间的数据是准备使用的数据
* @return 后续动作
* @throws IOException
*/
private NextAction receive(
FilterChainContext context,
Channel channel,
Buffer buffer,
int readable,
byte[] bytes,
int offset,
int limit)
throws IOException {
for (; ; ) {
int read = Math.min(readable, bytes.length - limit); // 取bytes缓存空闲区，和可读取新数据，的最小值，即：此次最多读写数据的大小
buffer.get(bytes, limit, read); // 从可读取新数据中，读取数据，尽量填满bytes缓存空闲区
limit += read; // 有效数据变长
readable -= read; // 可读数据变少
UnsafeByteArrayInputStream input =
new UnsafeByteArrayInputStream(
bytes, offset, limit - offset); // 将bytes缓存转成InputStream，不需要关闭
Object msg = upstreamCodec.decode(channel, input); // 调用Codec接口，解码数据
if (msg == Codec.NEED_MORE_INPUT) { // 如果Codec觉得数据不够，不足以解码成一个对象
if (readable == 0) { // 如果没有更多可读数据
channel.setAttribute(
BUFFER_KEY, new Object[] {bytes, offset, limit}); // 放入通道属性中，等待下一个Buffer的到来
return context.getStopAction();
} else { // 扩充或挪出空闲区，并循环，直到可读数据都加载到bytes缓存
if (offset == 0) { // 如果bytes缓存全部没有被使用，如果这时数据还不够
bytes = Bytes.copyOf(bytes, bytes.length << 1); // 将bytes缓存扩大一倍
} else { // 如果bytes缓存有一段数据已被使用
int len = limit - offset; // 计算有效数据长度
System.arraycopy(
bytes, offset, bytes, 0, len); // 将数据向前移到，压缩到已使用的部分，这样limit后面就会多出一些空闲，可以放数据
offset = 0; // 移到后，bytes缓存没有数据被使用
limit = len; // 移到后，有效数据都在bytes缓存最前面
}
}
} else { // 如果解析出一个结果
int position = input.position(); // 记录InputStream用了多少
if (position == offset) { // 如果InputStream没有被读过，就返回了数据，直接报错，否则InputStream永远读不完，会死递归
throw new IOException("Decode without read data.");
}
offset = position; // 记录已读数据
context.setMessage(msg); // 将消息改为解码后的对象，以便被后面的Filter使用。
if (limit - offset > 0 || readable > 0) { // 如果有效数据没有被读完，或者Buffer区还有未读数据
return context.getInvokeAction(
new Object[] {
buffer, readable, bytes, offset, limit
}); // 正常执行完Filter，并重新发起一轮Filter，继续读
} else { // 否则所有数据读完
return context.getInvokeAction(); // 正常执行完Filter
}
}
}
}
@Override
public NextAction handleWrite(final FilterChainContext ctx) throws IOException {
Object message = ctx.getMessage();
if (message instanceof RequestInfoHolder) {
ctx.setMessage(null);
if (!sendAsGrizzlyRequest((RequestInfoHolder) message, ctx)) {
return ctx.getSuspendAction();
}
} else if (message instanceof Buffer) {
return ctx.getInvokeAction();
}
return ctx.getStopAction();
}
private static FilterChainContext obtainProtocolChainContext(
final FilterChainContext ctx, final FilterChain completeProtocolFilterChain) {
final FilterChainContext newFilterChainContext =
completeProtocolFilterChain.obtainFilterChainContext(
ctx.getConnection(),
ctx.getStartIdx() + 1,
completeProtocolFilterChain.size(),
ctx.getFilterIdx() + 1);
newFilterChainContext.setAddressHolder(ctx.getAddressHolder());
newFilterChainContext.setMessage(ctx.getMessage());
newFilterChainContext.getInternalContext().setIoEvent(ctx.getInternalContext().getIoEvent());
ctx.getConnection().setProcessor(completeProtocolFilterChain);
return newFilterChainContext;
}