devbox
小舞很执着
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Spring Boot使用Netty实现客户端与服务器通信_springboot netty回复客户端

作者：小舞很执着 | 2024-08-13 07:50:51

赞

踩

springboot netty回复客户端

一、服务端

1、添加Maven依赖

  1.     <parent>
  2.         <groupId>org.springframework.boot</groupId>
  3.         <artifactId>spring-boot-starter-parent</artifactId>
  4.         <version>2.1.3.RELEASE</version>
  5.     </parent>
  6.  
  7.     <dependencies>
  8.         <dependency>
  9.             <groupId>org.springframework.boot</groupId>
  10.             <artifactId>spring-boot-starter-web</artifactId>
  11.         </dependency>
  12.  
  13.         <dependency>
  14.             <groupId>io.netty</groupId>
  15.             <artifactId>netty-all</artifactId>
  16.             <version>5.0.0.Alpha2</version>
  17.         </dependency>
  18.  
  19. 		<dependency>
  20.             <groupId>com.alibaba</groupId>
  21.             <artifactId>fastjson</artifactId>
  22.             <version>1.2.59</version>
  23.         </dependency>
  24.  
  25.         <dependency>
  26. 			<groupId>org.projectlombok</groupId>
  27. 			<artifactId>lombok</artifactId>
  28. 			<optional>true</optional>
  29. 		</dependency>
  30.     </dependencies>

2、application.yml

  1. server:
  2.   port: 8001

3、启动类

  1. @SpringBootApplication
  2. public class NettyServerApplication implements CommandLineRunner {
  3.  
  4.     @Autowired
  5.     private NettyServerBootStrap serverBootStrap;
  6.  
  7.     public static void main(String[] args) {
  8.         SpringApplication.run(NettyServerApplication.class, args);
  9.     }
  10.  
  11.     @Override
  12.     public void run(String... args) throws Exception {
  13.         serverBootStrap.start();
  14.     }
  15. }

4、NettyServerBootStrap

  1. @Component
  2. @Slf4j
  3. public class NettyServerBootStrap {
  4.  
  5.     @Autowired
  6.     private NettyServerHandler nettyServerHandler;
  7.  
  8.     public void start() throws InterruptedException {
  9.         EventLoopGroup boss = new NioEventLoopGroup();
  10.         EventLoopGroup worker = new NioEventLoopGroup();
  11.         ServerBootstrap bootstrap = new ServerBootstrap();
  12.         try {
  13.             bootstrap.group(boss, worker)
  14.                     .channel(NioServerSocketChannel.class)
  15.                     .option(ChannelOption.SO_BACKLOG, 128)
  16.                     // 使消息立即发出去，不用等待到一定的数据量才发出去
  17.                     .option(ChannelOption.TCP_NODELAY, true)
  18.                     // 保持长连接状态
  19.                     .childOption(ChannelOption.SO_KEEPALIVE, true)
  20.                     .childHandler(new ChannelInitializer<SocketChannel>() {
  21.                         @Override
  22.                         protected void initChannel(SocketChannel socketChannel) throws Exception {
  23.                             ChannelPipeline p = socketChannel.pipeline();
  24.                             p.addLast(new StringDecoder(CharsetUtil.UTF_8));
  25.                             p.addLast(new StringEncoder(CharsetUtil.UTF_8));
  26.                             p.addLast(nettyServerHandler);
  27.                         }
  28.                     });
  29.             // 绑定端口，同步等待成功
  30.             ChannelFuture f = bootstrap.bind(5678).sync();
  31.             if (f.isSuccess()) {
  32.                 log.info("Netty Start successful");
  33.             } else {
  34.                 log.error("Netty Start failed");
  35.             }
  36.             // 等待服务监听端口关闭
  37.             f.channel().closeFuture().sync();
  38.         } finally {
  39.             // 退出，释放线程资源
  40.             worker.shutdownGracefully();
  41.             boss.shutdownGracefully();
  42.         }
  43.     }
  44.  
  45. }

5、NettyServerHandler

  1. @Component
  2. @ChannelHandler.Sharable
  3. @Slf4j
  4. public class NettyServerHandler extends SimpleChannelInboundHandler<String> {
  5.  
  6.     /**
  7.      * @Description 客户端断开连接时执行，将客户端信息从Map中移除
  8.      * @param ctx
  9.      * @Date 2019/8/28 14:22
  10.      * @Author wuyong
  11.      * @return
  12.      **/
  13.     @Override
  14.     public void channelInactive(ChannelHandlerContext ctx) throws Exception {
  15.         log.info("客户端断开连接：{}", getClientIp(ctx.channel()));
  16.         NettyChannelMap.remove((SocketChannel) ctx.channel());
  17.     }
  18.  
  19.     /**
  20.      * @Description 客户端连接时执行，将客户端信息保存到Map中
  21.      * @param ctx
  22.      * @Date 2019/8/28 14:22
  23.      * @Author wuyong
  24.      * @return
  25.      **/
  26.     @Override
  27.     public void channelActive(ChannelHandlerContext ctx) throws Exception {
  28.         log.info("有新的客户端连接：{}", getClientIp(ctx.channel()));
  29.         String clientIp = getClientIp(ctx.channel());
  30.         NettyClient client = new NettyClient((SocketChannel) ctx.channel(), getClientIp(ctx.channel()));
  31.         NettyChannelMap.add(clientIp, client);
  32.     }
  33.  
  34.     /**
  35.      * @Description 收到消息时执行，根据消息类型做不同的处理
  36.      * @param ctx
  37.      * @param msg
  38.      * @Date 2019/8/28 14:33
  39.      * @Author wuyong
  40.      * @return
  41.      **/
  42.     @Override
  43.     public void messageReceived(ChannelHandlerContext ctx, String msg) throws Exception {
  44.         log.info("收到客户端消息：" + msg);
  45.         // 这个消息一般是结构化的数据，比如JSON字符串，解析这个JSON字符串，做相应的逻辑处理
  46.         JSONObject msgObj = JSON.parseObject(msg);
  47.         String msgType = msgObj.getString("msgType");
  48.         switch (msgType) {
  49.             // 回复客户端请求
  50.             case "req":
  51.                 doReply(ctx);
  52.                 break;
  53.  
  54.             default:
  55.                 break;
  56.         }
  57.     }
  58.  
  59.     /**
  60.      * @description: TODO
  61.      * @param ctx
  62.      * @param cause
  63.      * @Author: wuyong
  64.      * @Date: 2019/08/30 13:41:51
  65.      * @return: void
  66.      */
  67.     @Override
  68.     public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
  69.         log.info("抛出异常执行，包括客户端断开连接时，会抛出IO异常");
  70.     }
  71.  
  72.     /**
  73.      * @description: 当收到客户端的消息后，进行处理
  74.      * @param ctx
  75.      * @Author: wuyong
  76.      * @Date: 2019/08/30 14:10:59
  77.      * @return: void
  78.      */
  79.     private void doReply(ChannelHandlerContext ctx) {
  80.         String reply = "{\"msgType\":\"reply\",\"data\":\"回复的数据\"}";
  81.         ctx.channel().writeAndFlush(reply);
  82.     }
  83.  
  84.     /**
  85.      * @Description 获取客户端IP
  86.      * @param channel
  87.      * @Date 2019/8/28 14:32
  88.      * @Author wuyong
  89.      * @return
  90.      **/
  91.     private String getClientIp(Channel channel) {
  92.         InetSocketAddress inetSocketAddress = (InetSocketAddress) channel.remoteAddress();
  93.         String clientIP = inetSocketAddress.getAddress().getHostAddress();
  94.         return clientIP;
  95.     }
  96.  
  97.     /**
  98.      * @Description 当有新的客户端连接的时候，用于保存客户端信息
  99.      * @Date 2019/8/28 14:20
  100.      * @Author wuyong
  101.      * @return
  102.      **/
  103.     public static class NettyChannelMap {
  104.  
  105.         public static Map<String, NettyClient> map = new ConcurrentHashMap<>();
  106.  
  107.         public static void add(String clientId, NettyClient client) {
  108.             map.put(clientId, client);
  109.         }
  110.  
  111.         public static NettyClient get(String clientId) {
  112.             return map.get(clientId);
  113.         }
  114.  
  115.         public static void remove(SocketChannel socketChannel) {
  116.             for (Map.Entry entry : map.entrySet()) {
  117.                 if (((NettyClient) entry.getValue()).getChannel() == socketChannel) {
  118.                     map.remove(entry.getKey());
  119.                 }
  120.             }
  121.         }
  122.     }
  123.  
  124.     /**
  125.      * @Description 封装客户端的信息
  126.      * @Date 2019/8/28 14:21
  127.      * @Author wuyong
  128.      * @return
  129.      **/
  130.     @Data
  131.     public static class NettyClient {
  132.  
  133.         /**客户端与服务器的连接*/
  134.         private SocketChannel channel;
  135.  
  136.         /**ip地址*/
  137.         private String clientIp;
  138.  
  139.         // ......
  140.  
  141.         public NettyClient(SocketChannel channel, String clientIp) {
  142.             this.channel = channel;
  143.             this.clientIp = clientIp;
  144.         }
  145.  
  146.     }
  147.  
  148. }

至此，一个简单的Netty服务端就完成了。接下来写一个Controller，用于获取当前在线的客户端列表：

6、NettyServerController

  1. @RestController
  2. @RequestMapping("/server")
  3. public class NettyServerController {
  4.  
  5.     @GetMapping("/clientList")
  6.     public Map<String, NettyServerHandler.NettyClient> clientList() {
  7.         return NettyServerHandler.NettyChannelMap.map;
  8.     }
  9.  
  10. }

项目结构如下：

二、客户端

客户端添加的依赖、配置文件以及启动类和服务端类似。

1、NettyClientBootStrap

  1. @Component
  2. @Slf4j
  3. public class NettyClientBootStrap {
  4.  
  5.     private static final String HOST = "localhost";
  6.     private static final int PORT = 5678;
  7.     private static SocketChannel socketChannel = null;
  8.  
  9.     public void start() throws InterruptedException {
  10.         EventLoopGroup eventLoopGroup = new NioEventLoopGroup();
  11.         Bootstrap bootstrap = new Bootstrap();
  12.         bootstrap.channel(NioSocketChannel.class);
  13.         bootstrap.option(ChannelOption.SO_KEEPALIVE, true);
  14.         bootstrap.group(eventLoopGroup);
  15.         bootstrap.remoteAddress(HOST, PORT);
  16.         bootstrap.handler(new ChannelInitializer<SocketChannel>() {
  17.             @Override
  18.             protected void initChannel(SocketChannel socketChannel) throws Exception {
  19.                 socketChannel.pipeline().addLast(new IdleStateHandler(20, 10, 0));
  20.                 socketChannel.pipeline().addLast(new StringEncoder(CharsetUtil.UTF_8));
  21.                 socketChannel.pipeline().addLast(new StringDecoder(CharsetUtil.UTF_8));
  22.                 socketChannel.pipeline().addLast(new NettyClientHandler());
  23.             }
  24.         });
  25.         ChannelFuture future = bootstrap.connect(HOST, PORT).sync();
  26.         if (future.isSuccess()) {
  27.             socketChannel = (SocketChannel) future.channel();
  28.             log.info("connect server success");
  29.         }
  30.     }
  31.  
  32.     public static SocketChannel getSocketChannel() {
  33.         return socketChannel;
  34.     }
  35.  
  36. }

2、NettyClientHandler

  1. @Component
  2. @Slf4j
  3. @ChannelHandler.Sharable
  4. public class NettyClientHandler extends SimpleChannelInboundHandler<String> {
  5.  
  6.     @Override
  7.     public void channelInactive(ChannelHandlerContext ctx) throws Exception {
  8.         log.info("断开连接执行");
  9.     }
  10.  
  11.     @Override
  12.     public void channelActive(ChannelHandlerContext ctx) throws Exception {
  13.         log.info("连接成功执行");
  14.     }
  15.  
  16.     @Override
  17.     protected void messageReceived(ChannelHandlerContext ctx, String msg) throws Exception {
  18.         log.info("收到消息执行：" + msg);
  19.     }
  20.  
  21.     @Override
  22.     public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
  23.         log.info("抛出异常执行");
  24.     }
  25. }

3、编写一个Controller，用于向服务器发送消息：

  1. @RestController
  2. @RequestMapping("/client")
  3. public class NettyClientController {
  4.  
  5.     /**
  6.      * @description: 模拟向服务器发送消息
  7.      * @param
  8.      * @Author: wuyong
  9.      * @Date: 2019/08/30 14:10:09
  10.      * @return: java.lang.String
  11.      */
  12.     @RequestMapping("/req")
  13.     public String req() {
  14.         String msg = "{\"msgType\":\"req\",\"clientId\":\"请求数据\"}";
  15.         NettyClientBootStrap.getSocketChannel().writeAndFlush(msg);
  16.         return "success";
  17.     }
  18.  
  19. }

客户端的结构如下：

三、测试

首先启动服务端：

然后启动客户端，启动成功后可以看到如下输出：

然后查看服务端的控制台：

在浏览器中访问http://localhost:8001/server/clientList，可以看到确实注册成功了：

接下来使用客户端向服务器发消息，在浏览器中执行http://localhost:8002/client/req，在服务端的控制台输出如下信息：

客户端的控制台输出了如下信息：

接下来断开客户端的连接，在服务端的控制台输出了如下信息：

查看客户端列表，也为空了：

四、使用Socket连接服务器

也可以直接使用Socket连接Netty服务器，编写一个简单的Demo如下：

  1. public class Client {
  2.  
  3.     public static void main(String[] args) throws IOException, InterruptedException {
  4.         Socket socket = new Socket("localhost", 5678);
  5.  
  6.         // 向服务器发消息
  7.         OutputStream outputStream = socket.getOutputStream();
  8.         String msg = "{\"msgType\":\"req\",\"clientId\":\"请求数据\"}";
  9.         outputStream.write(msg.getBytes(CharsetUtil.UTF_8));
  10.         outputStream.flush();
  11.  
  12.         Thread.sleep(1000);
  13.         BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
  14.         char[] ch = new char[65536];
  15.         int len = -1;
  16.         while ((len = br.read(ch)) != -1) {
  17.             String result = new String(ch, 0, len);
  18.             System.out.println("服务器返回数据：" + result);
  19.         }
  20.     }
  21.  
  22. }

运行main方法，可以看到控制台输出：

服务器返回数据：{"msgType":"reply","data":"回复的数据"}

五、粘包/拆包

正常情况下，一条消息是一个整体，一次接收到的消息只会是一条。但是实际情况下，收到的消息可能是多条消息粘在一起，或者一条消息被拆分成了多条。这就是所谓的粘包/拆包。产生粘包和拆包问题的主要原因是，操作系统在发送TCP数据的时候，底层会有一个缓冲区，例如1024个字节大小，如果一次请求发送的数据量比较小，没达到缓冲区大小，TCP则会将多个请求合并为同一个请求进行发送，这就形成了粘包问题；如果一次请求发送的数据量比较大，超过了缓冲区大小，TCP就会将其拆分为多次发送，这就是拆包，也就是将一个大的包拆分为多个小包进行发送。

对于粘包和拆包问题，常见的解决方案有四种（https://my.oschina.net/zhangxufeng/blog/3023794）：

1、客户端在发送数据包的时候，每个包都固定长度，比如1024个字节大小，如果客户端发送的数据长度不足1024个字节，则通过补充空格的方式补全到指定长度（FixedLengthFrameDecoder解码器）。

2、客户端在每个包的末尾使用固定的分隔符，例如\r\n，如果一个包被拆分了，则等待下一个包发送过来之后找到其中的\r\n，然后对其拆分后的头部部分与前一个包的剩余部分进行合并，这样就得到了一个完整的包（LineBasedFrameDecoder或DelimiterBasedFrameDecoder解码器）。

3、将消息分为消息头和消息体，在头部中保存有当前整个消息的长度，只有在读取到足够长度的消息之后才算是读到了一个完整的消息（LengthFieldBasedFrameDecoder和LengthFieldPrepender）。

4、通过自定义协议进行粘包和拆包的处理（通过继承LengthFieldBasedFrameDecoder和LengthFieldPrepender来实现粘包和拆包的处理）。

首先，模拟一下粘包和拆包的问题。

修改NettyClientController，连续向服务器发送20条消息：

  1.     private void doReply(ChannelHandlerContext ctx) {
  2.         String reply = "{\"msgType\":\"reply\",\"data\":\"回复的数据\"}";
  3.         for (int i = 0; i < 20; i++) {
  4.             ctx.channel().writeAndFlush(reply);
  5.         }
  6.     }

查看服务端的控制台，输出如下：

  1. 2019-08-30 15:35:52.330  INFO 5772 --- [ntLoopGroup-1-0] com.wuychn.server.NettyServerHandler     : 收到客户端消息：{"msgType":"req","clientId":"请求数据"}
  2. 2019-08-30 15:35:52.331  INFO 5772 --- [ntLoopGroup-1-0] com.wuychn.server.NettyServerHandler     : 收到客户端消息：{"msgType":"req","clientId":"请求数据"}
  3. 2019-08-30 15:35:52.331  INFO 5772 --- [ntLoopGroup-1-0] com.wuychn.server.NettyServerHandler     : 收到客户端消息：{"msgType":"req","clientId":"请求数据"}{"msgType":"req","clientId":"请求数据"}{"msgType":"req","clientId":"请求数据"}{"msgType":"req","clientId":"请求数据"}{"msgType":"req","clientId":"请求数据"}
  4. 2019-08-30 15:35:52.331  INFO 5772 --- [ntLoopGroup-1-0] com.wuychn.server.NettyServerHandler     : 抛出异常执行，包括客户端断开连接时，会抛出IO异常
  5. 2019-08-30 15:35:52.331  INFO 5772 --- [ntLoopGroup-1-0] com.wuychn.server.NettyServerHandler     : 收到客户端消息：{"msgType":"req","clientId":"请求数据"}{"msgType":"req","clientId":"请求数据"}{"msgType":"req","clientId":"请求数据"}
  6. 2019-08-30 15:35:52.331  INFO 5772 --- [ntLoopGroup-1-0] com.wuychn.server.NettyServerHandler     : 抛出异常执行，包括客户端断开连接时，会抛出IO异常
  7. 2019-08-30 15:35:52.331  INFO 5772 --- [ntLoopGroup-1-0] com.wuychn.server.NettyServerHandler     : 收到客户端消息：{"msgType":"req","clientId":"请求数据"}{"msgType":"req","clientId":"请求数据"}
  8. 2019-08-30 15:35:52.332  INFO 5772 --- [ntLoopGroup-1-0] com.wuychn.server.NettyServerHandler     : 抛出异常执行，包括客户端断开连接时，会抛出IO异常
  9. 2019-08-30 15:35:52.332  INFO 5772 --- [ntLoopGroup-1-0] com.wuychn.server.NettyServerHandler     : 收到客户端消息：{"msgType":"req","clientId":"请求数据"}{"msgType":"req","clientId":"请求数据"}
  10. 2019-08-30 15:35:52.332  INFO 5772 --- [ntLoopGroup-1-0] com.wuychn.server.NettyServerHandler     : 抛出异常执行，包括客户端断开连接时，会抛出IO异常
  11. 2019-08-30 15:35:52.332  INFO 5772 --- [ntLoopGroup-1-0] com.wuychn.server.NettyServerHandler     : 收到客户端消息：{"msgType":"req","clientId":"请求数据"}{"msgType":"req","clientId":"请求数据"}
  12. 2019-08-30 15:35:52.332  INFO 5772 --- [ntLoopGroup-1-0] com.wuychn.server.NettyServerHandler     : 抛出异常执行，包括客户端断开连接时，会抛出IO异常
  13. 2019-08-30 15:35:52.332  INFO 5772 --- [ntLoopGroup-1-0] com.wuychn.server.NettyServerHandler     : 收到客户端消息：{"msgType":"req","clientId":"请求数据"}{"msgType":"req","clientId":"请求数据"}
  14. 2019-08-30 15:35:52.332  INFO 5772 --- [ntLoopGroup-1-0] com.wuychn.server.NettyServerHandler     : 抛出异常执行，包括客户端断开连接时，会抛出IO异常
  15. 2019-08-30 15:35:52.332  INFO 5772 --- [ntLoopGroup-1-0] com.wuychn.server.NettyServerHandler     : 收到客户端消息：{"msgType":"req","clientId":"请求数据"}{"msgType":"req","clientId":"请求数据"}
  16. 2019-08-30 15:35:52.332  INFO 5772 --- [ntLoopGroup-1-0] com.wuychn.server.NettyServerHandler     : 抛出异常执行，包括客户端断开连接时，会抛出IO异常

可知第三条消息就发生了粘包的问题。我这里采用在末尾加特定的分隔符（\r\n）的方式来解决。

修改NettyServerBootstrap，添加一个LineBasedFrameDecoder解码器：

  1. @Component
  2. @Slf4j
  3. public class NettyServerBootStrap {
  4.  
  5.     @Autowired
  6.     private NettyServerHandler nettyServerHandler;
  7.  
  8.     public void start() throws InterruptedException {
  9.         EventLoopGroup boss = new NioEventLoopGroup();
  10.         EventLoopGroup worker = new NioEventLoopGroup();
  11.         ServerBootstrap bootstrap = new ServerBootstrap();
  12.         try {
  13.             bootstrap.group(boss, worker)
  14.                     .channel(NioServerSocketChannel.class)
  15.                     .option(ChannelOption.SO_BACKLOG, 128)
  16.                     // 使消息立即发出去，不用等待到一定的数据量才发出去
  17.                     .option(ChannelOption.TCP_NODELAY, true)
  18.                     // 保持长连接状态
  19.                     .childOption(ChannelOption.SO_KEEPALIVE, true)
  20.                     .childHandler(new ChannelInitializer<SocketChannel>() {
  21.                         @Override
  22.                         protected void initChannel(SocketChannel socketChannel) throws Exception {
  23.                             ChannelPipeline p = socketChannel.pipeline();
  24.                             p.addLast(new LineBasedFrameDecoder(Integer.MAX_VALUE));
  25.                             p.addLast(new StringDecoder(CharsetUtil.UTF_8));
  26.                             p.addLast(new StringEncoder(CharsetUtil.UTF_8));
  27.                             p.addLast(nettyServerHandler);
  28.                         }
  29.                     });
  30.             // 绑定端口，同步等待成功
  31.             ChannelFuture f = bootstrap.bind(5678).sync();
  32.             if (f.isSuccess()) {
  33.                 log.info("Netty Start successful");
  34.             } else {
  35.                 log.error("Netty Start failed");
  36.             }
  37.             // 等待服务监听端口关闭
  38.             f.channel().closeFuture().sync();
  39.         } finally {
  40.             // 退出，释放线程资源
  41.             worker.shutdownGracefully();
  42.             boss.shutdownGracefully();
  43.         }
  44.     }
  45.  
  46. }

修改NettyClientController，在消息末尾增加\r\n：

  1. @RestController
  2. @RequestMapping("/client")
  3. public class NettyClientController {
  4.  
  5.     /**
  6.      * @description: 模拟向服务器发送消息
  7.      * @param
  8.      * @Author: wuyong
  9.      * @Date: 2019/08/30 14:10:09
  10.      * @return: java.lang.String
  11.      */
  12.     @RequestMapping("/req")
  13.     public String req() {
  14.         String msg = "{\"msgType\":\"req\",\"clientId\":\"请求数据\"}\r\n";
  15.         for (int i = 0; i < 20; i++) {
  16.             NettyClientBootStrap.getSocketChannel().writeAndFlush(msg);
  17.         }
  18.         return "success";
  19.     }
  20.  
  21. }

再次测试，服务器的控制台输出如下：

  1. 2019-08-30 15:47:05.959  INFO 216 --- [ntLoopGroup-1-1] com.wuychn.server.NettyServerHandler     : 收到客户端消息：{"msgType":"req","clientId":"请求数据"}
  2. 2019-08-30 15:47:06.050  INFO 216 --- [ntLoopGroup-1-1] com.wuychn.server.NettyServerHandler     : 收到客户端消息：{"msgType":"req","clientId":"请求数据"}
  3. 2019-08-30 15:47:06.051  INFO 216 --- [ntLoopGroup-1-1] com.wuychn.server.NettyServerHandler     : 收到客户端消息：{"msgType":"req","clientId":"请求数据"}
  4. 2019-08-30 15:47:06.051  INFO 216 --- [ntLoopGroup-1-1] com.wuychn.server.NettyServerHandler     : 收到客户端消息：{"msgType":"req","clientId":"请求数据"}
  5. 2019-08-30 15:47:06.051  INFO 216 --- [ntLoopGroup-1-1] com.wuychn.server.NettyServerHandler     : 收到客户端消息：{"msgType":"req","clientId":"请求数据"}
  6. 2019-08-30 15:47:06.051  INFO 216 --- [ntLoopGroup-1-1] com.wuychn.server.NettyServerHandler     : 收到客户端消息：{"msgType":"req","clientId":"请求数据"}
  7. 2019-08-30 15:47:06.051  INFO 216 --- [ntLoopGroup-1-1] com.wuychn.server.NettyServerHandler     : 收到客户端消息：{"msgType":"req","clientId":"请求数据"}
  8. 2019-08-30 15:47:06.051  INFO 216 --- [ntLoopGroup-1-1] com.wuychn.server.NettyServerHandler     : 收到客户端消息：{"msgType":"req","clientId":"请求数据"}
  9. 2019-08-30 15:47:06.052  INFO 216 --- [ntLoopGroup-1-1] com.wuychn.server.NettyServerHandler     : 收到客户端消息：{"msgType":"req","clientId":"请求数据"}
  10. 2019-08-30 15:47:06.052  INFO 216 --- [ntLoopGroup-1-1] com.wuychn.server.NettyServerHandler     : 收到客户端消息：{"msgType":"req","clientId":"请求数据"}
  11. 2019-08-30 15:47:06.052  INFO 216 --- [ntLoopGroup-1-1] com.wuychn.server.NettyServerHandler     : 收到客户端消息：{"msgType":"req","clientId":"请求数据"}
  12. 2019-08-30 15:47:06.052  INFO 216 --- [ntLoopGroup-1-1] com.wuychn.server.NettyServerHandler     : 收到客户端消息：{"msgType":"req","clientId":"请求数据"}
  13. 2019-08-30 15:47:06.052  INFO 216 --- [ntLoopGroup-1-1] com.wuychn.server.NettyServerHandler     : 收到客户端消息：{"msgType":"req","clientId":"请求数据"}
  14. 2019-08-30 15:47:06.052  INFO 216 --- [ntLoopGroup-1-1] com.wuychn.server.NettyServerHandler     : 收到客户端消息：{"msgType":"req","clientId":"请求数据"}
  15. 2019-08-30 15:47:06.053  INFO 216 --- [ntLoopGroup-1-1] com.wuychn.server.NettyServerHandler     : 收到客户端消息：{"msgType":"req","clientId":"请求数据"}
  16. 2019-08-30 15:47:06.053  INFO 216 --- [ntLoopGroup-1-1] com.wuychn.server.NettyServerHandler     : 收到客户端消息：{"msgType":"req","clientId":"请求数据"}
  17. 2019-08-30 15:47:06.053  INFO 216 --- [ntLoopGroup-1-1] com.wuychn.server.NettyServerHandler     : 收到客户端消息：{"msgType":"req","clientId":"请求数据"}
  18. 2019-08-30 15:47:06.053  INFO 216 --- [ntLoopGroup-1-1] com.wuychn.server.NettyServerHandler     : 收到客户端消息：{"msgType":"req","clientId":"请求数据"}
  19. 2019-08-30 15:47:06.053  INFO 216 --- [ntLoopGroup-1-1] com.wuychn.server.NettyServerHandler     : 收到客户端消息：{"msgType":"req","clientId":"请求数据"}
  20. 2019-08-30 15:47:06.053  INFO 216 --- [ntLoopGroup-1-1] com.wuychn.server.NettyServerHandler     : 收到客户端消息：{"msgType":"req","clientId":"请求数据"}

可见一切正常。

同样的道理，服务器发送给客户端的消息也会出现粘包/拆包的问题，客户端也可以加上LineBasedFrameDecoder解码器，然后服务器发送的消息使用\r\n结尾即可解决。

如果客户端使用的Socket，可以做如下处理：

  1. public class Client {
  2.  
  3.     public static void main(String[] args) throws IOException, InterruptedException {
  4.         Socket socket = new Socket("localhost", 5678);
  5.  
  6.         // 向服务器发消息
  7.         OutputStream outputStream = socket.getOutputStream();
  8.         String msg = "{\"msgType\":\"req\",\"clientId\":\"请求数据\"}\r\n";
  9.         outputStream.write(msg.getBytes(CharsetUtil.UTF_8));
  10.         outputStream.flush();
  11.  
  12.         // 模拟收到服务端粘包消息：服务器收到客户端消息后，循环回复20条消息
  13.         // 为了让小郭更明显，这里让客户端暂停1秒
  14.         Thread.sleep(1000);
  15.         BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
  16.         char[] ch = new char[65536];
  17.         int len = -1;
  18.         while ((len = br.read(ch)) != -1) {
  19.             String result = new String(ch, 0, len);
  20.             System.out.println("原始消息：" + result); // 获取到的原始消息，是有粘包或者拆包的
  21.             String[] results = result.split("\r\n"); // 按照\r\n拆分，这里没有处理拆包的问题
  22.             for (String str : results) {
  23.                 System.out.println("接收到消息：" + str);
  24.             }
  25.         }
  26.     }
  27.  
  28. }

 

 

本文内容由网友自发贡献，转载请注明出处：https://www.wpsshop.cn/w/小舞很执着/article/detail/973875
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号