Websocket 认证

更新：2025-09-29

方式1、方式2可以混用，否则会出现握手无响应（是因为有个 checkStartsWith 参数需要设置为 true）

1
2
3
io.netty.handler.codec.http.websocketx.WebSocketServerProtocolHandshakeHandler#channelRead
    
io.netty.handler.codec.http.websocketx.WebSocketServerHandshaker13#newHandshakeResponse

方式1 基于 url 参数方式

1
const socket = new WebSocket('ws://127.0.0.1:8080/ws?token=xxx')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
@Override
    protected void initChannel(SocketChannel socketChannel) throws Exception {
        ChannelPipeline pipeline = socketChannel.pipeline();
//        pipeline.addLast(new LoggingHandler(LogLevel.INFO));

        // 因为使用 HTTP 协议，所以需要 HTTP编码器，解码器
        // WebSocket 握手完成后，HTTP 相关的 handler（如 HttpServerCodec）会被移除，后续通信直接使用 WebSocket 帧
        pipeline.addLast(new HttpServerCodec());

        // 以块方式，添加 chunkedWriter 处理器
        pipeline.addLast(new ChunkedWriteHandler());

        /*
         * 1. http数据在传输中是分段的，HttpObjectAggregator 可以把多个段聚合起来
         * 2. 这就是为什么当浏览器发送大量数据时，就会发出多次 http请求的原因
         */
        pipeline.addLast(new HttpObjectAggregator(1024 * 512));

        // 添加WebSocket消息压缩处理器
        // 会报错
        //  RSV != 0 and no extension negotiated, RSV:4
//        pipeline.addLast(new WebSocketServerCompressionHandler());

        // 保存用户ip
        // pipeline.addLast(new HttpHeadersHandler());

//        pipeline.addLast(new LifeCyCleHandler());

        //设置一个空闲状态处理程序（心跳机制），读空闲，写空闲，读写空闲
        pipeline.addLast(new IdleStateHandler(120, 0, 0));

        // 自定义参数处理器，必须放在 new WebSocketServerProtocolHandler() 处理器之前
        pipeline.addLast("auth", authUrlHandler);
        // WebSocket协议处理器，关键配置
        pipeline.addLast(new WebSocketServerProtocolHandler(
                "/ws",  // WebSocket路径
                null,   // 子协议，不指定
                true,   // 允许扩展
                65536,  // 最大帧大小
                false,  // 不允许掩码
                true    // 握手超时后关闭连接
        ));
        pipeline.addLast(new WebSocketHandshakeCompleteHandler());
        pipeline.addLast(new NettyChatHandler());  //添加自定义handler
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
@Slf4j
@Component
@ChannelHandler.Sharable
public class AuthUrlHandler extends SimpleChannelInboundHandler<FullHttpRequest> {

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, FullHttpRequest httpRequest) throws Exception {

//        String method = httpRequest.method().name();
//        String upgrade = httpRequest.headers().get(HttpHeaderNames.UPGRADE);
//        log.info("authHandler channelRead0 ctx={}, method: {}, upgrade: {}", ctx.channel(), method, upgrade);

        QueryStringDecoder queryStringDecoder = new QueryStringDecoder(httpRequest.uri());
        List<String> tokens = queryStringDecoder.parameters().get("token");
        if (tokens != null && !tokens.isEmpty()) {
            // 将 token 放到 attr 中，后面握手成功后校验token
            ctx.channel().attr(AttributeKeyUtils.TOKEN).set(tokens.get(0));
        }
        ctx.fireChannelRead(httpRequest.retain());
    }

}
1
2
3
4
5
6
7
8
@Slf4j
public class NettyChatHandler extends SimpleChannelInboundHandler<TextWebSocketFrame> {
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, TextWebSocketFrame msg) throws Exception {
        String text = msg.text();
        log.info("Received Message: {}", text);
    }
}

方式2 基于 subprotocol 方式

长度受限制，浏览器实现、http 请求头长度（nginx、apache），netty 服务端可以配置 * 匹配所有的协议，或者在 selectSubprotocol 匹配指定前缀开始的协议。

1
2
3
const jwtToken = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...'; // 你的JWT Token
const authProtocol = 'auth.bearer.' + jwtToken;
const socket = new WebSocket('ws://127.0.0.1:8080/ws', [authProtocol, 'chat', 'gps']);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
@Component
public class NettyServerInitializer extends ChannelInitializer<SocketChannel> {

    @Autowired
    private NettyWebSocketProperties nettyWebSocketProperties;

    @Override
    protected void initChannel(SocketChannel socketChannel) throws Exception {
        ChannelPipeline pipeline = socketChannel.pipeline();
//        pipeline.addLast(new LoggingHandler(LogLevel.INFO));

        // 因为使用 HTTP 协议，所以需要 HTTP编码器，解码器
        // WebSocket 握手完成后，HTTP 相关的 handler（如 HttpServerCodec）会被移除，后续通信直接使用 WebSocket 帧
        pipeline.addLast(new HttpServerCodec());

        // 以块方式，添加 chunkedWriter 处理器
        pipeline.addLast(new ChunkedWriteHandler());

        /*
         * 1. http数据在传输中是分段的，HttpObjectAggregator 可以把多个段聚合起来
         * 2. 这就是为什么当浏览器发送大量数据时，就会发出多次 http请求的原因
         */
        pipeline.addLast(new HttpObjectAggregator(1024 * 512));

        // 添加WebSocket消息压缩处理器
        // 会报错
        //  RSV != 0 and no extension negotiated, RSV:4
//        pipeline.addLast(new WebSocketServerCompressionHandler());

        // 保存用户ip
        // pipeline.addLast(new HttpHeadersHandler());

//        pipeline.addLast(new LifeCyCleHandler());

        //设置一个空闲状态处理程序（心跳机制），读空闲，写空闲，读写空闲
        pipeline.addLast(new IdleStateHandler(120, 0, 0));

        pipeline.addLast("websocket", new CustomWebSocketServerProtocolHandler(nettyWebSocketProperties));
        pipeline.addLast(new WebSocketHandshakeCompleteHandler());
        pipeline.addLast(new NettyChatHandler());  //添加自定义handler
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
@Slf4j
@ChannelHandler.Sharable
public class WebSocketHandshakeCompleteHandler extends ChannelInboundHandlerAdapter {

    private static final String AUTH_BEARER_PREFIX = "auth.bearer.";

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {

        Channel channel = ctx.channel();
        String channelId = channel.id().asShortText();

        if (ChannelManager.containsChannel(channelId)) {
            return;
        }
        ChannelManager.registerChannel(ctx);
        channel.closeFuture().addListener(future -> ChannelManager.unregisterChannel(channelId));

        InetSocketAddress socketAddress = (InetSocketAddress) channel.remoteAddress();
        String clientIp = socketAddress.getAddress().getHostAddress();
        int clientPort = socketAddress.getPort();
        log.info("客户端【{}】连接 netty 服务器[{}: {}]，连接通道数量: {}", channelId, clientIp, clientPort, ChannelManager.channelCount());

        // 内部就是调用的     ctx.fireChannelActive();
        super.channelActive(ctx);
    }

    @Override
    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
        // 处理握手完成事件
        if (evt instanceof HandshakeComplete) {
            HandshakeComplete handshakeComplete = (HandshakeComplete) evt;
            //协议握手成功完成
            String subprotocol = handshakeComplete.selectedSubprotocol();
            log.info("WebSocket握手成功: URI={}, 子协议={}", handshakeComplete.requestUri(), subprotocol);
            if (subprotocol != null) {
            }
            HttpHeaders headers = handshakeComplete.requestHeaders();
            for (String name : headers.names()) {
                log.info("name: {},value: {}", name, headers.get(name));
            }

            String authToken = null;
            String protocolsHeaderValue = headers.get(HttpHeaderNames.SEC_WEBSOCKET_PROTOCOL);
            if (protocolsHeaderValue != null) {
                String[] requestedProtocols = protocolsHeaderValue.split(",");
                for (String protocol : requestedProtocols) {
                    String trimmedProtocol = protocol.trim();
                    if (trimmedProtocol.startsWith(AUTH_BEARER_PREFIX)) {
                        authToken = trimmedProtocol.substring(AUTH_BEARER_PREFIX.length());
                        log.info("Extracted auth.bearer token: {}", authToken);
                        ctx.channel().attr(AttributeKeyUtils.TOKEN).set(authToken);
                        break; // Found the token, no need to check further
                    }
                }
            }
            TokenUtil.validateToken(ctx);
            // 将事件传递给下一个处理器
            ctx.fireUserEventTriggered(evt);
        } else if (evt instanceof ServerHandshakeStateEvent) {
            ServerHandshakeStateEvent stateEvent = (ServerHandshakeStateEvent) evt;

            log.info("握手状态变化: {}", stateEvent);
            ctx.fireUserEventTriggered(evt);
        } else if (evt instanceof IdleStateEvent) {
            log.info("idle state event");
            super.userEventTriggered(ctx, evt);
        } else {
            super.userEventTriggered(ctx, evt);
        }
    }


    /**
     * 客户端、服务端断开都会调用
     *
     * @param ctx
     * @throws Exception
     */
    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {

        Channel channel = ctx.channel();
        String channelId = channel.id().asShortText();

        InetSocketAddress socketAddress = (InetSocketAddress) channel.remoteAddress();
        String clientIp = socketAddress.getAddress().getHostAddress();
        int clientPort = socketAddress.getPort();

        log.info("客户端【{}】退出 netty 服务器[IP:{}--->PORT:{}]", channelId, clientIp, clientPort);

        if (ChannelManager.containsChannel(channelId)) {
            ChannelManager.unregisterChannel(channelId);
        }

        super.channelInactive(ctx);
    }
}

io.netty.handler.codec.http.websocketx.WebSocketServerHandshaker13 重写 selectSubprotocol 方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
package io.netty.handler.codec.http.websocketx;

import io.arukas.netty.support.TokenUtil;
import io.netty.handler.codec.http.*;
import io.netty.util.CharsetUtil;

import static io.netty.handler.codec.http.HttpMethod.GET;
import static io.netty.handler.codec.http.HttpVersion.HTTP_1_1;

public class WebSocketServerHandshaker13 extends WebSocketServerHandshaker {

    public static final String WEBSOCKET_13_ACCEPT_GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";

    /**
     * Constructor specifying the destination web socket location
     *
     * @param webSocketURL
     *        URL for web socket communications. e.g "ws://myhost.com/mypath". Subsequent web
     *        socket frames will be sent to this URL.
     * @param subprotocols
     *        CSV of supported protocols
     * @param allowExtensions
     *        Allow extensions to be used in the reserved bits of the web socket frame
     * @param maxFramePayloadLength
     *        Maximum allowable frame payload length. Setting this value to your application's
     *        requirement may reduce denial of service attacks using long data frames.
     */
    public WebSocketServerHandshaker13(
            String webSocketURL, String subprotocols, boolean allowExtensions, int maxFramePayloadLength) {
        this(webSocketURL, subprotocols, allowExtensions, maxFramePayloadLength, false);
    }

    /**
     * Constructor specifying the destination web socket location
     *
     * @param webSocketURL
     *        URL for web socket communications. e.g "ws://myhost.com/mypath". Subsequent web
     *        socket frames will be sent to this URL.
     * @param subprotocols
     *        CSV of supported protocols
     * @param allowExtensions
     *        Allow extensions to be used in the reserved bits of the web socket frame
     * @param maxFramePayloadLength
     *        Maximum allowable frame payload length. Setting this value to your application's
     *        requirement may reduce denial of service attacks using long data frames.
     * @param allowMaskMismatch
     *            When set to true, frames which are not masked properly according to the standard will still be
     *            accepted.
     */
    public WebSocketServerHandshaker13(
            String webSocketURL, String subprotocols, boolean allowExtensions, int maxFramePayloadLength,
            boolean allowMaskMismatch) {
        this(webSocketURL, subprotocols, WebSocketDecoderConfig.newBuilder()
            .allowExtensions(allowExtensions)
            .maxFramePayloadLength(maxFramePayloadLength)
            .allowMaskMismatch(allowMaskMismatch)
            .build());
    }

    /**
     * Constructor specifying the destination web socket location
     *
     * @param webSocketURL
     *        URL for web socket communications. e.g "ws://myhost.com/mypath". Subsequent web
     *        socket frames will be sent to this URL.
     * @param subprotocols
     *        CSV of supported protocols
     * @param decoderConfig
     *            Frames decoder configuration.
     */
    public WebSocketServerHandshaker13(
            String webSocketURL, String subprotocols, WebSocketDecoderConfig decoderConfig) {
        super(WebSocketVersion.V13, webSocketURL, subprotocols, decoderConfig);
    }

    /**
     * <p>
     * Handle the web socket handshake for the web socket specification <a href=
     * "https://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-17">HyBi versions 13-17</a>. Versions 13-17
     * share the same wire protocol.
     * </p>
     *
     * <p>
     * Browser request to the server:
     * </p>
     *
     * <pre>
     * GET /chat HTTP/1.1
     * Host: server.example.com
     * Upgrade: websocket
     * Connection: Upgrade
     * Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==
     * Origin: http://example.com
     * Sec-WebSocket-Protocol: chat, superchat
     * Sec-WebSocket-Version: 13
     * </pre>
     *
     * <p>
     * Server response:
     * </p>
     *
     * <pre>
     * HTTP/1.1 101 Switching Protocols
     * Upgrade: websocket
     * Connection: Upgrade
     * Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=
     * Sec-WebSocket-Protocol: chat
     * </pre>
     */
    @Override
    protected FullHttpResponse newHandshakeResponse(FullHttpRequest req, HttpHeaders headers) {
        HttpMethod method = req.method();
        if (!GET.equals(method)) {
            throw new WebSocketServerHandshakeException("Invalid WebSocket handshake method: " + method, req);
        }

        HttpHeaders reqHeaders = req.headers();
        if (!reqHeaders.contains(HttpHeaderNames.CONNECTION) ||
            !reqHeaders.containsValue(HttpHeaderNames.CONNECTION, HttpHeaderValues.UPGRADE, true)) {
            throw new WebSocketServerHandshakeException(
                    "not a WebSocket request: a |Connection| header must includes a token 'Upgrade'", req);
        }

        if (!reqHeaders.contains(HttpHeaderNames.UPGRADE, HttpHeaderValues.WEBSOCKET, true)) {
            throw new WebSocketServerHandshakeException(
                    "not a WebSocket request: a |Upgrade| header must containing the value 'websocket'", req);
        }

        CharSequence key = reqHeaders.get(HttpHeaderNames.SEC_WEBSOCKET_KEY);
        if (key == null) {
            throw new WebSocketServerHandshakeException("not a WebSocket request: missing key", req);
        }

        FullHttpResponse res = new DefaultFullHttpResponse(HTTP_1_1, HttpResponseStatus.SWITCHING_PROTOCOLS,
                req.content().alloc().buffer(0));
        if (headers != null) {
            res.headers().add(headers);
        }

        String acceptSeed = key + WEBSOCKET_13_ACCEPT_GUID;
        byte[] sha1 = WebSocketUtil.sha1(acceptSeed.getBytes(CharsetUtil.US_ASCII));
        String accept = WebSocketUtil.base64(sha1);

        if (logger.isDebugEnabled()) {
            logger.debug("WebSocket version 13 server handshake key: {}, response: {}", key, accept);
        }

        res.headers().set(HttpHeaderNames.UPGRADE, HttpHeaderValues.WEBSOCKET)
                     .set(HttpHeaderNames.CONNECTION, HttpHeaderValues.UPGRADE)
                     .set(HttpHeaderNames.SEC_WEBSOCKET_ACCEPT, accept);

        String subprotocols = reqHeaders.get(HttpHeaderNames.SEC_WEBSOCKET_PROTOCOL);
        if (subprotocols != null) {
            String selectedSubprotocol = selectSubprotocol(subprotocols);
            if (selectedSubprotocol == null) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Requested subprotocol(s) not supported: {}", subprotocols);
                }
            } else {
                res.headers().set(HttpHeaderNames.SEC_WEBSOCKET_PROTOCOL, selectedSubprotocol);
            }
        }
        return res;
    }

    @Override
    protected WebSocketFrameDecoder newWebsocketDecoder() {
        return new WebSocket13FrameDecoder(decoderConfig());
    }

    @Override
    protected WebSocketFrameEncoder newWebSocketEncoder() {
        return new WebSocket13FrameEncoder(false);
    }

    @Override
    protected String selectSubprotocol(String requestedSubprotocols) {
        // 1. 先执行默认匹配逻辑
        String selected = super.selectSubprotocol(requestedSubprotocols);

        // 2. 自定义扩展：若默认匹配失败，检查动态协议（如JWT）
        if (selected == null && requestedSubprotocols != null) {
            String[] requested = requestedSubprotocols.split(",");
            for (String p : requested) {
                String protocol = p.trim();
                // 支持以"auth.jwt."为前缀的动态协议
                if (protocol.startsWith(TokenUtil.AUTH_BEARER_PREFIX)) {
                    return protocol; // 直接返回动态协议（需后续验证有效性）
                }
            }
        }

        return selected;
    }
}

方式3 基于 消息 方式(推荐)

握手成功后，第一条消息是认证消息，后面是业务消息

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
@Slf4j
@ChannelHandler.Sharable
public class WebSocketHandshakeCompleteHandler extends ChannelInboundHandlerAdapter {

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {

        Channel channel = ctx.channel();
        // 初始化为 false
        ctx.channel().attr(AttributeKeyUtils.AUTH).setIfAbsent(false);

        String channelId = channel.id().asShortText();

        if (ChannelManager.containsChannel(channelId)) {
            return;
        }
        ChannelManager.registerChannel(ctx);
        channel.closeFuture().addListener(future -> ChannelManager.unregisterChannel(channelId));

        InetSocketAddress socketAddress = (InetSocketAddress) channel.remoteAddress();
        String clientIp = socketAddress.getAddress().getHostAddress();
        int clientPort = socketAddress.getPort();
        log.info("客户端【{}】连接 netty 服务器[{}: {}]，连接通道数量: {}", channelId, clientIp, clientPort, ChannelManager.channelCount());

        // 内部就是调用的     ctx.fireChannelActive();
        super.channelActive(ctx);
    }

    @Override
    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
        // 处理握手完成事件
        if (evt instanceof HandshakeComplete) {
            //协议握手成功完成
            HandshakeComplete handshakeComplete = (HandshakeComplete) evt;
            String subprotocol = handshakeComplete.selectedSubprotocol();
            log.info("WebSocket握手成功: URI={}, 子协议={}", handshakeComplete.requestUri(), subprotocol);
            HttpHeaders headers = handshakeComplete.requestHeaders();
//            for (String name : headers.names()) {
//                log.info("name: {},value: {}", name, headers.get(name));
//            }

            String authToken = null;
            String protocolsHeaderValue = headers.get(HttpHeaderNames.SEC_WEBSOCKET_PROTOCOL);
            if (protocolsHeaderValue != null) {
                String[] requestedProtocols = protocolsHeaderValue.split(",");
                for (String protocol : requestedProtocols) {
                    String trimmedProtocol = protocol.trim();
                    if (trimmedProtocol.startsWith(TokenUtil.AUTH_BEARER_PREFIX)) {
                        authToken = trimmedProtocol.substring(TokenUtil.AUTH_BEARER_PREFIX.length());
                        log.info("Extracted auth.bearer token: {}", authToken);
                        ctx.channel().attr(AttributeKeyUtils.TOKEN).set(authToken);
                        break; // Found the token, no need to check further
                    }
                }
            }
            TokenUtil.validateToken(ctx);
            // 将事件传递给下一个处理器
            ctx.fireUserEventTriggered(evt);
        } else if (evt instanceof ServerHandshakeStateEvent) {
            ServerHandshakeStateEvent stateEvent = (ServerHandshakeStateEvent) evt;
            log.info("握手状态变化: {}", stateEvent);
            ctx.fireUserEventTriggered(evt);
        } else if (evt instanceof IdleStateEvent) {
            log.info("idle state event");
            super.userEventTriggered(ctx, evt);
        } else {
            super.userEventTriggered(ctx, evt);
        }
    }


    /**
     * 客户端、服务端断开都会调用
     *
     * @param ctx
     * @throws Exception
     */
    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {

        Channel channel = ctx.channel();
        String channelId = channel.id().asShortText();

        InetSocketAddress socketAddress = (InetSocketAddress) channel.remoteAddress();
        String clientIp = socketAddress.getAddress().getHostAddress();
        int clientPort = socketAddress.getPort();

        log.info("客户端【{}】退出 netty 服务器[IP:{}--->PORT:{}]", channelId, clientIp, clientPort);

        if (ChannelManager.containsChannel(channelId)) {
            ChannelManager.unregisterChannel(channelId);
        }

        super.channelInactive(ctx);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
@Slf4j
public class NettyChatHandler extends SimpleChannelInboundHandler<TextWebSocketFrame> {

    private static final ObjectMapper objectMapper = new ObjectMapper();
    private static final JsonNodeFactory factory = JsonNodeFactory.instance;

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, TextWebSocketFrame msg) throws Exception {
        String text = msg.text();
        log.info("Received Message: {}", text);

        NettyMsg nettyMsg = objectMapper.readValue(text, NettyMsg.class);

        Channel channel = ctx.channel();
        Boolean auth = channel.attr(AttributeKeyUtils.AUTH).get();
        String type = nettyMsg.getType();
        if(!auth){ // 没有认证
            if(!"auth".equals(type)){ // 不是认证消息，直接断开连接
                CloseWebSocketFrame closeFrame = new CloseWebSocketFrame(1008, "请先认证再发消息");
                ctx.writeAndFlush(closeFrame).addListener(ChannelFutureListener.CLOSE);
                return;
            }else{
                // TODO: 认证

                channel.attr(AttributeKeyUtils.AUTH).set(true);
                ctx.fireChannelRead(msg.retain());
                return;
            }
        }
	}
}
赏

谢谢你请我吃糖果

支付宝
微信
|阅读量()

扫一扫，分享到微信

微信分享二维码
本站总访问量次 |

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

Java码农