WebSocketServerProtocolHandler源碼分析
package io.netty.handler.codec.http.websocketx;
import io.netty.buffer.Unpooled;
import io.netty.channel.Channel;
import io.netty.channel.ChannelFutureListener;
import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandler;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.channel.ChannelPipeline;
import io.netty.handler.codec.http.DefaultFullHttpResponse;
import io.netty.handler.codec.http.FullHttpRequest;
import io.netty.handler.codec.http.FullHttpResponse;
import io.netty.handler.codec.http.HttpHeaders;
import io.netty.handler.codec.http.HttpResponseStatus;
import io.netty.util.AttributeKey;
import java.util.List;
import static io.netty.handler.codec.http.HttpVersion.*;
public class WebSocketServerProtocolHandler extends WebSocketProtocolHandler {
public enum ServerHandshakeStateEvent {
@Deprecated
HANDSHAKE_COMPLETE
}
public static final class HandshakeComplete {
private final String requestUri;
private final HttpHeaders requestHeaders;
private final String selectedSubprotocol;
HandshakeComplete(String requestUri, HttpHeaders requestHeaders, String selectedSubprotocol) {
this.requestUri = requestUri;
this.requestHeaders = requestHeaders;
this.selectedSubprotocol = selectedSubprotocol;
}
public String requestUri() {
return requestUri;
}
public HttpHeaders requestHeaders() {
return requestHeaders;
}
public String selectedSubprotocol() {
return selectedSubprotocol;
}
}
private static final AttributeKey<WebSocketServerHandshaker> HANDSHAKER_ATTR_KEY =
AttributeKey.valueOf(WebSocketServerHandshaker.class, "HANDSHAKER");
//websocket的path
private final String websocketPath;
//子協議
private final String subprotocols;
//是否允許擴展 默認false
private final boolean allowExtensions;
//數據荷載最大長度默認65536
private final int maxFramePayloadLength;
//是否允許確實掩碼 默認false
private final boolean allowMaskMismatch;
//
private final boolean checkStartsWith;
public WebSocketServerProtocolHandler(String websocketPath, String subprotocols,
boolean allowExtensions, int maxFrameSize, boolean allowMaskMismatch,
boolean checkStartsWith, boolean dropPongFrames) {
super(dropPongFrames);
this.websocketPath = websocketPath;
this.subprotocols = subprotocols;
this.allowExtensions = allowExtensions;
maxFramePayloadLength = maxFrameSize;
this.allowMaskMismatch = allowMaskMismatch;
this.checkStartsWith = checkStartsWith;
}
//在channel連接成功後會回調次方法,插入websocket握手用處理器
@Override
public void handlerAdded(ChannelHandlerContext ctx) {
ChannelPipeline cp = ctx.pipeline();
//如果沒有握手處理器
if (cp.get(WebSocketServerProtocolHandshakeHandler.class) == null) {
// Add the WebSocketHandshakeHandler before this one.
//插入握手處理器到當前處理器的前面
//pipeline.addLast("http-codec", new HttpServerCodec());
//pipeline.addLast("aggregator", new HttpObjectAggregator(655360));
//pipeline.addLast("http-chunked", new ChunkedWriteHandler());
//插入位置,順序非常重要,必須插在http編解碼器的後面,必須插在當前處理器的前面
// pipeline.addLast("webSocketHandler", new WebSocketServerProtocolHandler("/websocket"));
ctx.pipeline().addBefore(ctx.name(), WebSocketServerProtocolHandshakeHandler.class.getName(),
new WebSocketServerProtocolHandshakeHandler(websocketPath, subprotocols,
allowExtensions, maxFramePayloadLength, allowMaskMismatch, checkStartsWith));
}
if (cp.get(Utf8FrameValidator.class) == null) {
// Add the UFT8 checking before this one.
//插入在當前處理器的前面
ctx.pipeline().addBefore(ctx.name(), Utf8FrameValidator.class.getName(),
new Utf8FrameValidator());
}
}
@Override
protected void decode(ChannelHandlerContext ctx, WebSocketFrame frame, List<Object> out) throws Exception {
//如果是close幀
if (frame instanceof CloseWebSocketFrame) {
//獲取channel中關聯的握手器去關閉當前channel
WebSocketServerHandshaker handshaker = getHandshaker(ctx.channel());
if (handshaker != null) {
//因爲計數器需要+1,因爲傳入到close方法中會調用channel.write方法進行輸出,底層會再次釋放
frame.retain();
handshaker.close(ctx.channel(), (CloseWebSocketFrame) frame);
} else {
//沒有握手器輸出空字節後關閉底層socket
ctx.writeAndFlush(Unpooled.EMPTY_BUFFER).addListener(ChannelFutureListener.CLOSE);
}
return;
}
//調用父類,父類處理了ping-pong 二幀。
super.decode(ctx, frame, out);
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
//如果是websocket相關異常則返回http響應後關閉底層流
if (cause instanceof WebSocketHandshakeException) {
FullHttpResponse response = new DefaultFullHttpResponse(
HTTP_1_1, HttpResponseStatus.BAD_REQUEST, Unpooled.wrappedBuffer(cause.getMessage().getBytes()));
ctx.channel().writeAndFlush(response).addListener(ChannelFutureListener.CLOSE);
} else {
ctx.fireExceptionCaught(cause);
ctx.close();
}
}
//從channel獲取關聯的握手器
static WebSocketServerHandshaker getHandshaker(Channel channel) {
return channel.attr(HANDSHAKER_ATTR_KEY).get();
}
//握手器綁定到channel
static void setHandshaker(Channel channel, WebSocketServerHandshaker handshaker) {
channel.attr(HANDSHAKER_ATTR_KEY).set(handshaker);
}
//
static ChannelHandler forbiddenHttpRequestResponder() {
return new ChannelInboundHandlerAdapter() {
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
//返回拒絕的http響應
if (msg instanceof FullHttpRequest) {
((FullHttpRequest) msg).release();
FullHttpResponse response =
new DefaultFullHttpResponse(HTTP_1_1, HttpResponseStatus.FORBIDDEN);
ctx.channel().writeAndFlush(response);
} else {
//向下傳播
ctx.fireChannelRead(msg);
}
}
};
}
}