Springboot+Netty搭建TCP客户端-多客户端

川长思鸟来 2024-02-19 20:21 148阅读 0赞

之前搭建了一个Springboot+Netty服务端的应用，既然有服务端，自然也有客户端的应用，现在搭建一个Springboot+Netty客户端的应用Demo程序，多客户端方式，使用服务端和客户端进行联调测试，也可以用tcp的小工具来测试(中文可能乱码)

SpringBoot+Netty实现TCP服务端客户端的源码Demo

新建Springboot的maven项目，pom.xml文件导入依赖包

  1. <?xml version="1.0"?>
  2. <project
  3.     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"
  4.     xmlns="http://maven.apache.org/POM/4.0.0"
  5.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  6.     <modelVersion>4.0.0</modelVersion>
  8.     <parent>
  9.         <groupId>org.springframework.boot</groupId>
  10.         <artifactId>spring-boot-starter-parent</artifactId>
  11.         <version>2.0.5.RELEASE</version>
  12.         <relativePath />
  13.     </parent>
  15.     <groupId>boot.base.tcp.client</groupId>
  16.     <artifactId>boot-example-base-tcp-client-2.0.5</artifactId>
  17.     <version>0.0.1-SNAPSHOT</version>
  18.     <name>boot-example-base-tcp-client-2.0.5</name>
  19.     <url>http://maven.apache.org</url>
  20.     <properties>
  21.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  22.         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
  23.         <java.version>1.8</java.version>
  24.     </properties>
  26.     <dependencies>
  27.         <dependency>
  28.             <groupId>org.springframework.boot</groupId>
  29.             <artifactId>spring-boot-starter-web</artifactId>
  30.         </dependency>
  31.         <dependency>
  32.             <groupId>io.netty</groupId>
  33.             <artifactId>netty-all</artifactId>
  34.         </dependency>
  35.         <dependency>
  36.             <groupId>io.springfox</groupId>
  37.             <artifactId>springfox-swagger2</artifactId>
  38.             <version>2.9.2</version>
  39.         </dependency>
  40.         <dependency>
  41.             <groupId>com.github.xiaoymin</groupId>
  42.             <artifactId>swagger-bootstrap-ui</artifactId>
  43.             <version>1.9.2</version>
  44.         </dependency>
  45.     </dependencies>
  46.     <build>
  47.         <plugins>
  48.             <!-- 打包成一个可执行jar -->
  49.             <plugin>
  50.                 <groupId>org.springframework.boot</groupId>
  51.                 <artifactId>spring-boot-maven-plugin</artifactId>
  52.                 <executions>
  53.                     <execution>
  54.                         <goals>
  55.                             <goal>repackage</goal>
  56.                         </goals>
  57.                     </execution>
  58.                 </executions>
  59.             </plugin>
  60.         </plugins>
  61.     </build>
  62. </project>

Springboot启动类，启动一个Netty的客户端

  1. package boot.example.tcp.client;
  3. import boot.example.tcp.client.netty.BootNettyClientThread;
  4. import org.springframework.boot.CommandLineRunner;
  5. import org.springframework.boot.SpringApplication;
  6. import org.springframework.boot.autoconfigure.SpringBootApplication;
  7. import org.springframework.scheduling.annotation.Async;
  8. import org.springframework.scheduling.annotation.EnableAsync;
  9. import org.springframework.scheduling.annotation.EnableScheduling;
  11. /**
  12.  * 蚂蚁舞
  13.  */
  14. @SpringBootApplication
  15. @EnableAsync
  16. @EnableScheduling
  17. public class BootNettyClientApplication implements CommandLineRunner{
  18.     public static void main( String[] args ) {
  19.         SpringApplication app = new SpringApplication(BootNettyClientApplication.class);
  20.         app.run(args);
  22.         System.out.println( "Hello World!" );
  23.     }
  25.     @Async
  26.     @Override
  27.     public void run(String... args) throws Exception {
  28.         /**
  29.          * 使用异步注解方式启动netty客户端服务
  30.          */
  31.         int port = 6655;
  32.         String address = "127.0.0.1";
  33.         int count = 10; // 模拟多个客户端
  34.         for(int i = 0; i < count; i++) {
  35.             BootNettyClientThread thread = new BootNettyClientThread(port, address);
  36.             thread.start();
  37.         }
  39.     }
  40. }

Netty的client类

  1. package boot.example.tcp.client.netty;
  4. import io.netty.bootstrap.Bootstrap;
  5. import io.netty.channel.Channel;
  6. import io.netty.channel.ChannelFuture;
  7. import io.netty.channel.ChannelOption;
  8. import io.netty.channel.EventLoopGroup;
  9. import io.netty.channel.nio.NioEventLoopGroup;
  10. import io.netty.channel.socket.SocketChannel;
  11. import io.netty.channel.socket.nio.NioSocketChannel;
  13. /**
  14.  * 
  15.  * netty 客户端
  16.  * 蚂蚁舞
  17.  */
  18. public class BootNettyClient {
  20.     public void connect(int port, String host) throws Exception{
  22.         /**
  23.          * 客户端的NIO线程组
  24.          * 
  25.          */
  26.         EventLoopGroup group = new NioEventLoopGroup();
  28.         try {
  29.             /**
  30.              * Bootstrap 是一个启动NIO服务的辅助启动类 客户端的
  31.              */
  32.             Bootstrap bootstrap = new Bootstrap();
  33.             bootstrap = bootstrap.group(group);
  34.             bootstrap = bootstrap.channel(NioSocketChannel.class).option(ChannelOption.TCP_NODELAY, true);
  35.             /**
  36.              * 设置 I/O处理类,主要用于网络I/O事件，记录日志，编码、解码消息
  37.              */
  38.             bootstrap = bootstrap.handler(new BootNettyChannelInitializer<SocketChannel>());
  39.             /**
  40.              * 连接服务端
  41.              */
  42.             ChannelFuture future = bootstrap.connect(host, port).sync();
  43.             if(future.isSuccess()) {
  44.                 Channel channel = future.channel();
  45.                 String id = future.channel().id().toString();
  46.                 BootNettyClientChannel bootNettyClientChannel = new BootNettyClientChannel();
  47.                 bootNettyClientChannel.setChannel(channel);
  48.                 bootNettyClientChannel.setCode("clientId:"+id);
  49.                 BootNettyClientChannelCache.save("clientId:"+id, bootNettyClientChannel);
  50.                 System.out.println("netty client start success="+id);
  51.                 /**
  52.                  * 等待连接端口关闭
  53.                  */
  54.                 future.channel().closeFuture().sync();
  55.             }
  56.         } finally {
  57.             /**
  58.              * 退出，释放资源
  59.              */
  60.             group.shutdownGracefully().sync();
  61.         }
  63.     }
  66. }

通道初始化

  1. package boot.example.tcp.client.netty;
  4. import io.netty.channel.Channel;
  5. import io.netty.channel.ChannelHandler;
  6. import io.netty.channel.ChannelInitializer;
  7. import io.netty.handler.codec.string.StringDecoder;
  8. import io.netty.handler.codec.string.StringEncoder;
  9. import io.netty.util.CharsetUtil;
  11. /**
  12.  * 通道初始化
  13.  * 蚂蚁舞
  14.  */
  15. @ChannelHandler.Sharable
  16. public class BootNettyChannelInitializer<SocketChannel> extends ChannelInitializer<Channel> {
  18.     @Override
  19.     protected void initChannel(Channel ch) throws Exception {
  21.         ch.pipeline().addLast("encoder", new StringEncoder(CharsetUtil.UTF_8));
  22.         ch.pipeline().addLast("decoder", new StringDecoder(CharsetUtil.UTF_8));
  23.         /**
  24.          * 自定义ChannelInboundHandlerAdapter
  25.          */
  26.         ch.pipeline().addLast(new BootNettyChannelInboundHandlerAdapter());
  28.     }
  30. }

客户端I/O数据读写处理类

  1. package boot.example.tcp.client.netty;
  3. import java.io.IOException;
  4. import java.net.InetSocketAddress;
  6. import io.netty.channel.ChannelHandler;
  7. import io.netty.channel.ChannelHandlerContext;
  8. import io.netty.channel.ChannelInboundHandlerAdapter;
  10. /**
  11.  * 
  12.  * I/O数据读写处理类
  13.  * 蚂蚁舞
  14.  */
  15. @ChannelHandler.Sharable
  16. public class BootNettyChannelInboundHandlerAdapter extends ChannelInboundHandlerAdapter{
  18.     /**
  19.      * 从服务端收到新的数据时，这个方法会在收到消息时被调用
  20.      */
  21.     @Override
  22.     public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception, IOException {
  23.         if(msg == null){
  24.             return;
  25.         }
  26.         System.out.println("channelRead:read msg:"+msg.toString());
  27.         BootNettyClientChannel bootNettyClientChannel = BootNettyClientChannelCache.get("clientId:"+ctx.channel().id().toString());
  28.         if(bootNettyClientChannel != null){
  29.             System.out.println("to do");
  30.             bootNettyClientChannel.setLast_data(msg.toString());
  31.         }
  33.         //回应服务端
  34.         //ctx.write("I got server message thanks server!");
  35.     }
  37.     /**
  38.      * 从服务端收到新的数据、读取完成时调用
  39.      */
  40.     @Override
  41.     public void channelReadComplete(ChannelHandlerContext ctx) throws IOException {
  42.         System.out.println("channelReadComplete");
  43.         ctx.flush();
  44.     }
  46.     /**
  47.      * 当出现 Throwable 对象才会被调用，即当 Netty 由于 IO 错误或者处理器在处理事件时抛出的异常时
  48.      */
  49.     @Override
  50.     public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws IOException {
  51.         System.out.println("exceptionCaught");
  52.         cause.printStackTrace();
  53.         ctx.close();//抛出异常，断开与客户端的连接
  54.     }
  56.     /**
  57.      * 客户端与服务端第一次建立连接时 执行
  58.      */
  59.     @Override
  60.     public void channelActive(ChannelHandlerContext ctx) throws Exception, IOException {
  61.         super.channelActive(ctx);
  62.         InetSocketAddress inSocket = (InetSocketAddress) ctx.channel().remoteAddress();
  63.         String clientIp = inSocket.getAddress().getHostAddress();
  64.         System.out.println(clientIp);
  65.     }
  67.     /**
  68.      * 客户端与服务端 断连时 执行
  69.      */
  70.     @Override
  71.     public void channelInactive(ChannelHandlerContext ctx) throws Exception, IOException {
  72.         super.channelInactive(ctx);
  73.         InetSocketAddress inSocket = (InetSocketAddress) ctx.channel().remoteAddress();
  74.         String clientIp = inSocket.getAddress().getHostAddress();
  75.         ctx.close(); //断开连接时，必须关闭，否则造成资源浪费
  76.         System.out.println("channelInactive:"+clientIp);
  77.     }
  81. }

建立channel保存多客户端BootNettyClientChannel

  1. package boot.example.tcp.client.netty;
  3. import io.netty.channel.Channel;
  5. /**
  6.  *     蚂蚁舞
  7.  */
  8. public class BootNettyClientChannel {
  10.     //    连接客户端唯一的code
  11.     private String code;
  13.     //    客户端最新发送的消息内容
  14.     private String last_data;
  16.     private transient volatile Channel channel;
  18.     public String getCode() {
  19.         return code;
  20.     }
  22.     public void setCode(String code) {
  23.         this.code = code;
  24.     }
  26.     public Channel getChannel() {
  27.         return channel;
  28.     }
  30.     public void setChannel(Channel channel) {
  31.         this.channel = channel;
  32.     }
  34.     public String getLast_data() {
  35.         return last_data;
  36.     }
  38.     public void setLast_data(String last_data) {
  39.         this.last_data = last_data;
  40.     }
  41. }
  43. BootNettyClientChannelCache
  45. package boot.example.tcp.client.netty;
  47. import java.util.Map;
  48. import java.util.concurrent.ConcurrentHashMap;
  50. /**
  51.  *  蚂蚁舞
  52.  */
  53. public class BootNettyClientChannelCache {
  55.     public static volatile Map<String, BootNettyClientChannel> channelMapCache = new ConcurrentHashMap<String, BootNettyClientChannel>();
  57.     public static void add(String code, BootNettyClientChannel channel){
  58.         channelMapCache.put(code,channel);
  59.     }
  61.     public static BootNettyClientChannel get(String code){
  62.         return channelMapCache.get(code);
  63.     }
  65.     public static void remove(String code){
  66.         channelMapCache.remove(code);
  67.     }
  69.     public static void save(String code, BootNettyClientChannel channel) {
  70.         if(channelMapCache.get(code) == null) {
  71.             add(code,channel);
  72.         }
  73.     }
  76. }

netty的启动BootNettyClientThread

  1. package boot.example.tcp.client.netty;
  4. /**
  5.  * 
  6.  * netty 客户端
  7.  * 蚂蚁舞
  8.  */
  9. public class BootNettyClientThread extends Thread {
  11.     private final int port;
  13.     private final String address;
  14.     public BootNettyClientThread(int port, String address){
  15.         this.port = port;
  16.         this.address = address;
  17.     }
  19.     public void run() {
  20.         try {
  21.             new BootNettyClient().connect(port, address);
  22.         } catch (Exception e) {
  23.             throw new RuntimeException(e);
  24.         }
  25.     }
  26. }

心跳使用定时器BootNettyHeartTimer

  1. package boot.example.tcp.client.netty;
  4. import io.netty.buffer.Unpooled;
  5. import org.springframework.scheduling.annotation.Scheduled;
  6. import org.springframework.stereotype.Service;
  8. import java.util.Map;
  10. /**
  11.  *  蚂蚁舞
  12.  */
  13. @Service
  14. public class BootNettyHeartTimer {
  16.     //  使用定时器发送心跳
  17.     @Scheduled(cron = "0/30 * * * * ?")
  18.     public void heart_timer() {
  19.         String back = "heart";
  20.         if(BootNettyClientChannelCache.channelMapCache.size() > 0){
  21.             for (Map.Entry<String, BootNettyClientChannel> entry : BootNettyClientChannelCache.channelMapCache.entrySet()) {
  22.                 BootNettyClientChannel bootNettyChannel = entry.getValue();
  23.                 if(bootNettyChannel != null && bootNettyChannel.getChannel().isOpen()){
  24.                     bootNettyChannel.getChannel().writeAndFlush(Unpooled.buffer().writeBytes(back.getBytes()));
  25.                 }
  26.             }
  27.         }
  29.     }
  31. }

测试接口BootNettyClientController

  1. package boot.example.tcp.client.controller;
  3. import boot.example.tcp.client.netty.BootNettyClientChannel;
  4. import boot.example.tcp.client.netty.BootNettyClientChannelCache;
  5. import io.netty.buffer.Unpooled;
  6. import org.springframework.web.bind.annotation.GetMapping;
  7. import org.springframework.web.bind.annotation.PostMapping;
  8. import org.springframework.web.bind.annotation.RequestParam;
  9. import org.springframework.web.bind.annotation.RestController;
  11. import java.util.ArrayList;
  12. import java.util.HashMap;
  13. import java.util.List;
  14. import java.util.Map;
  16. /**
  17.  *     蚂蚁舞
  18.  */
  19. @RestController
  20. public class BootNettyClientController {
  22.     @GetMapping("/list")
  23.     public List<Map<String,String>> list() {
  24.         List<Map<String,String>> list = new ArrayList<>();
  25.         for (Map.Entry<String, BootNettyClientChannel> entry : BootNettyClientChannelCache.channelMapCache.entrySet()) {
  26.             Map<String, String> map = new HashMap<String, String>();
  27.             map.put("code", entry.getKey());
  28.             //map.put("code", entry.getValue().getCode());
  29.             map.put("last_data", entry.getValue().getLast_data());
  30.             list.add(map);
  31.         }
  32.         return list;
  33.     }
  35.     @PostMapping("/reportAllClientDataToServer")
  36.     public String reportAllClientDataToServer(@RequestParam(name="content", required = true) String content) {
  37.         for (Map.Entry<String, BootNettyClientChannel> entry : BootNettyClientChannelCache.channelMapCache.entrySet()) {
  38.             BootNettyClientChannel bootNettyChannel = entry.getValue();
  39.             if(bootNettyChannel != null && bootNettyChannel.getChannel().isOpen()){
  40.                 bootNettyChannel.getChannel().writeAndFlush(Unpooled.buffer().writeBytes(content.getBytes()));
  41.             }
  42.         }
  43.         return "ok";
  44.     }
  46.     @PostMapping("/reportClientDataToServer")
  47.     public String downDataToClient(@RequestParam(name="code", required = true) String code, @RequestParam(name="content", required = true) String content) {
  48.         BootNettyClientChannel bootNettyChannel = BootNettyClientChannelCache.get(code);
  49.         if(bootNettyChannel != null && bootNettyChannel.getChannel().isOpen()){
  50.             bootNettyChannel.getChannel().writeAndFlush(Unpooled.buffer().writeBytes(content.getBytes()));
  51.             return "success";
  52.         }
  53.         return "fail";
  54.     }
  58. }

SwaggerConfig测试方便

  1. package boot.example.tcp.client;
  3. import com.google.common.base.Predicates;
  4. import org.springframework.context.annotation.Bean;
  5. import org.springframework.context.annotation.Configuration;
  6. import springfox.documentation.builders.ApiInfoBuilder;
  7. import springfox.documentation.builders.PathSelectors;
  8. import springfox.documentation.builders.RequestHandlerSelectors;
  9. import springfox.documentation.service.ApiInfo;
  10. import springfox.documentation.spi.DocumentationType;
  11. import springfox.documentation.spring.web.plugins.Docket;
  12. import springfox.documentation.swagger2.annotations.EnableSwagger2;
  14. /**
  15.  *  蚂蚁舞
  16.  */
  17. @Configuration
  18. @EnableSwagger2
  19. public class SwaggerConfig {
  21.     @Bean
  22.     public Docket createRestApi(){
  23.         return new Docket(DocumentationType.SWAGGER_2).apiInfo(apiInfo()).select()
  24.                 .apis(RequestHandlerSelectors.any()).paths(PathSelectors.any())
  25.                 .paths(Predicates.not(PathSelectors.regex("/error.*")))
  26.                 .paths(PathSelectors.regex("/.*"))
  27.                 .build().apiInfo(apiInfo());
  28.     }
  30.     private ApiInfo apiInfo(){
  31.         return new ApiInfoBuilder()
  32.                 .title("netty tcp 客户端demo")
  33.                 .description("netty tcp 客户端接口测试demo")
  34.                 .version("0.01")
  35.                 .build();
  36.     }
  38.     /**
  39.      * http://localhost:8094/doc.html  地址和端口根据实际项目查看
  40.      */
  43. }

客户端demo代码的目录结构

  1. ├─boot-example-base-tcp-client-2.0.5
  2. │  │  pom.xml
  3. │  │  
  4. │  ├─src
  5. │  │  ├─main
  6. │  │  │  ├─java
  7. │  │  │  │  └─boot
  8. │  │  │  │      └─example
  9. │  │  │  │          └─tcp
  10. │  │  │  │              └─client
  11. │  │  │  │                  │  BootNettyClientApplication.java
  12. │  │  │  │                  │  SwaggerConfig.java
  13. │  │  │  │                  │  
  14. │  │  │  │                  ├─controller
  15. │  │  │  │                  │      BootNettyClientController.java
  16. │  │  │  │                  │      
  17. │  │  │  │                  └─netty
  18. │  │  │  │                          BootNettyChannelInboundHandlerAdapter.java
  19. │  │  │  │                          BootNettyChannelInitializer.java
  20. │  │  │  │                          BootNettyClient.java
  21. │  │  │  │                          BootNettyClientChannel.java
  22. │  │  │  │                          BootNettyClientChannelCache.java
  23. │  │  │  │                          BootNettyClientThread.java
  24. │  │  │  │                          BootNettyHeartTimer.java
  25. │  │  │  │                          
  26. │  │  │  └─resources
  27. │  │  │          application.properties
  28. │  │  │          
  29. │  │  └─test
  30. │  │      └─java
  31. │  │          └─boot
  32. │  │              └─example
  33. │  │                  └─tcp
  34. │  │                      └─client
  35. │  │                              BootNettyClientApplicationTest.java
  36. │  │

基本demo客户端代码就完成了，要进行测试了。

我这里不使用tcp服务端工具测试，之前使用之前使用netty搭建的服务端进行交互测试

地址Springboot+Netty搭建TCP服务端_蚂蚁舞的博客-CSDN博客

测试步骤

先启动springBoot+Netty的服务端代码

  1. 2023-01-20 10:25:55.677  INFO 2664 --- [           main] s.d.s.w.s.ApiListingReferenceScanner     : Scanning for api listing references
  2. 2023-01-20 10:25:55.904  INFO 2664 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 6654 (http) with context path ''
  3. 2023-01-20 10:25:55.909  INFO 2664 --- [           main] b.e.t.server.BootNettyServerApplication  : Started BootNettyServerApplication in 6.752 seconds (JVM running for 7.598)
  4. 2023-01-20 10:25:55.915  INFO 2664 --- [           main] .s.a.AnnotationAsyncExecutionInterceptor : No task executor bean found for async processing: no bean of type TaskExecutor and no bean named 'taskExecutor' either
  5. Hello World!
  6. netty server start success!

可以浏览器web访问

  1. http://localhost:6654/doc.html

再启动springBoot+Netty的客户端代码(多客户端啊，这里启动10个)

  1. int port = 6655;
  2.         String address = "127.0.0.1";
  3.         int count = 10; // 模拟多个客户端
  4.         for(int i = 0; i < count; i++) {
  5.             BootNettyClientThread thread = new BootNettyClientThread(port, address);
  6.             thread.start();
  7.         }
  9. 2023-01-20 10:29:01.955  INFO 13120 --- [           main] o.s.j.e.a.AnnotationMBeanExporter        : Registering beans for JMX exposure on startup
  10. 2023-01-20 10:29:01.966  INFO 13120 --- [           main] o.s.c.support.DefaultLifecycleProcessor  : Starting beans in phase 2147483647
  11. 2023-01-20 10:29:01.967  INFO 13120 --- [           main] d.s.w.p.DocumentationPluginsBootstrapper : Context refreshed
  12. 2023-01-20 10:29:02.007  INFO 13120 --- [           main] d.s.w.p.DocumentationPluginsBootstrapper : Found 1 custom documentation plugin(s)
  13. 2023-01-20 10:29:02.053  INFO 13120 --- [           main] s.d.s.w.s.ApiListingReferenceScanner     : Scanning for api listing references
  14. 2023-01-20 10:29:02.205  INFO 13120 --- [           main] s.a.ScheduledAnnotationBeanPostProcessor : No TaskScheduler/ScheduledExecutorService bean found for scheduled processing
  15. 2023-01-20 10:29:02.257  INFO 13120 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 8094 (http) with context path ''
  16. 2023-01-20 10:29:02.264  INFO 13120 --- [           main] b.e.t.client.BootNettyClientApplication  : Started BootNettyClientApplication in 6.258 seconds (JVM running for 7.18)
  17. 2023-01-20 10:29:02.270  INFO 13120 --- [           main] .s.a.AnnotationAsyncExecutionInterceptor : No task executor bean found for async processing: no bean of type TaskExecutor and no bean named 'taskExecutor' either
  18. Hello World!
  19. 127.0.0.1
  20. 127.0.0.1
  21. 127.0.0.1
  22. 127.0.0.1
  23. 127.0.0.1
  24. 127.0.0.1
  25. 127.0.0.1
  26. 127.0.0.1
  27. 127.0.0.1
  28. 127.0.0.1
  29. netty client start success=8f7ca2ce
  30. netty client start success=987e23c5
  31. netty client start success=dc272839
  32. netty client start success=c74a53a9
  33. netty client start success=cbf85db3
  34. netty client start success=e6ff0519
  35. netty client start success=bc0fc00f
  36. netty client start success=29db84c8
  37. netty client start success=6e20d3e6
  38. netty client start success=30378f02

可以浏览客户端的web访问

507be38575e34f7394e5e7a232faf77a.png

可以看到客户端启动了是个客户端，服务端也给客户端返回了服务端创建成功的code(实际是netty的通道id,唯一的拿来使用的)

5ee4ebe9e1d348629d384408dee6a7be.png

可以看到服务端收到了来自客户端的心跳

我选取一个客户端来测试客户端给服务端发送消息(含中文)

  1. {
  2.     "code": "clientId:bc0fc00f",
  3.     "last_data": "server:bd255b2d"
  4.   }

394244a5dc244c98b9e49ee58a27af2e.png

可以看到给服务端发送的数据是

  1. 蚂蚁舞mywhtw147258#$%^

服务端接收到的最新数据

586e8d2999474f15b21c3da5eadd1358.png

  1. {
  2.     "code": "server:bd255b2d",
  3.     "report_last_data": "蚂蚁舞mywhtw147258#$%^"
  4.   }

服务端控制台的打印日志

  1. channelId=bd255b2ddata=蚂蚁舞mywhtw147258#$%^
  2. channelReadComplete
  3. channelId=bd255b2ddata=蚂蚁舞mywhtw147258#$%^
  4. channelReadComplete

服务端给客户端发送消息的方式是一样的，以及服务端批量给客户端发送消息，还有多个客户端给服务端发送同样的消息，都是可以达到的。

基于springboot+netty的客户端和服务端就调通了，支持中文不乱码。

发表评论

表情：
评论列表 （有 0 条评论，148人围观）

还没有评论，来说两句吧...

相关阅读

    相关 搭建cas客户端

    今天大哥，就给了一个cas认证的包，和 一个cas证书 > 和一个 大片 web。xml 配置的 文档， > 让我部署到服务器上面 添加 cas 认证的包 ...

    小鱼儿小鱼儿/ 0 赞/ 172 阅读

    相关 Es搭建客户端

    ES提供多种不同的客户端：   1、TransportClient ES提供的传统客户端，官方计划8.0版本删除此客户端。  2、RestClient  RestCl

    叁歲伎倆叁歲伎倆/ 0 赞/ 447 阅读