Netty协议之 TCP （一）

古城微笑少年丶 2023-02-20 04:50 23阅读 0赞

# 前言 #

本章将会介绍如何使用Netty搭建一个TCP服务器，本系列不会详细介绍Netty本身框架。

# TCP 协议 #

传输控制协议（TCP，Transmission Control Protocol）是一种面向连接的、可靠的、基于字节流的传输层通信协议。

# Netty 支持 #

## 导入依赖包 ##

// gradle 
    compile group: 'io.netty', name: 'netty-all', version: '4.1.50.Final'
    // maven
    <dependency>
        <groupId>io.netty</groupId>
        <artifactId>netty-all</artifactId>
        <version>4.1.50.Final</version>
    </dependency>

## Server 服务端 ##

### 创建事件线程组 ###

EventLoopGroup bossGroup = new NioEventLoopGroup(1);
    EventLoopGroup workerGroup = new NioEventLoopGroup(6);

bossGroup 里面初始化了一条线程（这里就是NioEventLoop，包含一个NIO SELECTOR，一个队列，一条线程），其作用就是负责处理所有客户端连接的请求，创建新连接（channel），然后注册到workerGroup 的其中一个NioEventLoop。之后该channel的所有读/写操作都由与Channel绑定的NioEventLoop来处理。

workerGroup 如上所说，主要是负责处理读/写操作，这里初始化了6条线程（NioEventLoop）去执行。

Channel的整个生命周期都由同一个NioEventLoop处理。

### 服务启动器 ###

ServerBootstrap serverBootstrap = new ServerBootstrap();
    serverBootstrap.group(bossGroup,workerGroup)
            .channel(NioServerSocketChannel.class)
            .option(ChannelOption.SO_BACKLOG, 1024)
            .childOption(ChannelOption.SO_KEEPALIVE, true)
            .childHandler(new ChannelInitializer<SocketChannel>() { 
                @Override
                protected void initChannel(SocketChannel socketChannel) throws Exception { 
                    //添加自定义处理器
                    socketChannel.pipeline()
                            .addLast(new StringEncoder())
                            .addLast(new StringDecoder())
                            .addLast(new TcpNettyHandler());
                }
            });

*  serverBootstrap：为服务启动引导器，可以设置处理器，启动端口，绑定IP以及Channel配置等等。
 *  group：绑定线程组。
 *  NioServerSocketChannel：NIO模式。
 *  option(ChannelOption.SO\_BACKLOG, 1024)：标识当服务器请求处理线程全满时，用于临时存放已完成三次握手的请求的队列的最大长度。
 *  childOption(ChannelOption.SO\_KEEPALIVE, true)：启用心跳保活机制

这里说明下option和childOption的区别（下面childHandler同理）：

*  option主要是作用于boss线程，用于处理新连接。
 *  childOption主要作用与worker线程，也就是已创建的channel。

### handler处理器 ###

以上都是对Channel的配置，到这里，才是处理数据的关键。

#### 编解码器 ####

上面有提到，TCP是基于字节流的传输协议，因此我们必须要用到编解码器来处理字节流。本文我们当其是字符串处理。  
Netty提供了很多协议编解码器，无需我们自己去编写。

StringDecoder：字符串解码器，它会把输入的字节流解码成字符串。  
StringEncoder：字符串编码器，它会把输出的String编码为字节流。

源码可见，它们其实也是属于handler。

#### TcpServerNettyHandler ####

import io.netty.channel.ChannelHandler;
    import io.netty.channel.ChannelHandlerContext;
    import io.netty.channel.SimpleChannelInboundHandler;
    
    /** * Created by chenws on 2020/3/24. */
    @ChannelHandler.Sharable
    public class TcpServerNettyHandler extends SimpleChannelInboundHandler<String> { 
    
        @Override
        protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception { 
            System.out.println(msg);
            //把消息写到缓冲区
            ctx.write("I get the message " + msg);
        }
    
        @Override
        public void channelReadComplete(ChannelHandlerContext ctx) { 
            //刷新缓冲区，把消息发出去
            ctx.flush();
        }
    
        @Override
        public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception { 
            //异常处理，如果该handler不处理，将会传递到下一个handler
            cause.printStackTrace();
        }
    
        @Override
        public void channelActive(ChannelHandlerContext ctx) throws Exception { 
            ctx.writeAndFlush("connect success!");
        }
    }

该handler继承了SimpleChannelInboundHandler，它是继承了ChannelInboundHandlerAdapter，其实就是帮我们转化了数据的类型，体现在泛型上。这里我们指定了< String >。

*  channelRead0：当channel接收到数据时，该方法就会被执行。
 *  channelReadComplete：本次数据传输接收完后，该方法就会被执行。
 *  exceptionCaught：在接收数据过程中发生异常，该方法会被执行，如果不实现，则异常会传递到下一个handler。
 *  channelActive：channel建立成功后，该方法就会被执行。

那这里有个问题，channelReadComplete什么时候触发呢？换种说法也就是Netty是怎么知道本次传输已经读完呢？有两个条件，符合其一即会执行：

*  read 返回0字节
 *  read 传递给它的缓冲区有1024个字节要填充，但最终少于1024个字节被填充。

#### Bind ####

ChannelFuture channelFuture = serverBootstrap.bind(8080).sync();

最后一步就是绑定端口，默认绑定本机的IP 地址。

至此，TCP Netty的服务端已经完成，下面来看看客户端。

## Client 客户端 ##

大部分代码的逻辑都跟server服务端差不多，这也是netty的强大之处，下面我就直接贴

EventLoopGroup eventLoopGroup = new NioEventLoopGroup(1);
    try{ 
        Bootstrap bootstrap = new Bootstrap();
        bootstrap.group(eventLoopGroup)
    	    .channel(NioServerSocketChannel.class)
    	    .option(ChannelOption.SO_BACKLOG, 1024)
    	    .handler(new ChannelInitializer<SocketChannel>() { 
    	        @Override
    	        protected void initChannel(SocketChannel socketChannel) throws Exception { 
    	            socketChannel.pipeline()
    	                    .addLast(new StringEncoder())
    	                    .addLast(new StringDecoder())
    	                    .addLast(new TcpClientNettyHandler());
    	        }
    	    });
        ChannelFuture channelFuture = bootstrap.connect("127.0.0.1", 8080).sync();
    } catch (InterruptedException e) { 
        e.printStackTrace();
    } finally { 
        eventLoopGroup.shutdownGracefully();
    }

import io.netty.channel.ChannelHandlerContext;
    import io.netty.channel.SimpleChannelInboundHandler;
    import lombok.extern.slf4j.Slf4j;
    
    @Slf4j
    public class TcpClientNettyHandler extends SimpleChannelInboundHandler<String> { 
    
        @Override
        protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception { 
            log.info("接受来自服务器的消息：{}", msg);
            ctx.write(msg);
        }
    
        @Override
        public void channelActive(ChannelHandlerContext ctx) throws Exception { 
            super.channelActive(ctx);
        }
    
        @Override
        public void channelReadComplete(ChannelHandlerContext ctx) throws Exception { 
            //刷出通道
            ctx.flush();
        }
    
        @Override
        public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception { 
            super.exceptionCaught(ctx, cause);
        }
    }

主要区别是不再用ServerBootstrap，改用Bootstrap来启动客户端。代码没有什么难度，这里就不展开来说了。

# 总结 #

到此为止，Netty结合TCP已经介绍完，总的来说，Netty已经帮我们做了很多事情，如果对Netty感兴趣的，可以随时关注我的博客。

源码可以见：[Netty-Learn][]

[Netty-Learn]: https://github.com/SingleTigger/Netty-Learn