沉淀再出發：關於netty的一些理解和使用

沉淀再出發：關於netty的一些理解和使用

一、前言

    Netty是由JBOSS提供的一個java開源框架。Netty提供異步的、事件驅動的網絡應用程序框架和工具，用以快速開發高性能、高可靠性的網絡服務器和客戶端程序。也就是說，Netty 是一個基於NIO的客戶、服務器端編程框架，使用Netty 可以確保你快速和簡單的開發出一個網絡應用，例如實現了某種協議的客戶、服務端應用。Netty相當於簡化和流線化了網絡應用的編程開發過程，例如：基於TCP和UDP的socket服務開發。“快速”和“簡單”並不用產生維護性或性能上的問題。Netty 是一個吸收了多種協議（包括FTP、SMTP、HTTP等各種二進制文本協議）的實現經驗，並經過相當精心設計的項目。最終，Netty 成功的找到了一種方式，在保證易於開發的同時還保證了其應用的性能，穩定性和伸縮性。netty在底層的數據通信和封裝之中有着重要的作用，下面我們就來看看netty的簡單使用過程，以及背后的原理。

二、netty的簡單使用

  2.1、netty的環境部署和使用

   在這里我們使用myeclipse平台，maven管理工具進行開發，其實使用eclipse或者其他軟件也可以。首先我們新建一個maven項目，項目名和包名自定：

    之后我們修改pom.xml文件，增加netty依賴：

    保存之后，系統就會自動為我們下載和安裝了，非常的方便，這樣，我們的環境就部署完畢了。

   2.2、一個簡單的案例

    下面我們看一個簡單地案例：

    我們新建一個包，然后寫入兩個文件：

    首先我們編寫一個處理連接的類 HelloServerHandler ：

package com.coder.server;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.util.CharsetUtil;
import io.netty.util.ReferenceCountUtil;


public class HelloServerHandler extends ChannelInboundHandlerAdapter {
    /**
     * 收到數據時調用
     */
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        try {
            ByteBuf in = (ByteBuf)msg;
            System.out.print(in.toString(CharsetUtil.UTF_8));
        } finally {
            // 拋棄收到的數據
            ReferenceCountUtil.release(msg);
        }
    }
    
    /**
     * 當Netty由於IO錯誤或者處理器在處理事件時拋出異常時調用
     */
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        // 當出現異常就關閉連接
        cause.printStackTrace();
        ctx.close();
    }
}

   其次，我們編寫接收連接，並且派發和處理的類 HelloServer :

package com.coder.server;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;

public class HelloServer {
    private int port;
    
    public HelloServer(int port) {
        this.port = port;
    }
    
    public void run() throws Exception {
        EventLoopGroup bossGroup = new NioEventLoopGroup();        // 用來接收進來的連接
        EventLoopGroup workerGroup = new NioEventLoopGroup();    // 用來處理已經被接收的連接
        System.out.println("准備運行端口：" + port);
        
        try {
            ServerBootstrap b = new ServerBootstrap();
            b.group(bossGroup, workerGroup)
            .channel(NioServerSocketChannel.class)            // 這里告訴Channel如何接收新的連接
            .childHandler( new ChannelInitializer<SocketChannel>() {
                @Override
                protected void initChannel(SocketChannel ch) throws Exception {
                    // 自定義處理類
                    ch.pipeline().addLast(new HelloServerHandler());
                }
            })
            .option(ChannelOption.SO_BACKLOG, 128)
            .childOption(ChannelOption.SO_KEEPALIVE, true);
            
            // 綁定端口，開始接收進來的連接
            ChannelFuture f = b.bind(port).sync();
            
            // 等待服務器socket關閉
            f.channel().closeFuture().sync();
        } catch (Exception e) {
            workerGroup.shutdownGracefully();
            bossGroup.shutdownGracefully();
        }
    }
    
    public static void main(String[] args) throws Exception {
        int port = 12345;
        new HelloServer(port).run();
    }
}

     然后運行，等待連接就好了，那么問題來了，使用什么進行連接呢？在windows中，我們可以使用Telnet，這個比較方便和簡單，但是我們需要打開控制面板的程序和功能模塊，並且啟動服務，之后最好重啟一下電腦：

 

    下面我們運行程序，並使用Telnet客戶端測試一下：

   在telnet中‘ctrl+]’可以顯示輸入的文字，否則將看不到輸入。

三、使用netty自定義時間服務器

      本例中我們試圖在服務器和客戶端連接被創立時發送一個消息，然后在客戶端解析收到的消息並輸出。並且，在這個項目中使用 POJO 代替 ByteBuf 來作為傳輸對象。

 

 3.1、pojo對象創建

   Time 類：

package com.coder.pojo;

import java.util.Date;

/**
 * 自定義時間數據類
 *
 */
public class Time {
    private final long value;

    public Time() {
        // 除以1000是為了使時間精確到秒
           //注意這里的this，其實就是調用了 public Time(long value) ，並且更加的方便和快捷。
        this(System.currentTimeMillis() / 1000L);
    }

    public Time(long value) {
        this.value = value;
    }

    public long value() {
        return value;
    }

    @Override
    public String toString() {
        return new Date((value()) * 1000L).toString();
    }
}

 3.2、服務器程序

   TimeEncoderPOJO類：

package com.coder.server;

import com.coder.pojo.Time;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.MessageToByteEncoder;

/**
 * 服務器數據編碼類
 *
 */
public class TimeEncoderPOJO extends MessageToByteEncoder<Time> {

    // 發送數據時調用
    @Override
    protected void encode(ChannelHandlerContext ctx, Time msg, ByteBuf out) throws Exception {
        // 只傳輸當前時間，精確到秒
        out.writeInt((int)msg.value());
    }

}

   TimeServerHandlerPOJO類：連接建立並且准備通信的時候進行處理，發送當前時間，並增加監聽。

package com.coder.server;

import com.coder.pojo.Time;

import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelFutureListener;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;

/**
 * 服務器解碼器
 * 連接建立時發送當前時間
 *
 */
public class TimeServerHandlerPOJO extends ChannelInboundHandlerAdapter {
    /**
     * 連接建立的時候並且准備進行通信時被調用
     */
    @Override
    public void channelActive(final ChannelHandlerContext ctx) throws Exception {
        // 發送當前時間信息
        ChannelFuture f = ctx.writeAndFlush(new Time());
        // 發送完畢之后關閉 Channel
        f.addListener(ChannelFutureListener.CLOSE);
    }
    
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }
}

   TimeServerPOJO類：服務器的主程序

package com.coder.server;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;

public class TimeServerPOJO {
private int port;
    
    public TimeServerPOJO(int port) {
        this.port = port;
    }
    
    public void run() throws Exception {
        EventLoopGroup bossGroup = new NioEventLoopGroup();        // 用來接收進來的連接
        EventLoopGroup workerGroup = new NioEventLoopGroup();    // 用來處理已經被接收的連接
        System.out.println("准備運行端口：" + port);
        
        try {
            ServerBootstrap b = new ServerBootstrap();        // 啟動NIO服務的輔助啟動類
            b.group(bossGroup, workerGroup)
            .channel(NioServerSocketChannel.class)            // 這里告訴Channel如何接收新的連接
            .childHandler( new ChannelInitializer<SocketChannel>() {
                @Override
                protected void initChannel(SocketChannel ch) throws Exception {
                    // 自定義處理類
                    // 注意添加順序
                    ch.pipeline().addLast(new TimeEncoderPOJO(),new TimeServerHandlerPOJO());
                }
            })
            .option(ChannelOption.SO_BACKLOG, 128)
            .childOption(ChannelOption.SO_KEEPALIVE, true);
            
            // 綁定端口，開始接收進來的連接
            ChannelFuture f = b.bind(port).sync();
            
            // 等待服務器socket關閉
            f.channel().closeFuture().sync();
        } catch (Exception e) {
            workerGroup.shutdownGracefully();
            bossGroup.shutdownGracefully();
        }
    }
    
    public static void main(String[] args) throws Exception {
        int port = 12345;
        new TimeServerPOJO(port).run();
    }
}

   其中ch.pipeline().addLast(new TimeEncoderPOJO(),new TimeServerHandlerPOJO());方法的含義為：Handles an I/O event or intercepts an I/O operation, and forwards it to its next handler in its ChannelPipeline.也就是說當我們添加一些處理的時候會按照管道的方式，一步步的處理，因此先后順序非常重要。

 3.3、客戶端程序

   先來看看解碼器（服務器端發送了編碼后的時間信息，因此，這里客戶端收到之后需要解碼）：

   TimeDecoderPOJO 類：

package com.coder.client;

import java.util.List;

import com.coder.pojo.Time;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.ByteToMessageDecoder;

public class TimeDecoderPOJO extends ByteToMessageDecoder {
    /**
     * 有新數據接收時調用
     * 為防止分包現象，先將數據存入內部緩存，到達滿足條件之后再進行解碼
     */
    @Override
    protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
        if(in.readableBytes() < 4) {
            return;
        }
        
        // out添加對象則表示解碼成功
        out.add(new Time(in.readUnsignedInt()));
    }
}

  再看看客戶端數據處理類：

  TimeClientHandlerPOJO類：

package com.coder.client;

import com.coder.pojo.Time;

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;

/**
 * 客戶端數據處理類
 *
 */
public class TimeClientHandlerPOJO extends ChannelInboundHandlerAdapter {
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        // 直接將信息轉換成Time類型輸出即可
        Time time = (Time)msg;
        System.out.println(time);
        ctx.close();
    }
    
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }
}

  最后是客戶端的主程序：

   TimeClientPOJO類：

package com.coder.client;

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;

public class TimeClientPOJO {
    public static void main(String[] args) throws Exception{
        String host = "127.0.0.1";            // ip
        int port = 12345;                    // 端口
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        
        try {
            Bootstrap b = new Bootstrap();            // 與ServerBootstrap類似
            b.group(workerGroup);                    // 客戶端不需要boss worker
            b.channel(NioSocketChannel.class);
            b.option(ChannelOption.SO_KEEPALIVE, true);    // 客戶端的socketChannel沒有父親
            b.handler(new ChannelInitializer<SocketChannel>() {
                @Override
                protected void initChannel(SocketChannel ch) throws Exception {
                    // POJO
                    ch.pipeline().addLast(new TimeDecoderPOJO() ,new TimeClientHandlerPOJO());
                }
            });
            
            // 啟動客戶端，客戶端用connect連接
            ChannelFuture f = b.connect(host, port).sync();
            
            // 等待連接關閉
            f.channel().closeFuture().sync();
        } finally {
            workerGroup.shutdownGracefully();
        }
    }
}

    至此程序編寫完畢，先運行服務器，再運行客戶端程序，然后測試即可，我們會發現服務器一直等待着請求，當客戶端連接上之后，服務器就會發出帶着格式的時間，客戶端接收到之后進行解碼，然后顯示出來並且退出。在同一個myeclipse之中可以運行多個程序，使用下圖中的按鈕可以進行切換。

四、netty的基本組成部分

 4.1、Channel　　

    Channel 是 Java NIO 的一個基本構造。它代表一個到實體（如一個硬件設備、一個文件、一個網絡套接字或者一個能夠執行一個或者多個不同的I/O操作的程序組件）的開放連接，如讀操作和寫操作。目前，可以把 Channel 看作是傳入（入站）或者傳出（出站）數據的載體。因此，它可以被打開或者被關閉，連接或者斷開連接。

 4.2、Callback（回調）　　

   Netty 在內部使用了回調來處理事件；當一個回調被觸發時，相關的事件可以被一個 interfaceChannelHandler 的實現處理。

 4.3、Future

　 Future 提供了另一種在操作完成時通知應用程序的方式。這個對象可以看作是一個異步操作的結果的占位符；它將在未來的某個時刻完成，並提供對其結果的訪問。JDK 預置了 interface java.util.concurrent.Future，但是其所提供的實現，只允許手動檢查對應的操作是否已經完成，或者一直阻塞直到它完成。這是非常繁瑣的，所以 Netty 提供了它自己的實現ChannelFuture，用於在執行異步操作的時候使用。

 4.4、Event 和 Handler

     Netty 使用不同的事件來通知我們狀態的改變或者是操作的狀態。這使得我們能夠基於已經發生的事件來觸發適當的動作。這些動作可能是：記錄日志、數據轉換、流控制、應用程序邏輯。Netty 是一個網絡編程框架，所以事件是按照它們與入站或出站數據流的相關性進行分類的。可能由入站數據或者相關的狀態更改而觸發的事件包括：連接已被激活或者連接失活、數據讀取、用戶事件、錯誤事件。出站事件是未來將會觸發的某個動作的操作結果，這些動作包括：打開或者關閉到遠程節點的連接、將數據寫到或者沖刷到套接字。
    Netty 的 ChannelHandler 為處理器提供了基本的抽象，目前可以認為每個 ChannelHandler 的實例都類似於一種為了響應特定事件而被執行的回調。Netty 提供了大量預定義的可以開箱即用的 ChannelHandler 實現，包括用於各種協議（如 HTTP 和 SSL/TLS）的 ChannelHandler。在內部 ChannelHandler 自己也使用了事件和 Future。

五、netty聊天程序

 5.1、服務器端

   SimpleChatServerInitializer類：

package com.coder.server;

import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.codec.DelimiterBasedFrameDecoder;
import io.netty.handler.codec.Delimiters;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;

/**
 * 服務器配置初始化
 * 添加多個處理器
 */
public class SimpleChatServerInitializer extends ChannelInitializer<SocketChannel> {

    @Override
    protected void initChannel(SocketChannel ch) throws Exception {
        ChannelPipeline pipeline = ch.pipeline();
        // 添加處理類
        // 使用'\r''\n'分割幀
        pipeline.addLast("framer", 
                new DelimiterBasedFrameDecoder(8192, Delimiters.lineDelimiter()));
        // 解碼、編碼器
        pipeline.addLast("decoder", new StringDecoder());
        pipeline.addLast("encoder", new StringEncoder());
        // 處理器
        pipeline.addLast("handler", new SimpleChatServerHandler());
        
        System.out.println("SimpleChatClient: " + ch.remoteAddress() + "連接上");
    }

}

  SimpleChatServerHandler類：

package com.coder.server;


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

/**
 * 服務端處理器
 */
public class SimpleChatServerHandler extends SimpleChannelInboundHandler<String> {
 
    public static ChannelGroup channels = new DefaultChannelGroup(GlobalEventExecutor.INSTANCE);
    
    /**
     * 收到新的客戶端連接時調用
     * 將客戶端channel存入列表，並廣播消息
     */
    @Override
    public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
        Channel incoming = ctx.channel();
        // 廣播加入消息
        channels.writeAndFlush("[SERVER] - " + incoming.remoteAddress() + " 加入\n");
        channels.add(incoming);        // 存入列表    
    }
    
    /**
     * 客戶端連接斷開時調用
     * 廣播消息
     */
    @Override
    public void handlerRemoved(ChannelHandlerContext ctx) throws Exception {
        Channel incoming = ctx.channel();
        // 廣播離開消息
        channels.writeAndFlush("[SERVER] - " + incoming.remoteAddress() + " 離開\n");
        // channel會自動從ChannelGroup中刪除 
    }
    
    /**
     * 收到消息時調用
     * 將消息轉發給其他客戶端
     */
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {
        Channel incoming = ctx.channel();
        for(Channel channel : channels) {        // 遍歷所有連接的客戶端
            if(channel != incoming) {            // 其他客戶端
                channel.writeAndFlush("[" + incoming.remoteAddress() + "] " + msg + "\n" );
            } else {                            // 自己
                channel.writeAndFlush("[you] " + msg + "\n" );
            }
        }
    }
    
    /**
     * 監聽到客戶端活動時調用
     */
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        Channel incoming = ctx.channel();
        System.out.println("SimpleChatClient: " + incoming.remoteAddress() + " 在線");
    }
    
    /**
     * 監聽到客戶端不活動時調用
     */
    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        Channel incoming = ctx.channel();
        System.out.println("SimpleChatClient: " + incoming.remoteAddress() + " 掉線");
    }
    
    /**
     * 當Netty由於IO錯誤或者處理器在處理事件拋出異常時調用
     * 關閉連接
     */
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        Channel incoming = ctx.channel();
        System.out.println("SimpleChatClient: " + incoming.remoteAddress() + " 異常");
    }
}

 SimpleChatServer類：

package com.coder.server;

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

/**
 * 服務端 main 啟動
 */
public class SimpleChatServer {
    private int port;        // 端口
    
    public SimpleChatServer(int port) {
        this.port = port;
    }
    
    // 配置並開啟服務器
    public void run() throws Exception {
        EventLoopGroup bossGroup = new NioEventLoopGroup();        // 用來接收進來的連接
        EventLoopGroup workerGroup = new NioEventLoopGroup();    // 用來處理已接收的連接
        
        try {
            ServerBootstrap sb = new ServerBootstrap();            // 啟動NIO服務的輔助啟動類
            sb.group(bossGroup, workerGroup)
                .channel(NioServerSocketChannel.class)                // 設置如何接受連接
                .childHandler(new SimpleChatServerInitializer())    // 配置Channel
                .option(ChannelOption.SO_BACKLOG, 128)                // 設置緩沖區
                .childOption(ChannelOption.SO_KEEPALIVE, true);    // 啟用心跳機制
            
            System.out.println("SimpleChatServer 啟動了");
            ChannelFuture future = sb.bind(port).sync();        // 綁定端口，開始接收連接
            future.channel().closeFuture().sync();                // 等待關閉服務器（不會發生）
        } finally {
            workerGroup.shutdownGracefully();
            bossGroup.shutdownGracefully();
            System.out.println("SimpleChatServer 關閉了");
        }
    }
    
    public static void main(String[] args) throws Exception {
        int port = 8080;
        new SimpleChatServer(port).run();     // 開啟服務器
    }
}

5.2、客戶端程序

 SimpleChatClientInitializer類：

package com.coder.client;

import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.codec.DelimiterBasedFrameDecoder;
import io.netty.handler.codec.Delimiters;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;

/**
 * 客戶端配置初始化
 * 與服務端類似
 */
public class SimpleChatClientInitializer extends ChannelInitializer<SocketChannel> {

    @Override
    protected void initChannel(SocketChannel ch) throws Exception {
        ChannelPipeline pipeline = ch.pipeline();
        // 添加處理類
        // 使用'\r''\n'分割幀
        pipeline.addLast("framer", 
                new DelimiterBasedFrameDecoder(8192, Delimiters.lineDelimiter()));
        // 解碼、編碼器
        pipeline.addLast("decoder", new StringDecoder());
        pipeline.addLast("encoder", new StringEncoder());
        // 處理器
        pipeline.addLast("handler", new SimpleChatClientHandler());
    }

}

 SimpleChatClientHandler類：

package com.coder.client;

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;

/**
 * 客戶端處理類
 * 直接輸出收到的消息
 */
public class SimpleChatClientHandler extends SimpleChannelInboundHandler<String> {

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {
        System.out.println(msg);    // 直接輸出消息        
    }

}

 SimpleChatClient類：

package com.coder.client;

import java.io.BufferedReader;
import java.io.InputStreamReader;

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.Channel;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioSocketChannel;
/**
 * 客戶端
 * 開啟客戶端，接收控制台輸入並發送給服務端
 */
public class SimpleChatClient {
    private final String host;        // IP
    private final int port;        // 端口
    
    public SimpleChatClient(String host, int port) {
        this.host = host;
        this.port = port;
    }
    
    // 配置並運行客戶端
    public void run() throws Exception {
        EventLoopGroup group = new NioEventLoopGroup();
        try {
            Bootstrap b = new Bootstrap();        // 客戶端輔助啟動類
            b.group(group)                                    // 客戶端只需要一個用來接收並處理連接
                .channel(NioSocketChannel.class)            // 設置如何接受連接
                .handler(new SimpleChatClientInitializer());// 配置 channel
            // 連接服務器
            Channel channel = b.connect(host, port).sync().channel();
            // 讀取控制台輸入字符
            BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
            while(true) {
                // 每行成一幀輸出，以"\r\n"結尾
                channel.writeAndFlush(in.readLine() + "\r\n");
            }
        } catch (Exception e) {
            e.printStackTrace();        // 輸出異常
        } finally {
            group.shutdownGracefully();    // 關閉
        }
    }
    
    public static void main(String[] args) throws Exception {
        new SimpleChatClient("localhost", 8080).run();        // 啟動客戶端
    }

}

   運行結果：

六、總結

    通過代碼的形式，我們對netty有了直觀的了解和實際上的掌握。

   程序源碼

參考文獻：https://www.cnblogs.com/coderJiebao/tag/netty/