java串口通信详细教程（附源码）

介绍

java串口通信其实很早就有用到，最近是项目的新需求才让我发现这玩意，搞的我还挺费劲的，不过还好捣鼓出来了；java中的串口通信主要还是跟SerialPort类打交道，引入的jar包是RXTXComm.jar，这是从Comm.jar里面扩展出去的；当然这是有原因的，因为之前的只适用于32位的，由于新的需求才诞生的。

实战

首先我们需要下载jar包及其dll文件（必须要有）这个具体我也不大清除哈，我是看了很多都是要弄这个的，我也没太去深究这个，下载RXTXComm.jar地址（提取码：gwpc）

下载之后将RXTXcomm.jar包放置C:\Program Files\Java\jre1.8.0_181\lib\ext\ 目录下，rxtxParallel.dll和rxtxSerial.dll放置C:\Program Files\Java\jre1.8.0_181\bin 目录下。

安装串口驱动：串口驱动地址（提取码：8j5w）

接下来开始编写代码：

创建工具类并实现SerialPortEventListener接口

import gnu.io.*;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import java.util.TooManyListenersException;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

import org.apache.tomcat.util.buf.HexUtils;

public class ContinueRead extends Thread implements SerialPortEventListener {


    static CommPortIdentifier portId; // 串口通信管理类
    static Enumeration<?> portList; // 有效连接上的端口的枚举
    static InputStream inputStream; // 从串口来的输入流
    static OutputStream outputStream;// 向串口输出的流
    static SerialPort serialPort; // 串口的引用
    // 堵塞队列用来存放读到的数据
    private BlockingQueue<String> msgQueue = new LinkedBlockingQueue<String>();
    public static Map<Integer, String> map = new HashMap<Integer, String>();

    @Override
    /**
     * SerialPort EventListene 的方法,持续监听端口上是否有数据流
     */
    public void serialEvent(SerialPortEvent event) {//

        switch (event.getEventType()) {
            case SerialPortEvent.BI:
            case SerialPortEvent.OE:
            case SerialPortEvent.FE:
            case SerialPortEvent.PE:
            case SerialPortEvent.CD:
            case SerialPortEvent.CTS:
            case SerialPortEvent.DSR:
            case SerialPortEvent.RI:
            case SerialPortEvent.OUTPUT_BUFFER_EMPTY:
                break;
            case SerialPortEvent.DATA_AVAILABLE:// 当有可用数据时读取数据
                byte[] readBuffer = new byte[20];
                try {
                    int numBytes = -1;
                    while (inputStream.available() > 0) {
                        numBytes = inputStream.read(readBuffer);

                        if (numBytes > 0) {
                            msgQueue.add(HexUtils.toHexString(readBuffer).substring(0, 2));
                            readBuffer = new byte[20];// 重新构造缓冲对象，否则有可能会影响接下来接收的数据
                        } else {
                            msgQueue.add("额------没有读到数据");
                        }
                    }
                } catch (IOException e) {
                }
                break;
        }
    }

    /**
     * 通过程序打开COM3串口，设置监听器以及相关的参数
     *
     * @return 返回1 表示端口打开成功，返回 0表示端口打开失败
     */
    public int startComPort() {
        // 通过串口通信管理类获得当前连接上的串口列表
        portList = CommPortIdentifier.getPortIdentifiers();

        while (portList.hasMoreElements()) {

            // 获取相应串口对象
            portId = (CommPortIdentifier) portList.nextElement();

            System.out.println("设备类型：--->" + portId.getPortType());
            System.out.println("设备名称：---->" + portId.getName());
            // 判断端口类型是否为串口
            if (portId.getPortType() == CommPortIdentifier.PORT_SERIAL) {
                // 判断如果COM4串口存在，就打开该串口
                if (portId.getName().equals("COM3")) {
                    try {
                        // 打开串口名字为COM_3(名字任意),延迟为2毫秒
                        serialPort = (SerialPort) portId.open("COM3", 2000);

                    } catch (PortInUseException e) {
                        e.printStackTrace();
                        return 0;
                    }
                    // 设置当前串口的输入输出流
                    try {
                        inputStream = serialPort.getInputStream();
                        outputStream = serialPort.getOutputStream();
                    } catch (IOException e) {
                        e.printStackTrace();
                        return 0;
                    }
                    // 给当前串口添加一个监听器
                    try {
                        serialPort.addEventListener(this);
                    } catch (TooManyListenersException e) {
                        e.printStackTrace();
                        return 0;
                    }
                    // 设置监听器生效，即：当有数据时通知
                    serialPort.notifyOnDataAvailable(true);

                    // 设置串口的一些读写参数
                    try {
                        // 比特率、数据位、停止位、奇偶校验位
                        serialPort.setSerialPortParams(9600,
                                SerialPort.DATABITS_8, SerialPort.STOPBITS_1,
                                SerialPort.PARITY_NONE);
                    } catch (UnsupportedCommOperationException e) {
                        e.printStackTrace();
                        return 0;
                    }

                    return 1;
                }
            }
        }
        return 0;
    }

    /**
     * 关闭串口
     *
     * @throws
     * @Description: 关闭串口
     * @param:
     * @return: void
     */
    public static void closeSerialPort() {
        if (serialPort != null) {
            serialPort.notifyOnDataAvailable(false);
            serialPort.removeEventListener();
            if (inputStream != null) {
                try {
                    inputStream.close();
                    inputStream = null;
                } catch (IOException e) {
                    System.out.println("关闭输入流时发生IO异常");
                }
            }
            if (outputStream != null) {
                try {
                    outputStream.close();
                    outputStream = null;
                } catch (IOException e) {
                    System.out.println("关闭输出流时发生IO异常");
                }
            }
            serialPort.close();
            serialPort = null;
        }
    }


    @Override
    public void run() {
        // TODO Auto-generated method stub
        try {
            System.out.println("--------------任务处理线程运行了--------------");
            while (true) {
                // 如果堵塞队列中存在数据就将其输出
                if (msgQueue.size() > 0) {
                    String tempStr = msgQueue.take();
                    System.out.println(tempStr);
                    map.put(Integer.valueOf(tempStr.substring(0, 1)), tempStr.substring(1, 2));
                }
            }
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

测试：

public static void main(String[] args) {
        ContinueRead cRead = new ContinueRead();
        int i = cRead.startComPort();
        if (i == 1) {
            // 启动线程来处理收到的数据
            cRead.start();
            try {
                String st = "start";
                System.out.println("发出字节数：" + st.getBytes("gbk").length);
                outputStream.write(st.getBytes("gbk"), 0, st.getBytes("gbk").length);
                System.out.println("成员变量大小：" + map.size());
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }

报错了，为什么因为你的电脑找不到它，所以还需要将rxtxSerial.dll放置C:\Windows\System32目录下，然后就ok了。

附上CommPortIdentifier类的一些方法（网上找的）：

     addPortName(String, int, CommDriver) —添加端口名到端口列表里 
     addPortOwnershipListener(CommPortOwnershipListener) —添加端口拥有的监听器 
     removePortOwnershipListener(CommPortOwnershipListener) —移除端口拥有的监听器 
     getCurrentOwner() —得到当前占有端口的对象或应用程序 
     getName()— 得到端口名称 
     getPortIdentifier(CommPort) —得到参数打开的端口的CommPortIdentifier类型对象 
     getPortIdentifier(String) —得到以参数命名的端口的CommPortIdentifier类型对象 
     getPortIdentifiers() —得到系统中的端口列表 
     getPortType() —得到端口的类型 
     isCurrentlyOwned() —判断当前端口是否被占用 
     open(FileDescriptor) —用文件描述的类型打开端口 
     open(String, int) —打开端口,两个参数：程序名称,延迟时间(毫秒数) 

今天的文章java串口通信详细教程（附源码）分享到此就结束了，感谢您的阅读，如果确实帮到您，您可以动动手指转发给其他人。