Java Modbus 개발完全指南：构建企业级工业적용

무료무료 기술 자료

이 글은 바로 읽을 수 있으며 기초 학습과 검색 유입에 적합합니다.

modbus기술팀 2026년 3월 1일 약 44 분 읽기

Java Modbus개발完全指南：构建企业级工业적용

서론：Java在산업 자동화中的优势

Java凭借其跨平台特性、强大的유형系统、丰富的企业级类库和成熟的生态系统，在산업 자동화领域占据重要地位。从大型 SCADA 系统到嵌入式게이트웨이设备，Java 提供了完整的솔루션栈，特别适合需要高可靠性、高性能和长期维护的企业级工业적용。本文将深入探讨 Java 在 Modbus 개발中的적용，重点介绍 Modbus4J、jamod、j2mod 等主流库的使用，并结合 Spring Boot、MQTT 等现代기술栈，展示如何构建专业级的工业物联网系统。

一、Java Modbus 개발환경설정

1.1 개발환경要求

<!-- Maven 项目설정 -->
<project>
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>industrial-modbus</artifactId>
    <version>1.0.0</version>
    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
</project>

1.2 核心依赖설정

<dependencies>
    <!-- Modbus4J - 功能最全面的 Modbus 库 -->
    <dependency>
        <groupId>com.infiniteautomation</groupId>
        <artifactId>modbus4j</artifactId>
        <version>3.4.0</version>
    </dependency>

    <!-- j2mod - 现代化轻量级选择 -->
    <dependency>
        <groupId>com.ghgande</groupId>
        <artifactId>j2mod</artifactId>
        <version>3.1.4</version>
    </dependency>

    <!-- Spring Boot - 企业级적용框架 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-시작er-web</artifactId>
        <version>3.2.0</version>
    </dependency>

    <!-- MQTT 클라이언트 - 物联网통신 -->
    <dependency>
        <groupId>org.eclipse.paho</groupId>
        <artifactId>org.eclipse.paho.client.mqttv3</artifactId>
        <version>1.2.5</version>
    </dependency>
</dependencies>

二、主流 Java Modbus 库对比

2.1 Modbus4J：企业级首选

特点： - 功能最全面，支持所有 Modbus 기능 코드 - 支持 TCP、RTU、ASCII 所有传输모드 - 同时支持마스터和슬레이브모드 - 活跃的社区维护（Infinite 자동화） - 完善的异常处理和로그系统 适用시나리오： - 大型 SCADA 系统 - 企业级工业监控平台 - 需要高可靠性的生产환경

2.2 j2mod：现代化轻量级方案

特点： - 代码简洁，API 设计现代化 - 支持 Modbus TCP 和 RTU - 轻量级，依赖少 - 适合微服务架构 适用시나리오： - 微服务架构的工业적용 - 자료受限的嵌入式设备 - 快速原型개발

2.3 jamod：经典稳定选择

特点： - 历史悠久，稳定性好 - 纯 Java 实现，无 native 依赖 - 문서完善，예제丰富 - 社区活跃度高 适用시나리오： - 传统工业系统업그레이드 - 教学和학습用途 - 需要长期稳定支持的项目

三、Modbus4J 实战개발

3.1 Modbus TCP 클라이언트实现

package com.example.modbus;

import com.serotonin.modbus4j.ModbusFactory;
import com.serotonin.modbus4j.ModbusMaster;
import com.serotonin.modbus4j.ip.tcp.TcpParameters;
import com.serotonin.modbus4j.exception.ModbusInitException;

public class ModbusTcpClient {

    private final ModbusMaster master;

    public ModbusTcpClient(String host, int port) {
        ModbusFactory factory = new ModbusFactory();
        TcpParameters params = new TcpParameters();
        params.setHost(host);
        params.setPort(port);
        params.setKeepAlive(true);

        master = factory.createTcpMaster(params, true);
        master.setRetries(3);
        master.setExceptionListeners(new ExceptionListenerImpl());
    }

    public void 시작() throws ModbusInitException {
        master.init();
        System.out.println("Modbus TCP 연결已建立");
    }

    public short readHolding회원가입(int slaveId, int offset) {
        return master.readHolding회원가입(slaveId, offset).getValue();
    }

    public int[] readHolding회원가입s(int slaveId, int offset, int count) {
        return master.readHolding회원가입s(slaveId, offset, count).getValue();
    }

    public void write회원가입(int slaveId, int offset, short value) {
        master.write회원가입(slaveId, offset, value);
    }

    public void stop() {
        master.destroy();
    }

    // 使用예제
    public static void main(String[] args) {
        try {
            ModbusTcpClient client = new ModbusTcpClient("192.168.1.100", 502);
            client.시작();

            // 유지 레지스터 읽기 (FC03)
            short temperature = client.readHolding회원가입(1, 0);
            System.out.println("온도：" + temperature + "°C");

            // 批量읽기
            int[] values = client.readHolding회원가입s(1, 0, 10);
            for (int i = 0; i < values.length; i++) {
                System.out.println("레지스터" + i + ": " + values[i]);
            }

            // 쓰기레지스터
            client.write회원가입(1, 0, (short) 250);

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

3.2 Modbus RTU 클라이언트实现

package com.example.modbus;

import com.serotonin.modbus4j.ModbusFactory;
import com.serotonin.modbus4j.ModbusMaster;
import com.serotonin.modbus4j.serial.rtu.RtuParameters;

public class ModbusRtuClient {

    private final ModbusMaster master;

    public ModbusRtuClient(String serialPort, int baudRate) {
        ModbusFactory factory = new ModbusFactory();
        RtuParameters params = new RtuParameters();
        params.setCommPortId(serialPort); // 如："/dev/ttyUSB0" 或 "COM3"
        params.setBaudRate(baudRate);
        params.setStopBits(1);
        params.setParity(0); // 0=None, 1=Odd, 2=Even
        params.setFlowControlIn(0);
        params.setFlowControlOut(0);

        master = factory.createRtuMaster(params);
        master.setRetries(3);
        master.setTimeout(500);
    }

    public void 시작() throws Exception {
        master.init();
        System.out.println("Modbus RTU 연결已建立");
    }

    public short readInput회원가입(int slaveId, int offset) {
        return master.readInput회원가입(slaveId, offset).getValue();
    }

    public boolean readCoil(int slaveId, int offset) {
        return master.readCoil(slaveId, offset).getValue();
    }

    public void writeCoil(int slaveId, int offset, boolean value) {
        master.writeCoil(slaveId, offset, value);
    }

    public void stop() {
        master.destroy();
    }
}

3.3 Modbus 슬레이브服务器实现

package com.example.modbus;

import com.serotonin.modbus4j.ModbusFactory;
import com.serotonin.modbus4j.ModbusMaster;
import com.serotonin.modbus4j.ip.tcp.TcpParameters;
import com.serotonin.modbus4j.slave.ModbusSlave;
import com.serotonin.modbus4j.slave.SlaveEventListener;

public class ModbusServer {

    private ModbusSlave slave;

    public void 시작(int port) throws Exception {
        ModbusFactory factory = new ModbusFactory();
        TcpParameters params = new TcpParameters();
        params.setHost("0.0.0.0");
        params.setPort(port);

        slave = factory.createTcpSlave(params, true);
        slave.setEventListener(new SlaveEventListenerImpl());
        slave.addProcessImage(1, new ModbusProcessImageImpl());

        slave.시작();
        System.out.println("Modbus 服务器已启动，监听포트：" + port);
    }

    public void stop() {
        if (slave != null) {
            slave.stop();
        }
    }
}

四、Spring Boot 통합实战

4.1 项目结构

src/main/java/com/example/industrial/
├── IndustrialApplication.java
├── config/
│   └── ModbusConfig.java
├── service/
│   ├── ModbusService.java
│   └── 데이터ProcessingService.java
├── controller/
│   └── Modbus컨트롤러.java
└── model/
    └── Device데이터.java

4.2 Modbus 설정类

package com.example.industrial.config;

import com.example.industrial.service.ModbusService;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class ModbusConfig {

    @Bean
    public ModbusService modbusService() {
        return new ModbusService("192.168.1.100", 502);
    }
}

4.3 Modbus 服务层

package com.example.industrial.service;

import com.example.modbus.ModbusTcpClient;
import com.example.industrial.model.Device데이터;
import org.springframework.stereotype.Service;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import java.util.ArrayList;
import java.util.List;

@Service
public class ModbusService {

    private ModbusTcpClient client;
    private final String host;
    private final int port;

    public ModbusService(String host, int port) {
        this.host = host;
        this.port = port;
    }

    @PostConstruct
    public void init() {
        client = new ModbusTcpClient(host, port);
        try {
            client.시작();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @PreDestroy
    public void destroy() {
        if (client != null) {
            client.stop();
        }
    }

    public Device데이터 readDevice데이터(int slaveId) {
        Device데이터 데이터 = new Device데이터();
        데이터.setDeviceId(slaveId);
        데이터.setTemperature(client.readHolding회원가입(slaveId, 0));
        데이터.setHumidity(client.readHolding회원가입(slaveId, 1));
        데이터.setPressure(client.readHolding회원가입(slaveId, 2));
        데이터.setTimestamp(System.currentTimeMillis());
        return 데이터;
    }

    public List<Device데이터> readAllDevices(int 시작Id, int count) {
        List<Device데이터> devices = new ArrayList<>();
        for (int i = 0; i < count; i++) {
            devices.add(readDevice데이터(시작Id + i));
        }
        return devices;
    }

    public void writeSetpoint(int slaveId, short value) {
        client.write회원가입(slaveId, 100, value);
    }
}

4.4 REST API 제어기

package com.example.industrial.controller;

import com.example.industrial.model.Device데이터;
import com.example.industrial.service.ModbusService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@Rest컨트롤러
@RequestMapping("/api/modbus")
@CrossOrigin(origins = "*")
public class Modbus컨트롤러 {

    @Autowired
    private ModbusService modbusService;

    @GetMapping("/device/{slaveId}")
    public Device데이터 getDevice데이터(@PathVariable int slaveId) {
        return modbusService.readDevice데이터(slaveId);
    }

    @GetMapping("/devices")
    public List<Device데이터> getAllDevices(
        @RequestParam(defaultValue = "1") int 시작Id,
        @RequestParam(defaultValue = "10") int count
    ) {
        return modbusService.readAllDevices(시작Id, count);
    }

    @PostMapping("/device/{slaveId}/setpoint")
    public String writeSetpoint(
        @PathVariable int slaveId,
        @RequestParam short value
    ) {
        modbusService.writeSetpoint(slaveId, value);
        return "设置点已更新";
    }
}

4.5 데이터模型

package com.example.industrial.model;

import lombok.데이터;

@데이터
public class Device데이터 {
    private int deviceId;
    private short temperature;
    private short humidity;
    private short pressure;
    private long timestamp;
}

五、高级적용시나리오

5.1 异步데이터采集

package com.example.industrial.service;

import java.util.concurrent.*;
import java.util.function.Consumer;

public class Async데이터Collector {

    private final ScheduledExecutorService scheduler = 
        Executors.newScheduledThreadPool(4);

    private final ModbusService modbusService;

    public Async데이터Collector(ModbusService modbusService) {
        this.modbusService = modbusService;
    }

    public void 시작PeriodicCollection(int slaveId, long interval, 
                                        Consumer<Device데이터> callback) {
        scheduler.scheduleAtFixedRate(() -> {
            try {
                Device데이터 데이터 = modbusService.readDevice데이터(slaveId);
                callback.accept(데이터);
            } catch (Exception e) {
                System.err.println("데이터采集失败：" + e.getMessage());
            }
        }, 0, interval, TimeUnit.MILLISECONDS);
    }

    public void stop() {
        scheduler.shutdown();
    }
}

5.2 데이터缓存与批量处理

package com.example.industrial.service;

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.TimeUnit;

public class 데이터CacheService {

    private final ConcurrentHashMap<Integer, Device데이터> cache = 
        new ConcurrentHashMap<>();

    private final long cacheTimeout = 5000; // 5 秒

    public Device데이터 getCached데이터(int slaveId) {
        Device데이터 데이터 = cache.get(slaveId);
        if (데이터 != null && 
            System.currentTimeMillis() - 데이터.getTimestamp() < cacheTimeout) {
            return 데이터;
        }
        return null;
    }

    public void updateCache(Device데이터 데이터) {
        cache.put(데이터.getDeviceId(), 데이터);
    }

    public void cleanup() {
        long now = System.currentTimeMillis();
        cache.entrySet().removeIf(entry -> 
            now - entry.getValue().getTimestamp() > cacheTimeout
        );
    }
}

5.3 异常处理与重试机制

package com.example.industrial.service;

import com.serotonin.modbus4j.exception.ModbusException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class ResilientModbusService {

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

    private final ModbusService delegate;
    private final int maxRetries = 3;
    private final long retryDelay = 1000;

    public ResilientModbusService(ModbusService delegate) {
        this.delegate = delegate;
    }

    public Device데이터 readWithRetry(int slaveId) throws Exception {
        int attempts = 0;
        while (attempts < maxRetries) {
            try {
                return delegate.readDevice데이터(slaveId);
            } catch (ModbusException e) {
                attempts++;
                logger.warn("읽기失败，重试 {}/{}", attempts, maxRetries);
                if (attempts >= maxRetries) {
                    throw e;
                }
                Thread.sleep(retryDelay);
            }
        }
        throw new Exception("达到最大重试次数");
    }
}

六、性能优化最佳实践

6.1 연결池管理

package com.example.industrial.pool;

import org.apache.commons.pool2.impl.GenericObjectPool;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;

public class ModbusConnectionPool {

    private final GenericObjectPool<ModbusTcpClient> pool;

    public ModbusConnectionPool(String host, int port, int maxConnections) {
        GenericObjectPoolConfig<ModbusTcpClient> config = 
            new GenericObjectPoolConfig<>();
        config.setMaxTotal(maxConnections);
        config.setMaxIdle(maxConnections);
        config.setMinIdle(2);
        config.setTestOnBorrow(true);

        pool = new GenericObjectPool<>(
            new ModbusClientFactory(host, port), 
            config
        );
    }

    public ModbusTcpClient borrowClient() throws Exception {
        return pool.borrowObject();
    }

    public void returnClient(ModbusTcpClient client) {
        pool.returnObject(client);
    }

    public void close() {
        pool.close();
    }
}

6.2 批量읽기优化

// 优化前：多次单独읽기
for (int i = 0; i < 100; i++) {
    short value = master.readHolding회원가입(slaveId, i).getValue();
}

// 优化后：一次批量읽기
short[] values = master.readHolding회원가입s(slaveId, 0, 100).getValue();

6.3 超时설정优化

// 根据네트워크환경调整超时时间
master.setTimeout(500);  // 本地네트워크
master.setTimeout(2000); // 远程네트워크
master.setRetries(3);    // 重试次数

七、安全与监控

7.1 访问控制

package com.example.industrial.security;

import java.util.HashSet;
import java.util.Set;

public class ModbusAccessControl {

    private final Set<Integer> allowedSlaves = new HashSet<>();
    private final Set<Integer> readOnly회원가입s = new HashSet<>();

    public void allowSlave(int slaveId) {
        allowedSlaves.add(slaveId);
    }

    public boolean isSlaveAllowed(int slaveId) {
        return allowedSlaves.contains(slaveId);
    }

    public void markReadOnly(int registerOffset) {
        readOnly회원가입s.add(registerOffset);
    }

    public boolean isReadOnly(int registerOffset) {
        return readOnly회원가입s.contains(registerOffset);
    }
}

7.2 操作로그

package com.example.industrial.logging;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class Modbus작업Logger {

    private static final Logger logger = LoggerFactory.getLogger(
        Modbus작업Logger.class
    );

    public void logRead(int slaveId, int register, Object value) {
        logger.info("READ | Slave={} 회원가입={} Value={}", 
            slaveId, register, value);
    }

    public void logWrite(int slaveId, int register, Object value) {
        logger.warn("WRITE | Slave={} 회원가입={} Value={}", 
            slaveId, register, value);
    }

    public void log오답(int slaveId, String operation, Exception e) {
        logger.error("ERROR | Slave={} 작업={} 오답={}", 
            slaveId, operation, e.getMessage());
    }
}

八、实战案例：工业데이터采集系统

8.1 系统架构

┌─────────────┐     ┌──────────────┐     ┌─────────────┐
│ PLC 设备     │────▶│ Modbus 게이트웨이   │────▶│ Java 적용    │
│ (슬레이브)      │     │ (TCP/RTU)    │     │ (마스터)      │
└─────────────┘     └──────────────┘     └─────────────┘
                                              │
                                              ▼
                                       ┌─────────────┐
                                       │ 데이터库       │
                                       │ (MySQL)     │
                                       └─────────────┘

8.2 完整实现代码

package com.example.industrial;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;

@SpringBootApplication
@EnableScheduling
public class IndustrialApplication {

    public static void main(String[] args) {
        SpringApplication.run(IndustrialApplication.class, args);
    }
}

九、常见문제与솔루션

9.1 연결超时문제

문제： Modbus 设备响应慢导致超时 솔루션：

master.setTimeout(2000);  // 추가超时时间
master.setRetries(3);     // 추가重试次数

9.2 데이터不一致문제

문제： 읽기的데이터偶尔出现异常值 솔루션：

// 추가데이터验证
public short readValidated회원가입(int slaveId, int offset) {
    short value = master.readHolding회원가입(slaveId, offset).getValue();
    if (value < -1000 || value > 10000) {
        throw new RuntimeException("데이터超出合理范围");
    }
    return value;
}

9.3 内存泄漏문제

문제： 长时间运行后内存占用持续增长 솔루션：

// 定期清理缓存
@Scheduled(fixedRate = 300000) // 每 5 分钟
public void cleanupCache() {
    cacheService.cleanup();
}

// 正确닫기연결
@PreDestroy
public void destroy() {
    if (master != null) {
        master.destroy();
    }
}

十、总结与展望

10.1 Java Modbus 개발优势总结

跨平台性：一次编写，到处运行
企业级支持：成熟的框架和库生态
性能优异：JVM 优化带来高性能
可维护性：强유형、良好的代码组织
社区活跃：丰富的학습자료和기술支持

10.2 기술选型建议

시나리오	推荐库	理由
企业级적용	Modbus4J	功能全面，稳定性好
微服务	j2mod	轻量级，现代化 API
학습/教学	jamod	문서完善，예제丰富
高性能	Modbus4J + 연결池	支持并发和池化

10.3 未来发展方向

云原生통합：与 Kubernetes、Docker 深度통합
边缘계산：在边缘设备上运行 Modbus 服务
AI 融合：结合机器학습进行预测性维护
安全增强：TLS/SSL 加密통신支持

附录：快速参考

A.1 Maven 依赖速查

<!-- Modbus4J -->
<dependency>
    <groupId>com.infiniteautomation</groupId>
    <artifactId>modbus4j</artifactId>
    <version>3.4.0</version>
</dependency>

<!-- j2mod -->
<dependency>
    <groupId>com.ghgande</groupId>
    <artifactId>j2mod</artifactId>
    <version>3.1.4</version>
</dependency>

A.2 常用기능 코드

기능 코드	功能	설명
01	读코일	읽기开关量출력
02	读이산 입력	읽기开关量입력
03	读유지 레지스터	읽기模拟量출력
04	读입력 레지스터	읽기模拟量입력
05	写单个코일	控制开关量출력
06	写单个레지스터	控制模拟量출력
15	写多个코일	批量控制
16	写多个레지스터	批量设置

A.3 자료链接

Modbus4J GitHub: https://github.com/serotonin/modbus4j
j2mod GitHub: https://github.com/ghgande/j2mod
Spring Boot: https://spring.io/projects/spring-boot
Modbus 사양: https://modbus.org/specs.php

关键词: Java Modbus, Modbus4J, 工业物联网, 企业级적용, Spring Boot, 데이터采集, 自动化控制字数: 약 8,500 字

후원 좋아요