Netty学习篇②

Channel、ChannelPipeline、ChannelHandlerContent发送数据的不同

// channel往回写数据
Channel channel = ctx.channel();
channel.writeAndFlush(Unpooled.copiedBuffer(new String("123").toCharArray(), CharsetUtil.UTF_8));

// pipeline写回数据
ChannelPipeline pipeline = ctx.pipeline();
pipeline.writeAndFlush(Unpooled.copiedBuffer(new String("123").toCharArray(), CharsetUtil.UTF_8));

// ctx写回数据
ctx.writeAndFlush(Unpooled.copiedBuffer(new String("123").toCharArray(), CharsetUtil.UTF_8));

三种方式的区别

• 前2种影响channel整个通道的channelHandler的事件
• ctx.writeAndFlush只影响当前handler

netty入站出站handler执行顺序问题

总结：
1. InboundHandler顺序执行，OutboundHandler逆序执行

2. InboundHandler通过write方法与OutboundHandler进行交互

3. InboundHandler想要传递消息到OutboundHandler，OutboundHandler需要在InboundHandler之前添加到管道中，否则在InboundHandler中write(msg)的时候OutboundHandler可能还没注册到管道中（前提是用ChannelHandlerContent进行回写数据）

4. InboundHandler和OutBoundHandler角色的不同顺序不同；针对客户端而言，客户端是先发起请求在接收数据，所以是OutboundHandler > InboundHandler；针对服务端则反之

netty异步操作

netty中所有的IO操作都是异步的，意味着任何IO调用都会立即返回，通过ChannelFuture获得IO操作的结果和状态

ChannelFuture

ChannelFuture提供了IO操作的结果和状态
它继承了io.netty.util.concurrent包下的Future 
间接继承了并发包下的Future

ChannelFuture的类图

注意：
不要在IO线程内调用future对象的sync/await方法，不能再ChannelHandler中调用sync/await方法，可能导致死锁问题

ChannelPromise

继承ChannelFuture，进一步拓展用于设置IO操作结果

TCP粘包拆包

• TCP拆包

  所谓拆包就是一个数据包拆分成多个包进行发送，就好比咱们在同一家店购买东西过多会拆成多个包裹进去发货类似，一个完成的数据包可能会被TCP拆分成多个包进行传输发送

• TCP粘包

  粘包则和拆包相反，将多个小包封装成一个大的数据包，就好比快递站收到包裹不会立马运输派送，会等到一定的量才会运输派送；客户端发送若干的数据包，服务端接收的时候粘合成一个包接收
  

  // 客户端
  public class HtNettyClient {
  
      private String ip;
  
      private int port;
  
      HtNettyClient(String ip, int port) {
          this.ip = ip;
          this.port = port;
      }
  
      public void start() {
          EventLoopGroup workGroup = new NioEventLoopGroup();
          try {
              Bootstrap bootstrap = new Bootstrap();
              bootstrap.group(workGroup)
                      .channel(NioSocketChannel.class)
                      .remoteAddress(new InetSocketAddress(ip, port))
                      .handler(new ChannelInitializer() {
                  @Override
                  protected void initChannel(SocketChannel ch) throws Exception {
                      ch.pipeline().addLast(new HtNettyClientHandler());
                  }
              });
              ChannelFuture future = bootstrap.connect().sync();
              future.channel().closeFuture().sync();
          } catch (Exception e) {
  
          } finally {
              workGroup.shutdownGracefully();
          }
      }
  
      public static void main(String[] args) {
          HtNettyClient client = new HtNettyClient("127.0.0.1", 9000);
          client.start();
      }
  }
  
  // 客户端发送数据handler
  public class HtNettyClientHandler extends ChannelInboundHandlerAdapter {
  
      @Override
      public void channelActive(ChannelHandlerContext ctx) throws Exception {
          // 数据缓冲区
          ByteBuf byteBuf = null;
          byte[] req = ("hetangyuese" +System.getProperty("line.separator")).getBytes();
          for (int i= 0; i<10; i++) {
              byteBuf = Unpooled.buffer(req.length);
              byteBuf.writeBytes(req);
              ctx.writeAndFlush(byteBuf);
          }
   }
  
  
  // 服务端
  public class HtNettyServer {
  
      private int port;
  
      HtNettyServer(int port) {
          this.port = port;
      }
  
      public void start() {
          // 定义一个boss来处理请求
          EventLoopGroup bossGroup = new NioEventLoopGroup(1);
          EventLoopGroup workGroup = new NioEventLoopGroup();
          try {
              ServerBootstrap serverBootstrap = new ServerBootstrap();
              serverBootstrap.group(bossGroup, workGroup)
                      .option(ChannelOption.SO_BACKLOG, 1024)
                      .channel(NioServerSocketChannel.class)
                      .childHandler(new ChannelInitializer() {
                          @Override
                          protected void initChannel(SocketChannel ch) throws Exception {
                              ch.pipeline()
  //                                    .addLast(new LineBasedFrameDecoder(3))
                                      .addLast(new HtNettyHandler());
                          }
                      });
              // 绑定端口
              ChannelFuture channelFuture = serverBootstrap.bind(port).sync();
              // 阻塞至直至关闭通道
              channelFuture.channel().closeFuture().sync();
  
          } catch (Exception e) {
              e.printStackTrace();
          } finally {
              bossGroup.shutdownGracefully();
              workGroup.shutdownGracefully();
          }
      }
  
      public static void main(String[] args) {
          HtNettyServer server = new HtNettyServer(9000);
          server.start();
      }
  }
  
  // 服务端handler
  public class HtNettyHandler extends ChannelInboundHandlerAdapter {
  
  
      private int count;
  
      @Override
      public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
          // 如果没有定义解码器的话 默认转byteBuf
          ByteBuf byteBuf = (ByteBuf)msg;
          byte[] params = new byte[byteBuf.readableBytes()];
          byteBuf.readBytes(params);
          String body = new String(params, CharsetUtil.UTF_8);
          System.out.println("收到了请求，请求内容：" + body + ", 收到请求次数：" + ++count);
      }
  
      @Override
      public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
          cause.printStackTrace();
          ctx.close();
      }
  }
  
  // 结果
  收到了请求，请求内容：hetangyuese
  hetangyuese
  hetangyuese
  hetangyuese
  hetangyuese
  hetangyuese
  hetangyuese
  hetangyuese
  hetangyuese
  hetangyuese
  , 收到请求次数：1
  

粘、拆包

为何TCP会导致粘包和拆包？

TCP每次在发送数据时都是以流的形式进行传输，底层有一个缓冲区来存储发送的字节流，

1.当发送数据小于缓冲区的饱和的大小时，会发生粘包，粘成一个包发送至服务端（每个包之间的间隔时间短，包数据很小）；

2.当发送的数据大于缓冲区的阈值，则会拆分成多个包进行发送

3.服务端没及时读取缓冲区的数据，导致数据堆积，可能导致服务端粘包

4.发送方由于Nagle算法机制

Nagle算法

TCP/IP协议中，无论发送多少数据，总是要在数据前面加上协议头，同时，对方接收到数据，也需要发送ACK表示确认。为了尽可能的利用网络带宽，TCP总是希望尽可能的发送足够大的数据。（一个连接会设置MSS参数，因此，TCP/IP希望每次都能够以MSS尺寸的数据块来发送数据）。Nagle算法就是为了尽可能发送大块数据，避免网络中充斥着许多小数据块。

粘包、拆包解决方法

1. 设置定长消息（根据业务设置足够长）
2. 设置消息的边界（设置分隔符）
3. 使用带消息头的协议，消息头存储消息开始标识及消息的长度信息
4. 发送端关闭Nagle算法

Netty编、解码器

Decoder解码

主要对应的是ChannelInboundHandler，主要作用将字节数组转换成对象消息

Decoder解码常用抽象类

• ByteToMessageDecoder

  字节码转消息对象时需要检查缓冲区是否有足够的字节
  

  @Override
  protected void decode(ChannelHandlerContext ctx, ByteBuf in,List