一、代码实现

你可以基于Spring Boot集成Netty来实现一个TCP协议的数据接收程序。基本步骤如下：

  1. 添加依赖： 在 pom.xml 中添加 Netty 和 Spring Boot 的相关依赖。

    <dependency>
    <groupId>io.netty</groupId>
    <artifactId>netty-all</artifactId>
    <version>4.1.68.Final</version> <!-- 或最新版本 -->
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
</dependency>

  2. 配置Netty服务器： 创建一个 NettyServer 类，用于启动Netty TCP服务并接收数据。

    import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.Channel;
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.NioServerSocketChannel;
import org.springframework.stereotype.Service;

@Service
public class NettyServer {
    private final int port = 8080;  // 端口号，可以根据需要更改

    public void start() throws InterruptedException {
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup workerGroup = new NioEventLoopGroup();

        try {
            ServerBootstrap b = new ServerBootstrap();
            b.group(bossGroup, workerGroup)
                .channel(NioServerSocketChannel.class)
                .childHandler(new ChannelInitializer<SocketChannel>() {
                    @Override
                    public void initChannel(SocketChannel ch) throws Exception {
                        ch.pipeline().addLast(new TcpServerHandler());
                    }
                });

            ChannelFuture f = b.bind(port).sync();
            f.channel().closeFuture().sync();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}

  3. 处理TCP数据： 创建一个 TcpServerHandler 类，用于处理接收到的设备数据。

    import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;

public class TcpServerHandler extends ChannelInboundHandlerAdapter {
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        // 处理接收到的数据
        String receivedData = (String) msg;
        System.out.println("接收到数据：" + receivedData);
        // 这里可以根据需要进行解析或其他操作
    }

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

  4. 启动Netty服务器： 在 Spring Boot 启动类中启动 Netty 服务器。

    import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;

@SpringBootApplication
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }

    @Bean
    public CommandLineRunner startNettyServer(NettyServer nettyServer) {
        return args -> {
            nettyServer.start();
        };
    }
}

  5. 测试： 启动应用程序后，你的服务将会监听TCP端口（如8080），并接收设备发来的数据。

以上是一个简单的TCP服务器框架，你可以根据实际需求进一步处理接收到的数据，解析设备协议等。如果需要集成更复杂的功能，可以继续扩展TcpServerHandler的功能。

二、代码解释

下面我会逐步解释每个部分的代码，帮助你理解它是如何实现基于Spring Boot和Netty的TCP服务器。

1. 依赖配置

在 pom.xml 中引入了必要的依赖：

<dependency>
    <groupId>io.netty</groupId>
    <artifactId>netty-all</artifactId>
    <version>4.1.68.Final</version>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
</dependency>
  • Netty：Netty是一个高性能的异步事件驱动的网络通信框架。它的核心是通过事件和回调来进行非阻塞式的I/O操作。
  • Spring Boot：Spring Boot用来快速开发Java应用程序，它为应用程序提供了很多自动配置选项。
2. NettyServer 类

NettyServer 类的目的是配置和启动一个Netty服务器，监听TCP连接。

@Service
public class NettyServer {
    private final int port = 8080;  // 端口号

    public void start() throws InterruptedException {
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);  // 负责接受连接的线程池
        EventLoopGroup workerGroup = new NioEventLoopGroup();  // 负责处理已连接请求的线程池

        try {
            // 创建一个 ServerBootstrap 实例，用来启动服务器
            ServerBootstrap b = new ServerBootstrap();
            b.group(bossGroup, workerGroup)  // 设置 bossGroup 和 workerGroup
             .channel(NioServerSocketChannel.class)  // 使用 NioServerSocketChannel 作为通道实现（基于NIO的）
             .childHandler(new ChannelInitializer<SocketChannel>() {  // 设置连接到服务器的客户端管道（Channel）初始化器
                 @Override
                 public void initChannel(SocketChannel ch) throws Exception {
                     ch.pipeline().addLast(new TcpServerHandler());  // 添加自定义的Handler来处理请求数据
                 }
             });

            // 绑定端口并启动服务器
            ChannelFuture f = b.bind(port).sync();  // 绑定端口并同步等待完成
            f.channel().closeFuture().sync();  // 等待服务器关闭
        } finally {
            // 优雅关闭线程池
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}
关键点解释：
  • EventLoopGroup：Netty的线程池模型，负责处理I/O操作。bossGroup 负责接收客户端的连接请求，workerGroup 负责处理客户端的请求。
  • ServerBootstrap：用于配置服务器的启动过程，指定通道类型（NioServerSocketChannel）和请求处理器（ChannelInitializer）。
  • ChannelInitializer：它会在每次客户端连接时初始化一个新的通道（SocketChannel），并为该通道添加一个或多个处理器（Handler）。这里我们添加了 TcpServerHandler 来处理TCP数据。
  • bind(port)：Netty服务器绑定指定的端口（8080），并开始监听传入连接。
  • closeFuture().sync()：使得服务器阻塞，直到关闭。
3. TcpServerHandler 类

TcpServerHandler 是自定义的处理器，用于处理接收到的数据。它继承自 ChannelInboundHandlerAdapter，这是Netty中处理接收到消息的基本类。

public class TcpServerHandler extends ChannelInboundHandlerAdapter {
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        // 处理接收到的数据
        String receivedData = (String) msg;  // 将消息转化为字符串
        System.out.println("接收到数据：" + receivedData);
        // 根据需要解析数据或执行其他操作
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        cause.printStackTrace();  // 打印异常信息
        ctx.close();  // 关闭连接
    }
}
关键点解释：
  • channelRead：这是核心方法，当Netty的Channel接收到数据时，它会触发这个方法。这里的msg就是接收到的客户端消息，我们把它强制转化为字符串（假设接收到的数据是文本）。
  • exceptionCaught：用于捕获并处理异常，如果出现任何异常，都会打印堆栈信息，并关闭连接。
4. Spring Boot 启动类

在 Spring Boot 启动类中，我们配置了一个 CommandLineRunner 来启动Netty服务器。

@SpringBootApplication
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);  // 启动Spring Boot应用
    }

    @Bean
    public CommandLineRunner startNettyServer(NettyServer nettyServer) {
        return args -> {
            nettyServer.start();  // 启动Netty服务器
        };
    }
}
关键点解释：
  • CommandLineRunner：是Spring Boot提供的一个接口，它会在Spring Boot应用启动完成后立即执行。我们在这里使用它来启动Netty服务器。
  • @Bean：表示Spring Boot管理的一个Bean，通过依赖注入传递给 startNettyServer 方法。启动时，nettyServer.start() 会被调用，启动Netty服务器。
5. 总结
  • NettyServer 类配置了Netty的TCP服务器，负责监听客户端连接。
  • TcpServerHandler 负责处理接收到的数据，在 channelRead 方法中对数据进行处理。
  • 在Spring Boot应用启动时，通过 CommandLineRunner 来启动Netty服务器。
进一步的扩展
  • 设备协议解析：如果设备发送的数据是特定格式（如JSON、二进制协议等），你可以在 TcpServerHandler 中加入协议解析的代码。
  • 多线程处理：Netty本身支持异步和多线程处理，可以通过线程池等方式来优化性能。
  • 数据存储：可以在处理完数据后将其存储到数据库或者进行其他后续处理。
# spring boot # tcp/ip # 网络
Logo
DAMO开发者矩阵

DAMO开发者矩阵，由阿里巴巴达摩院和中国互联网协会联合发起，致力于探讨最前沿的技术趋势与应用成果，搭建高质量的交流与分享平台，推动技术创新与产业应用链接，围绕“人工智能与新型计算”构建开放共享的开发者生态。

更多推荐

cover

KingbaseES数据库：医疗信创潮涌沅江，国产化信创打造医疗新质生产力

avatar DAMO开发者矩阵
cover

告别迁移焦虑：金仓KDMS V4带你轻松搞定数据库国产化替代

avatar DAMO开发者矩阵
cover

KingbaseES数据库在常德二院全栈国产化信创中产生新质生产力,医疗信创的部署如何实现，如何操作？

avatar DAMO开发者矩阵