Java實現ModbusTCP通信

原創 行思坐忆，志凌云 2020-02-20 13:15

一個項目，需要用Java實現使用ModbusTCP和硬件設備通信

資料

代碼下載

官網資料

關於Java的開源庫

  • Jamod：Java Modbus實現：Java Modbus庫。該庫由Dieter Wimberger實施。
  • ModbusPal：ModbusPal是一個正在進行的Java項目，用於創建逼真的Modbus從站模擬器。由於預定義的數學函數和/或Python腳本，寄存器值是動態生成的。ModbusPal依賴於RxTx進行串行通信，而Jython則依賴於腳本支持。
  • Modbus4J：Serotonin Software用Java編寫的Modbus協議的高性能且易於使用的實現。支持ASCII，RTU，TCP和UDP傳輸作爲從站或主站，自動請求分區，響應數據類型解析和節點掃描。
  • JLibModbus：JLibModbus是java語言中Modbus協議的一種實現。jSSC和RXTX用於通過串行端口進行通信。該庫是一個經過積極測試和改進的項目。

博客資料

Github資料

ModbusTCP協議

Modbus由MODICON公司於1979年開發，是一種工業現場總線協議標準。1996年施耐德公司推出基於以太網TCP/IP的Modbus協議：ModbusTCP。

Modbus協議是一項應用層報文傳輸協議，包括ASCII、RTU、TCP三種報文類型。

標準的Modbus協議物理層接口有RS232、RS422、RS485和以太網接口，採用master/slave方式通信。

個人感覺：

modbus協議也是對地址變量進行讀取或者寫入操作，變化的可能是地址變量的地址和數據類型。
這個功能碼（指定要做什麼，指定存儲器，然後指定動作：是讀啊，是寫啊，還是對多個一起操作啊）

Modbus和RS485的關係：Modbus是協議，物理層接口有RS232、RS422、RS485和以太網接口幾種

仿真軟件

驗證4個常用功能碼，仿真軟件上面有F=01，F=02，F=03和F=04來顯示

  • 0x01：讀線圈
  • 0x02：讀離散量輸入
  • 0x03：讀保持寄存器
  • 0x04：讀輸入寄存器

對應的代碼要寫4個方法

我要寫一個Master(主站)，所以需要一個Slave(從站)

  • Modbus Slave下載
  • 安裝：一直下一步
  • 激活碼：5455415451475662（來源）
  • 激活：Connection-->connect...（F3），輸入激活碼，下面截圖沒輸入激活碼，因爲當時沒找到激活碼

選擇TCP模式，端口是固定的502

地址類型

F8：

Slave Definition

功能碼

數據類型

功能碼01

功能碼02

功能碼03，選擇Float類型

雙擊第一個地址輸入數據，會提示輸入數據的類型，32位數據佔2個地址，所以下一個地址是--

功能碼04

使用jlibmodbus

特別有意思：常用的串口通信庫都加進去了

maven依賴

<dependency>
<groupId>com.intelligt.modbus</groupId>
<artifactId>jlibmodbus</artifactId>
<version>1.2.9.7</version>
</dependency>

測試功能碼04

package com.tcb.jlibmodbus;

import java.net.InetAddress;

import com.intelligt.modbus.jlibmodbus.Modbus;
import com.intelligt.modbus.jlibmodbus.exception.ModbusIOException;
import com.intelligt.modbus.jlibmodbus.exception.ModbusNumberException;
import com.intelligt.modbus.jlibmodbus.exception.ModbusProtocolException;
import com.intelligt.modbus.jlibmodbus.master.ModbusMaster;
import com.intelligt.modbus.jlibmodbus.master.ModbusMasterFactory;
import com.intelligt.modbus.jlibmodbus.tcp.TcpParameters;

/**

  • Hello world!

*/
public class App {
public static void main(String[] args) {
try {
// 設置主機TCP參數
TcpParameters tcpParameters = new TcpParameters();

        <span class="hljs-comment">// 設置TCP的ip地址</span>
        InetAddress adress = InetAddress.getByName(<span class="hljs-string">"127.0.0.1"</span>);

        <span class="hljs-comment">// TCP參數設置ip地址</span>
        <span class="hljs-comment">// tcpParameters.setHost(InetAddress.getLocalHost());</span>
        tcpParameters.setHost(adress);

        <span class="hljs-comment">// TCP設置長連接</span>
        tcpParameters.setKeepAlive(<span class="hljs-keyword">true</span>);
        <span class="hljs-comment">// TCP設置端口，這裏設置是默認端口502</span>
        tcpParameters.setPort(Modbus.TCP_PORT);

        <span class="hljs-comment">// 創建一個主機</span>
        ModbusMaster master = ModbusMasterFactory.createModbusMasterTCP(tcpParameters);
        Modbus.setAutoIncrementTransactionId(<span class="hljs-keyword">true</span>);

        <span class="hljs-keyword">int</span> slaveId = <span class="hljs-number">1</span>;<span class="hljs-comment">//從機地址</span>
        <span class="hljs-keyword">int</span> offset = <span class="hljs-number">0</span>;<span class="hljs-comment">//寄存器讀取開始地址</span>
        <span class="hljs-keyword">int</span> quantity = <span class="hljs-number">10</span>;<span class="hljs-comment">//讀取的寄存器數量</span>


        <span class="hljs-keyword">try</span> {
            <span class="hljs-keyword">if</span> (!master.isConnected()) {
                master.connect();<span class="hljs-comment">// 開啓連接</span>
            }

            <span class="hljs-comment">// 讀取對應從機的數據，readInputRegisters讀取的寫寄存器，功能碼04</span>
            <span class="hljs-keyword">int</span>[] registerValues = master.readInputRegisters(slaveId, offset, quantity);

            <span class="hljs-comment">// 控制檯輸出</span>
            <span class="hljs-keyword">for</span> (<span class="hljs-keyword">int</span> value : registerValues) {
                System.out.println(<span class="hljs-string">"Address: "</span> + offset++ + <span class="hljs-string">", Value: "</span> + value);
            }

        } <span class="hljs-keyword">catch</span> (ModbusProtocolException e) {
            e.printStackTrace();
        } <span class="hljs-keyword">catch</span> (ModbusNumberException e) {
            e.printStackTrace();
        } <span class="hljs-keyword">catch</span> (ModbusIOException e) {
            e.printStackTrace();
        } <span class="hljs-keyword">finally</span> {
            <span class="hljs-keyword">try</span> {
                master.disconnect();
            } <span class="hljs-keyword">catch</span> (ModbusIOException e) {
                e.printStackTrace();
            }
        }
    } <span class="hljs-keyword">catch</span> (RuntimeException e) {
        <span class="hljs-keyword">throw</span> e;
    } <span class="hljs-keyword">catch</span> (Exception e) {
        e.printStackTrace();
    }
}

}

打印到控制檯的信息

Address: 0, Value: 88
Address: 1, Value: 66
Address: 2, Value: 8
Address: 3, Value: 6
Address: 4, Value: 32727
Address: 5, Value: 32808
Address: 6, Value: 0
Address: 7, Value: 3
Address: 8, Value: 2
Address: 9, Value: 1

使用modbus4j

maven依賴

  • 官方說明：https://github.com/infiniteautomation/modbus4j
  • 有個坑：Maven配的阿里雲倉庫，下載不下來，註釋掉阿里雲倉庫使用默認倉庫才能下載好。

pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

<groupId>com.tcb</groupId>
<artifactId>modbus</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>

<name>modbus</name>
<url>http://maven.apache.org</url>

<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>

<!-- 若想引用modbus4j需要引入下列repository id:ias-snapshots id:ias-releases 兩個 ，使用默認倉庫下載，不要使用阿里雲倉庫–>
<repositories>
<repository>
<releases>
<enabled>false</enabled>
</releases>
<snapshots>
<enabled>true</enabled>
</snapshots>
<id>ias-snapshots</id>
<name>Infinite Automation Snapshot Repository</name>
<url>https://maven.mangoautomation.net/repository/ias-snapshot/</url>
</repository>
<repository>
<releases>
<enabled>true</enabled>
</releases>
<snapshots>
<enabled>false</enabled>
</snapshots>
<id>ias-releases</id>
<name>Infinite Automation Release Repository</name>
<url>https://maven.mangoautomation.net/repository/ias-release/</url>
</repository>
</repositories>

<span class="hljs-tag">&lt;<span class="hljs-name">dependencies</span>&gt;</span>
     <span class="hljs-tag">&lt;<span class="hljs-name">dependency</span>&gt;</span>
        <span class="hljs-tag">&lt;<span class="hljs-name">groupId</span>&gt;</span>junit<span class="hljs-tag">&lt;/<span class="hljs-name">groupId</span>&gt;</span>
        <span class="hljs-tag">&lt;<span class="hljs-name">artifactId</span>&gt;</span>junit<span class="hljs-tag">&lt;/<span class="hljs-name">artifactId</span>&gt;</span>
        <span class="hljs-tag">&lt;<span class="hljs-name">version</span>&gt;</span>4.13-beta-3<span class="hljs-tag">&lt;/<span class="hljs-name">version</span>&gt;</span>
        <span class="hljs-tag">&lt;<span class="hljs-name">scope</span>&gt;</span>test<span class="hljs-tag">&lt;/<span class="hljs-name">scope</span>&gt;</span>
    <span class="hljs-tag">&lt;/<span class="hljs-name">dependency</span>&gt;</span>
    <span class="hljs-tag">&lt;<span class="hljs-name">dependency</span>&gt;</span>
        <span class="hljs-tag">&lt;<span class="hljs-name">groupId</span>&gt;</span>com.infiniteautomation<span class="hljs-tag">&lt;/<span class="hljs-name">groupId</span>&gt;</span>
        <span class="hljs-tag">&lt;<span class="hljs-name">artifactId</span>&gt;</span>modbus4j<span class="hljs-tag">&lt;/<span class="hljs-name">artifactId</span>&gt;</span>
        <span class="hljs-tag">&lt;<span class="hljs-name">version</span>&gt;</span>3.0.3<span class="hljs-tag">&lt;/<span class="hljs-name">version</span>&gt;</span>
    <span class="hljs-tag">&lt;/<span class="hljs-name">dependency</span>&gt;</span>
    
    <span class="hljs-tag">&lt;<span class="hljs-name">dependency</span>&gt;</span>
        <span class="hljs-tag">&lt;<span class="hljs-name">groupId</span>&gt;</span>org.apache.commons<span class="hljs-tag">&lt;/<span class="hljs-name">groupId</span>&gt;</span>
        <span class="hljs-tag">&lt;<span class="hljs-name">artifactId</span>&gt;</span>commons-lang3<span class="hljs-tag">&lt;/<span class="hljs-name">artifactId</span>&gt;</span>
        <span class="hljs-tag">&lt;<span class="hljs-name">version</span>&gt;</span>3.9<span class="hljs-tag">&lt;/<span class="hljs-name">version</span>&gt;</span>
    <span class="hljs-tag">&lt;/<span class="hljs-name">dependency</span>&gt;</span>
<span class="hljs-tag">&lt;/<span class="hljs-name">dependencies</span>&gt;</span>

</project>

Java實現modbus協議通訊

原文鏈接：http://www.leftso.com/blog/83.html
核心依賴:

  • modbus4j.jar
  • commons-lang3-3.0.jar

Modbus4jUtils類

package com.tcb.modbus;

import com.serotonin.modbus4j.BatchRead;
import com.serotonin.modbus4j.BatchResults;
import com.serotonin.modbus4j.ModbusFactory;
import com.serotonin.modbus4j.ModbusMaster;
import com.serotonin.modbus4j.code.DataType;
import com.serotonin.modbus4j.exception.ErrorResponseException;
import com.serotonin.modbus4j.exception.ModbusInitException;
import com.serotonin.modbus4j.exception.ModbusTransportException;
import com.serotonin.modbus4j.ip.IpParameters;
import com.serotonin.modbus4j.locator.BaseLocator;

/**

  • modbus通訊工具類,採用modbus4j實現

  • @author lxq

  • @dependencies modbus4j-3.0.3.jar

  • @website https://github.com/infiniteautomation/modbus4j
    /
    public class Modbus4jUtils {
    /    *

    • 工廠。
      */
      static ModbusFactory modbusFactory;
      static {
      if (modbusFactory == null) {
      modbusFactory = new ModbusFactory();
      }
      }

    /**

    • 獲取master

    • @return

    • @throws ModbusInitException
      */
      public static ModbusMaster getMaster() throws ModbusInitException {
      IpParameters params = new IpParameters();
      params.setHost(“localhost”);
      params.setPort(502);
      //
      // modbusFactory.createRtuMaster(wapper); //RTU 協議
      // modbusFactory.createUdpMaster(params);//UDP 協議
      // modbusFactory.createAsciiMaster(wrapper);//ASCII 協議
      ModbusMaster master = modbusFactory.createTcpMaster(params, false);// TCP 協議
      master.init();

      return master;
      }

    /**

    • 讀取[01 Coil Status 0x]類型 開關數據
    • @param slaveId
    •        slaveId
    • @param offset
    •        位置
    • @return 讀取值
    • @throws ModbusTransportException
    •         異常
    • @throws ErrorResponseException
    •         異常
    • @throws ModbusInitException
    •         異常

    */
    public static Boolean readCoilStatus(int slaveId, int offset)
    throws ModbusTransportException, ErrorResponseException, ModbusInitException     {
    // 01 Coil Status
    BaseLocator<Boolean> loc = BaseLocator.coilStatus(slaveId, offset);
    Boolean value = getMaster().getValue(loc);
    return value;
    }

    /**

    • 讀取[02 Input Status 1x]類型 開關數據
    • @param slaveId
    • @param offset
    • @return
    • @throws ModbusTransportException
    • @throws ErrorResponseException
    • @throws ModbusInitException
      */
      public static Boolean readInputStatus(int slaveId, int offset)
      throws ModbusTransportException, ErrorResponseException, ModbusInitException       {
      // 02 Input Status
      BaseLocator<Boolean> loc = BaseLocator.inputStatus(slaveId, offset);
      Boolean value = getMaster().getValue(loc);
      return value;
      }

    /**

    • 讀取[03 Holding Register類型 2x]模擬量數據
    • @param slaveId
    •        slave Id
    • @param offset
    •        位置
    • @param dataType
    •        數據類型,來自com.serotonin.modbus4j.code.DataType
    • @return
    • @throws ModbusTransportException
    •         異常
    • @throws ErrorResponseException
    •         異常
    • @throws ModbusInitException
    •         異常

    */
    public static Number readHoldingRegister(int slaveId, int offset, int dataType)
    throws ModbusTransportException, ErrorResponseException, ModbusInitException     {
    // 03 Holding Register類型數據讀取
    BaseLocator<Number> loc = BaseLocator.holdingRegister(slaveId, offset, dataType);
    Number value = getMaster().getValue(loc);
    return value;
    }

    /**

    • 讀取[04 Input Registers 3x]類型 模擬量數據
    • @param slaveId
    •        slaveId
    • @param offset
    •        位置
    • @param dataType
    •        數據類型,來自com.serotonin.modbus4j.code.DataType
    • @return 返回結果
    • @throws ModbusTransportException
    •         異常
    • @throws ErrorResponseException
    •         異常
    • @throws ModbusInitException
    •         異常

    */
    public static Number readInputRegisters(int slaveId, int offset, int dataType)
    throws ModbusTransportException, ErrorResponseException, ModbusInitException     {
    // 04 Input Registers類型數據讀取
    BaseLocator<Number> loc = BaseLocator.inputRegister(slaveId, offset, dataType);
    Number value = getMaster().getValue(loc);
    return value;
    }

    /**

    • 批量讀取使用方法

    • @throws ModbusTransportException

    • @throws ErrorResponseException

    • @throws ModbusInitException
      */
      public static void batchRead() throws ModbusTransportException, ErrorResponseException, ModbusInitException {

      BatchRead<Integer> batch = new BatchRead<Integer>();

      batch.addLocator(0, BaseLocator.holdingRegister(1, 1, DataType.FOUR_BYTE_FLOAT));
      batch.addLocator(1, BaseLocator.inputStatus(1, 0));

      ModbusMaster master = getMaster();

      batch.setContiguousRequests(false);
      BatchResults<Integer> results = master.send(batch);
      System.out.println(results.getValue(0));
      System.out.println(results.getValue(1));
      }

    /**

    • 測試

    • @param args
      */
      public static void main(String[] args) {
      try {
      // 01測試
      Boolean v011 = readCoilStatus(1, 0);
      Boolean v012 = readCoilStatus(1, 1);
      Boolean v013 = readCoilStatus(1, 6);
      System.out.println(“v011:” + v011);
      System.out.println(“v012:” + v012);
      System.out.println(“v013:” + v013);
      // 02測試
      Boolean v021 = readInputStatus(1, 0);
      Boolean v022 = readInputStatus(1, 1);
      Boolean v023 = readInputStatus(1, 2);
      System.out.println(“v021:” + v021);
      System.out.println(“v022:” + v022);
      System.out.println(“v023:” + v023);

       <span class="hljs-comment">// 03測試</span>
 Number v031 = readHoldingRegister(<span class="hljs-number">1</span>, <span class="hljs-number">1</span>, DataType.FOUR_BYTE_FLOAT);<span class="hljs-comment">// 注意,float</span>
 Number v032 = readHoldingRegister(<span class="hljs-number">1</span>, <span class="hljs-number">3</span>, DataType.FOUR_BYTE_FLOAT);<span class="hljs-comment">// 同上</span>
 System.out.println(<span class="hljs-string">"v031:"</span> + v031);
 System.out.println(<span class="hljs-string">"v032:"</span> + v032);

 <span class="hljs-comment">// 04測試</span>
 Number v041 = readInputRegisters(<span class="hljs-number">1</span>, <span class="hljs-number">0</span>, DataType.FOUR_BYTE_FLOAT);<span class="hljs-comment">//</span>
 Number v042 = readInputRegisters(<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, DataType.FOUR_BYTE_FLOAT);<span class="hljs-comment">//</span>
 System.out.println(<span class="hljs-string">"v041:"</span> + v041);
 System.out.println(<span class="hljs-string">"v042:"</span> + v042);
 <span class="hljs-comment">// 批量讀取</span>
 batchRead();

      } catch (Exception e) {
      e.printStackTrace();
      }
      }
      }

代碼理解

slave配置

輸出信息

v011:true
v012:false
v013:true
v021:true
v022:false
v023:true
v031:7.5
v032:10.5
v041:1.5
v042:3.0
7.5
true

Java通過modbus4j對數據的寫入

原文鏈接：http://www.leftso.com/blog/83.html

類Modbus4jWriteUtils.java

package com.tcb.modbus;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import com.serotonin.modbus4j.ModbusFactory;
import com.serotonin.modbus4j.ModbusMaster;
import com.serotonin.modbus4j.code.DataType;
import com.serotonin.modbus4j.exception.ErrorResponseException;
import com.serotonin.modbus4j.exception.ModbusInitException;
import com.serotonin.modbus4j.exception.ModbusTransportException;
import com.serotonin.modbus4j.ip.IpParameters;
import com.serotonin.modbus4j.locator.BaseLocator;
import com.serotonin.modbus4j.msg.ModbusResponse;
import com.serotonin.modbus4j.msg.WriteCoilRequest;
import com.serotonin.modbus4j.msg.WriteCoilResponse;
import com.serotonin.modbus4j.msg.WriteCoilsRequest;
import com.serotonin.modbus4j.msg.WriteCoilsResponse;
import com.serotonin.modbus4j.msg.WriteRegisterRequest;
import com.serotonin.modbus4j.msg.WriteRegisterResponse;
import com.serotonin.modbus4j.msg.WriteRegistersRequest;

/**

  • modbus4j寫入數據
  • @author xq

/
public class Modbus4jWriteUtils {
static Log log = LogFactory.getLog(Modbus4jWriteUtils.class);
/*
* 工廠。
*/
static ModbusFactory modbusFactory;
static {
if (modbusFactory == null) {
modbusFactory = new ModbusFactory();
}
}

<span class="hljs-comment">/**
 * 獲取tcpMaster
 * 
 * <span class="hljs-doctag">@return</span>
 * <span class="hljs-doctag">@throws</span> ModbusInitException
 */</span>
<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">static</span> ModbusMaster <span class="hljs-title">getMaster</span><span class="hljs-params">()</span> <span class="hljs-keyword">throws</span> ModbusInitException </span>{
    IpParameters params = <span class="hljs-keyword">new</span> IpParameters();
    params.setHost(<span class="hljs-string">"localhost"</span>);
    params.setPort(<span class="hljs-number">502</span>);

    ModbusMaster tcpMaster = modbusFactory.createTcpMaster(params, <span class="hljs-keyword">false</span>);
    tcpMaster.init();

    <span class="hljs-keyword">return</span> tcpMaster;
}

<span class="hljs-comment">/**
 * 寫 [01 Coil Status(0x)]寫一個 function ID = 5
 * 
 * <span class="hljs-doctag">@param</span> slaveId
 *            slave的ID
 * <span class="hljs-doctag">@param</span> writeOffset
 *            位置
 * <span class="hljs-doctag">@param</span> writeValue
 *            值
 * <span class="hljs-doctag">@return</span> 是否寫入成功
 * <span class="hljs-doctag">@throws</span> ModbusTransportException
 * <span class="hljs-doctag">@throws</span> ModbusInitException
 */</span>
<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">static</span> <span class="hljs-keyword">boolean</span> <span class="hljs-title">writeCoil</span><span class="hljs-params">(<span class="hljs-keyword">int</span> slaveId, <span class="hljs-keyword">int</span> writeOffset, <span class="hljs-keyword">boolean</span> writeValue)</span>
        <span class="hljs-keyword">throws</span> ModbusTransportException, ModbusInitException </span>{
    <span class="hljs-comment">// 獲取master</span>
    ModbusMaster tcpMaster = getMaster();
    <span class="hljs-comment">// 創建請求</span>
    WriteCoilRequest request = <span class="hljs-keyword">new</span> WriteCoilRequest(slaveId, writeOffset, writeValue);
    <span class="hljs-comment">// 發送請求並獲取響應對象</span>
    WriteCoilResponse response = (WriteCoilResponse) tcpMaster.send(request);
    <span class="hljs-keyword">if</span> (response.isException()) {
        <span class="hljs-keyword">return</span> <span class="hljs-keyword">false</span>;
    } <span class="hljs-keyword">else</span> {
        <span class="hljs-keyword">return</span> <span class="hljs-keyword">true</span>;
    }
}

<span class="hljs-comment">/**
 * 寫[01 Coil Status(0x)] 寫多個 function ID = 15
 * 
 * <span class="hljs-doctag">@param</span> slaveId
 *            slaveId
 * <span class="hljs-doctag">@param</span> startOffset
 *            開始位置
 * <span class="hljs-doctag">@param</span> bdata
 *            寫入的數據
 * <span class="hljs-doctag">@return</span> 是否寫入成功
 * <span class="hljs-doctag">@throws</span> ModbusTransportException
 * <span class="hljs-doctag">@throws</span> ModbusInitException
 */</span>
<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">static</span> <span class="hljs-keyword">boolean</span> <span class="hljs-title">writeCoils</span><span class="hljs-params">(<span class="hljs-keyword">int</span> slaveId, <span class="hljs-keyword">int</span> startOffset, <span class="hljs-keyword">boolean</span>[] bdata)</span>
        <span class="hljs-keyword">throws</span> ModbusTransportException, ModbusInitException </span>{
    <span class="hljs-comment">// 獲取master</span>
    ModbusMaster tcpMaster = getMaster();
    <span class="hljs-comment">// 創建請求</span>
    WriteCoilsRequest request = <span class="hljs-keyword">new</span> WriteCoilsRequest(slaveId, startOffset, bdata);
    <span class="hljs-comment">// 發送請求並獲取響應對象</span>
    WriteCoilsResponse response = (WriteCoilsResponse) tcpMaster.send(request);
    <span class="hljs-keyword">if</span> (response.isException()) {
        <span class="hljs-keyword">return</span> <span class="hljs-keyword">false</span>;
    } <span class="hljs-keyword">else</span> {
        <span class="hljs-keyword">return</span> <span class="hljs-keyword">true</span>;
    }

}

<span class="hljs-comment">/***
 * 寫[03 Holding Register(4x)] 寫一個 function ID = 6
 * 
 * <span class="hljs-doctag">@param</span> slaveId
 * <span class="hljs-doctag">@param</span> writeOffset
 * <span class="hljs-doctag">@param</span> writeValue
 * <span class="hljs-doctag">@return</span>
 * <span class="hljs-doctag">@throws</span> ModbusTransportException
 * <span class="hljs-doctag">@throws</span> ModbusInitException
 */</span>
<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">static</span> <span class="hljs-keyword">boolean</span> <span class="hljs-title">writeRegister</span><span class="hljs-params">(<span class="hljs-keyword">int</span> slaveId, <span class="hljs-keyword">int</span> writeOffset, <span class="hljs-keyword">short</span> writeValue)</span>
        <span class="hljs-keyword">throws</span> ModbusTransportException, ModbusInitException </span>{
    <span class="hljs-comment">// 獲取master</span>
    ModbusMaster tcpMaster = getMaster();
    <span class="hljs-comment">// 創建請求對象</span>
    WriteRegisterRequest request = <span class="hljs-keyword">new</span> WriteRegisterRequest(slaveId, writeOffset, writeValue);
    WriteRegisterResponse response = (WriteRegisterResponse) tcpMaster.send(request);
    <span class="hljs-keyword">if</span> (response.isException()) {
        log.error(response.getExceptionMessage());
        <span class="hljs-keyword">return</span> <span class="hljs-keyword">false</span>;
    } <span class="hljs-keyword">else</span> {
        <span class="hljs-keyword">return</span> <span class="hljs-keyword">true</span>;
    }

}

<span class="hljs-comment">/**
 * 
 * 寫入[03 Holding Register(4x)]寫多個 function ID=16
 * 
 * <span class="hljs-doctag">@param</span> slaveId
 *            modbus的slaveID
 * <span class="hljs-doctag">@param</span> startOffset
 *            起始位置偏移量值
 * <span class="hljs-doctag">@param</span> sdata
 *            寫入的數據
 * <span class="hljs-doctag">@return</span> 返回是否寫入成功
 * <span class="hljs-doctag">@throws</span> ModbusTransportException
 * <span class="hljs-doctag">@throws</span> ModbusInitException
 */</span>
<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">static</span> <span class="hljs-keyword">boolean</span> <span class="hljs-title">writeRegisters</span><span class="hljs-params">(<span class="hljs-keyword">int</span> slaveId, <span class="hljs-keyword">int</span> startOffset, <span class="hljs-keyword">short</span>[] sdata)</span>
        <span class="hljs-keyword">throws</span> ModbusTransportException, ModbusInitException </span>{
    <span class="hljs-comment">// 獲取master</span>
    ModbusMaster tcpMaster = getMaster();
    <span class="hljs-comment">// 創建請求對象</span>
    WriteRegistersRequest request = <span class="hljs-keyword">new</span> WriteRegistersRequest(slaveId, startOffset, sdata);
    <span class="hljs-comment">// 發送請求並獲取響應對象</span>
    ModbusResponse response = tcpMaster.send(request);
    <span class="hljs-keyword">if</span> (response.isException()) {
        log.error(response.getExceptionMessage());
        <span class="hljs-keyword">return</span> <span class="hljs-keyword">false</span>;
    } <span class="hljs-keyword">else</span> {
        <span class="hljs-keyword">return</span> <span class="hljs-keyword">true</span>;
    }
}

<span class="hljs-comment">/**
 * 寫入數字類型的模擬量（如:寫入Float類型的模擬量、Double類型模擬量、整數類型Short、Integer、Long）
 * 
 * <span class="hljs-doctag">@param</span> slaveId
 * <span class="hljs-doctag">@param</span> offset
 * <span class="hljs-doctag">@param</span> value
 *            寫入值,Number的子類,例如寫入Float浮點類型,Double雙精度類型,以及整型short,int,long
 * <span class="hljs-doctag">@param</span> registerCount
 *            ,com.serotonin.modbus4j.code.DataType
 * <span class="hljs-doctag">@throws</span> ModbusTransportException
 * <span class="hljs-doctag">@throws</span> ErrorResponseException
 * <span class="hljs-doctag">@throws</span> ModbusInitException
 */</span>
<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">static</span> <span class="hljs-keyword">void</span> <span class="hljs-title">writeHoldingRegister</span><span class="hljs-params">(<span class="hljs-keyword">int</span> slaveId, <span class="hljs-keyword">int</span> offset, Number value, <span class="hljs-keyword">int</span> dataType)</span>
        <span class="hljs-keyword">throws</span> ModbusTransportException, ErrorResponseException, ModbusInitException </span>{
    <span class="hljs-comment">// 獲取master</span>
    ModbusMaster tcpMaster = getMaster();
    <span class="hljs-comment">// 類型</span>
    BaseLocator&lt;Number&gt; locator = BaseLocator.holdingRegister(slaveId, offset, dataType);
    tcpMaster.setValue(locator, value);
}

<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">static</span> <span class="hljs-keyword">void</span> <span class="hljs-title">main</span><span class="hljs-params">(String[] args)</span> </span>{
    <span class="hljs-keyword">try</span> {
        <span class="hljs-comment">//@formatter:off</span>
        <span class="hljs-comment">// 測試01</span>

// boolean t01 = writeCoil(1, 0, true);
// System.out.println(“T01:” + t01);

        <span class="hljs-comment">// 測試02</span>

// boolean t02 = writeCoils(1, 0, new boolean[] { true, false, true });
// System.out.println(“T02:” + t02);

        <span class="hljs-comment">// 測試03</span>

// short v = -3;
// boolean t03 = writeRegister(1, 0, v);
// System.out.println(“T03:” + t03);
// 測試04
// boolean t04 = writeRegisters(1, 0, new short[] { -3, 3, 9 });
// System.out.println(“t04:” + t04);
//寫模擬量
writeHoldingRegister(1,0, 10.1f, DataType.FOUR_BYTE_FLOAT);

        <span class="hljs-comment">//@formatter:on</span>
    } <span class="hljs-keyword">catch</span> (Exception e) {
        e.printStackTrace();
    }

}

}

代碼理解

使用modbus-master-tcp

原文鏈接：http://www.leftso.com/blog/310.html
modbus tcp通訊Java的方案之前已經講解過一種,modbus4j實現Java語言的modbus tcp協議通訊。從上一個方案中我們不難發現modbus4j的通訊實現方式是同步的。
實際應用中可能會讀取大量的數據。同步處理對於應用的響應還是不太友好的。
本博客主要講解另外一種Java語言的modbux tcp通訊方案。那就是modbus-master-tcp。

maven依賴

pom.xml注意,需要將java的編譯版本指定到1.8.因爲只有1.8以後才支持lambda表達式。

    <dependency>
        <groupId>com.digitalpetri.modbus</groupId>
        <artifactId>modbus-master-tcp</artifactId>
        <version>1.1.0</version>
    </dependency>

觀察可以發現,modbus-master-tcp項目的底層是基於netty框架開發。天然的支持異步處理。在性能方面有很好的提升。

編寫modbus tcp讀取案例

類SimpleMasterExample

package com.tcb.modbusmastertcp;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

import com.digitalpetri.modbus.codec.Modbus;
import com.digitalpetri.modbus.master.ModbusTcpMaster;
import com.digitalpetri.modbus.master.ModbusTcpMasterConfig;
import com.digitalpetri.modbus.requests.ReadCoilsRequest;
import com.digitalpetri.modbus.requests.ReadDiscreteInputsRequest;
import com.digitalpetri.modbus.requests.ReadHoldingRegistersRequest;
import com.digitalpetri.modbus.requests.ReadInputRegistersRequest;
import com.digitalpetri.modbus.responses.ReadCoilsResponse;
import com.digitalpetri.modbus.responses.ReadDiscreteInputsResponse;
import com.digitalpetri.modbus.responses.ReadHoldingRegistersResponse;
import com.digitalpetri.modbus.responses.ReadInputRegistersResponse;

import io.netty.buffer.ByteBuf;
import io.netty.util.ReferenceCountUtil;

/***

  • modbus TCP協議Java通訊讀取例子
  • @author xqlee

*/
public class SimpleMasterExample {

<span class="hljs-keyword">static</span> ModbusTcpMaster master;

<span class="hljs-comment">/**
 * 獲取TCP協議的Master
 * 
 * <span class="hljs-doctag">@return</span>
 */</span>
<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">static</span> <span class="hljs-keyword">void</span> <span class="hljs-title">initModbusTcpMaster</span><span class="hljs-params">()</span> </span>{
    <span class="hljs-keyword">if</span> (master == <span class="hljs-keyword">null</span>) {
        <span class="hljs-comment">// 創建配置</span>
        ModbusTcpMasterConfig config = <span class="hljs-keyword">new</span> ModbusTcpMasterConfig.Builder(<span class="hljs-string">"localhost"</span>).setPort(<span class="hljs-number">502</span>).build();
        master = <span class="hljs-keyword">new</span> ModbusTcpMaster(config);
    }
}

<span class="hljs-comment">/***
 * 釋放資源
 */</span>
<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">static</span> <span class="hljs-keyword">void</span> <span class="hljs-title">release</span><span class="hljs-params">()</span> </span>{
    <span class="hljs-keyword">if</span> (master != <span class="hljs-keyword">null</span>) {
        master.disconnect();
    }
    Modbus.releaseSharedResources();
}

<span class="hljs-comment">/**
 * 讀取HoldingRegister數據
 * 
 * <span class="hljs-doctag">@param</span> address
 *            寄存器地址
 * <span class="hljs-doctag">@param</span> quantity
 *            寄存器數量
 * <span class="hljs-doctag">@param</span> unitId
 *            id
 * <span class="hljs-doctag">@return</span> 讀取結果
 * <span class="hljs-doctag">@throws</span> InterruptedException
 *             異常
 * <span class="hljs-doctag">@throws</span> ExecutionException
 *             異常
 */</span>
<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">static</span> Number <span class="hljs-title">readHoldingRegisters</span><span class="hljs-params">(<span class="hljs-keyword">int</span> address, <span class="hljs-keyword">int</span> quantity, <span class="hljs-keyword">int</span> unitId)</span>
        <span class="hljs-keyword">throws</span> InterruptedException, ExecutionException </span>{
    Number result = <span class="hljs-keyword">null</span>;
    CompletableFuture&lt;ReadHoldingRegistersResponse&gt; future = master
            .sendRequest(<span class="hljs-keyword">new</span> ReadHoldingRegistersRequest(address, quantity), unitId);
    ReadHoldingRegistersResponse readHoldingRegistersResponse = future.get();<span class="hljs-comment">// 工具類做的同步返回.實際使用推薦結合業務進行異步處理</span>
    <span class="hljs-keyword">if</span> (readHoldingRegistersResponse != <span class="hljs-keyword">null</span>) {
        ByteBuf buf = readHoldingRegistersResponse.getRegisters();
        result = buf.readFloat();
        ReferenceCountUtil.release(readHoldingRegistersResponse);
    }
    <span class="hljs-keyword">return</span> result;
}

<span class="hljs-comment">/**
 * 讀取InputRegisters模擬量數據
 * 
 * <span class="hljs-doctag">@param</span> address
 *            寄存器開始地址
 * <span class="hljs-doctag">@param</span> quantity
 *            數量
 * <span class="hljs-doctag">@param</span> unitId
 *            ID
 * <span class="hljs-doctag">@return</span> 讀取值
 * <span class="hljs-doctag">@throws</span> InterruptedException
 *             異常
 * <span class="hljs-doctag">@throws</span> ExecutionException
 *             異常
 */</span>
<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">static</span> Number <span class="hljs-title">readInputRegisters</span><span class="hljs-params">(<span class="hljs-keyword">int</span> address, <span class="hljs-keyword">int</span> quantity, <span class="hljs-keyword">int</span> unitId)</span>
        <span class="hljs-keyword">throws</span> InterruptedException, ExecutionException </span>{
    Number result = <span class="hljs-keyword">null</span>;
    CompletableFuture&lt;ReadInputRegistersResponse&gt; future = master
            .sendRequest(<span class="hljs-keyword">new</span> ReadInputRegistersRequest(address, quantity), unitId);
    ReadInputRegistersResponse readInputRegistersResponse = future.get();<span class="hljs-comment">// 工具類做的同步返回.實際使用推薦結合業務進行異步處理</span>
    <span class="hljs-keyword">if</span> (readInputRegistersResponse != <span class="hljs-keyword">null</span>) {
        ByteBuf buf = readInputRegistersResponse.getRegisters();
        result = buf.readFloat();
        ReferenceCountUtil.release(readInputRegistersResponse);
    }
    <span class="hljs-keyword">return</span> result;
}

<span class="hljs-comment">/**
 * 讀取Coils開關量
 * 
 * <span class="hljs-doctag">@param</span> address
 *            寄存器開始地址
 * <span class="hljs-doctag">@param</span> quantity
 *            數量
 * <span class="hljs-doctag">@param</span> unitId
 *            ID
 * <span class="hljs-doctag">@return</span> 讀取值
 * <span class="hljs-doctag">@throws</span> InterruptedException
 *             異常
 * <span class="hljs-doctag">@throws</span> ExecutionException
 *             異常
 */</span>
<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">static</span> Boolean <span class="hljs-title">readCoils</span><span class="hljs-params">(<span class="hljs-keyword">int</span> address, <span class="hljs-keyword">int</span> quantity, <span class="hljs-keyword">int</span> unitId)</span>
        <span class="hljs-keyword">throws</span> InterruptedException, ExecutionException </span>{
    Boolean result = <span class="hljs-keyword">null</span>;
    CompletableFuture&lt;ReadCoilsResponse&gt; future = master.sendRequest(<span class="hljs-keyword">new</span> ReadCoilsRequest(address, quantity),
            unitId);
    ReadCoilsResponse readCoilsResponse = future.get();<span class="hljs-comment">// 工具類做的同步返回.實際使用推薦結合業務進行異步處理</span>
    <span class="hljs-keyword">if</span> (readCoilsResponse != <span class="hljs-keyword">null</span>) {
        ByteBuf buf = readCoilsResponse.getCoilStatus();
        result = buf.readBoolean();
        ReferenceCountUtil.release(readCoilsResponse);
    }
    <span class="hljs-keyword">return</span> result;
}

<span class="hljs-comment">/**
 * 讀取readDiscreteInputs開關量
 * 
 * <span class="hljs-doctag">@param</span> address
 *            寄存器開始地址
 * <span class="hljs-doctag">@param</span> quantity
 *            數量
 * <span class="hljs-doctag">@param</span> unitId
 *            ID
 * <span class="hljs-doctag">@return</span> 讀取值
 * <span class="hljs-doctag">@throws</span> InterruptedException
 *             異常
 * <span class="hljs-doctag">@throws</span> ExecutionException
 *             異常
 */</span>
<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">static</span> Boolean <span class="hljs-title">readDiscreteInputs</span><span class="hljs-params">(<span class="hljs-keyword">int</span> address, <span class="hljs-keyword">int</span> quantity, <span class="hljs-keyword">int</span> unitId)</span>
        <span class="hljs-keyword">throws</span> InterruptedException, ExecutionException </span>{
    Boolean result = <span class="hljs-keyword">null</span>;
    CompletableFuture&lt;ReadDiscreteInputsResponse&gt; future = master
            .sendRequest(<span class="hljs-keyword">new</span> ReadDiscreteInputsRequest(address, quantity), unitId);
    ReadDiscreteInputsResponse discreteInputsResponse = future.get();<span class="hljs-comment">// 工具類做的同步返回.實際使用推薦結合業務進行異步處理</span>
    <span class="hljs-keyword">if</span> (discreteInputsResponse != <span class="hljs-keyword">null</span>) {
        ByteBuf buf = discreteInputsResponse.getInputStatus();
        result = buf.readBoolean();
        ReferenceCountUtil.release(discreteInputsResponse);
    }
    <span class="hljs-keyword">return</span> result;
}

<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">static</span> <span class="hljs-keyword">void</span> <span class="hljs-title">main</span><span class="hljs-params">(String[] args)</span> </span>{
    <span class="hljs-keyword">try</span> {
        <span class="hljs-comment">// 初始化資源</span>
        initModbusTcpMaster();
        <span class="hljs-comment">// 執行操作</span>
        <span class="hljs-comment">// 讀取模擬量</span>
        System.out.println(readHoldingRegisters(<span class="hljs-number">0</span>, <span class="hljs-number">4</span>, <span class="hljs-number">1</span>));
        System.out.println(readInputRegisters(<span class="hljs-number">0</span>, <span class="hljs-number">4</span>, <span class="hljs-number">1</span>));

        <span class="hljs-comment">// 讀取開關量</span>
        System.out.println(readCoils(<span class="hljs-number">0</span>, <span class="hljs-number">1</span>, <span class="hljs-number">1</span>));
        System.out.println(readDiscreteInputs(<span class="hljs-number">0</span>, <span class="hljs-number">1</span>, <span class="hljs-number">1</span>));
        System.out.println(readDiscreteInputs(<span class="hljs-number">2</span>, <span class="hljs-number">1</span>, <span class="hljs-number">1</span>));

        <span class="hljs-comment">// 釋放資源</span>
        release();
    } <span class="hljs-keyword">catch</span> (Exception e) {
        e.printStackTrace();
    }
}

}

代碼理解

slave：和上面的一樣

輸出信息

2.5039635
1.5
true
true
true

評價感受

  • jlibmodbus：集成多個串口通信開源庫，有意思
  • modbus4j：很有名
  • modbus-master-tcp：底層netty，支持異步
  • Jamod：Github上安卓開發modbus通信用的多
行思坐憶，志凌雲
發佈了198 篇原創文章 · 獲贊 58 · 訪問量 16萬+
私信 關注
發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

從缺陷到創新：質量保障的新視角

1.背景： 最近一段時間研發大佬們在積極的治理告警，經過一段時間的治理，現在告警情況已經有了很大的改觀，但難免還有漏網之魚；具體我們可以以下邊一個例子來看： 這是一個生產的UMP告警，通過這個告警我們發現XXX這個應用的堆內存使用率

原創 2024-06-07 23:55:01

CI+GPT雙引擎驅動，開啓AI代碼評審新紀元

一. 現狀問題 代碼評審 Code Review 是提高代碼質量、促進團隊合作、知識間共享的關鍵環節，對於系統代碼質量和穩定性都至關重要。 【人爲代碼評審（Code Review）】存在很多弊端 時間消耗大：代碼評審是一

京東雲開發者 2024-06-07 23:54:54

Java開發必讀，談談對Spring IOC與AOP的理解

本文分享自華爲雲社區《超詳細的Java後臺開發面試題之Spring IOC與AOP》，作者：GaussDB 數據庫。 一、前言 IOC和AOP是Spring中的兩個核心的概念，下面談談對這兩個概念的理解。 二、IOC（Inverse o

原創 2024-06-07 22:57:21

Junit4遇上chatGPT

這是一篇適合Java工程師體質的AI開發教程。 本教程會教你寫一個簡單的junit4的Rule，該Rule在基於junit4的測試方法失敗後，自動向GPT發送錯誤信息並通過GPT分析得出代碼修改建議。 首先向AI問好 簡單的通過AI，讓它

原創 2024-06-06 23:55:13

一文搞懂 Spring 循環依賴

這個其實是一個特別高頻的面試題，松哥也一直很想和大家仔細來聊一聊這個話題，網上關於這塊的文章很多，但是我一直覺得要把這個問題講清楚還有點難度，今天我來試一試，看能不能和小夥伴們把這個問題梳理清楚，當然，如果小夥伴們覺得看文章不過癮，松哥也有

原創 2024-06-06 13:11:47

營銷系統黑名單優化：位圖的應用解析

背景 營銷系統中，客戶投訴是業務發展的一大阻礙，一般會過濾掉黑名單高風險賬號，並配合頻控策略，來減少客訴，進而增加營銷效率，減少營銷成本，提升營銷質量。 營銷系統一般是通過大數據分析建模，在CDP（客戶數據平臺，以客戶爲核心，圍繞數據融

京東雲開發者 2024-06-06 11:54:12

基於阿里雲服務網格流量泳道的全鏈路流量管理（三）：無侵入式的寬鬆模式泳道

作者：尹航 在前文《基於阿里雲服務網格流量泳道的全鏈路流量管理（一）：嚴格模式流量泳道》、《基於阿里雲服務網格流量泳道的全鏈路流量管理（二）：寬鬆模式流量泳道》中，我們介紹了流量泳道的概念、使用流量泳道進行全鏈路灰度管理的方案，以及阿里雲服

原創 2024-06-05 21:13:51

iLogtail 2.0 重大升級，端上支持 SPL

作者：太業 流式處理語言發展 早期流式處理概念： 20 世紀 70 年代，編程語言如 APL 提供了對數組的流式操作，這可以看作是流式處理語法的早期形式。 管道（Pipes）概念在 UNIX 系統中的引進使得可以通過命令行將一個命令的

原創 2024-06-05 21:13:43

一文搞懂5種內存溢出案例，內含完整源碼

本文分享自華爲雲社區《10分鐘搞懂各種內存溢出案例！！（含完整源碼，建議收藏）》，作者：冰 河。 作爲程序員，多多少少都會遇到一些內存溢出的場景，如果你還沒遇到，說明你工作的年限可能比較短，或者你根本就是個假程序員！哈哈，開個玩笑。今天，我

原創 2024-06-05 10:56:55

高效啓動DolphinScheduler工作流：Java URL調用詳解

轉載自牛肉胡辣湯 在大數據分析和處理的領域中，DolphinScheduler是一個開源的分佈式工作流調度系統，可以用於調度和管理複雜的工作流任務。本文將介紹如何使用Java中的URL類來調用DolphinScheduler的API，實現啓

原創 2024-06-04 21:21:59

記一次疑似JVM內存泄漏的排查過程

一、背景 在日常部門OpsReview過程中，部門內多次遇到應用容器所在的宿主機磁盤繁忙導致的接口響應緩慢，TP99增高等影響服務性能的問題，其中比較有效的解決方案是開啓日誌的異步打印，可以有效避免同步日誌打印在磁盤IO高起的情況下拖慢業

原創 2024-06-04 12:09:32

?* CI+GPT雙引擎驅動，?* 開啓AI代碼評審新紀元

一. 現狀問題 代碼評審 Code Review 是提高代碼質量、促進團隊合作、知識間共享的關鍵環節，對於系統代碼質量和穩定性都至關重要。 【人爲代碼評審（Code Review）】存在很多弊端 時間消耗大：代碼評審是一個耗時

原創 2024-06-04 12:09:24

pfinder實現原理揭祕

1. 引言 在現代軟件開發過程中，性能優化和故障排查是保證應用穩定運行的關鍵任務之一。Java作爲一種廣泛使用的編程語言，其生態中湧現出了許多優秀的監控和診斷工具，諸如：SkyWalking、Zipkin等，它們幫助開發者和運維人員

原創 2024-06-04 02:39:24

pfinder實現原理揭祕

1. 引言 在現代軟件開發過程中，性能優化和故障排查是保證應用穩定運行的關鍵任務之一。Java作爲一種廣泛使用的編程語言，其生態中湧現出了許多優秀的監控和診斷工具，諸如：SkyWalking、Zipkin等，它們幫助開發者和運維人員

原創 2024-06-04 02:37:09

pfinder實現原理揭祕

1. 引言 在現代軟件開發過程中，性能優化和故障排查是保證應用穩定運行的關鍵任務之一。Java作爲一種廣泛使用的編程語言，其生態中湧現出了許多優秀的監控和診斷工具，諸如：SkyWalking、Zipkin等，它們幫助開發者和運維人員

原創 2024-06-04 02:34:44