java 网络通信 netty TCP Hello World和TCP拆包粘包问题（基于Netty5.0）

服务器端
- 创建处理客户端连接处理的线程组
- 创建网络读写处理的线程组
- 创建ServerBootstrap辅助处理类
- 绑定俩个线程组
- 配置为NioServerSocketChannel的nio模式
- 配置服务器端处理类
- 绑定端口
- 启动服务器异步监听
- 服务器端异步关闭
- 线程组异步关闭

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 Server {

    public static void main(String[] args) throws Exception {
        //1 创建线两个程组 
        //一个是用于处理服务器端接收客户端连接的
        //一个是进行网络通信的（网络读写的）
        EventLoopGroup pGroup = new NioEventLoopGroup();
        EventLoopGroup cGroup = new NioEventLoopGroup();
        
        //2 创建辅助工具类，用于服务器通道的一系列配置
        ServerBootstrap b = new ServerBootstrap();
        b.group(pGroup, cGroup)     //绑定俩个线程组
        .channel(NioServerSocketChannel.class)      //指定NIO的模式
        .option(ChannelOption.SO_BACKLOG, 1024)     //设置tcp缓冲区，默认128
        .option(ChannelOption.SO_SNDBUF, 32*1024)   //设置发送缓冲大小
        .option(ChannelOption.SO_RCVBUF, 32*1024)   //这是接收缓冲大小
        .option(ChannelOption.SO_KEEPALIVE, true)   //保持连接
        .childHandler(new ChannelInitializer() {
            @Override
            protected void initChannel(SocketChannel sc) throws Exception {
                //3 在这里配置具体数据接收方法的处理
                sc.pipeline().addLast(new ServerHandler());
            }
        });
        
        //4 进行绑定 
        ChannelFuture cf1 = b.bind(8765).sync();
        //ChannelFuture cf2 = b.bind(8764).sync();
        //5 等待关闭
        cf1.channel().closeFuture().sync();
        //cf2.channel().closeFuture().sync();
        pGroup.shutdownGracefully();
        cGroup.shutdownGracefully();
    }
}

java 网络通信 netty TCP Hello World和TCP拆包粘包问题（基于Netty5.0）_第1张图片

关于SO_BACKLOG参数

服务器端处理器
- 继承ChannelHandlerAdapter 类
- 重写 exceptionCaught，channelActive， channelRead，channelReadComplete方法
- ChannelHandlerContext 对象可以对客户端进行响应
- 释放客户端发送过来的数据ReferenceCountUtil.release(msg)，当有给客户端端写数据的时候不用释放，netty会帮忙释放

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelFutureListener;
import io.netty.channel.ChannelHandlerAdapter;
import io.netty.channel.ChannelHandlerContext;

public class ServerHandler extends ChannelHandlerAdapter {


    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("server channel active... ");
    }


    @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("Server :" + body );
            String response = "进行返回给客户端的响应：" + body ;
            ctx.writeAndFlush(Unpooled.copiedBuffer(response.getBytes()));
            //.addListener(ChannelFutureListener.CLOSE);   //写完之后客户端自动断开连接，不加就是一直连接，加就是短连接，不加就是长连接
    }

    @Override
    public void channelReadComplete(ChannelHandlerContext ctx)
            throws Exception {
        System.out.println("读完了");
        ctx.flush();
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable t)
            throws Exception {
        ctx.close();
    }

}

客户端
- 创建工作线程组
- 创建Bootstrap（客户端的辅助类），配置工作线程组
- 配置为NioSocketChannel（客户端）nio模式
- 配置客户端处理类，异步连接服务器
- 异步关闭连接
- 异步关闭线程组

import io.netty.bootstrap.Bootstrap;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
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 Client {

    public static void main(String[] args) throws Exception{
        
        EventLoopGroup group = new NioEventLoopGroup();
        Bootstrap b = new Bootstrap(); //注意这里的区别
        b.group(group) //注意这里的区别
        .channel(NioSocketChannel.class) //注意这里的区别
        .handler(new ChannelInitializer() { //注意这里的区别
            @Override
            protected void initChannel(SocketChannel sc) throws Exception {
                sc.pipeline().addLast(new ClientHandler());
            }
        });
        
        ChannelFuture cf1 = b.connect("127.0.0.1", 8765).sync();
        //ChannelFuture cf2 = b.connect("127.0.0.1", 8764).sync();
        //发送消息
        Thread.sleep(1000);
        cf1.channel().writeAndFlush(Unpooled.copiedBuffer("777".getBytes()));
        cf1.channel().writeAndFlush(Unpooled.copiedBuffer("666".getBytes()));
        //cf2.channel().writeAndFlush(Unpooled.copiedBuffer("888".getBytes()));
        Thread.sleep(2000);
        cf1.channel().writeAndFlush(Unpooled.copiedBuffer("888".getBytes()));
        //cf2.channel().writeAndFlush(Unpooled.copiedBuffer("666".getBytes()));
        
        cf1.channel().closeFuture().sync();
        //cf2.channel().closeFuture().sync();
        group.shutdownGracefully();
        
        
        
    }
}

客户端处理器
- 继承ChannelHandlerAdapter
- 重写 exceptionCaught，channelActive， channelRead，channelReadComplete方法
- 在channelRead里对服务器端数据进行处理，或者给服务器端发送数据
- 释放服务器端发送过来的数据ReferenceCountUtil.release(msg)，当有给服务端写数据的时候不用释放，netty会帮忙释放

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerAdapter;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelPromise;
import io.netty.util.ReferenceCountUtil;

public class ClientHandler extends ChannelHandlerAdapter{


    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        try {
            ByteBuf buf = (ByteBuf) msg;
            
            byte[] req = new byte[buf.readableBytes()];
            buf.readBytes(req);
            
            String body = new String(req, "utf-8");
            System.out.println("Client :" + body );
            String response = "收到服务器端的返回信息：" + body;
        } finally {
            ReferenceCountUtil.release(msg);
        }
    }

    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {

    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)
            throws Exception {
        ctx.close();
    }

}

补充
- 多次write，不flush会导致发出的数据粘在一起，并不是一部分一部分的，推荐使用writeAndFlush方法写数据
- 如果发送一次数据后要关闭连接，请在服务器端关闭，方法为，ctx.writeAndFlush(buf),返回ChannelFuture对象，添加ChannelFutureListener监听器，一般为ChannelFutureListener.CLOSE,可以自定义
- 服务器端可以绑定多个端口，使用同一个ServerBootstrap对象。详情见代码
tcp的拆包粘包问题
- 假如你使用cf1.channel().writeAndFlush(Unpooled.copiedBuffer("777".getBytes())); cf1.channel().writeAndFlush(Unpooled.copiedBuffer("666".getBytes()));写出数据的话，这会导致粘包，也就是说777和666会被服务器端认为这是一条消息，而不是俩条
- 解决的办法之一是在这俩语句中间加个sleep，当然，实际不可能这么用
- 解决方案
  - 每个数据包使用一个特殊字符作为分隔符
    在netty的辅助类配置处理器（Handler中）的时候，添加配置：
    ByteBuf buf = Unpooled.copiedBuffer("$".getBytes());//特殊分割符，写的时候消息以$字符结尾
    sc.pipeline().addLast(new DelimiterBasedFrameDecoder(1024, buf));
    sc.pipeline().addLast(new StringDecoder());//添加这个客户端可以直接write 字符串，而不用write buffer，但是服务器还是要write buffer
    这俩个处理器要在服务器端和客户端都同时配置，写数据的时候记得尾部添加分隔符
  - 数据包定长，如果数据长度不够定长，用空格补位，如果超出，将丢失，比如定长是5，数据长度是7，发送数据的时候只会发送前五位，后俩位将丢失，不发送，用空格补位的动作要自己完成，比如数据只有三位，补俩空格，服务器端也能接收到
    在netty的辅助类配置处理器（Handler中）的时候，添加配置：
    //设置定长字符串接收
    sc.pipeline().addLast(new FixedLengthFrameDecoder(5));
    //设置字符串形式的解码
    sc.pipeline().addLast(new StringDecoder());//添加这个客户端可以直接write 字符串，而不用write buffer，但是服务器还是要write buffer
    这俩个处理器要在服务器端和客户端都同时配置，写数据的时候，数据长度不够记得补位
  - 将消息分为消息头和消息体，消息头中包含表示消息总长度的字段，主要用于安全，详见

java 网络通信 netty TCP Hello World和TCP拆包粘包问题（基于Netty5.0）

你可能感兴趣的:(java 网络通信 netty TCP Hello World和TCP拆包粘包问题（基于Netty5.0）)