SpringBoot项目监听端口接受数据(NIO版)

已于 2024-12-17 16:58:01 修改
阅读量540 收藏 4
点赞数 5
分类专栏： 网络编程 文章标签： spring boot nio 后端 网络
于 2024-12-11 18:21:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_46425661/article/details/144405786
版权

文章目录

前言

环境：
JDK：64位 Jdk1.8
SpringBoot：2.1.7.RELEASE

功能：
使用Java中原生的NIO监听端口接受客户端的数据，并发送数据给客户端。

服务端

相关配置

application.yml

socket:
  port: 9991
  bufferSize: 2048
  timeout: 3000

配置类

import lombok.Getter;
import lombok.Setter;
import lombok.ToString;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

/**
 * @author qf
 * @since 2024/10/08 21:20
 */
@Component
@ConfigurationProperties(prefix = "socket")
@Setter
@Getter
@ToString
public class NioSocketConfig {

    private Integer port;
    private Integer bufferSize;
    private Integer timeout;
}

核心代码

CommandLineRunner
当应用程序启动时，CommandLineRunner 接口的实现类中的 run 方法会被调用

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

/**
 * @author qf
 * @since 2024/10/08 21:25
 */
@Slf4j
@Component
public class CommandLineRunnerImpl implements CommandLineRunner {

    private NioSocketConfig nioSocketConfig;

    @Autowired
    public CommandLineRunnerImpl(NioSocketConfig nioSocketConfig) {
        this.nioSocketConfig = nioSocketConfig;
    }

    @Override
    public void run(String... args) {
        ServerSelector serverSelector = new ServerSelector(nioSocketConfig);
        log.info("-----------监听端口启动成功！-----------");
        serverSelector.server();
    }
}

服务类

import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Bean;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.util.Iterator;

 /**
 * NIO Socket Server
 * @author qf
 * @since 2024/10/08 21:30
 */
@Slf4j
public class ServerSelector {

    private NioSocketConfig nioSocketConfig;

    public ServerSelector(NioSocketConfig nioSocketConfig){
        this.nioSocketConfig = nioSocketConfig;
    }

    @Bean
    public void server() {
        Selector selector = null;
        Protocol protocol = null;
        try {
            // 实例化一个信道
            ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
            // 将该信道绑定到指定端口
            serverSocketChannel.bind(new InetSocketAddress(nioSocketConfig.getPort()));
            // 配置信道为非阻塞模式
            serverSocketChannel.configureBlocking(false);
            // 创建一个选择器
            selector = Selector.open();
            // 将选择器注册到各个信道
            serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
            // 初始化事件处理器
            protocol = new EchoSelectorProtocol(nioSocketConfig.getBufferSize());
        } catch (IOException e) {
            log.error("粒径设备监听10091端口时发生异常：",e);
        }
        // 不断轮询select方法，获取准备好的信道所关联的Key集
        while (true) {
            try {
                if (selector == null || protocol == null) {
                    break;
                }
                Thread.sleep(100);
                // 一直等待,直至有信道准备好了I/O操作
                if (selector.select(nioSocketConfig.getTimeout()) == 0) {
                    // 在等待信道准备的同时，也可以异步地执行其他任务，
                    continue;
                }

                // 获取准备好的信道所关联的Key集合的iterator实例
                Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
                // 循环取得集合中的每个键值
                while (iterator.hasNext()) {
                    SelectionKey selectionKey = iterator.next();
                    // 如果服务端信道感兴趣的I/O操作为accept
                    if (selectionKey.isValid() && selectionKey.isAcceptable()) {
                        protocol.handleAccept(selectionKey);
                    }
                    // 如果客户端信道感兴趣的I/O操作为read
                    if (selectionKey.isValid() && selectionKey.isReadable()) {
                        protocol.handleRead(selectionKey);
                    }
                    // 如果该键值有效，并且其对应的客户端信道感兴趣的I/O操作为write
                    if (selectionKey.isValid() && selectionKey.isWritable()) {
                        protocol.handleWrite(selectionKey);
                    }
                    // 这里需要手动从键集中移除当前的key
                    iterator.remove();
                }
            } catch (Exception e) {
                log.error("监听端口轮询selector时发生异常：",e);
            }
        }
    }
}

协议接口

import java.io.IOException;
import java.nio.channels.SelectionKey;

/**
 * 该接口定义了通用TCPSelectorServer类与特定协议之间的接口，
 * 它把与具体协议相关的处理各种I/O的操作分离了出来，
 * 以使不同协议都能方便地使用这个基本的服务模式。
 * @author qf
 * @since 2024/10/08 20:30
 */
public interface Protocol {

    //accept I/O形式
    void handleAccept(SelectionKey selectionKey) throws IOException;

    //read I/O形式
    void handleRead(SelectionKey selectionKey) throws IOException;

    //write I/O形式
    void handleWrite(SelectionKey selectionKey) throws IOException;
}

实现类

import lombok.extern.slf4j.Slf4j;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.nio.charset.StandardCharsets;

/**
 * @author qf
 * @since 2024/10/08 20:30
 */
@Slf4j
public class EchoSelectorProtocol implements Protocol {

    private int bufSize; // 缓冲区的长度

    public EchoSelectorProtocol(int bufSize) {
        this.bufSize = bufSize;
    }

    // 服务端信道已经准备好了接收新的客户端连接
    public void handleAccept(SelectionKey selectionKey) {
        try {
            SocketChannel socketChannel = ((ServerSocketChannel) selectionKey.channel()).accept();
            socketChannel.configureBlocking(false);
            // 将选择器注册到连接到的客户端信道，并指定该信道key值的属性为OP_READ，同时为该信道指定关联的附件
            socketChannel.register(selectionKey.selector(), SelectionKey.OP_READ, ByteBuffer.allocate(bufSize));
        } catch (IOException e) {
            log.error("accept异常：",e);
            selectionKey.cancel();
        }
    }

    // 客户端信道已经准备好了从信道中读取数据到缓冲区
    public void handleRead(SelectionKey selectionKey) {
        try {
            SocketChannel socketChannel = (SocketChannel) selectionKey.channel();
            if (!(selectionKey.attachment() instanceof ByteBuffer)) {
                return;
            }
            // 获取该信道所关联的附件，这里为缓冲区
            ByteBuffer byteBuffer = (ByteBuffer) selectionKey.attachment();
            long bytesRead = socketChannel.read(byteBuffer);
            // 如果read()方法返回-1，说明客户端关闭了连接，那么客户端已经接收到了与自己发送字节数相等的数据，可以安全地关闭
            if (bytesRead == -1) {
                socketChannel.close();
            } else if (bytesRead > 0) {
                // 将channel改为读取状态
                byteBuffer.flip();
                String dateStr = new String(byteBuffer.array());
                if (true) {
                    // 注册写事件
                    selectionKey.interestOps(SelectionKey.OP_WRITE);
                    selectionKey.attach("test"); // 将数据附加到SelectionKey上
                }
                byteBuffer.clear();
                // 如果缓冲区总读入了数据，则将该信道感兴趣的操作设置为为可读可写
                selectionKey.interestOps(SelectionKey.OP_READ | SelectionKey.OP_WRITE);
            }
        } catch (IOException e) {
            log.error("read异常，", e);
            selectionKey.cancel();
        } catch (Exception e) {
            log.error("read异常：", e);
        }
    }


    // 客户端信道已经准备好了将数据从缓冲区写入信道
    public void handleWrite(SelectionKey selectionKey) throws IOException {
        SocketChannel socketChannel = (SocketChannel) selectionKey.channel();
        if (selectionKey.attachment() instanceof String) {
            String data = (String) selectionKey.attachment(); // 获取附加的数据
            ByteBuffer buffer = ByteBuffer.wrap(data.getBytes(StandardCharsets.UTF_8));
            socketChannel.write(buffer);
        }
        // 写完后取消写事件，重新注册读事件
        selectionKey.interestOps(SelectionKey.OP_READ);
    }
}

客户端

import lombok.extern.slf4j.Slf4j;

import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
import java.nio.charset.StandardCharsets;


/** 
 *  模拟客户端
 * @author qf
 * @date 2024/7/8 19:25 
 */
@Slf4j
public class NIOClient {
    public static void main(String[] args) throws Exception{

        //得到一个网络通道
        SocketChannel socketChannel = SocketChannel.open();
        //设置非阻塞
        socketChannel.configureBlocking(false);
        //提供服务器端的ip 和 端口
        InetSocketAddress inetSocketAddress = new InetSocketAddress("127.0.0.1", 9991);
        //连接服务器
        if (!socketChannel.connect(inetSocketAddress)) {
            while (!socketChannel.finishConnect()) {//!没有 完成连接finishConnect方法
                log.info("因为连接需要时间，客户端不会阻塞，可以做其它工作..");
            }
        }

        //...如果连接成功，就发送数据
        String str  = "hello！";
        ByteBuffer buffer = ByteBuffer.wrap(str.getBytes());
        //发送数据，将 buffer 数据写入 channel
        socketChannel.write(buffer);
        // 接收服务器发送的数据
        int count = 0;
        while (true) {
            ByteBuffer readBuffer = ByteBuffer.allocate(1024 * 1024);
            count += socketChannel.read(readBuffer);
            if(count != 0){
                System.out.println(count);
                String data = StandardCharsets.UTF_8.decode(readBuffer).toString();
                System.out.println(data);
                String x = new String(readBuffer.array());
                System.out.println(x);

                count = 0;
            }
            readBuffer.clear();
        }

    }
}

相关文章：
SpringBoot项目监听端口接受数据(Netty版)
NIO笔记01-NIO 基础三大组件
NIO笔记02-ByteBuffer
NIO笔记03-文件编程
NIO笔记04-网络编程
NIO笔记05-NIO 和 BIO

Spring Boot项目接收前端参数的11种方式
m0_74824592的博客
02-15 1216
RequestParam主要用于在Spring MVC后台控制层获取参数，它有三个常用参数。参数名描述表示设置默认值required表示该参数是否必传value值表示接收传入的参数的key@PathVariable用于将请求URL中的模板变量映射到功能处理方法的参数上，即取出URL模板中的变量作为参数。@RequestBody该注解会把接收到的参数转为JSON格式。
无法同时开启springboot和netty服务器端口的监听，和netty整合使用mybatis的问题 (后附完整的springboot整合netty代码)
qq_45369827的博客
03-15 4946
目的 背景描述 解决办法 SpringBoot整合Netty完整代码 目的  解决springboot程序监听的端口和netty服务监听的端口无法同时开启的问题，以及netty无法较为便利地使用mybatis操作数据库的问题。 背景描述  正在做的一个IM即时通讯项目，springboot服务器负责监听http的CRUD等请求，netty的websocket服务器负责即时聊天消息的签收和推送功能。常见的两种springboot整合netty的方法如下：  1、单独写一个main方法，运行nett..
Java 串口通信—收发，监听数据(代码实现)
白白白鲤鱼的博客
09-14 2828
Java 实现串口通信—收发，监听数据
Springboot启用多个监听端口代码实例
08-19
主要介绍了Springboot启用多个监听端口代码实例,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
踏莎行·术 - NIO系列2：TCP监听绑定
tulunta
04-01 141
注：本文适合对象需对java NIO API的使用及异步事件模型（Reactor模式）有一定程度的了解，主要讲述使用java原生NIO实现一个TCP监听绑定的过程及细节设计。 我们一开始设计了一个TCP接入服务类，这个类提供了一个API方法提供对本地一系列地址（端口）的监听绑定，类初始化后完成Selector的open操作如下： selector = Selector.open(); ...
Springboot+Socket 接收数据
linge-的博客
08-03 2040
@Component @Slf4j public class SocketListener implements CommandLineRunner { @Resource private TestService testService; @Override public void run(String... args) throws Exception { ServerSocket serverSocket = null; try { .
springboot 项目监听多个端口
qq_58280734的博客
09-15 2228
步骤： 1.在配置文件添加 #端口设置 server.port=8088 server.additionalPorts: 8089,8090 2.编写ApplicationConfig.class类 import org.apache.catalina.connector.Connector; import org.springframework.boot.web.embedded.tomcat.*; import org.springframework.beans.factory.annotat.
SpringBoot实现通过串口互传数据
最新发布
liao3399084的博客
01-09 365
【代码】SpringBoot实现通过串口互传数据。
SpringBoot框架实现把netty框架接受串口数据，并且把串口数据显示在jsp/html页面上
tian_jiangnan的博客
07-04 4241
要求 1、netty框架接受串口数据信息 2、netty接受到串口数据以后把信息通过websocket实时推送到html/jsp页面上 我们先看效果 我现在呈现上所有的代码 1、启动程序 package com.example.demo; import com.example.demo.socket.BootNettyServer; import org.springframework.boot.CommandLineRunner; import org.springframewo..
再临SpringBoot——同步异步、阻塞非阻塞、NIO与Reactor模式
No_Game_No_Life_的博客
09-23 7042
文章目录同步、异步、阻塞、非阻塞Proactor 与 Reactor 模式ReactorProactorNIO 同步、异步、阻塞、非阻塞 在高性能的I/O设计中，有两个比较著名的模式Reactor和Proactor模式，其中Reactor模式用于同步I/O，而Proactor运用于异步I/O操作。 在比较这两个模式之前，我们首先的搞明白几个概念，什么是阻塞和非阻塞，什么是同步和异步? 同步和异步是...
spring boot 整合的netty 实现的socket的服务端和客户端
05-08
spring boot 整合的netty 实现的socket的demo（包括服务端和客户端是分开的两个项目，导入idea，启动即可）。
spring集成socket服务
09-25
spring框架集成socket服务，监听器检测到容器启动完成，通过线程启动socket服务
springboot 事件监听的实现方法
08-26
主要介绍了springboot 事件监听的实现方法，并详细的介绍了四种监听方式，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Springboot项目Netty服务并自定义Gson配置类解析数据包
12-14
接下来，我们创建一个Netty服务器端点，该端点会监听特定端口并处理接收到的Json数据包。一个简单的服务器启动类可能如下所示： ```java import io.netty.bootstrap.ServerBootstrap; import io.netty.channel....
Java Springboot TcpIp数据交互可持续接收数据可发送消息可多端口链接
槐序二十四的博客
11-25 3163
Java Springboot TcpIp数据交互 支持持续接收数、可发送数据、可多端口链接、贴了就好使。 开始加载监听Tcp/Ip端口、监听用户链接 向客户端发送指令，接收指令、接收消息
监听tcp端口发送/接收数据包
weixin_52799485的博客
05-26 2770
ApplicationEnvironmentPreparedEvent：在Spring已经准备好上下文但是上下文尚未创建的时候触发。ApplicationStartedEvent. ：在刷新上下文之后、调用application命令之前触发。ApplicationPreparedEvent：在Bean定义加载之后、刷新上下文之前触发。ApplicationStartingEvent：在Spring最开始启动的时候触发。这部分我使用了异步处理，可按需加或者删除。
【SpringBoot实战】WebSocket+Stomp+SockJs实现客户端状态监听
qq_21609191的博客
10-28 3616
对于SpringBoot而言，使用传统WebSocket监听客户端状态想必大家已经很熟悉了，比如@onClose和@onOpen注解可以用来监听客户端连线状态，但SockJs在使用上并没有可直接使用的注解或方法对客户端进行监听，这边提供了一些方法，看起来也并不复杂。以下让我们来了解一下SpringBoot的SockJs如何来对客户端进行监听。提示：以下是本篇文章正文内容，下面案例可供参考接下来，我们新建一个（自定义握手管理器）类，继承自（默认握手管理器）。重写方法，从对象中可以获取到客户端信息。
springboot TCP socket通信远程监听采集数据.
热门推荐
liukangjie520的博客
07-17 1万+
记录下最近研究的成果,以免以后用到的时候忘记了. socket建立长链接,双方(客户端--服务器)握手后一方不断掉信道就会一直存在.本次文章业务场景是模拟温度湿度传感器发送温度湿度数据通过网关传送到服务器,服务器接收消息和作出回应. 项目基于springboot2.1.3构建主要用到萝卜和commons-codec辅助(主要是java.nio包) <!--字节转换--> <dependency> ...
个人笔记篇-SpringBoot集成Socket
qq_33351639的博客
02-20 1万+
SpringBoot简单集成WebSocket初步了解后,本次再进行一个深入通俗的理解。Socket作为一种通信机制,通常也被称为"套接字"。它类似于人们之间的"打电话行为"。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值