Netty是由JBOSS提供的一款基于NIO的客戶、服務器端編程的Java開源框架，用以快速開發高性能、高可靠性的網絡服務器和客戶端程序。
轉載：http://www.lxweimin.com/p/331ee864bda9

BIO：同步阻塞IO

服務端采用一個獨立的Acceptor線程監聽客戶端的連接，當接收到客戶端連接請求后，為每個客戶端創建一個新的線程進行鏈路處理，處理完成后通過輸出流返回給客戶端，然后銷毀線程。屬于典型的一請求一應答通信模型，缺乏彈性伸縮能力。當客戶端并發訪問量增加后，服務端的線程數同步增加，由于線程是jvm非常寶貴的系統資源，線程數增加，系統的性能急劇下降，甚至會造成堆棧溢出，創建線程失敗等問題。

bio.png

偽異步IO

當有新的客戶端接入的時候，將客戶端socket封裝成Task到線程池中處理。線程池可以設置消息隊列的大小和最大線程數，因此它的資源占用是可控的。但是當有大量客戶端接入的時候會造成線程池阻塞。

偽異步IO.png

NIO：同步非阻塞IO

• 緩沖區Buffer：一塊連續的內存塊，是 NIO 數據讀或寫的中轉地。
• 通道Channel：數據的源頭或者數據的目的地，用于向 buffer 提供數據或者讀取 buffer 數據 ,buffer 對象的唯一接口。支持異步 I/O 。
• 多路復用器Selector：具有選擇就緒任務的能力。

Buffer作為IO流中數據的緩沖區，而Channel則作為socket的IO流與Buffer的傳輸通道。客戶端socket與服務端socket之間的IO傳輸不直接把數據交給CPU使用，而是先經過Channel通道把數據保存到Buffer，然后CPU直接從Buffer區讀寫數據，一次可以讀寫更多的內容。

nio.png

NIO是對BIO的改進，基于Reactor模型。NIO的最重要的地方是當一個連接創建后，不需要對應一個線程，這個連接會被注冊到多路復用器上面，所以所有的連接只需要一個線程就可以搞定，當這個線程中的多路復用器進行輪詢的時候，發現連接上有請求的話，才開啟一個線程進行處理。

AIO：異步阻塞IO

AIO是對NIO的改進，是基于Proactor模型。與NIO不同，當進行讀寫操作時，只須直接調用API的read或write方法即可。這兩種方法均為異步的，對于讀操作而言，當有流可讀取時，操作系統會將可讀的流傳入read方法的緩沖區，并通知應用程序；對于寫操作而言，當操作系統將write方法傳遞的流寫入完畢時，操作系統主動通知應用程序。較之NIO而言，AIO一方面簡化了程序出的編寫，流的讀取和寫入都由操作系統來代替完成；另一方面省去了NIO中程序要遍歷事件通知隊列（selector）的代價。Windows基于[IOCP(http://en.wikipedia.org/wiki/Input/output_completion_port)實現了AIO，Linux目前只有基于epoll實現的AIO。

Java對BIO、NIO、AIO的支持：

• BIO ： 同步并阻塞，服務器實現模式為一個連接一個線程，即客戶端有連接請求時服務器端就需要啟動一個線程進行處理，如果這個連接不做任何事情會造成不必要的線程開銷，當然可以通過線程池機制改善。
• NIO ： 同步非阻塞，服務器實現模式為一個請求一個線程，即客戶端發送的連接請求都會注冊到多路復用器上，多路復用器輪詢到連接有I/O請求時才啟動一個線程進行處理。
• AIO(NIO.2) ： 異步非阻塞，服務器實現模式為一個有效請求一個線程，客戶端的I/O請求都是由OS先完成了再通知服務器應用去啟動線程進行處理。

BIO、NIO、AIO適用場景分析:

• BIO方式適用于連接數目比較小且固定的架構，這種方式對服務器資源要求比較高，并發局限于應用中，JDK1.4以前的唯一選擇，但程序直觀簡單易理解。
• NIO方式適用于連接數目多且連接比較短（輕操作）的架構，比如聊天服務器，并發局限于應用中，編程比較復雜，JDK1.4開始支持。
• AIO方式使用于連接數目多且連接比較長（重操作）的架構，比如相冊服務器，充分調用OS參與并發操作，編程比較復雜，JDK7開始支持。

WebSocket

WebSocket是HTML5開始提供的一種在單個 TCP 連接上進行全雙工通訊的協議。在WebSocket API中，瀏覽器和服務器只需要做一個握手的動作，然后，瀏覽器和服務器之間就形成了一條快速通道。兩者之間就直接可以數據互相傳送。瀏覽器通過 JavaScript 向服務器發出建立 WebSocket 連接的請求，連接建立以后，客戶端和服務器端就可以通過 TCP 連接直接交換數據。當你獲取 Web Socket 連接后，你可以通過 send() 方法來向服務器發送數據，并通過 onmessage 事件來接收服務器返回的數據。

當WebSocket的客戶端與服務端通信以后，就不需要之前握手請求HTTP協議的參與了

WebSocket的優點

• 節省通信開銷（HttpRequest中的head很長，占用帶寬和資源）
• 服務器可以主動傳送數據給客戶端
• 實時通信
  因為HTTP 協議是一種無狀態的、無連接的、單向的應用層協議。它采用了請求/響應模型。通信請求只能由客戶端發起，服務端對請求做出應答處理。這種通信模型有一個弊端：HTTP 協議無法實現服務器主動向客戶端發起消息。如果服務器有連續的狀態變化，客戶端要獲知就非常麻煩。大多數 Web 應用程序將通過頻繁的異步JavaScript和XML（AJAX）請求實現長輪詢。輪詢的效率低，非常浪費資源（因為必須不停連接，或者 HTTP 連接始終打開）。

WebSocket的生命周期

WebSocket端點生命周期的第一個事件是打開通知，它用來指示到WebSocket會話另一端的連接已經建立。一旦打開通知被WebSocket對話的兩端都接收到，參與的任意WebSocket后續就可以發送消息了。在WebSocket對話期間，可能會出現一些消息傳遞的錯誤。接受消息的WebSocket端點本身就可能產生錯誤，或者WebSocket實現本身在某些情況下也會產生錯誤。要注意對錯誤的處理。不管在WebSocket對話的哪一端準備結束對話，他都可以初始化關閉事件。下面從Java組件的視角來看看其生命周期如何呈現。

• 打開事件：＠OnOpen 此事件發生在端點上建立新連接時并且在任何其他事件發生之前
• 消息事件：@OnMessage 此事件接收WebSocket對話中另一端發送的消息。
• 錯誤事件：@OnError 此事件在WebSocket連接或者端點發生錯誤時產生
• 關閉事件：@OnClose 此事件表示WebSocket端點的連接目前部分地關閉，它可以由參與連接的任意一個端點發出

Netty實現WebSocket

import io.netty.channel.group.ChannelGroup;
import io.netty.channel.group.DefaultChannelGroup;
import io.netty.util.concurrent.GlobalEventExecutor;

/**
 * 存儲整個工程的全局配置
 */
public class NettyConfig {

    //存儲每一個客戶端接入進來時的channel對象
    public static ChannelGroup group = new DefaultChannelGroup(GlobalEventExecutor.INSTANCE);
}

import java.util.Date;
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.SimpleChannelInboundHandler;
import io.netty.handler.codec.http.DefaultFullHttpResponse;
import io.netty.handler.codec.http.FullHttpRequest;
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;

/**
 * 接收/處理/響應客戶端websocket請求的核心業務處理類
 */
public class MyWebSocketHandler extends SimpleChannelInboundHandler<Object> {
    
    private WebSocketServerHandshaker handshaker;
    private static final String WEB_SOCKET_URL = "ws://localhost:8888/websocket";
    //客戶端與服務端創建連接的時候調用
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        NettyConfig.group.add(ctx.channel());
        System.out.println("客戶端與服務端連接開啟...");
    }

    //客戶端與服務端斷開連接的時候調用
    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        NettyConfig.group.remove(ctx.channel());
        System.out.println("客戶端與服務端連接關閉...");
    }

    //服務端接收客戶端發送過來的數據結束之后調用
    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
            ctx.flush();
    }

    //工程出現異常的時候調用
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }

    //服務端處理客戶端websocket請求的核心方法
    @Override
    protected void messageReceived(ChannelHandlerContext context, Object msg) throws Exception {
        //處理客戶端向服務端發起http握手請求的業務
        if (msg instanceof FullHttpRequest) {
            handHttpRequest(context,  (FullHttpRequest)msg);
        }else if (msg instanceof WebSocketFrame) { //處理websocket連接業務
            handWebsocketFrame(context, (WebSocketFrame)msg);
        }
    }
    
    // 處理客戶端與服務端之前的websocket業務
    private void handWebsocketFrame(ChannelHandlerContext ctx, WebSocketFrame frame){
        //判斷是否是關閉websocket的指令
        if (frame instanceof CloseWebSocketFrame) {
            handshaker.close(ctx.channel(), (CloseWebSocketFrame)frame.retain());
        }
        //判斷是否是ping消息
        if (frame instanceof PingWebSocketFrame) {
            ctx.channel().write(new PongWebSocketFrame(frame.content().retain()));
            return;
        }
        
        //判斷是否是二進制消息，如果是二進制消息，拋出異常
        if( ! (frame instanceof TextWebSocketFrame) ){
            System.out.println("目前我們不支持二進制消息");
            throw new RuntimeException("【"+this.getClass().getName()+"】不支持消息");
        }
        //返回應答消息
        //獲取客戶端向服務端發送的消息
        String request = ((TextWebSocketFrame) frame).text();
        System.out.println("服務端收到客戶端的消息====>>>" + request);
        TextWebSocketFrame tws = new TextWebSocketFrame(new Date().toString()                                                                               + ctx.channel().id()    + " ===>>> " + request);                                                                                                                                                            
        //服務端向每個連接上來的客戶端群發消息
        NettyConfig.group.writeAndFlush(tws);
    }
    // 處理客戶端向服務端發起http握手請求的業務
    private void handHttpRequest(ChannelHandlerContext ctx, FullHttpRequest req){
        if (!req.getDecoderResult().isSuccess() 
                || ! ("websocket".equals(req.headers().get("Upgrade")))) {
            sendHttpResponse(ctx, req, 
                    new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.BAD_REQUEST));
            return;
        }
        WebSocketServerHandshakerFactory wsFactory = new WebSocketServerHandshakerFactory(
                WEB_SOCKET_URL, null, false);
        handshaker = wsFactory.newHandshaker(req);
        if (handshaker == null) {
            WebSocketServerHandshakerFactory.sendUnsupportedWebSocketVersionResponse(ctx.channel());
        }else{
            handshaker.handshake(ctx.channel(), req);
        }
    }
    
    // 服務端向客戶端響應消息
    private void sendHttpResponse(ChannelHandlerContext ctx, FullHttpRequest req,
            DefaultFullHttpResponse res){
        if (res.getStatus().code() != 200) {
            ByteBuf buf = Unpooled.copiedBuffer(res.getStatus().toString(), CharsetUtil.UTF_8);
            res.content().writeBytes(buf);
            buf.release();
        }
        //服務端向客戶端發送數據
        ChannelFuture f = ctx.channel().writeAndFlush(res);
        if (res.getStatus().code() != 200) {
            f.addListener(ChannelFutureListener.CLOSE);
        }
    }
}

import io.netty.channel.ChannelInitializer;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.codec.http.HttpObjectAggregator;
import io.netty.handler.codec.http.HttpServerCodec;
import io.netty.handler.stream.ChunkedWriteHandler;

/**
 * 初始化連接時候的各個組件
 */
public class MyWebSocketChannelHandler extends ChannelInitializer<SocketChannel> {

    @Override
    protected void initChannel(SocketChannel e) throws Exception {
        e.pipeline().addLast("http-codec", new HttpServerCodec());
        e.pipeline().addLast("aggregator", new HttpObjectAggregator(65536));
        e.pipeline().addLast("http-chunked", new ChunkedWriteHandler());
        e.pipeline().addLast("handler", new MyWebSocketHandler());
    }
}

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.Channel;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;

/**
 * 程序的入口，負責啟動應用
 */
public class Main {
    public static void main(String[] args) {
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap b = new ServerBootstrap();
            b.group(bossGroup, workGroup);
            b.channel(NioServerSocketChannel.class);
            b.childHandler(new MyWebSocketChannelHandler());
            System.out.println("服務端開啟等待客戶端連接....");
            Channel ch = b.bind(8888).sync().channel();
            ch.closeFuture().sync();
            
        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            //優雅的退出程序
            bossGroup.shutdownGracefully();
            workGroup.shutdownGracefully();
        }
    }
}

<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset = utf-8"/>
        <title>WebSocket客戶端</title>
    <script type="text/javascript">
        var socket;
        if(!window.WebSocket){
            window.WebSocket = window.MozWebSocket;
        }

        if(window.WebSocket){
            socket = new WebSocket("ws://localhost:8888/websocket");
            socket.onmessage = function(event){
                var ta = document.getElementById('responseContent');
                ta.value += event.data + "\r\n";
            };

            socket.onopen = function(event){
                var ta = document.getElementById('responseContent');
                ta.value = "你當前的瀏覽器支持WebSocket,請進行后續操作\r\n";
            };

            socket.onclose = function(event){
                var ta = document.getElementById('responseContent');
                ta.value = "";
                ta.value = "WebSocket連接已經關閉\r\n";
            };
        }else{
            alert("您的瀏覽器不支持WebSocket");
        }


        function send(message){
            if(!window.WebSocket){
                return;
            }
            if(socket.readyState == WebSocket.OPEN){
                socket.send(message);
            }else{
                alert("WebSocket連接沒有建立成功！！");
            }
        }
    </script>
    </head>
    <body>
        <form onSubmit="return false;">
            <input type = "text" name = "message" value = ""/>
            <br/><br/>
            <input type = "button" value = "發送WebSocket請求消息" onClick = "send(this.form.message.value)"/>
            <hr color="red"/>
            <h2>客戶端接收到服務端返回的應答消息</h2>
            <textarea id = "responseContent" style = "width:1024px; height:300px"></textarea>
        </form>
    </body>
</html>

參考

netty-all-5.0.0.Alpha1.jar
WebSocket 詳解教程
SpringBoot 開發WebSocket