Netty就是這麼回事（二）

承接上一章，接下來開始進入Netty入門，本文所採用的Netty版本號是5.0，這個請你們注意下。

仍是上一個場景，一個簡單的客戶端和服務端直接發送字符串的程序，若是使用Netty框架如何展現呢？廢話很少說，直接上代碼。

服務端：

package com.dlb.note.server;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;

/**
 * 功能：服務器
 * 版本：1.0
 * 日期：2016年12月8日14:58:06
 * 做者：馟蘇
 */
public class TimeServer {

    /**
     * 主函數
     */
    public static void main(String []args) {
        // 配置服務端的NIO線程池
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();

        try {
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap.group(bossGroup, workerGroup)
                    .channel(NioServerSocketChannel.class)
                    // 當服務器請求處理線程全滿時，用於臨時存放已完成三次握手的請求的隊列的最大長度
                    .option(ChannelOption.SO_BACKLOG, 1024)
                    .childHandler(new ChildChannelHandler());

            // 綁定端口，同步等待成功
            ChannelFuture future = serverBootstrap.bind(8888).sync();
            System.out.println("服務器在8888端口監聽hello");

            // 等待服務端監聽端口關閉
            future.channel().closeFuture().sync();
            System.out.println("服務器關閉bye");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 優雅退出，釋放線程池資源
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}

class ChildChannelHandler extends ChannelInitializer<SocketChannel> {
    @Override
    protected void initChannel(SocketChannel socketChannel) throws Exception {
        socketChannel.pipeline().addLast(new TimerServerHandler());
    }
}

class TimerServerHandler extends ChannelHandlerAdapter {
    // 可讀
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        // 讀數據
        ByteBuf buf = (ByteBuf) msg;

        byte[] req = new byte[buf.readableBytes()];
        buf.readBytes(req);

        String body = new String(req, "UTF-8");
        System.out.println("receive:" + body);

        // 寫數據
        ByteBuf res = Unpooled.copiedBuffer("hello,client!".getBytes());
        ctx.write(res);
        ctx.flush();
    }

    // 鏈接
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("client come,ip:" + ctx.channel().remoteAddress());
    }

    // 關閉
    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("client close,ip:" + ctx.channel().remoteAddress());
        ctx.close();
    }

    // 異常
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        System.out.println(cause.toString());
        ctx.close();
    }
}

如今來分析一下：首先服務端作了兩個線程池，一個是boss線程池，一個worker線程，這是Netty框架給咱們提供的。而且在使用完畢後，能夠優雅的關閉。而後作一個服務器啓動引導serverBootStrap，咱們能夠設置TCP鏈接的屬性，Netty給咱們提供了不少屬性。接下來，註冊管道，設置處理器，綁定端口監聽。

其中比較重要的是處理器，咱們能夠這麼考慮，Netty爲咱們提供了一個管道，管道中存在許多個處理器。一個客戶端連接對應着一個管道。這樣咱們就能夠把處理邏輯寫在處理器中。在處理器中咱們主要關心這麼幾個方法，可讀：channelRead、連接到來：channelActive、連接斷開：channelInactive、異常：exceptionCaught。而且在連接關閉後，直接經過ctx.close();能夠將關聯的通道等都關閉，而且釋放資源。

客戶端：

package com.dlb.note.client;

import io.netty.bootstrap.Bootstrap;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioSocketChannel;

/**
 * 功能：支持tcp粘包/拆包的時間客戶端
 * 版本：1.0
 * 日期：2016/12/9 15:40
 * 做者：馟蘇
 */
public class TimeClient {
    /**
     * main函數
     * @param args
     */
    public static void main(String []args) {
        EventLoopGroup group = new NioEventLoopGroup();

        try {
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.group(group)
                    .channel(NioSocketChannel.class)
                    .option(ChannelOption.TCP_NODELAY, true)
                    .handler(new ChannelInitializer() {
                        protected void initChannel(Channel channel) throws Exception {
                            channel.pipeline().addLast(new MyHandler());
                        }
                    });

            // 等待客戶端連接成功
            ChannelFuture future = bootstrap.connect("localhost", 8888).sync();
            System.out.println("客戶端連接成功！");

            // 等待客戶端連接關閉
            future.channel().closeFuture().sync();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            group.shutdownGracefully();
        }
    }
}

class MyHandler extends ChannelHandlerAdapter {
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        for (int i = 0; i < 1000; i++) {
            // 1. 以回車/換行符區分
//            ByteBuf msg = Unpooled.copiedBuffer(("你好啊，服務器，我是董魯北啊！"
//                    + System.getProperty("line.separator")).getBytes());

            // 2. 採用特殊分隔符區分
            ByteBuf msg = Unpooled.copiedBuffer(("你好啊，服務器，我是revoid！$_".getBytes()));

            ctx.writeAndFlush(msg);
        }

        ctx.close();
        super.channelActive(ctx);
    }
}

客戶端也是很是簡單的，首先建立一個線程池，而後註冊管道，處理器，在連接服務器成功後，給服務器發送消息。

經過上述介紹，咱們能夠發現，經過Netty框架編寫一個簡單的客戶端和服務端通訊程序，只須要寥寥幾行就能夠實現。可是仍然還有一個問題沒有解決，那就是沒有解決，TCP的粘包和分包問題，這個問題，將會在下一章介紹。