AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

Java串口通信技术探究3：RXTX库线程 优化系统性能的SerialPortEventListener类

2024-05-02 521
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
云数据库 Tair（兼容Redis），内存型 2GB
推荐场景：
通过缓存加速数据库访问
Redis 开源版，标准版 2GB
推荐场景：
搭建游戏排行榜
日志服务 SLS，月写入数据量 50GB 1个月
简介： Java串口通信技术探究3：RXTX库线程 优化系统性能的SerialPortEventListener类

在之前的文章中，我们讨论了使用单例模式的SerialPortEventListener类。然而，这种模式在某些情况下并不理想，因为它会导致重复创建监听器，从而无法正确获取串口返回的数据。那么，如何实现SerialPortEventListener的复用呢？

首先，我们需要了解什么是SerialPortEventListener类。SerialPortEventListener是一个用于监听串口事件的类，可以接收串口事件通知，并在事件发生时执行相应的操作。例如，当有数据可读时，它可以帮助我们进行数据缓存和处理。

setListenerToSerialPort函数用于建立监听，前端使用一个定时器不断地请求receiveDataTest()来获取数据，而后端则不断返回数据。但是，这个方法有一个问题，就是后端会重复创建监听器，导致每次都拿不到一个监听器的数据。

一、失败方案

原本获取串口返回的信息是这样写的：

串口监听工具

import gnu.io.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.*;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
/**
 * Created by Yeats
 * 串口工具类
 */
public class SerialPortTool {
    /**
     * slf4j 日志记录器
     */
    private static final Logger logger = LoggerFactory.getLogger(SerialPortTool.class);
    /**
     * 查找电脑上所有可用 com 端口
     *
     * @return 可用端口名称列表，没有时 列表为空
     */
    public static final ArrayList<String> findSystemAllComPort() {
        /**
         *  getPortIdentifiers：获得电脑主板当前所有可用串口
         */
        Enumeration<CommPortIdentifier> portList = CommPortIdentifier.getPortIdentifiers();
        ArrayList<String> portNameList = new ArrayList<>();
        /**
         *  将可用串口名添加到 List 列表
         */
        while (portList.hasMoreElements()) {
            String portName = portList.nextElement().getName();//名称如 COM1、COM2....
            portNameList.add(portName);
        }
        return portNameList;
    }
    /**
     * 打开电脑上指定的串口
     *
     * @param portName 端口名称，如 COM1，为 null 时，默认使用电脑中能用的端口中的第一个
     * @param b        波特率(baudrate)，如 9600
     * @param d        数据位（datebits），如 SerialPort.DATABITS_8 = 8
     * @param s        停止位（stopbits），如 SerialPort.STOPBITS_1 = 1
     * @param p        校验位 (parity)，如 SerialPort.PARITY_NONE = 0
     * @return 打开的串口对象，打开失败时，返回 null
     */
    public static final SerialPort openComPort(String portName, int b, int d, int s, int p) {
        CommPort commPort = null;
        try {
            //当没有传入可用的 com 口时，默认使用电脑中可用的 com 口中的第一个
            if (portName == null || "".equals(portName)) {
                List<String> comPortList = findSystemAllComPort();
                if (comPortList != null && comPortList.size() > 0) {
                    portName = comPortList.get(0);
                }
            }
            logger.info("开始打开串口：portName=" + portName + ",baudrate=" + b + ",datebits=" + d + ",stopbits=" + s + ",parity=" + p);
            //通过端口名称识别指定 COM 端口
            CommPortIdentifier portIdentifier = CommPortIdentifier.getPortIdentifier(portName);
            /**
             * open(String TheOwner, int i)：打开端口
             * TheOwner 自定义一个端口名称，随便自定义即可
             * i：打开的端口的超时时间，单位毫秒，超时则抛出异常：PortInUseException if in use.
             * 如果此时串口已经被占用，则抛出异常：gnu.io.PortInUseException: Unknown Application
             */
            commPort = portIdentifier.open(portName, 5000);
            /**
             * 判断端口是不是串口
             * public abstract class SerialPort extends CommPort
             */
            if (commPort instanceof SerialPort) {
                SerialPort serialPort = (SerialPort) commPort;
                /**
                 * 设置串口参数：setSerialPortParams( int b, int d, int s, int p )
                 * b：波特率（baudrate）
                 * d：数据位（datebits），SerialPort 支持 5,6,7,8
                 * s：停止位（stopbits），SerialPort 支持 1,2,3
                 * p：校验位 (parity)，SerialPort 支持 0,1,2,3,4
                 * 如果参数设置错误，则抛出异常：gnu.io.UnsupportedCommOperationException: Invalid Parameter
                 * 此时必须关闭串口，否则下次 portIdentifier.open 时会打不开串口，因为已经被占用
                 */
                serialPort.setSerialPortParams(b, d, s, p);
                logger.info("打开串口 " + portName + " 成功...");
                return serialPort;
            } else {
                logger.error("当前端口 " + commPort.getName() + " 不是串口...");
            }
        } catch (NoSuchPortException e) {
            e.printStackTrace();
        } catch (PortInUseException e) {
            logger.warn("串口 " + portName + " 已经被占用，请先解除占用...");
            e.printStackTrace();
        } catch (UnsupportedCommOperationException e) {
            logger.warn("串口参数设置错误，关闭串口，数据位[5-8]、停止位[1-3]、验证位[0-4]...");
            e.printStackTrace();
            if (commPort != null) {//此时必须关闭串口，否则下次 portIdentifier.open 时会打不开串口，因为已经被占用
                commPort.close();
            }
        }
        logger.error("打开串口 " + portName + " 失败...");
        return null;
    }
    /**
     * 往串口发送数据
     *
     * @param serialPort 串口对象
     * @param orders     待发送数据
     */
    public static void sendDataToComPort(SerialPort serialPort, byte[] orders) {
        OutputStream outputStream = null;
        try {
            if (serialPort != null) {
                outputStream = serialPort.getOutputStream();
                outputStream.write(orders);
                outputStream.flush();
                logger.info("往串口 " + serialPort.getName() + " 发送数据：" + Arrays.toString(orders) + " 完成...");
            } else {
                logger.error("gnu.io.SerialPort 为null，取消数据发送...");
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (outputStream != null) {
                try {
                    outputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    /**
     * 从串口读取数据
     *
     * @param serialPort 要读取的串口
     * @return 读取的数据
     */
    public static byte[] getDataFromComPort(SerialPort serialPort) {
        InputStream inputStream = null;
        byte[] data = null;
        try {
            if (serialPort != null) {
                inputStream = serialPort.getInputStream();
                // 等待数据接收完成
                Thread.sleep(500);
                // 获取可读取的字节数
                int availableBytes = inputStream.available();
                if (availableBytes > 0) {
                    data = new byte[availableBytes];
                    int readBytes = inputStream.read(data);
                    logger.info("从串口 " + serialPort.getName() + " 接收到数据：" + Arrays.toString(data) + " 完成...");
                } else {
                    logger.warn("从串口 " + serialPort.getName() + " 接收到空数据...");
                }
            } else {
                logger.error("gnu.io.SerialPort 为null，取消数据接收...");
            }
        } catch (IOException | InterruptedException e) {
            e.printStackTrace();
        } finally {
            if (inputStream != null) {
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return data;
    }
    /**
     * 关闭串口
     *
     * @param serialPort 待关闭的串口对象
     */
    public static void closeComPort(SerialPort serialPort) {
        if (serialPort != null) {
            serialPort.close();
            logger.info("关闭串口 " + serialPort.getName());
        }
    }
    /**
     * 16进制字符串转十进制字节数组
     * 这是常用的方法，如某些硬件的通信指令就是提供的16进制字符串，发送时需要转为字节数组再进行发送
     *
     * @param strSource 16进制字符串，如 "455A432F5600"，每两位对应字节数组中的一个10进制元素
     *                  默认会去除参数字符串中的空格，所以参数 "45 5A 43 2F 56 00" 也是可以的
     * @return 十进制字节数组, 如 [69, 90, 67, 47, 86, 0]
     */
    public static byte[] hexString2Bytes(String strSource) {
        if (strSource == null || "".equals(strSource.trim())) {
            System.out.println("hexString2Bytes 参数为空，放弃转换.");
            return null;
        }
        strSource = strSource.replace(" ", "");
        int l = strSource.length() / 2;
        byte[] ret = new byte[l];
        for (int i = 0; i < l; i++) {
            ret[i] = Integer.valueOf(strSource.substring(i * 2, i * 2 + 2), 16).byteValue();
        }
        return ret;
    }
    /**
     * 给串口设置监听
     *
     * @param serialPort serialPort 要读取的串口
     * @param listener   SerialPortEventListener监听对象
     * @throws TooManyListenersException 监听对象太多
     */
    public static void setListenerToSerialPort(SerialPort serialPort, SerialPortEventListener listener) throws TooManyListenersException {
        //给串口添加事件监听
        serialPort.addEventListener(listener);
        //串口有数据监听
        serialPort.notifyOnDataAvailable(true);
        //中断事件监听
        serialPort.notifyOnBreakInterrupt(true);
    }
}

Controller层

@GetMapping("/open")
    public String openSerialPort(@RequestParam() String port) throws NoSuchPortException, PortInUseException, UnsupportedCommOperationException, TooManyListenersException {
        port = "COM" + port;
        log.debug(port);
        SerialPort serialPort = remoteService.openSerialPortTest(port);
        return "Serial Port Opened";
    }
    @PostMapping("/send")
    public String sendData(@RequestBody String data) throws TooManyListenersException, UnsupportedCommOperationException, NoSuchPortException, PortInUseException {
        remoteService.sendData(data);
        return "Data Sent";
    }
    @GetMapping("/receive")
    public String receiveData() throws TooManyListenersException {
        return remoteService.getCurrentListener().getData();
    }
    @GetMapping("/close")
    public String closeSerialPort() throws TooManyListenersException, NoSuchPortException, PortInUseException, UnsupportedCommOperationException {
        remoteService.closeSerialPort();
        return "Serial Port Closed";
    }

MySerialPortEventListener

public class MySerialPortEventListener implements SerialPortEventListener {
    private RedisCache redisCache;
    private Queue<String> dataQueue = new LinkedList<>();
    private String latestData = "";
    public MySerialPortEventListener(SerialPort serialPort, int eventType) throws TooManyListenersException {
        this.serialPort = serialPort;
        this.eventType = eventType;
        this.redisCache = new RedisCache();
        //给串口添加事件监听
        serialPort.addEventListener(this);
        //串口有数据监听
        serialPort.notifyOnDataAvailable(true);
        //中断事件监听
        serialPort.notifyOnBreakInterrupt(true);
    }
    private SerialPort serialPort;
    
    private int eventType;
    private static ConcurrentHashMap<Long, MySerialPortEventListener> instanceMap = new ConcurrentHashMap<>();
    public static synchronized MySerialPortEventListener getInstance(SerialPort serialPort, int eventType) throws TooManyListenersException {
        long threadId = Thread.currentThread().getId();
        MySerialPortEventListener instance = instanceMap.get(threadId);
        if (instance == null) {
            instance = new MySerialPortEventListener(serialPort, eventType);
            instanceMap.put(threadId, instance);
        }
        return instance;
    }
    public static ConcurrentHashMap<Long, MySerialPortEventListener> getInstanceMap() {
        return instanceMap;
    }
    @Override
    public void serialEvent(SerialPortEvent arg0) {
        if (arg0.getEventType() == SerialPortEvent.DATA_AVAILABLE) {
            // 数据通知
            byte[] bytes = SerialPortTool.getDataFromComPort(serialPort);
            System.out.println("收到的数据长度：" + bytes.length);
            String str = new String(bytes);
            latestData = str;
            System.out.println("收到的数据：" + str);
            eventType = arg0.getEventType(); // 将事件类型赋值给eventType
        }
    }
    public String getData() {
        if (latestData != null) {
            String data = latestData;
            latestData = null; // 清空最新数据，避免重复获取
            return data;
        } else {
            return "";
        }
    }
    public int getEventType() {
        return eventType;
    }
    public SerialPort getSerialPort() {
        return serialPort;
    }
}

impl

private SerialPort serialPort;
@Override
    public SerialPort openSerialPort(String port) {
        serialPort = SerialPortTool.openComPort(port, 9600, 8, 1, 0);
        // 创建新线程来处理串口的打开操作
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    MySerialPortEventListener listener = MySerialPortEventListener.getInstance(serialPort, 1);
                } catch (TooManyListenersException e) {
                    e.printStackTrace();
                }
            }
        });
        thread.start();
        return serialPort;
    }
    @Override
    public void sendData(String senData) {
        String data = senData;
        // 获取当前线程的MySerialPortEventListener实例
        MySerialPortEventListener listener = getCurrentListener();
        if (listener != null) {
            SerialPortTool.sendDataToComPort(listener.getSerialPort(), data.getBytes());
        }
    }
    @Override
    public SerialPort getSerialPort() {
        // 获取当前线程的MySerialPortEventListener实例
        MySerialPortEventListener listener = getCurrentListener();
        if (listener != null) {
            return listener.getSerialPort();
        } else {
            return null;
        }
    }
    @Override
    // 获取当前线程的MySerialPortEventListener实例
    public MySerialPortEventListener getCurrentListener() {
        long threadId = Thread.currentThread().getId();
        MySerialPortEventListener listener = MySerialPortEventListener.getInstanceMap().get(threadId);
        return listener;
    }
    // 关闭串口测试
    @Override
    public void closeSerialPort() {
        SerialPortTool.closeComPort(serialPort);
    }

现在我把发送数据，设置监听，获取数据单独拿出来了，但是获取不到数据了，我已经把listener对象作为一个成员变量保存在RemoteService类中了。

问题是每次请求数据时都使用不到同一个SerialPortEventListener对象，所以拿不到串口返回的数据

if (arg0.getEventType() == SerialPortEvent.DATA_AVAILABLE) {
                    // 数据通知
                    byte[] bytes = SerialPortTool.getDataFromComPort(serialPort);
                    System.out.println("收到的数据长度：" + bytes.length);
                    System.out.println("收到的数据：" + new String(bytes));

因为 getCurrentListener() 方法返回了 null，导致在 receiveDataTest() 方法中调用 getData() 方法时出现了 NullPointerException。这可能是因为你没有在第二个用户访问 COM6 时创建一个新的 MySerialPortEventListener 实例，而是继续使用了第一个用户的实例，导致数据被覆盖或丢失。

二、成功方案

在这个示例中，我们在后端定义了一个MySerialPortEventListener类，每个用户访问串口时创建一个新的 MySerialPortEventListener 实例，并将其存储在一个 Map 中，以便在后续的请求中使用。这样每个用户都有自己的监听器实例，互不干扰。

串口监听工具

import gnu.io.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.*;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
/**
 *
 * 串口工具类
 */
public class SerialPortTool {
    private static final Logger logger = LoggerFactory.getLogger(SerialPortTool.class);//slf4j 日志记录器
    /**
     * 查找电脑上所有可用 com 端口
     *
     * @return 可用端口名称列表，没有时 列表为空
     */
    public static final ArrayList<String> findSystemAllComPort() {
        /**
         *  getPortIdentifiers：获得电脑主板当前所有可用串口
         */
        Enumeration<CommPortIdentifier> portList = CommPortIdentifier.getPortIdentifiers();
        ArrayList<String> portNameList = new ArrayList<>();
        /**
         *  将可用串口名添加到 List 列表
         */
        while (portList.hasMoreElements()) {
            String portName = portList.nextElement().getName();//名称如 COM1、COM2....
            portNameList.add(portName);
        }
        return portNameList;
    }
    /**
     * 打开电脑上指定的串口
     *
     * @param portName 端口名称，如 COM1，为 null 时，默认使用电脑中能用的端口中的第一个
     * @param b        波特率(baudrate)，如 9600
     * @param d        数据位（datebits），如 SerialPort.DATABITS_8 = 8
     * @param s        停止位（stopbits），如 SerialPort.STOPBITS_1 = 1
     * @param p        校验位 (parity)，如 SerialPort.PARITY_NONE = 0
     * @return 打开的串口对象，打开失败时，返回 null
     */
    public static final SerialPort openComPort(String portName, int b, int d, int s, int p) {
        CommPort commPort = null;
        try {
            //当没有传入可用的 com 口时，默认使用电脑中可用的 com 口中的第一个
//            if (portName == null || "".equals(portName)) {
//                List<String> comPortList = findSystemAllComPort();
//                if (comPortList != null && comPortList.size() > 0) {
//                    portName = comPortList.get(0);
//                }
//            }
            logger.info("开始打开串口：portName=" + portName + ",baudrate=" + b + ",datebits=" + d + ",stopbits=" + s + ",parity=" + p);
            //通过端口名称识别指定 COM 端口
            CommPortIdentifier portIdentifier = CommPortIdentifier.getPortIdentifier(portName);
            /**
             * open(String TheOwner, int i)：打开端口
             * TheOwner 自定义一个端口名称，随便自定义即可
             * i：打开的端口的超时时间，单位毫秒，超时则抛出异常：PortInUseException if in use.
             * 如果此时串口已经被占用，则抛出异常：gnu.io.PortInUseException: Unknown Application
             */
            commPort = portIdentifier.open(portName, 5000);
            /**
             * 判断端口是不是串口
             * public abstract class SerialPort extends CommPort
             */
            if (commPort instanceof SerialPort) {
                SerialPort serialPort = (SerialPort) commPort;
                /**
                 * 设置串口参数：setSerialPortParams( int b, int d, int s, int p )
                 * b：波特率（baudrate）
                 * d：数据位（datebits），SerialPort 支持 5,6,7,8
                 * s：停止位（stopbits），SerialPort 支持 1,2,3
                 * p：校验位 (parity)，SerialPort 支持 0,1,2,3,4
                 * 如果参数设置错误，则抛出异常：gnu.io.UnsupportedCommOperationException: Invalid Parameter
                 * 此时必须关闭串口，否则下次 portIdentifier.open 时会打不开串口，因为已经被占用
                 */
                serialPort.setSerialPortParams(b, d, s, p);
                logger.info("打开串口 " + portName + " 成功...");
                return serialPort;
            } else {
                logger.error("当前端口 " + commPort.getName() + " 不是串口...");
                return null;
            }
        } catch (NoSuchPortException e) {
            e.printStackTrace();
        } catch (PortInUseException e) {
            logger.warn("串口 " + portName + " 已经被占用，请先解除占用...");
            e.printStackTrace();
        } catch (UnsupportedCommOperationException e) {
            logger.warn("串口参数设置错误，关闭串口，数据位[5-8]、停止位[1-3]、验证位[0-4]...");
            e.printStackTrace();
            if (commPort != null) {//此时必须关闭串口，否则下次 portIdentifier.open 时会打不开串口，因为已经被占用
                commPort.close();
            }
        }
        logger.error("打开串口 " + portName + " 失败...");
        return null;
    }
    /**
     * 往串口发送数据
     *
     * @param serialPort 串口对象
     * @param orders     待发送数据
     * @return
     */
    public static String sendDataToComPort(SerialPort serialPort, byte[] orders) {
        OutputStream outputStream = null;
        try {
            if (serialPort != null) {
                outputStream = serialPort.getOutputStream();
                outputStream.write(orders);
                outputStream.flush();
                logger.info("往串口 " + serialPort.getName() + " 发送数据：" + Arrays.toString(orders) + " 完成");
                return "往串口 " + serialPort.getName() + " 发送数据：" + Arrays.toString(orders) + " 完成";
            } else {
                logger.error("gnu.io.SerialPort 为null，取消数据发送...");
                return "串口为空，取消数据发送";
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (outputStream != null) {
                try {
                    outputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return null;
    }
    /**
     * 向串口发送数据
     */
    public static String sendDataToPort(SerialPort serialPort, byte[] data) {
        OutputStream outputStream = null;
        try {
            if (serialPort != null) {
                outputStream = serialPort.getOutputStream();
                outputStream.write(data);
                outputStream.flush();
                logger.info("Successfully sent data to serial port " + serialPort.getName() + ": " + Arrays.toString(data));
                return "Successfully sent data to serial port " + serialPort.getName();
            } else {
                logger.error("Failed to send data to serial port: serial port is null");
                return null;
            }
        } catch (IOException e) {
            logger.error("Failed to send data to serial port " + serialPort.getName() + ": " + e.getMessage());
        } finally {
            if (outputStream != null) {
                try {
                    outputStream.close();
                } catch (IOException e) {
                    logger.error("Failed to close output stream for serial port " + serialPort.getName() + ": " + e.getMessage());
                }
            }
        }
        return null;
    }
    /**
     * 从串口获取数据
     */
    public static byte[] getDataFromPort(SerialPort serialPort) {
        InputStream inputStream = null;
        byte[] data = null;
        try {
            if (serialPort != null) {
                inputStream = serialPort.getInputStream();
                // 等待数据接收完成
                Thread.sleep(500);
                // 获取可读取的字节数
                int availableBytes = inputStream.available();
                if (availableBytes > 0) {
                    data = new byte[availableBytes];
                    int readBytes = inputStream.read(data);
                    logger.info("从串口 " + serialPort.getName() + " 接收到数据：" + Arrays.toString(data) + " 完成...");
                } else {
                    logger.warn("从串口 " + serialPort.getName() + " 接收到空数据...");
                }
            } else {
                logger.error("gnu.io.SerialPort 为null，取消数据接收...");
            }
        } catch (IOException | InterruptedException e) {
            e.printStackTrace();
        } finally {
            if (inputStream != null) {
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return data;
    }
    /**
     * 关闭串口
     *
     * @param serialPort 待关闭的串口对象
     */
    public static void closeSerialPort(SerialPort serialPort) {
        if (serialPort != null) {
            serialPort.close();
            logger.info("Successfully closed serial port " + serialPort.getName());
        } else {
            logger.error("Failed to close serial port: serial port is null");
        }
    }
    /**
     * 16进制字符串转十进制字节数组
     * 这是常用的方法，如某些硬件的通信指令就是提供的16进制字符串，发送时需要转为字节数组再进行发送
     *
     * @param strSource 16进制字符串，如 "455A432F5600"，每两位对应字节数组中的一个10进制元素
     *                  默认会去除参数字符串中的空格，所以参数 "45 5A 43 2F 56 00" 也是可以的
     * @return 十进制字节数组, 如 [69, 90, 67, 47, 86, 0]
     */
    public static byte[] hexString2Bytes(String strSource) {
        if (strSource == null || "".equals(strSource.trim())) {
            System.out.println("hexString2Bytes 参数为空，放弃转换.");
            return null;
        }
        strSource = strSource.replace(" ", "");
        int l = strSource.length() / 2;
        byte[] ret = new byte[l];
        for (int i = 0; i < l; i++) {
            ret[i] = Integer.valueOf(strSource.substring(i * 2, i * 2 + 2), 16).byteValue();
        }
        return ret;
    }
    /**
     * 给串口设置监听
     */
    public static void setListenerToSerialPort(SerialPort serialPort, SerialPortEventListener listener) throws TooManyListenersException {
//        serialPort.removeEventListener();
        //给串口添加事件监听
        serialPort.addEventListener(listener);
        //串口有数据监听
        serialPort.notifyOnDataAvailable(true);
        //中断事件监听
        serialPort.notifyOnBreakInterrupt(true);
    }
}

Controller层

@Slf4j
@RestController
@RequestMapping("/remote/remote")
public class RemoteController {
    @Autowired
    private IRemoteService remoteService;
    /**
     * 打开串口
     */
    @GetMapping("/open")
    public AjaxResult openSerialPort(@RequestParam() String port) {
        String portName = "COM" + port;
        try {
            SerialPort serialPort = remoteService.openSerialPort(portName);
            if (serialPort == null) {
                return AjaxResult.error("打开串口失败");
            }
            return AjaxResult.success("打开串口成功");
        } catch (Exception e) {
            return AjaxResult.error("打开串口失败: " + e.getMessage());
        }
    }
    /**
     * 向串口发送数据
     */
    @GetMapping("/send")
    public AjaxResult sendDataToPort(@RequestParam() String data, @RequestParam() String port) throws TooManyListenersException, UnsupportedCommOperationException, NoSuchPortException, PortInUseException {
        String portName = "COM" + port;
        try {
            String result = remoteService.sendDataToPort(data, portName);
            if (result != null) {
                return AjaxResult.success("发送数据成功");
            } else {
                return AjaxResult.error("发送数据失败");
            }
        } catch (Exception e) {
            return AjaxResult.error("发送数据失败: " + e.getMessage());
        }
    }
    /**
     * 从串口接收数据
     */
    @GetMapping("/receive")
    public AjaxResult receiveDataFromPort(@RequestParam() String port) {
        String portName = "COM" + port;
        try {
            String data = remoteService.receiveDataFromPort(portName);
            return AjaxResult.success(data);
        } catch (Exception e) {
            return AjaxResult.error("接收串口数据失败: " + e.getMessage());
        }
    }
    /**
     * 关闭串口
     */
    @GetMapping("/close")
    public AjaxResult closeSerialPort(@RequestParam() String port) {
        String portName = "COM" + port;
        try {
            remoteService.closeSerialPort(portName);
            return AjaxResult.success("关闭串口成功");
        } catch (Exception e) {
            return AjaxResult.warn(e.getMessage());
        }
    }
}

MySerialPortEventListener

package com.ruoyi.remote.burn;
import gnu.io.SerialPort;
import gnu.io.SerialPortEvent;
import gnu.io.SerialPortEventListener;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.TooManyListenersException;
/**
 * 串口监听器
 *
 * @author Yeats
 */
public class MySerialPortEventListener implements SerialPortEventListener {
    private String latestData = "";
    private SerialPort serialPort;
    private int eventType;
    private static final Logger logger = LoggerFactory.getLogger(SerialPortTool.class);//slf4j 日志记录器
    /**
     * 构造串口监听器
     *
     * @param serialPort
     * @param eventType
     * @throws TooManyListenersException
     */
    public MySerialPortEventListener(SerialPort serialPort, int eventType) throws TooManyListenersException {
        this.serialPort = serialPort;
        this.eventType = eventType;
        //给串口添加事件监听
        serialPort.addEventListener(this);
        //串口有数据监听
        serialPort.notifyOnDataAvailable(true);
        //中断事件监听
        serialPort.notifyOnBreakInterrupt(true);
    }
    /**
     * 串口监听事件
     *
     * @param arg0
     * @throws TooManyListenersException
     */
    @Override
    public void serialEvent(SerialPortEvent arg0) {
        if (arg0.getEventType() == SerialPortEvent.DATA_AVAILABLE) {
            // 数据通知
            byte[] bytes = SerialPortTool.getDataFromPort(serialPort);
            String str = new String(bytes);
            latestData = str;
            eventType = arg0.getEventType(); // 将事件类型赋值给eventType
            logger.info("收到的数据长度：" + bytes.length);
            logger.info("收到的数据：" + str);
        }
    }
    /**
     * 获取最新数据
     *
     * @return 最新数据
     */
    public String getData() {
        if (latestData != null) {
            // 清空最新数据，避免重复获取
            String data = " " + latestData;
            latestData = null;
            return data;
        } else {
            return "";
        }
    }
    /**
     * 获取串口对象
     *
     * @return 串口对象
     */
    public SerialPort getSerialPort() {
        return serialPort;
    }
}

impl

@Service
public class RemoteServiceImpl implements IRemoteService {
    private static final Logger logger = LoggerFactory.getLogger(SerialPortTool.class);//slf4j 日志记录器
    /**
     * 查找电脑上所有可用 com 端口
     *
     * @return 可用端口名称列表，没有时 列表为空
     */
    public static final ArrayList<String> findSystemAllComPort() {
        /**
         *  getPortIdentifiers：获得电脑主板当前所有可用串口
         */
        Enumeration<CommPortIdentifier> portList = CommPortIdentifier.getPortIdentifiers();
        ArrayList<String> portNameList = new ArrayList<>();
        /**
         *  将可用串口名添加到 List 列表
         */
        while (portList.hasMoreElements()) {
            String portName = portList.nextElement().getName();//名称如 COM1、COM2....
            portNameList.add(portName);
        }
        return portNameList;
    }
    
  private Map<String, MySerialPortEventListener> listenerMap = new HashMap<>();
    /**
     * 打开串口
     */
    @Override
    public SerialPort openSerialPort(String portName) {
        SerialPort serialPort = SerialPortTool.openComPort(portName, 9600, 8, 1, 0);
        if (serialPort == null) {
            throw new RuntimeException("打开串口 " + portName + " 失败");
        }
        // 创建新线程来处理串口的打开操作
        Thread thread = new Thread(() -> {
            try {
                MySerialPortEventListener listener = new MySerialPortEventListener(serialPort, 1);
                listenerMap.put(portName, listener);
            } catch (TooManyListenersException e) {
                e.printStackTrace();
            }
        });
        thread.start();
        return serialPort;
    }
    /**
     * 向串口发送数据
     */
    @Override
    public String sendDataToPort(String senData, String portName) {
        MySerialPortEventListener listener = listenerMap.get(portName);
        if (listener != null) {
            return SerialPortTool.sendDataToPort(listener.getSerialPort(), senData.getBytes());
        } else {
            throw new RuntimeException("发送串口失败，未找到该串口");
        }
    }
    /**
     * 从串口接收数据
     */
    @Override
    public String receiveDataFromPort(String portName) throws RuntimeException {
        MySerialPortEventListener listener = listenerMap.get(portName);
        if (listener != null) {
            return listener.getData();
        } else {
            return "";
        }
    }
    /**
     * 关闭串口
     */
    @Override
    public void closeSerialPort(String portName) throws RuntimeException {
        MySerialPortEventListener listener = listenerMap.get(portName);
        if (listener != null) {
            SerialPortTool.closeSerialPort(listener.getSerialPort());
            listenerMap.remove(portName);
        } else {
            throw new RuntimeException("当前串口已关闭");
        }
    }
}
import gnu.io.SerialPort;
public interface IRemoteService {
    /**
     * 打开串口
     */
    public SerialPort openSerialPort(String portName);
    /**
     * 向串口发送数据
     */
    public String sendDataToPort(String senData, String portName);
    /**
     * 从串口接收数据
     */
    public String receiveDataFromPort(String portName);
    /**
     * 关闭串口
     */
    public void closeSerialPort(String portName);
}

前端Api

// 发送数据到串口
export function sendDataToPort(data) {
  return request({
    url: '/remote/remote/send',
    method: 'get',
    params: data,
  })
}
// 接收数据从串口
export function receiveDataFromPort(data) {
  return request({
    url: '/remote/remote/receive',
    method: 'get',
    params: data,
  })
}
// 打开串口
export function openSerialPort(data) {
  return request({
    url: '/remote/remote/open',
    method: 'get',
    params: data,
  })
}
// 关闭串口
export function closeSerialPort(data) {
  return request({
    url: '/remote/remote/close',
    method: 'get',
    params: data,
  })
}

vue前端

data() {
        return {
            sendDataString: "",
            receivedDataString: "",
            timerId: null,
        };
    },
 methods: {
        // 在openSerialPort方法中调用后端接口
        openSerialPort() {
            let serialPort = {
                port: this.port51
            };
            // 调用后端接口打开串口
            openSerialPort(serialPort).then((response) => {
                // 如果成功打开串口，则开启定时器
                if (response.code == 200) {
                    this.$message.success(response.msg);
                    this.startTimer();
                } else {
                    this.$message.error(response.msg);
                }
            });
        },
        // 关闭串口
        closeSerialPort() {
            let serialPort = {
                port: this.port51
            };
            this.stopTimer();
            closeSerialPort(serialPort).then((response) => {
                if (response.code == 200) {
                    this.sendDataString = "";
                    this.receivedDataString = "";
                    this.$message.success(response.msg);
                } else {
                    this.$message.error(response.msg);
                }
            });
        },
        
        // 清空接收数据
        clearReceive() {
            this.receivedDataString = "";
        },
        
        // 发送数据
        sendDataToPort() {
            this.isSending = true;
            if (!this.sendDataString || this.sendDataString.trim().length === 0) {
                this.$message.warning("发送数据不能为空");
                this.isSending = false;
            } else {
                let serialPort = {
                    data: this.sendDataString,
                    port: this.port51
                };
                sendDataToPort(serialPort).then((response) => {
                    if (response.code == 200) {
                        this.isSending = false;
                        this.$message.success(response.msg);
                    } else {
                        this.isSending = false;
                        this.$message.error(response.msg);
                    }
                });
            }
        },
        // 定义一个函数，用于开启定时器
        startTimer() {
            // 如果定时器已经开启，则直接返回
            if (this.timerId) {
                return;
            }
            let serialPort = {
                port: this.port51
            };
            // 开启定时器，每隔100毫秒请求一次数据
            this.timerId = setInterval(() => {
                receiveDataFromPort(serialPort).then((response) => {
                    if (response.code == 200) {
                        // 将接收到的数据存储到全局变量中
                        this.receivedDataString += response.msg;
                        this.isOpenPort = true;
                        this.isOpening = false;
                    } else {
                        this.$message.error(response.msg);
                    }
                });
            }, 1000);
        },
        // 定义一个函数，用于停止定时器
        stopTimer() {
            // 如果定时器已经停止，则直接返回
            if (!this.timerId) {
                return;
            }
            clearInterval(this.timerId);
            this.timerId = null;
        },
        // 在beforeDestroy生命周期钩子中清除定时器
        beforeDestroy() {
            this.closeSerialPort();
        },
    },


文章标签：
云数据库 Tair（兼容 Redis）
日志服务
Java
前端开发
JavaScript
缓存
存储
关键词：
Java技术
Java线程
Java优化
库线程
Java线程优化
相关实践学习
基于Redis实现在线游戏积分排行榜
本场景将介绍如何基于Redis数据库实现在线游戏中的游戏玩家积分排行榜功能。
云数据库 Redis 版使用教程
云数据库Redis版是兼容Redis协议标准的、提供持久化的内存数据库服务，基于高可靠双机热备架构及可无缝扩展的集群架构，满足高读写性能场景及容量需弹性变配的业务需求。 产品详情：https://www.aliyun.com/product/kvstore &nbsp; &nbsp; ------------------------------------------------------------------------- 阿里云数据库体验：数据库上云实战 开发者云会免费提供一台带自建MySQL的源数据库&nbsp;ECS 实例和一台目标数据库&nbsp;RDS实例。跟着指引，您可以一步步实现将ECS自建数据库迁移到目标数据库RDS。 点击下方链接，领取免费ECS&amp;RDS资源，30分钟完成数据库上云实战！https://developer.aliyun.com/adc/scenario/51eefbd1894e42f6bb9acacadd3f9121?spm=a2c6h.13788135.J_3257954370.9.4ba85f24utseFl
Yeats_Liao
目录
相关文章
小白学大数据
|
15天前
|
数据采集 Java API
Jsoup库能处理多线程下载吗？
Jsoup库能处理多线程下载吗？
小白学大数据
25 0
Java开发者
|
25天前
|
存储 缓存 安全
java 中操作字符串都有哪些类，它们之间有什么区别
Java中操作字符串的类主要有String、StringBuilder和StringBuffer。String是不可变的，每次操作都会生成新对象；StringBuilder和StringBuffer都是可变的，但StringBuilder是非线程安全的，而StringBuffer是线程安全的，因此性能略低。
Java开发者
44 8
dufadayang
|
25天前
|
Java 开发者
在 Java 中，一个类可以实现多个接口吗？
这是 Java 面向对象编程的一个重要特性，它提供了极大的灵活性和扩展性。
dufadayang
53 1
Naylor
|
1月前
|
存储 安全 Java
java.util的Collections类
Collections 类位于 java.util 包下，提供了许多有用的对象和方法，来简化java中集合的创建、处理和多线程管理。掌握此类将非常有助于提升开发效率和维护代码的简洁性，同时对于程序的稳定性和安全性有大有帮助。
Naylor
62 17
2G冲浪词条
|
1月前
|
安全 Java
Java多线程集合类
本文介绍了Java中线程安全的问题及解决方案。通过示例代码展示了使用`CopyOnWriteArrayList`、`CopyOnWriteArraySet`和`ConcurrentHashMap`来解决多线程环境下集合操作的线程安全问题。这些类通过不同的机制确保了线程安全，提高了并发性能。
2G冲浪词条
38 1
软件求生
|
1月前
|
存储 Java 程序员
Java基础的灵魂——Object类方法详解（社招面试不踩坑）
本文介绍了Java中`Object`类的几个重要方法，包括`toString`、`equals`、`hashCode`、`finalize`、`clone`、`getClass`、`notify`和`wait`。这些方法是面试中的常考点，掌握它们有助于理解Java对象的行为和实现多线程编程。作者通过具体示例和应用场景，详细解析了每个方法的作用和重写技巧，帮助读者更好地应对面试和技术开发。
软件求生
112 4
众所周知
|
1月前
|
Java 编译器 开发者
Java异常处理的最佳实践，涵盖理解异常类体系、选择合适的异常类型、提供详细异常信息、合理使用try-catch和finally语句、使用try-with-resources、记录异常信息等方面
本文探讨了Java异常处理的最佳实践，涵盖理解异常类体系、选择合适的异常类型、提供详细异常信息、合理使用try-catch和finally语句、使用try-with-resources、记录异常信息等方面，帮助开发者提高代码质量和程序的健壮性。
众所周知
57 2
Java开发者
|
1月前
|
存储 安全 Java
如何保证 Java 类文件的安全性？
Java类文件的安全性可以通过多种方式保障，如使用数字签名验证类文件的完整性和来源，利用安全管理器和安全策略限制类文件的权限，以及通过加密技术保护类文件在传输过程中的安全。
Java开发者
50 4
叫做饺子
|
1月前
|
存储 Java 编译器
java wrapper是什么类
【10月更文挑战第16天】
叫做饺子
41 3
听白
|
1月前
|
Java Android开发
Eclipse 创建 Java 类
Eclipse 创建 Java 类
听白
26 0

热门文章

最新文章

  • 1
    线程状态&&Wait和sleep的区别？
  • 2
    ConcurrentDictionary线程不安全么
  • 3
    threading多线程总结
  • 4
    java中线程存活和线程执行的问题！
  • 5
    object-c 多线程 加锁
  • 6
    多线程锁sync+lock使用，@Async使用
  • 7
    明述java中线程(thread)的使用(1)
  • 8
    线程的优先级
  • 9
    线程基础知识系列(二）线程的管理
  • 10
    c#多线程 Invoke方法的使用
  • 1
    【Java开发指南 | 第三十一篇】Java 包(package)
    71
  • 2
    【Java开发指南 | 第二十九篇】Java接口
    46
  • 3
    【Java开发指南 | 第二十八篇】Java封装
    53
  • 4
    【Java开发指南 | 第二十六篇】Java多态
    40
  • 5
    【Java开发指南 | 第二十四篇】Java继承
    58
  • 6
    【Java开发指南 | 第九篇】访问实例变量和方法、继承、接口
    53
  • 7
    【Java开发指南 | 第八篇】Java变量、构造方法、创建对象
    91
  • 8
    Java Stream API详解与使用
    93
  • 9
    Java医院绩效考核系统源码B/S+avue+MySQL助力医院实现精细化管理
    79
  • 10
    《手把手教你》系列技巧篇（四十三）-java+ selenium自动化测试-处理https 安全问题或者非信任站点-上篇（详解教程）
    131

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Alibaba Dragonwell 基于Anolis OS的企业级Java应用规模化实践
  • Java开发手册（嵩山版）灵魂17问
  • 多IO线程优化版

    • 相关实验场景

    更多
  • 阿里云平台上进行Java程序的编译与运行
  • 使用Java面向对象编写网络通信程序应用
  • Python网络通信程序典型应用
  • 手动部署Java Web环境（Alibaba Cloud Linux 2）
  • 搭建Java Web开发环境（Anolis OS）
  • RocketMQ中使用Java客户端发送消息和消费的应用
    • 下一篇
    阿里云oss存储简介和如何使用