Springboot+Netty搭建TCP服务端

男娘i 2024-01-20 06:34 92阅读 0赞

Netty是业界最流行的nio框架之一，它具有功能强大、性能优异、可定制性和可扩展性的优点

Netty的优点：

1.API使用简单，开发入门门槛低。

2.功能十分强大，预置多种编码解码功能，支持多种主流协议。

3.可定制、可扩展能力强，可以通过其提供的ChannelHandler进行灵活的扩展。

4.性能优异，特别在综合性能上的优异性。

5.成熟，稳定，适用范围广。

6.可用于智能GSM/GPRS模块的通讯服务端开发，使用它进行MQTT协议的开发。

Netty结合Springboot快速开发框架搭建服务端程序：

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.server</groupId>
  16.     <artifactId>boot-example-base-tcp-server-2.0.5</artifactId>
  17.     <version>0.0.1-SNAPSHOT</version>
  18.     <name>boot-example-base-tcp-server-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.server;
  3. import boot.example.tcp.server.netty.BootNettyServer;
  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;
  10. /**
  11.  *     蚂蚁舞
  12.  */
  13. @SpringBootApplication
  14. @EnableAsync
  15. public class BootNettyServerApplication implements CommandLineRunner{
  16.     public static void main( String[] args ) {
  17.         SpringApplication app = new SpringApplication(BootNettyServerApplication.class);
  18.         app.run(args);
  19.         System.out.println( "Hello World!" );
  20.     }
  22.     @Async
  23.     @Override
  24.     public void run(String... args) throws Exception {
  25.         /**
  26.          * 使用异步注解方式启动netty服务端服务
  27.          */
  28.         new BootNettyServer().bind(6655);
  30.     }
  31. }

Netty的server类

  1. package boot.example.tcp.server.netty;
  4. import io.netty.bootstrap.ServerBootstrap;
  5. import io.netty.channel.ChannelFuture;
  6. import io.netty.channel.ChannelOption;
  7. import io.netty.channel.EventLoopGroup;
  8. import io.netty.channel.nio.NioEventLoopGroup;
  9. import io.netty.channel.socket.SocketChannel;
  10. import io.netty.channel.socket.nio.NioServerSocketChannel;
  12. /**
  13.  *  蚂蚁舞
  14.  */
  15. public class BootNettyServer {
  17.     public void bind(int port) throws Exception {
  19.         /**
  20.          *     配置服务端的NIO线程组
  21.          *     NioEventLoopGroup 是用来处理I/O操作的Reactor线程组
  22.          *     bossGroup：用来接收进来的连接，workerGroup：用来处理已经被接收的连接,进行socketChannel的网络读写，
  23.          *     bossGroup接收到连接后就会把连接信息注册到workerGroup
  24.          *     workerGroup的EventLoopGroup默认的线程数是CPU核数的二倍
  25.          */
  26.         EventLoopGroup bossGroup = new NioEventLoopGroup(1);
  27.         EventLoopGroup workerGroup = new NioEventLoopGroup();
  29.         try {
  30.             /**
  31.              * ServerBootstrap 是一个启动NIO服务的辅助启动类
  32.              */
  33.             ServerBootstrap serverBootstrap = new ServerBootstrap();
  34.             /**
  35.              *     设置group，将bossGroup， workerGroup线程组传递到ServerBootstrap
  36.              */
  37.             serverBootstrap = serverBootstrap.group(bossGroup, workerGroup);
  38.             /**
  39.              * ServerSocketChannel是以NIO的selector为基础进行实现的，用来接收新的连接，这里告诉Channel通过NioServerSocketChannel获取新的连接
  40.              */
  41.             serverBootstrap = serverBootstrap.channel(NioServerSocketChannel.class);
  43.             //  option是设置 bossGroup，childOption是设置workerGroup
  45.             /**
  46.              * 服务端接受连接的队列长度，如果队列已满，客户端连接将被拒绝(队列被接收后，拒绝的客户端下次连接上来只要队列有空余就能连上)
  47.              */
  48.             serverBootstrap = serverBootstrap.option(ChannelOption.SO_BACKLOG, 128);
  49.             /**
  50.              * 立即发送数据，默认值为Ture（Netty默认为True而操作系统默认为False）。
  51.              * 该值设置Nagle算法的启用，改算法将小的碎片数据连接成更大的报文来最小化所发送的报文的数量，如果需要发送一些较小的报文，则需要禁用该算法。
  52.              * Netty默认禁用该算法，从而最小化报文传输延时。
  53.              */
  54.             serverBootstrap = serverBootstrap.childOption(ChannelOption.TCP_NODELAY, true);
  55.             /**
  56.              * 连接保活，默认值为False。启用该功能时，TCP会主动探测空闲连接的有效性。
  57.              * 可以将此功能视为TCP的心跳机制，默认的心跳间隔是7200s即2小时, Netty默认关闭该功能。
  58.              */
  59.             serverBootstrap = serverBootstrap.childOption(ChannelOption.SO_KEEPALIVE, true);
  61.             /**
  62.              * 设置 I/O处理类,主要用于网络I/O事件，记录日志，编码、解码消息
  63.              */
  64.             serverBootstrap = serverBootstrap.childHandler(new BootNettyChannelInitializer<SocketChannel>());
  66.             /**
  67.              * 绑定端口，同步等待成功
  68.              */
  69.             ChannelFuture f = serverBootstrap.bind(port).sync();
  70.             if(f.isSuccess()){
  71.                 System.out.println("netty server start success!");
  72.                 /**
  73.                  * 等待服务器监听端口关闭
  74.                  */
  75.                 f.channel().closeFuture().sync();
  76.             }
  77.         } catch (InterruptedException e) {
  78.             System.out.println(e.toString());
  79.         } finally {
  80.             /**
  81.              * 退出，释放线程池资源
  82.              */
  83.             bossGroup.shutdownGracefully().sync();
  84.             workerGroup.shutdownGracefully().sync();
  85.         }
  87.     }
  88. }

通道初始化

  1. package boot.example.tcp.server.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.handler.timeout.IdleStateHandler;
  10. import io.netty.util.CharsetUtil;
  12. import java.util.concurrent.TimeUnit;
  14. /**
  15.  * 通道初始化
  16.  * 蚂蚁舞
  17.  */
  18. @ChannelHandler.Sharable
  19. public class BootNettyChannelInitializer<SocketChannel> extends ChannelInitializer<Channel> {
  21.     public static long READ_TIME_OUT = 60;
  23.     public static long WRITE_TIME_OUT = 60;
  25.     public static long ALL_TIME_OUT = 60;
  27.     @Override
  28.     protected void initChannel(Channel ch) throws Exception {
  30.         ch.pipeline().addLast(new IdleStateHandler(READ_TIME_OUT, WRITE_TIME_OUT, ALL_TIME_OUT, TimeUnit.SECONDS));
  32.         // 带编码
  33.         ch.pipeline().addLast("encoder", new StringEncoder(CharsetUtil.UTF_8));
  34.         ch.pipeline().addLast("decoder", new StringDecoder(CharsetUtil.UTF_8));
  36. //        // ChannelOutboundHandler，依照逆序执行
  37. //        ch.pipeline().addLast("encoder", new StringEncoder());
  38. //
  39. //        // 属于ChannelInboundHandler，依照顺序执行
  40. //        ch.pipeline().addLast("decoder", new StringDecoder());
  42.         //自定义ChannelInboundHandlerAdapter
  43.         ch.pipeline().addLast(new BootNettyChannelInboundHandlerAdapter());
  45.     }
  47. }

I/O数据读写处理类

  1. package boot.example.tcp.server.netty;
  3. import java.io.IOException;
  4. import java.net.InetSocketAddress;
  5. import java.nio.charset.StandardCharsets;
  7. import io.netty.buffer.Unpooled;
  8. import io.netty.channel.ChannelHandler;
  9. import io.netty.channel.ChannelHandlerContext;
  10. import io.netty.channel.ChannelInboundHandlerAdapter;
  11. import io.netty.util.CharsetUtil;
  13. /**
  14.  * I/O数据读写处理类
  15.  * 蚂蚁舞
  16.  */
  17. @ChannelHandler.Sharable
  18. public class BootNettyChannelInboundHandlerAdapter extends ChannelInboundHandlerAdapter{
  20.     /**
  21.      *  注册时执行
  22.      */
  23.     @Override
  24.     public void channelRegistered(ChannelHandlerContext ctx) throws Exception {
  25.         super.channelRegistered(ctx);
  26.         System.out.println("--channelRegistered--"+ctx.channel().id().toString());
  27.     }
  29.     /**
  30.      *  离线时执行
  31.      */
  32.     @Override
  33.     public void channelUnregistered(ChannelHandlerContext ctx) throws Exception {
  34.         super.channelUnregistered(ctx);
  35.         System.out.println("--channelUnregistered--"+ctx.channel().id().toString());
  36.     }
  38.     /**
  39.      * 从客户端收到新的数据时，这个方法会在收到消息时被调用
  40.      */
  41.     @Override
  42.     public void channelRead(ChannelHandlerContext ctx, Object msg) {
  43.         try {
  44.             if(msg == null){return;}
  45.             String data = (String) msg;
  46.             data = data.replaceAll("\r|\n", "");
  47.             String channelId = ctx.channel().id().toString();
  48.             System.out.println("channelId="+channelId + "data="+data);
  50.             // 这里我将通道id作为code来使用，实际是需要msg里来摘取的客户端数据里的唯一值的
  51.             // 如果没有则创建 如果有，更新data值
  52.             BootNettyChannel b = BootNettyChannelCache.get("server:"+channelId);
  53.             if(b == null){
  54.                 BootNettyChannel bootNettyChannel = new BootNettyChannel();
  55.                 bootNettyChannel.setChannel(ctx.channel());
  56.                 bootNettyChannel.setCode("server:"+channelId);
  57.                 bootNettyChannel.setReport_last_data(data);
  58.                 BootNettyChannelCache.save("server:"+channelId, bootNettyChannel);
  59.             } else {
  60.                 b.setReport_last_data(data);
  61.             }
  62.             ctx.writeAndFlush(Unpooled.buffer().writeBytes(("server:"+channelId).getBytes()));
  63.             // netty的编码已经指定，因此可以不需要再次确认编码
  64.             // ctx.writeAndFlush(Unpooled.buffer().writeBytes(channelId.getBytes(CharsetUtil.UTF_8)));
  65.         } catch (Exception e) {
  66.             System.out.println("channelRead--"+e.toString());
  67.         }
  68.     }
  70.     /**
  71.      * 从客户端收到新的数据、读取完成时调用
  72.      */
  73.     @Override
  74.     public void channelReadComplete(ChannelHandlerContext ctx) throws IOException {
  75.         System.out.println("channelReadComplete");
  76.         ctx.flush();
  77.     }
  79.     /**
  80.      * 当出现 Throwable 对象才会被调用，即当 Netty 由于 IO 错误或者处理器在处理事件时抛出的异常时
  81.      */
  82.     @Override
  83.     public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws IOException {
  84.         System.out.println("exceptionCaught");
  85.         cause.printStackTrace();
  86.         BootNettyChannel bootNettyChannel = BootNettyChannelCache.get("server:"+ctx.channel().id().toString());
  87.         if(bootNettyChannel != null){
  88.             BootNettyChannelCache.remove("server:"+ctx.channel().id().toString());
  89.         }
  90.         ctx.close();//抛出异常，断开与客户端的连接
  91.     }
  93.     /**
  94.      * 客户端与服务端第一次建立连接时 执行
  95.      */
  96.     @Override
  97.     public void channelActive(ChannelHandlerContext ctx) throws Exception, IOException {
  98.         super.channelActive(ctx);
  99.         ctx.channel().read();
  100.         InetSocketAddress inSocket = (InetSocketAddress) ctx.channel().remoteAddress();
  101.         String clientIp = inSocket.getAddress().getHostAddress();
  102.         //此处不能使用ctx.close()，否则客户端始终无法与服务端建立连接
  103.         System.out.println("channelActive:"+clientIp+ctx.name());
  104.     }
  106.     /**
  107.      * 客户端与服务端 断连时 执行
  108.      */
  109.     @Override
  110.     public void channelInactive(ChannelHandlerContext ctx) throws Exception, IOException {
  111.         super.channelInactive(ctx);
  112.         InetSocketAddress inSocket = (InetSocketAddress) ctx.channel().remoteAddress();
  113.         String clientIp = inSocket.getAddress().getHostAddress();
  114.         System.out.println("channelInactive:"+clientIp);
  115.         BootNettyChannel bootNettyChannel = BootNettyChannelCache.get("server:"+ctx.channel().id().toString());
  116.         if(bootNettyChannel != null){
  117.             BootNettyChannelCache.remove("server:"+ctx.channel().id().toString());
  118.         }
  119.         ctx.close(); //断开连接时，必须关闭，否则造成资源浪费，并发量很大情况下可能造成宕机
  120.     }
  122.     /**
  123.      * 服务端当read超时, 会调用这个方法
  124.      */
  125.     @Override
  126.     public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception, IOException {
  127.         super.userEventTriggered(ctx, evt);
  128.         InetSocketAddress inSocket = (InetSocketAddress) ctx.channel().remoteAddress();
  129.         String clientIp = inSocket.getAddress().getHostAddress();
  131.         ctx.close();//超时时断开连接
  132.         System.out.println("userEventTriggered:"+clientIp);
  133.     }
  136. }
  138. BootNettyChannel
  140. package boot.example.tcp.server.netty;
  142. import io.netty.channel.Channel;
  144. /**
  145.  *     蚂蚁舞
  146.  */
  147. public class BootNettyChannel {
  149.     //    连接客户端唯一的code
  150.     private String code;
  152.     //    客户端最新发送的消息内容
  153.     private String report_last_data;
  155.     private transient volatile Channel channel;
  157.     public String getCode() {
  158.         return code;
  159.     }
  161.     public void setCode(String code) {
  162.         this.code = code;
  163.     }
  165.     public String getReport_last_data() {
  166.         return report_last_data;
  167.     }
  169.     public void setReport_last_data(String report_last_data) {
  170.         this.report_last_data = report_last_data;
  171.     }
  173.     public Channel getChannel() {
  174.         return channel;
  175.     }
  177.     public void setChannel(Channel channel) {
  178.         this.channel = channel;
  179.     }
  182. }
  184. BootNettyChannelCache
  186. package boot.example.tcp.server.netty;
  188. import java.util.Map;
  189. import java.util.concurrent.ConcurrentHashMap;
  191. /**
  192.  *  蚂蚁舞
  193.  */
  194. public class BootNettyChannelCache {
  196.     public static volatile Map<String, BootNettyChannel> channelMapCache = new ConcurrentHashMap<String, BootNettyChannel>();
  198.     public static void add(String code, BootNettyChannel channel){
  199.         channelMapCache.put(code,channel);
  200.     }
  202.     public static BootNettyChannel get(String code){
  203.         return channelMapCache.get(code);
  204.     }
  206.     public static void remove(String code){
  207.         channelMapCache.remove(code);
  208.     }
  210.     public static void save(String code, BootNettyChannel channel) {
  211.         if(channelMapCache.get(code) == null) {
  212.             add(code,channel);
  213.         }
  214.     }
  217. }
  219. BootNettyController
  221. package boot.example.tcp.server.controller;
  223. import boot.example.tcp.server.netty.BootNettyChannel;
  224. import boot.example.tcp.server.netty.BootNettyChannelCache;
  225. import io.netty.buffer.Unpooled;
  226. import io.netty.util.CharsetUtil;
  227. import org.springframework.web.bind.annotation.GetMapping;
  228. import org.springframework.web.bind.annotation.PostMapping;
  229. import org.springframework.web.bind.annotation.RequestParam;
  230. import org.springframework.web.bind.annotation.RestController;
  232. import java.util.ArrayList;
  233. import java.util.HashMap;
  234. import java.util.List;
  235. import java.util.Map;
  237. /**
  238.  *     蚂蚁舞
  239.  */
  240. @RestController
  241. public class BootNettyController {
  243.     @GetMapping(value = {"", "/"})
  244.     public String index() {
  245.         return "netty springBoot tcp demo";
  246.     }
  248.     @GetMapping("/clientList")
  249.     public List<Map<String,String>> clientList() {
  250.         List<Map<String,String>> list = new ArrayList<>();
  251.         for (Map.Entry<String, BootNettyChannel> entry : BootNettyChannelCache.channelMapCache.entrySet()) {
  252.             Map<String, String> map = new HashMap<String, String>();
  253.             map.put("code", entry.getKey());
  254.             //map.put("code", entry.getValue().getCode());
  255.             map.put("report_last_data", entry.getValue().getReport_last_data());
  256.             list.add(map);
  257.         }
  258.         return list;
  259.     }
  261.     @PostMapping("/downDataToAllClient")
  262.     public String downDataToAllClient(@RequestParam(name="content", required = true) String content) {
  263.         for (Map.Entry<String, BootNettyChannel> entry : BootNettyChannelCache.channelMapCache.entrySet()) {
  264.             BootNettyChannel bootNettyChannel = entry.getValue();
  265.             if(bootNettyChannel != null && bootNettyChannel.getChannel().isOpen()){
  266.                 bootNettyChannel.getChannel().writeAndFlush(Unpooled.buffer().writeBytes(content.getBytes()));
  267.                 // netty的编码已经指定，因此可以不需要再次确认编码
  268.                 // bootNettyChannel.getChannel().writeAndFlush(Unpooled.buffer().writeBytes(content.getBytes(CharsetUtil.UTF_8)));
  269.             }
  270.         }
  271.         return "ok";
  272.     }
  274.     @PostMapping("/downDataToClient")
  275.     public String downDataToClient(@RequestParam(name="code", required = true) String code, @RequestParam(name="content", required = true) String content) {
  276.         BootNettyChannel bootNettyChannel = BootNettyChannelCache.get(code);
  277.         if(bootNettyChannel != null && bootNettyChannel.getChannel().isOpen()){
  278.             bootNettyChannel.getChannel().writeAndFlush(Unpooled.buffer().writeBytes(content.getBytes()));
  279.             // netty的编码已经指定，因此可以不需要再次确认编码
  280.             // bootNettyChannel.getChannel().writeAndFlush(Unpooled.buffer().writeBytes(content.getBytes(CharsetUtil.UTF_8)));
  281.             return "success";
  282.         }
  283.         return "fail";
  284.     }
  287. }
  289. SwaggerConfig
  291. package boot.example.tcp.server;
  293. import com.google.common.base.Predicates;
  294. import org.springframework.context.annotation.Bean;
  295. import org.springframework.context.annotation.Configuration;
  296. import springfox.documentation.builders.ApiInfoBuilder;
  297. import springfox.documentation.builders.PathSelectors;
  298. import springfox.documentation.builders.RequestHandlerSelectors;
  299. import springfox.documentation.service.ApiInfo;
  300. import springfox.documentation.spi.DocumentationType;
  301. import springfox.documentation.spring.web.plugins.Docket;
  302. import springfox.documentation.swagger2.annotations.EnableSwagger2;
  304. /**
  305.  *  蚂蚁舞
  306.  */
  307. @Configuration
  308. @EnableSwagger2
  309. public class SwaggerConfig {
  311.     @Bean
  312.     public Docket createRestApi(){
  313.         return new Docket(DocumentationType.SWAGGER_2).apiInfo(apiInfo()).select()
  314.                 .apis(RequestHandlerSelectors.any()).paths(PathSelectors.any())
  315.                 .paths(Predicates.not(PathSelectors.regex("/error.*")))
  316.                 .paths(PathSelectors.regex("/.*"))
  317.                 .build().apiInfo(apiInfo());
  318.     }
  320.     private ApiInfo apiInfo(){
  321.         return new ApiInfoBuilder()
  322.                 .title("netty tcp 服务端demo")
  323.                 .description("netty tcp 服务端接口测试demo")
  324.                 .version("0.01")
  325.                 .build();
  326.     }
  328.     /**
  329.      * http://localhost:6654/doc.html  地址和端口根据实际项目查看
  330.      */
  333. }

目录结构

  1. ├─boot-example-base-tcp-server-2.0.5
  2. │  │  pom.xml
  3. │  │  
  4. │  ├─src
  5. │  │  ├─main
  6. │  │  │  ├─java
  7. │  │  │  │  └─boot
  8. │  │  │  │      └─example
  9. │  │  │  │          └─tcp
  10. │  │  │  │              └─server
  11. │  │  │  │                  │  BootNettyServerApplication.java
  12. │  │  │  │                  │  SwaggerConfig.java
  13. │  │  │  │                  │  
  14. │  │  │  │                  ├─controller
  15. │  │  │  │                  │      BootNettyController.java
  16. │  │  │  │                  │      
  17. │  │  │  │                  └─netty
  18. │  │  │  │                          BootNettyChannel.java
  19. │  │  │  │                          BootNettyChannelCache.java
  20. │  │  │  │                          BootNettyChannelInboundHandlerAdapter.java
  21. │  │  │  │                          BootNettyChannelInitializer.java
  22. │  │  │  │                          BootNettyServer.java
  23. │  │  │  │                          
  24. │  │  │  └─resources
  25. │  │  │          application.properties
  26. │  │  │          
  27. │  │  └─test
  28. │  │      └─java
  29. │  │          └─boot
  30. │  │              └─example
  31. │  │                  └─tcp
  32. │  │                      └─server
  33. │  │                              BootNettyServerApplicationTest.java
  34. │  │

很简单的几个类加swagger，启动Springboot应用的同时也就启动了Netty

Netty Server端口：6655

SpringBoot Web端口: 6654

访问

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

使用常见的tcp客户端工具发送字母或数字(客户端工具发送中文可能出现乱码的，虽然程序已经处理了中文乱码，但依旧容易出现，处理办法是用netty写一个客户端来测试)

a37d668792ed4a46ad52a8894a95a092.png

2ada18822d3f45a8880db65bc6681b6b.png

可以看到客户端发送消息，服务端能收到消息，并且在服务端做了保活，服务端也可以根据客户端的信息向客户端发送消息

Springboot整合Netty的服务端demo开发测试完成。

注意：如果乱码的话需要统一编码，最简单的方式

  1. // 带编码
  2.         ch.pipeline().addLast("encoder", new StringEncoder(CharsetUtil.UTF_8));
  3.         ch.pipeline().addLast("decoder", new StringDecoder(CharsetUtil.UTF_8));

发表评论

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

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

相关阅读

    相关 Springboot+Netty搭建TCP服务端

    Netty是业界最流行的nio框架之一，它具有功能强大、性能优异、可定制性和可扩展性的优点 Netty的优点： 1.API使用简单，开发入门门槛低。 2.功能十分强大，预

    男娘i男娘i/ 0 赞/ 93 阅读

    相关 17. 搭建FTP服务端

    熟悉FTP的读者可能会觉得这个太简单了，直接在网上下载软件安装运行就可以了，客户端和服务器都有，但是只能满足一些简单的工作需求。如果我们通过写Python代码搭建FTP服务器和

    - 日理万妓- 日理万妓/ 0 赞/ 256 阅读