netty的ChannelPipeline執行順序對inBound和outBound執行器造成的影響

　　進行這項實驗之前，先讀了xbmchina的簡書文章，感謝這位大神提供的關於channelPipeline和channelHandler文章：

　　【Netty】ChannelPipeline和ChannelHandler（一）

　　【Netty】ChannelHandler的添加和刪除（二）

　　【Netty】inBound和outBound事件的傳播過程

　　之前想以leonzm的websocket_demo項目為基礎，寫netty4版本的聊天室，但是發現netty4的函數不一樣，messageReceived（建立鏈接/接收數據包）和close（斷開鏈接）不能覆寫，研究了下handler的生命周期。知道channelRead0可以建立鏈接，並接收已建立鏈接的客戶端的數據包；當隧道處於channelInactived階段時，表明數據隧道（鏈接）要斷開了，就要進入channelUnregistered階段，這時就可以在上面執行鏈接相關數據清除工作；隧道的處理器ChannelHandler也有生命周期，handlerRemoved時也可以執行類似操作。

　　netty的inbound和outbound的區別：除了inbound事件為被動觸發，在某些情況發生時自動觸發，outbound為主動觸發，在需要主動執行某些操作時觸發以外，outBound單獨用不能接收到websocket客戶端的信息（這是向外主動發信息的handler，接收信息要inbound來），outBound這個跟適合在pipeline流水線上嵌入，做AOP（切面編程）。

　　開始執行channelPipeline流水線程序比較：

　　Lanucher.java:（開啟netty服務的主函數）

package com.company.lanucher;

import com.company.server.ReversedWebSocketServer;
import com.company.server.WebSocketServer;

public class Lanucher {

    public static void main(String[] args) throws Exception {
        // 啟動WebSocket，如果想開啟另一個服務器，注釋掉Reversed，再解除WebSocketServer的注釋即可
        //new WebSocketServer().run(WebSocketServer.WEBSOCKET_PORT);
        new ReversedWebSocketServer().run(ReversedWebSocketServer.WEBSOCKET_PORT);
    }
    
}

　　WebSocketServer.java:（流水線先執行inBoundHandler再執行OutBoundAdapter）

package com.company.server;

import org.apache.log4j.Logger;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.Channel;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.http.HttpObjectAggregator;
import io.netty.handler.codec.http.HttpServerCodec;
import io.netty.handler.stream.ChunkedWriteHandler;

/**
 * WebSocket服務
 *
 */
public class WebSocketServer {
    private static final Logger LOG = Logger.getLogger(WebSocketServer.class);
    
    // websocket端口
    public static final int WEBSOCKET_PORT = 9090;

    public void run(int port) throws Exception {
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap b = new ServerBootstrap();
            b.group(bossGroup, workerGroup).channel(NioServerSocketChannel.class).childHandler(new ChannelInitializer<Channel>() {

                @Override
                protected void initChannel(Channel channel) throws Exception {
                    ChannelPipeline pipeline = channel.pipeline();
                    pipeline.addLast("http-codec", new HttpServerCodec()); // Http消息編碼解碼
                    pipeline.addLast("aggregator", new HttpObjectAggregator(65536)); // Http消息組裝
                    pipeline.addLast("http-chunked", new ChunkedWriteHandler()); // WebSocket通信支持
                    pipeline.addLast("adapter", new FunWebSocketServerHandler()); // WebSocket服務端Handler的前置攔截器
                    pipeline.addLast("handler", new BananaWebSocketServerHandler()); // WebSocket服務端Handler
                }
            });
            
            Channel channel = b.bind(port).sync().channel();
            LOG.info("WebSocket 已經啟動，端口：" + port + ".");
            channel.closeFuture().sync();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}

　　ReversedWebSocketServer.java:（流水線先執行OutBoundAdapter再執行inBoundHandler）

package com.company.server;

import org.apache.log4j.Logger;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.Channel;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.http.HttpObjectAggregator;
import io.netty.handler.codec.http.HttpServerCodec;
import io.netty.handler.stream.ChunkedWriteHandler;

public class ReversedWebSocketServer {
    private static final Logger LOG = Logger.getLogger(WebSocketServer.class);
    
    // websocket端口
    public static final int WEBSOCKET_PORT = 9090;
    public static final int FUN_WEBSOCKET_PORT = 9091;

    public void run(int port) throws Exception {
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap b = new ServerBootstrap();
            b.group(bossGroup, workerGroup).channel(NioServerSocketChannel.class).childHandler(new ChannelInitializer<Channel>() {

                @Override
                protected void initChannel(Channel channel) throws Exception {
                    ChannelPipeline pipeline = channel.pipeline();
                    pipeline.addLast("http-codec", new HttpServerCodec()); // Http消息編碼解碼
                    pipeline.addLast("aggregator", new HttpObjectAggregator(65536)); // Http消息組裝
                    pipeline.addLast("http-chunked", new ChunkedWriteHandler()); // WebSocket通信支持
                    pipeline.addLast("handler", new BananaWebSocketServerHandler()); // WebSocket服務端Handler
                    pipeline.addLast("adapter", new FunWebSocketServerHandler()); // WebSocket服務端Handler
                }
            });
            
            Channel channel = b.bind(port).sync().channel();
            LOG.info("WebSocket 已經啟動，端口：" + port + ".");
            channel.closeFuture().sync();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
    
}

　　BananaWebSocketServerHandler.java:（inBoundHandler，處理從客戶端接收的請求）

package com.company.server;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelFutureListener;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelPromise;
import io.netty.channel.SimpleChannelInboundHandler;
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.handler.codec.http.HttpVersion;
import io.netty.handler.codec.http.websocketx.CloseWebSocketFrame;
import io.netty.handler.codec.http.websocketx.PingWebSocketFrame;
import io.netty.handler.codec.http.websocketx.PongWebSocketFrame;
import io.netty.handler.codec.http.websocketx.TextWebSocketFrame;
import io.netty.handler.codec.http.websocketx.WebSocketFrame;
import io.netty.handler.codec.http.websocketx.WebSocketServerHandshaker;
import io.netty.handler.codec.http.websocketx.WebSocketServerHandshakerFactory;
import io.netty.util.CharsetUtil;

import org.apache.log4j.Logger;

import com.company.serviceimpl.BananaService;
import com.company.util.BufToString;
import com.company.util.CODE;
import com.company.util.Request;
import com.company.util.Response;
import com.google.common.base.Strings;
import com.google.gson.JsonSyntaxException;


/**
 * WebSocket服務端Handler
 *
 */
public class BananaWebSocketServerHandler extends SimpleChannelInboundHandler<Object> {
    private static final Logger LOG = Logger.getLogger(BananaWebSocketServerHandler.class.getName());
    
    private WebSocketServerHandshaker handshaker;
    private ChannelHandlerContext ctx;
    private String sessionId;
    private boolean isLog = true;
    
    public BananaWebSocketServerHandler() {
        super();
    }
    
    public BananaWebSocketServerHandler(boolean isLog) {
        this();
        this.isLog = isLog;
    }

    //netty 5的覆寫函數，netty4中用channelRead0代替
    public void messageReceived(ChannelHandlerContext ctx, Object msg) throws Exception {
        if(this.isLog) {
            System.out.print("channel MessageReceived = = " + ctx.name());
        }
        if (msg instanceof FullHttpRequest) { // 傳統的HTTP接入
            FullHttpRequest mymsg = (FullHttpRequest) msg;
            System.out.println(" with http request : " + BufToString.convertByteBufToString(mymsg.content()));
            handleHttpRequest(ctx, mymsg);
        } else if (msg instanceof WebSocketFrame) { // WebSocket接入
            WebSocketFrame mymsg = (WebSocketFrame) msg;
            System.out.println(" with socket request : " + BufToString.convertByteBufToString(mymsg.content()));
            handleWebSocketFrame(ctx, mymsg);
        }
    }
    
    @Override
    public void handlerAdded(ChannelHandlerContext ctx) throws Exception{
        System.out.println("channel handlerAdded = = " + ctx.name());
    }
    
    @Override
    public void handlerRemoved(ChannelHandlerContext ctx) throws Exception{
        System.out.println("channel handlerRemoved = = " + ctx.name());
    }
    
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, Object msg) throws Exception {
        if(this.isLog) {
            System.out.print("channel Read0 = = " + ctx.name());
        }
        if (msg instanceof FullHttpRequest) { // 傳統的HTTP接入
            FullHttpRequest mymsg = (FullHttpRequest) msg;
            System.out.println(" with http request : " + BufToString.convertByteBufToString(mymsg.content()));
            handleHttpRequest(ctx, mymsg);
        } else if (msg instanceof WebSocketFrame) { // WebSocket接入
            WebSocketFrame mymsg = (WebSocketFrame) msg;
            System.out.println(" with socket request : " + BufToString.convertByteBufToString(mymsg.content()));
            handleWebSocketFrame(ctx, mymsg);
        }
    }
    
    @Override
    public void channelInactive(ChannelHandlerContext ctx) {
        if(this.isLog) {
            System.out.println("channel Inactive = = " + ctx.name());
        }
        try {
            this.close(ctx, null);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    @Override
    public void channelUnregistered(ChannelHandlerContext ctx) {
        if(this.isLog) {
            System.out.println("channel Unregistered = = " + ctx.name());
        }
    }

    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        ctx.flush();
        System.out.println("channel Flush = = " + ctx.name());
    }
    
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {

        ctx.close();
        if(this.isLog) {
            System.err.println("channel exceptionCaught = = " + ctx.name());
            cause.printStackTrace();
        }
        BananaService.logout(sessionId); // 注銷
        BananaService.notifyDownline(sessionId); // 通知有人下線
    }

    //netty 5的覆寫函數，netty4中用channelInactive代替
    public void close(ChannelHandlerContext ctx, ChannelPromise promise) throws Exception {
        if(this.isLog) {
            System.out.println("channel close = = " + ctx.name());
        }
        BananaService.logout(sessionId); // 注銷
        BananaService.notifyDownline(sessionId); // 通知有人下線
        ctx.close();
    }

    /**
     * 處理Http請求，完成WebSocket握手<br/>
     * 注意：WebSocket連接第一次請求使用的是Http
     * @param ctx
     * @param request
     * @throws Exception
     */
    private void handleHttpRequest(ChannelHandlerContext ctx, FullHttpRequest request) throws Exception {
        // 如果HTTP解碼失敗，返回HHTP異常
        if (!request.getDecoderResult().isSuccess() || (!"websocket".equals(request.headers().get("Upgrade")))) {
            sendHttpResponse(ctx, request, new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.BAD_REQUEST));
            return;
        }

        // 正常WebSocket的Http連接請求，構造握手響應返回
        WebSocketServerHandshakerFactory wsFactory = new WebSocketServerHandshakerFactory("ws://" + request.headers().get(HttpHeaders.Names.HOST), null, false);
        handshaker = wsFactory.newHandshaker(request);
        if (handshaker == null) { // 無法處理的websocket版本
            WebSocketServerHandshakerFactory.sendUnsupportedWebSocketVersionResponse(ctx.channel());
        } else { // 向客戶端發送websocket握手,完成握手
            handshaker.handshake(ctx.channel(), request);
            // 記錄管道處理上下文，便於服務器推送數據到客戶端
            this.ctx = ctx;
        }
    }

    /**
     * 處理Socket請求
     * @param ctx
     * @param frame
     * @throws Exception 
     */
    private void handleWebSocketFrame(ChannelHandlerContext ctx, WebSocketFrame frame) throws Exception {
        // 判斷是否是關閉鏈路的指令
        if (frame instanceof CloseWebSocketFrame) {
            handshaker.close(ctx.channel(), (CloseWebSocketFrame) frame.retain());
            return;
        }
        // 判斷是否是Ping消息
        if (frame instanceof PingWebSocketFrame) {
            ctx.channel().write(new PongWebSocketFrame(frame.content().retain()));
            return;
        }
        // 當前只支持文本消息，不支持二進制消息
        if (!(frame instanceof TextWebSocketFrame)) {
            throw new UnsupportedOperationException("當前只支持文本消息，不支持二進制消息");
        }
        
        // 處理來自客戶端的WebSocket請求
        try {
            /*
            if(this.isLog) {
                System.out.println("handleWebSocketFrame-=-=-" + ((TextWebSocketFrame)frame).text());
            }
            */
            Request request = Request.create(((TextWebSocketFrame)frame).text());
            Response response = new Response();
            response.setServiceId(request.getServiceId());
            if (CODE.online.code.intValue() == request.getServiceId()) { // 客戶端注冊
                String requestId = request.getRequestId();
                if (Strings.isNullOrEmpty(requestId)) {
                    response.setIsSucc(false).setMessage("requestId不能為空");
                    return;
                } else if (Strings.isNullOrEmpty(request.getName())) {
                    response.setIsSucc(false).setMessage("name不能為空");
                    return;
                } else if (BananaService.bananaWatchMap.containsKey(requestId)) {
                    response.setIsSucc(false).setMessage("您已經注冊了，不能重復注冊");
                    return;
                }
                if (!BananaService.register(requestId, new BananaService(ctx, request.getName()))) {
                    response.setIsSucc(false).setMessage("注冊失敗");
                } else {
                    response.setIsSucc(true).setMessage("注冊成功");
                    
                    BananaService.bananaWatchMap.forEach((reqId, callBack) -> {
                        response.getHadOnline().put(reqId, ((BananaService)callBack).getName()); // 將已經上線的人員返回
                        
                        if (!reqId.equals(requestId)) {
                            Request serviceRequest = new Request();
                            serviceRequest.setServiceId(CODE.online.code);
                            serviceRequest.setRequestId(requestId);
                            serviceRequest.setName(request.getName());
                            try {
                                callBack.send(serviceRequest); // 通知有人上線
                            } catch (Exception e) {
                                LOG.warn("回調發送消息給客戶端異常", e);
                            }
                        }
                    });
                }
                sendWebSocket(response.toJson());
                this.sessionId = requestId; // 記錄會話id，當頁面刷新或瀏覽器關閉時，注銷掉此鏈路
            } else if (CODE.send_message.code.intValue() == request.getServiceId()) { // 客戶端發送消息到聊天群
                String requestId = request.getRequestId();
                if (Strings.isNullOrEmpty(requestId)) {
                    response.setIsSucc(false).setMessage("requestId不能為空");
                } else if (Strings.isNullOrEmpty(request.getName())) {
                    response.setIsSucc(false).setMessage("name不能為空");
                } else if (Strings.isNullOrEmpty(request.getMessage())) {
                    response.setIsSucc(false).setMessage("message不能為空");
                } else {
                    response.setIsSucc(true).setMessage("發送消息成功");
                    
                    BananaService.bananaWatchMap.forEach((reqId, callBack) -> { // 將消息發送到所有機器
                        Request serviceRequest = new Request();
                        serviceRequest.setServiceId(CODE.receive_message.code);
                        serviceRequest.setRequestId(requestId);
                        serviceRequest.setName(request.getName());
                        serviceRequest.setMessage(request.getMessage());
                        try {
                            callBack.send(serviceRequest);
                        } catch (Exception e) {
                            LOG.warn("回調發送消息給客戶端異常", e);
                        }
                    });
                }
                sendWebSocket(response.toJson());
            } else if (CODE.downline.code.intValue() == request.getServiceId()) { // 客戶端下線
                String requestId = request.getRequestId();
                if (Strings.isNullOrEmpty(requestId)) {
                    sendWebSocket(response.setIsSucc(false).setMessage("requestId不能為空").toJson());
                } else {
                    BananaService.logout(requestId);
                    response.setIsSucc(true).setMessage("下線成功");
                    
                    BananaService.notifyDownline(requestId); // 通知有人下線
                    
                    sendWebSocket(response.toJson());
                }
                
            } else {
                sendWebSocket(response.setIsSucc(false).setMessage("未知請求").toJson());
            }
        } catch (JsonSyntaxException e1) {
            LOG.warn("Json解析異常", e1);
            System.err.println("Json解析異常");
            e1.printStackTrace();
        } catch (Exception e2) {
            LOG.error("處理Socket請求異常", e2);
            System.err.println("處理Socket請求異常");
            e2.printStackTrace();
        }
    }

    /**
     * Http返回
     * @param ctx
     * @param request
     * @param response
     */
    private static void sendHttpResponse(ChannelHandlerContext ctx, FullHttpRequest request, FullHttpResponse response) {
        // 返回應答給客戶端
        if (response.getStatus().code() != 200) {
            ByteBuf buf = Unpooled.copiedBuffer(response.getStatus().toString(), CharsetUtil.UTF_8);
            response.content().writeBytes(buf);
            buf.release();
            HttpHeaders.setContentLength(response, response.content().readableBytes());
        }

        // 如果是非Keep-Alive，關閉連接
        ChannelFuture f = ctx.channel().writeAndFlush(response);
        if (!HttpHeaders.isKeepAlive(request) || response.getStatus().code() != 200) {
            f.addListener(ChannelFutureListener.CLOSE);
        }
    }
    
    /**
     * WebSocket返回
     * @param ctx
     * @param req
     * @param res
     */
    public void sendWebSocket(String msg) throws Exception {
        if (this.handshaker == null || this.ctx == null || this.ctx.isRemoved()) {
            throw new Exception("尚未握手成功，無法向客戶端發送WebSocket消息");
        }
        this.ctx.channel().write(new TextWebSocketFrame(msg));
        this.ctx.flush();
    }

}

　　FunWebSocketServerHandler.java:（outBoundAdapter，處理從服務器發出的響應）

package com.company.server;

import java.net.SocketAddress;

import com.company.util.BufToString;

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelOutboundHandlerAdapter;
import io.netty.channel.ChannelPromise;
import io.netty.handler.codec.http.DefaultFullHttpResponse;
import io.netty.handler.codec.http.websocketx.CloseWebSocketFrame;
import io.netty.handler.codec.http.websocketx.TextWebSocketFrame;

public class FunWebSocketServerHandler extends ChannelOutboundHandlerAdapter{
    
    @Override
    public void read(ChannelHandlerContext ctx) throws Exception {  
        ChannelHandlerContext readRes = ctx.read();  
        System.out.println(ctx.name() + " is read in " + readRes.toString());
    }
    
    @Override
    public void handlerAdded(ChannelHandlerContext ctx) throws Exception{
        System.out.println(ctx.name() + " handlerAdded = = " + ctx.name());
    }
    
    @Override
    public void handlerRemoved(ChannelHandlerContext ctx) throws Exception{
        System.out.println(ctx.name() + " handlerRemoved = = " + ctx.name());
    }
    
    @Override
    public void bind(ChannelHandlerContext ctx, SocketAddress localAddress,  
            ChannelPromise promise) throws Exception {  
        ctx.bind(localAddress, promise);  
        System.out.println(ctx.name() + " is bind in " + localAddress.toString() + " in " + promise.toString());
    }
    @Override
    public void connect(ChannelHandlerContext ctx, SocketAddress remoteAddress,  
            SocketAddress localAddress, ChannelPromise promise) throws Exception {  
        ctx.connect(remoteAddress, localAddress, promise);  
        System.out.println(ctx.name() + " is connect in " + localAddress.toString() + " in client "  + remoteAddress.toString() + " in " + promise.toString());
    }   
    @Override
    public void disconnect(ChannelHandlerContext ctx, ChannelPromise promise)  
            throws Exception {  
        ctx.disconnect(promise);  
        System.out.println(ctx.name() + " is disconnect in " + promise.toString());
    }   
    @Override
    public void close(ChannelHandlerContext ctx, ChannelPromise promise)  
            throws Exception {  
        ctx.close(promise);  
        System.out.println(ctx.name() + " is close in " + promise.toString());
    }   
    @Override
    public void deregister(ChannelHandlerContext ctx, ChannelPromise promise) throws Exception {  
        ctx.deregister(promise); 
        System.out.println(ctx.name() + " is deregister in " + promise.toString());
    }   

    @Override
    public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {  
        ctx.write(msg, promise);  
        System.out.print(ctx.name() + " is write in " + promise.toString());
        if(msg instanceof DefaultFullHttpResponse) {
            System.out.println(" with message : " + BufToString.convertByteBufToString(((DefaultFullHttpResponse)msg).content()));
        }
        else if(msg instanceof TextWebSocketFrame) {
            System.out.println(" with socket message : " + ((TextWebSocketFrame)msg).text());
        }
        else if(msg instanceof CloseWebSocketFrame) {
            System.out.println(" close reason : " + ((CloseWebSocketFrame)msg).reasonText());
        }
        else {
            System.out.println(" with message : " + msg.getClass());
        }
    }   
    @Override
    public void flush(ChannelHandlerContext ctx) throws Exception {  
        ctx.flush();  
        System.out.println(ctx.name() + " is flush");
    }  
}

　　banana.html:（聊天室前端）

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Netty WebSocket 聊天實例</title>
</head>
<script src="https://cdn.staticfile.org/jquery/1.10.2/jquery.min.js" type="text/javascript"></script>
<script src="map.js" type="text/javascript"></script>
<script type="text/javascript">
$(document).ready(function() {
    var uuid = guid(); // uuid在一個會話唯一
    var nameOnline = ''; // 上線姓名
    var onlineName = new Map(); // 已上線人員, <requestId, name>
    
    $("#name").attr("disabled","disabled");
    $("#onlineBtn").attr("disabled","disabled");
    $("#downlineBtn").attr("disabled","disabled");
    
    $("#banana").hide();

    // 初始化websocket
    var socket;
    if (!window.WebSocket) {
        window.WebSocket = window.MozWebSocket;
    }
    if (window.WebSocket) {
        socket = new WebSocket("ws://localhost:9090/");
        socket.onmessage = function(event) {
            console.log("收到服務器消息:" + event.data);
            if (event.data.indexOf("isSucc") != -1) {// 這里需要判斷是客戶端請求服務端返回后的消息（response）
                var response = JSON.parse(event.data);
                if (response != undefined && response != null) {
                    if (response.serviceId == 1001) { // 上線
                        if (response.isSucc) {
                            // 上線成功，初始化已上線人員
                            onlineName.clear();
                            $("#showOnlineNames").empty();
                            for (var reqId in response.hadOnline) {
                                onlineName.put(reqId, response.hadOnline[reqId]);
                            }
                            initOnline();
                            
                            $("#name").attr("disabled","disabled");
                            $("#onlineBtn").attr("disabled","disabled");
                            $("#downlineBtn").removeAttr("disabled");
                            $("#banana").show();
                        } else {
                            alert("上線失敗");
                        }
                    } else if (response.serviceId == 1004) {
                        if (response.isSucc) {
                            onlineName.clear();
                            $("#showBanana").empty();
                            $("#showOnlineNames").empty();
                            $("#name").removeAttr("disabled");
                            $("#onlineBtn").removeAttr("disabled");
                            $("#downlineBtn").attr("disabled","disabled");
                            $("#banana").hide();
                        } else {
                            alert("下線失敗");
                        }
                    }
                }
            } else {// 還是服務端向客戶端的請求（request）
                var request = JSON.parse(event.data);
                if (request != undefined && request != null) {
                    if (request.serviceId == 1001 || request.serviceId == 1004) { // 有人上線/下線
                        if (request.serviceId == 1001) {
                            onlineName.put(request.requestId, request.name);
                        }
                        if (request.serviceId == 1004) {
                            onlineName.removeByKey(request.requestId);
                        }
                        
                        initOnline();
                    } else if (request.serviceId == 1003) { // 有人發消息
                        appendBanana(request.name, request.message);
                    }
                }
            }
        };
        socket.onopen = function(event) {
            $("#name").removeAttr("disabled");
            $("#onlineBtn").removeAttr("disabled");
            console.log("已連接服務器");
        };
        socket.onclose = function(event) { // WebSocket 關閉
            console.log("WebSocket已經關閉!");
        };
        socket.onerror = function(event) {
            console.log("WebSocket異常!");
        };
    } else {
        alert("抱歉，您的瀏覽器不支持WebSocket協議!");
    }
    
    // WebSocket發送請求
    function send(message) {
        if (!window.WebSocket) { return; }
        if (socket.readyState == WebSocket.OPEN) {
            socket.send(message);
        } else {
            console.log("WebSocket連接沒有建立成功!");
            alert("您還未連接上服務器，請刷新頁面重試");
        }
    }
    
    // 刷新上線人員
    function initOnline() {
        $("#showOnlineNames").empty();
        for (var i=0;i<onlineName.size();i++) {
            $("#showOnlineNames").append('<tr><td>' + (i+1) + '</td>' +
            '<td>' + onlineName.element(i).value + '</td>' +
            '</tr>');
        }
    }
    // 追加聊天信息
    function appendBanana(name, message) {
        $("#showBanana").append('<tr><td>' + name + ': ' + message + '</td></tr>');
    }
    
    $("#onlineBtn").bind("click", function() {
        var name = $("#name").val();
        if (name == null || name == '') {
            alert("請輸入您的尊姓大名");
            return;
        }

        nameOnline = name;
        // 上線
        send(JSON.stringify({"requestId":uuid, "serviceId":1001, "name":name}));
    });
    
    $("#downlineBtn").bind("click", function() {
        // 下線
        send(JSON.stringify({"requestId":uuid, "serviceId":1004}));
    });
    
    $("#sendBtn").bind("click", function() {
        var message = $("#messageInput").val();
        if (message == null || message == '') {
            alert("請輸入您的聊天信息");
            return;
        }
        
        // 發送聊天消息
        send(JSON.stringify({"requestId":uuid, "serviceId":1002, "name":nameOnline, "message":message}));
        $("#messageInput").val("");
    });
    
});

function guid() {
    function S4() {
       return (((1+Math.random())*0x10000)|0).toString(16).substring(1);
    }
    return (S4()+S4()+"-"+S4()+"-"+S4()+"-"+S4()+"-"+S4()+S4()+S4());
}
</script>
<body>
  <h1>Netty WebSocket 聊天實例</h1>
  <input type="text" id="name" value="佚名" placeholder="姓名" />
  <input type="button" id="onlineBtn" value="上線" />
  <input type="button" id="downlineBtn" value="下線" />
  <hr/>
  <table id="banana" border="1" >
    <tr>
      <td width="600" align="center">聊天</td>
      <td width="100" align="center">上線人員</td>
    </tr>
    <tr height="200" valign="top">
      <td>
        <table id="showBanana" border="0" width="600">
            <!--
            <tr>
              <td>張三: 大家好</td>
            </tr>
            <tr>
              <td>李四: 歡迎加入群聊</td>
            </tr>
            -->
        </table>
      </td>
      <td>
        <table id="showOnlineNames" border="0">
            <!--
            <tr>
              <td>1</td>
              <td>張三</td>
            <tr/>
            <tr>
              <td>2</td>
              <td>李四</td>
            <tr/>
            -->
        </table>
      </td>
    </tr>
    <tr height="40">
      <td></td>
      <td></td>
    </tr>
    <tr>
      <td>
        <input type="text" id="messageInput"  style="width:590px" placeholder="巴拉巴拉點什么吧" />
      </td>
      <td>
        <input type="button" id="sendBtn" value="發送" />
      </td>
    </tr>
  </table>

</body>
</html>

　　分別運行WebSocketServer和ReservedWebSocketServer，運行日志如下：

============先adapter后handler==============
============連接開始========================

adapter handlerAdded = = adapter
channel handlerAdded = = handler
adapter is read in ChannelHandlerContext(adapter, [id: 0x5560f152, L:/0:0:0:0:0:0:0:1:9090 - R:/0:0:0:0:0:0:0:1:49245])
channel Read0 = = handler with http request : 
adapter is write in DefaultChannelPromise@3b536aab(incomplete) with message : 
adapter is flush
adapter is flush
channel Flush = = handler
adapter is read in ChannelHandlerContext(adapter, [id: 0x5560f152, L:/0:0:0:0:0:0:0:1:9090 - R:/0:0:0:0:0:0:0:1:49245])

============上線用戶========================

channel Read0 = = handler with socket request : {"requestId":"edaffbe7-efd7-d7a7-e8bd-4a42c24bfe6d","serviceId":1001,"name":"佚名"}
adapter is write in DefaultChannelPromise@61ace442(incomplete) with socket message : {"serviceId":1001,"isSucc":true,"message":"注冊成功","hadOnline":{"edaffbe7-efd7-d7a7-e8bd-4a42c24bfe6d":"佚名"}}
adapter is flush
adapter is flush
channel Flush = = handler
adapter is read in ChannelHandlerContext(adapter, [id: 0x5560f152, L:/0:0:0:0:0:0:0:1:9090 - R:/0:0:0:0:0:0:0:1:49245])

============發送信息========================

channel Read0 = = handler with socket request : {"requestId":"edaffbe7-efd7-d7a7-e8bd-4a42c24bfe6d","serviceId":1002,"name":"佚名","message":"queue"}
adapter is write in DefaultChannelPromise@5a4c689a(incomplete) with socket message : {"requestId":"edaffbe7-efd7-d7a7-e8bd-4a42c24bfe6d","serviceId":1003,"name":"佚名","message":"queue"}
adapter is flush
adapter is write in DefaultChannelPromise@3cfa9e57(incomplete) with socket message : {"serviceId":1002,"isSucc":true,"message":"發送消息成功","hadOnline":{}}
adapter is flush
adapter is flush
channel Flush = = handler
adapter is read in ChannelHandlerContext(adapter, [id: 0x5560f152, L:/0:0:0:0:0:0:0:1:9090 - R:/0:0:0:0:0:0:0:1:49245])

============下線用戶========================

channel Read0 = = handler with socket request : {"requestId":"edaffbe7-efd7-d7a7-e8bd-4a42c24bfe6d","serviceId":1004}
adapter is write in DefaultChannelPromise@b6ce0dc(incomplete) with socket message : {"serviceId":1004,"isSucc":true,"message":"下線成功","hadOnline":{}}
adapter is flush
adapter is flush
channel Flush = = handler
adapter is read in ChannelHandlerContext(adapter, [id: 0x5560f152, L:/0:0:0:0:0:0:0:1:9090 - R:/0:0:0:0:0:0:0:1:49245])

============用戶斷線========================

channel Read0 = = handler with socket request : �
adapter is write in DefaultChannelPromise@567e3360(incomplete) close reason : 
adapter is flush
adapter is close in DefaultChannelPromise@1b6673fb(success)
adapter is flush
channel Flush = = handler
adapter is read in ChannelHandlerContext(adapter, [id: 0x5560f152, L:/0:0:0:0:0:0:0:1:9090 ! R:/0:0:0:0:0:0:0:1:49245])
channel Inactive = = handler
channel close = = handler
adapter is close in DefaultChannelPromise@5b261d0a(success)
channel Unregistered = = handler
channel handlerRemoved = = handler
adapter handlerRemoved = = adapter

　　以及

============先adapter后handler==============
============連接開始========================

channel handlerAdded = = handler
adapter handlerAdded = = adapter
adapter is read in ChannelHandlerContext(adapter, [id: 0xa48d64f4, L:/0:0:0:0:0:0:0:1:9090 - R:/0:0:0:0:0:0:0:1:64671])
channel Read0 = = handler with http request : 
adapter is write in DefaultChannelPromise@171fb888(incomplete) with message : 
adapter is flush
channel Flush = = handler
adapter is read in ChannelHandlerContext(adapter, [id: 0xa48d64f4, L:/0:0:0:0:0:0:0:1:9090 - R:/0:0:0:0:0:0:0:1:64671])

============上線用戶========================

channel Read0 = = handler with socket request : {"requestId":"70d182cf-b0ae-27ba-296d-33bd3ab5177b","serviceId":1001,"name":"佚名"}
adapter is write in DefaultChannelPromise@54042c55(incomplete) with socket message : {"serviceId":1001,"isSucc":true,"message":"注冊成功","hadOnline":{"70d182cf-b0ae-27ba-296d-33bd3ab5177b":"佚名"}}
channel Flush = = handler
adapter is read in ChannelHandlerContext(adapter, [id: 0xa48d64f4, L:/0:0:0:0:0:0:0:1:9090 - R:/0:0:0:0:0:0:0:1:64671])

============發送信息========================

channel Read0 = = handler with socket request : {"requestId":"70d182cf-b0ae-27ba-296d-33bd3ab5177b","serviceId":1002,"name":"佚名","message":"queue"}
adapter is write in DefaultChannelPromise@324cb9a(incomplete) with socket message : {"requestId":"70d182cf-b0ae-27ba-296d-33bd3ab5177b","serviceId":1003,"name":"佚名","message":"queue"}
adapter is write in DefaultChannelPromise@269f3a70(incomplete) with socket message : {"serviceId":1002,"isSucc":true,"message":"發送消息成功","hadOnline":{}}
channel Flush = = handler
adapter is read in ChannelHandlerContext(adapter, [id: 0xa48d64f4, L:/0:0:0:0:0:0:0:1:9090 - R:/0:0:0:0:0:0:0:1:64671])

============下線用戶========================

channel Read0 = = handler with socket request : {"requestId":"70d182cf-b0ae-27ba-296d-33bd3ab5177b","serviceId":1004}
adapter is write in DefaultChannelPromise@2f6a67d7(incomplete) with socket message : {"serviceId":1004,"isSucc":true,"message":"下線成功","hadOnline":{}}
channel Flush = = handler
adapter is read in ChannelHandlerContext(adapter, [id: 0xa48d64f4, L:/0:0:0:0:0:0:0:1:9090 - R:/0:0:0:0:0:0:0:1:64671])

============用戶斷線========================

channel Read0 = = handler with socket request : �
adapter is write in DefaultChannelPromise@5dff633(incomplete) close reason : 
adapter is flush
adapter is close in DefaultChannelPromise@1e58e8f0(success)
channel Flush = = handler
adapter is read in ChannelHandlerContext(adapter, [id: 0xa48d64f4, L:/0:0:0:0:0:0:0:1:9090 ! R:/0:0:0:0:0:0:0:1:64671])
channel Inactive = = handler
channel close = = handler
channel Unregistered = = handler
adapter handlerRemoved = = adapter
channel handlerRemoved = = handler

　　除了運行順序不同，outBoundAdapter的flush操作也多了幾次，尤其在發送這一塊，因為不僅要接收數據包，還要發送數據包，要多刷新adapter。

　　由此可見，netty的pipeline一定要仔細規划，能先讓服務器處理就先讓服務器處理，把outbound攔截器放在inbound攔截器前面。