Java通过WebSocket读取传输串口数据

Hao_Yu666

已于 2024-08-13 10:50:01 修改

阅读量2.4k

点赞数 3

文章标签： java 开发语言

于 2023-07-25 14:50:35 首次发布

本文链接：https://blog.youkuaiyun.com/Hao_Yu666/article/details/131917109

版权

本文介绍了如何使用Java的WebSocket进行串口数据传输，首先展示了SpringBoot2.0中WebSocket的配置和基础使用，然后通过一个示例代码说明了在实现过程中遇到的错误，即只有一个连接能接收数据的问题。作者分享了修正后的代码，通过在WebSocket服务器端读取串口数据并广播给所有连接的客户端，解决了多用户同时接收串口数据的难题。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

部分学习java的人都可能会接触串口数据，今天我们就利用websocket将串口数据进行传输。

java读取串口数据教程参考上一篇文章

Java读取串口数据

maven依赖

SpringBoot2.0对WebSocket的支持简直太棒了，直接就有包可以引入

		<dependency>  
           <groupId>org.springframework.boot</groupId>  
           <artifactId>spring-boot-starter-websocket</artifactId>  
       </dependency>

WebSocketConfig

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.socket.server.standard.ServerEndpointExporter;

@Configuration
public class WebSocketConfig {
    @Bean
    public ServerEndpointExporter serverEndpointExporter() {
        return new ServerEndpointExporter();
    }

}

我在学习使用WebSocket传输串口数据时，起初是已经成功的，但是后来发现写的有bug，现在把当时的经历来分享给大家，以后避免出现我这样的行为。

最初WebSocket是这样

MyWebSocket

import org.springframework.stereotype.Component;

import javax.websocket.*;
import javax.websocket.server.ServerEndpoint;
import java.io.IOException;
import java.util.concurrent.CopyOnWriteArraySet;

@ServerEndpoint(value = "/demo")
@Component
public class MyWebSocket {
    /**静态变量，用来记录当前在线连接数。应该把它设计成线程安全的。*/
    private static int onlineCount = 0;

    /** concurrent包的线程安全Set，用来存放每个客户端对应的MyWebSocket对象。
     在外部可以获取此连接的所有websocket对象，并能对其触发消息发送功能，我们的定时发送核心功能的实现在与此变量 */
    private static CopyOnWriteArraySet<MyWebSocket> webSocketSet = new CopyOnWriteArraySet<MyWebSocket>();

    /**与某个客户端的连接会话，需要通过它来给客户端发送数据*/
    private Session session;

    /**
     * 连接建立成功调用的方法
     *
     * 类似dwr的onpage方法，参考之前文章中demo有
     * */
    @OnOpen
    public void onOpen(Session session) {
        this.session = session;
        webSocketSet.add(this);     //加入set中
        addOnlineCount();           //在线数加1
        System.out.println("有新连接加入！当前在线人数为" + getOnlineCount());
        try {
            sendMessage("连接已建立成功.");
        } catch (Exception e) {
            System.out.println("IO异常");
        }
    }

    /**
     * 连接关闭调用的方法
     *
     * 参考dwrsession摧毁方法
     */
    @OnClose
    public void onClose() {
        webSocketSet.remove(this);  //连接关闭后，将此websocket从set中删除
        subOnlineCount();           //在线数减1
        System.out.println("有一连接关闭！当前在线人数为" + getOnlineCount());
    }

    /**
     * 收到客户端消息后调用的方法
     *
     * @param message 客户端发送过来的消息*/
    @OnMessage
    public void onMessage(String message, Session session) {
        System.out.println("来自客户端的消息:" + message);
    }

    // 错误提示
    @OnError
    public void onError(Session session, Throwable error) {
        System.out.println("发生错误");
        error.printStackTrace();
    }

    // 发送消息，在定时任务中会调用此方法
    public void sendMessage(String message) throws IOException {
        this.session.getBasicRemote().sendText(message);
    }




    public static synchronized int getOnlineCount() {
        return onlineCount;
    }

    public static synchronized void addOnlineCount() {
        MyWebSocket.onlineCount++;
    }

    public static synchronized void subOnlineCount() {
        MyWebSocket.onlineCount--;
    }



    public Session getSession() {
        return session;
    }

    public void setSession(Session session) {
        this.session = session;
    }

    public static CopyOnWriteArraySet<MyWebSocket> getWebSocketSet() {
        return webSocketSet;
    }

    public static void setWebSocketSet(CopyOnWriteArraySet<MyWebSocket> webSocketSet) {
        MyWebSocket.webSocketSet = webSocketSet;
    }
}

TimeTask

import gnu.io.CommPortIdentifier;
import gnu.io.SerialPort;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import java.io.IOException;
import java.io.InputStream;
import java.util.Date;
import java.util.Scanner;
import java.util.concurrent.CopyOnWriteArraySet;

@Component
@EnableScheduling
public class TimeTask {
    private static Logger logger = LoggerFactory.getLogger(TimeTask.class);
    private SerialPort serialPort;
    private InputStream input;

    @PostConstruct
    public void init() {
        try {
            CommPortIdentifier portIdentifier = CommPortIdentifier.getPortIdentifier("COM3");
            serialPort = (SerialPort) portIdentifier.open("SerialReader", 2000);
            serialPort.setSerialPortParams(9600, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);
            input = serialPort.getInputStream();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Scheduled(cron = "0/3 * * * * ?")   //3秒钟执行一次
    public void test() {
        System.err.println("*********   定时任务执行   **************");
        try {
            serialPort.setSerialPortParams(9600, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);
            CopyOnWriteArraySet<MyWebSocket> webSocketSet = MyWebSocket.getWebSocketSet();
            webSocketSet.forEach(webSocket -> {
                try {
                    String message = new String(); // 初始化消息
                    Scanner scanner = new Scanner(input);
                    while (scanner.hasNextLine()) {
                        String line = scanner.nextLine();
                        message += " " + line; // 将每行数据添加到消息中
                    }
                    webSocket.sendMessage( /*new Date().toLocaleString()+*/ message); // 发送合并后的消息到 WebSocket
                } catch (IOException e) {
                    e.printStackTrace();
                } catch (Throwable t) {
                    t.printStackTrace();
                }
            });
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @PreDestroy
    public void destroy() {
        if (serialPort != null) {
            serialPort.close();
        }
        System.err.println("关闭串口连接");
    }
}

按照这种写的方式确实可以利用WebSocket拿到数据。但是在后续的测试中发现，这种方式只有第一个连接WebSocket的用户可以拿到数据，因为他在连接的时候将端口进行占用，后续的人在连接的时候端口已经被占用了。于是便想到了一种方式，就是在websocket开启的时候由系统本身读取数据，然后利用系统来发送数据。

于是便有了如下代码：

修改后MyWebSocket

import javax.websocket.*;
import javax.websocket.server.ServerEndpoint;
import java.io.IOException;
import java.io.InputStream;
import java.nio.ByteBuffer;
import java.util.Scanner;
import java.util.concurrent.CopyOnWriteArraySet;

@ServerEndpoint(value = "/demo")
@Component
public class MyWebSocket {

    private static Logger logger = LoggerFactory.getLogger(MyWebSocket.class);

    private static CopyOnWriteArraySet<MyWebSocket> webSocketSet = new CopyOnWriteArraySet<MyWebSocket>();
    private Session session;

    private static SerialPort serialPort;
    private static InputStream input;

    // 记录当前连接数
    private static int connectCount = -1;


    public MyWebSocket() {
        try {
            if (connectCount == -1) {
                connectCount++;
                CommPortIdentifier portIdentifier = CommPortIdentifier.getPortIdentifier("COM3");
                serialPort = (SerialPort) portIdentifier.open("SerialReader", 2000);
                serialPort.setSerialPortParams(9600, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);
                input = serialPort.getInputStream();
                Thread thread = new Thread(() -> {
                    while (true) {
                        try {
                            String message = ""; // 初始化消息
                            Scanner scanner = new Scanner(input);
                            while (scanner.hasNextLine()) {
                                String line = scanner.nextLine();
                                message += " " + line; // 将每行数据添加到消息中
                            }
                            if (!message.isEmpty()) {
                                sendMessage(message);
                            }
                            Thread.sleep(800); // 休眠1秒钟
                        } catch (Exception e) {
                            logger.error("读取串口数据出错", e);
                        }
                    }
                });
                thread.start();
            }
        } catch (Exception e) {
            logger.error("打开串口连接出错", e);
        }
    }

    @OnOpen
    public void onOpen(Session session) {
        this.session = session;
        webSocketSet.add(this);
        connectCount++;
    }

    @OnClose
    public void onClose() {
        webSocketSet.remove(this);
        connectCount--;
//        serialPort.removeEventListener();
//        serialPort.close();

    }

    @OnMessage
    public void onMessage(String message, Session session) {
        logger.info("收到来自客户端的消息: {}", message);
    }

    public static synchronized  void sendMessage(String message) {
        for (MyWebSocket webSocket : webSocketSet) {
            try {
                webSocket.session.getBasicRemote().sendText(message);
            } catch (IOException e) {
                logger.error("向客户端发送消息出错", e);
            }
        }
//        webSocketSet.forEach(webSocket -> {
//            try {
//                webSocket.session.getBasicRemote().sendText(message);
//            } catch (IOException e) {
//                logger.error("向客户端发送消息出错", e);
//            }
//        });
    }


    @OnError
    public void onError(Throwable throwable) {
        logger.error("WebSocket发生错误", throwable);
    }
}

TimeTask不再需要了，

connectCount定义-1是因为connectCount为连接数量，系统默认占用一个，所以这样可以保证记录数量正确。因为这篇文章过的有点久了，所以写的相对很笼统，有什么错误欢迎大家指出。

下面就是利用WebSocket传输数据的效果了

推荐使用postman或者WebSocket在线测试工具进行测试。

也可以考虑用下面html测试

index

<!DOCTYPE HTML>
<html>
<head>
    <title>My WebSocket</title>
</head>

<body>
Welcome<br/>
<input id="text" type="text" /><button onclick="send()">Send</button>    <button onclick="closeWebSocket()">Close</button>
<div id="message">
</div>
</body>

<script type="text/javascript">
    var websocket = null;

    //判断当前浏览器是否支持WebSocket  ,主要此处要更换为自己的地址
    if('WebSocket' in window){
        websocket = new WebSocket("ws://localhost:9191/demo");
    }
    else{
        alert('Not support websocket')
    }

    //连接发生错误的回调方法
    websocket.onerror = function(){
        setMessageInnerHTML("error");
    };

    //连接成功建立的回调方法
    websocket.onopen = function(event){
        setMessageInnerHTML("open");
    }

    //接收到消息的回调方法
    websocket.onmessage = function(event){
        setMessageInnerHTML(event.data);
    }

    //连接关闭的回调方法
    websocket.onclose = function(){
        setMessageInnerHTML("close");
    }

    //监听窗口关闭事件，当窗口关闭时，主动去关闭websocket连接，防止连接还没断开就关闭窗口，server端会抛异常。
    window.onbeforeunload = function(){
        websocket.close();
    }

    //将消息显示在网页上
    function setMessageInnerHTML(innerHTML){
        document.getElementById('message').innerHTML += innerHTML + '<br/>';
    }

    //关闭连接
    function closeWebSocket(){
        websocket.close();
    }

    //发送消息
    function send(){
        var message = document.getElementById('text').value;
        websocket.send(message);
    }
</script>
</html>