SpringBoot对OpcUA的实现：Eclipse Milo

于 2025-04-09 18:43:17 发布
阅读量386 收藏 8
点赞数 3
分类专栏： 物联网 文章标签： spring boot 后端 物联网
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_42878689/article/details/147099423
版权

OPC UA

概述

OPC UA（OPC Unified Architecture）是一种工业自动化领域的通信协议和标准，定义了一套统一的信息模型，用于描述设备的各种信息，如设备的属性、功能、数据等。这使得不同设备之间能够以标准化的方式表示和交换信息，避免了因信息表示不一致而导致的互操作性问题。以智能工厂中的机器人为例，无论机器人来自哪个厂家，通过 OPC UA 的信息模型，都可以将其运动状态、任务执行情况等信息以统一的格式提供给其他设备或系统。

特点

  • 统一通信标准：OPC UA 提供了一种统一的通信标准，能够将这些异构设备连接在一起，实现设备之间的无缝通信和互操作性。
  • 信息模型标准化：OPC UA 定义了一套统一的信息模型，用于描述设备的各种信息。
  • 高效数据采集：OPC UA 能够与各种工业设备、传感器等进行通信，高效地采集它们产生的数据。它支持多种数据采集方式，包括周期性采集、事件触发采集等，可以根据实际需求灵活选择。
  • 可靠数据传输：OPC UA 采用了可靠的通信协议，能够确保数据在传输过程中的准确性和完整性。它支持数据的加密和压缩，提高了数据传输的安全性和效率。

Eclipse Milo

Milo 是 OPC UA（目前针对 1.03 版本）的开源实现。它包含了一个高性能的栈（通道、序列化、数据结构、安全）以及基于该栈构建的客户端和服务器软件开发工具包（SDK）。

SpringBoot集成Eclipse Milo

版本

java.version  17
SpringBoot.version  3.4.1
org.eclipse.milo.version  0.6.14

添加依赖

<dependency>
    <groupId>org.eclipse.milo</groupId>
    <artifactId>sdk-client</artifactId>
    <version>${org.eclipse.milo.version}</version>
</dependency>

<dependency>
    <groupId>org.eclipse.milo</groupId>
    <artifactId>stack-client</artifactId>
    <version>${org.eclipse.milo.version}</version>
</dependency>

初始化OpcUA并启动

从数据库中查出opc信息，并构建需要订阅的NodeId。

@Service
@Slf4j
public class GlobalBoostrapService implements ApplicationRunner{

	@Resource
	private SyncOpcInfoService syncOpcInfoService;
	@Resource
	private SyncOpcNodeService syncOpcNodeService;

	@Override
	public void run(ApplicationArguments args) {
		try{
			List<SyncOpcInfo> list = syncOpcInfoService.list();
			List<SyncOpcNode> nodes = syncOpcNodeService.list();
			if(list.isEmpty()) return;
			OpcUaCache.nodeMap = nodes.stream().collect(Collectors.toMap(SyncOpcNode::getId, node -> node));
			OpcUaCache.urls = list.stream().collect(Collectors.toMap(SyncOpcInfo::getId, SyncOpcInfo::getUrl));
			list.forEach(info -> CompletableFuture.runAsync(()->{
				OpcUaClient client = OpcUaClientUtils.getClient(info.getUrl());
				if(client == null) return;
				List<SyncOpcNode> nodeList = nodes.stream().filter(node -> node.getOpcId().equals(info.getId())).toList();
				if(nodeList.isEmpty()) return;
				Map<String,SyncOpcNode> map = new HashMap<>();
				nodeList.forEach(node -> {
					String key = StringUtils.isBlank(node.getIdentifier())?String.valueOf(node.getRealAddress()):node.getIdentifier();
					map.put(key,node);
				});
				OpcUaCache.nodes.put(info.getUrl(),map);
				List<NodeId> listNodeId = new ArrayList<>();
				nodeList.forEach(node -> {
					String identifier = node.getIdentifier();
					if(!StringUtils.isBlank(identifier)){
						if ("Integer".equalsIgnoreCase(node.getNodeType())) {
							listNodeId.add(new NodeId(node.getNameSpace(), Integer.parseInt(identifier)));
						}else{
							listNodeId.add(new NodeId(node.getNameSpace(), identifier));
						}
					}else {
						listNodeId.add(new NodeId(node.getNameSpace(), node.getRealAddress()));
					}
				});
				OpcUaClientUtils.createSubscription(info.getUrl(), listNodeId, 50);
			}));
		}catch (Exception e){
			log.error("GlobalBoostrapService.run error: {}", e.getMessage(), e);
		}
	}
}

服务关闭时需断开OPC连接

@SpringBootApplication
public class Application {

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

    @PreDestroy
    public void destroy() {
        for (Map.Entry<String, OpcUaClient> entry: OpcUaCache.clients.entrySet()) {
            String url = entry.getKey();
            OpcUaClientUtils.closeClient(url);
        }
    }
}

OpcUA启动相关类

Client

import org.eclipse.milo.opcua.stack.core.types.structured.EndpointDescription;
import java.util.function.Predicate;

public class Client {
	
	private String url;
	
	public Client() {
	}
	
	public Client(String url) {
		this.url = url;
	}
	
    public String getEndpointUrl() {
        return url;
    }
    
    public Predicate<EndpointDescription> endpointFilter() {
        return e -> true;
    }
}

启动类：ClientRunner

此类实现了连接失败自动重连的机制，以及事务完成后关闭连接，释放资源。

import lombok.extern.slf4j.Slf4j;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.eclipse.milo.opcua.sdk.client.OpcUaClient;
import java.security.Security;
import java.util.concurrent.*;

@Slf4j
public class ClientRunner {

    private final ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);

    static {
        Security.addProvider(new BouncyCastleProvider());
    }

    public Client client;
    
    public ClientRunner(Client client) {
        this.client = client;
    }

    public OpcUaClient run() {
    	CompletableFuture<OpcUaClient> future = new CompletableFuture<>();//首先new一个任务
        OpcUaClient opcUaClient;
        try {
            String url = client.getEndpointUrl();
            opcUaClient = OpcUaClient.create(url);//创建客户端
            opcUaClient.connect().get();
            OpcUaCache.clients.put(url, opcUaClient);
            log.info("{} is connect success", url);
            //任务完成后的处理
            future.whenCompleteAsync((c, ex) -> {
                if (ex != null) {
                    log.error("Error running example: {}", ex.getMessage(), ex);
                }
                try {
                    OpcUaCache.clients.remove(url);
                    log.info("{} is close success", url);
                	opcUaClient.disconnect().get();
                } catch (InterruptedException | ExecutionException e) {
                    log.error("Error disconnecting: {}", e.getMessage(), e);
                }
            });
            return opcUaClient;
        } catch (Throwable t) {
            log.error("Error getting client: {}{}", t.getMessage(), client.getEndpointUrl());
            executor.schedule(() -> {
                this.run();
            },5000, TimeUnit.MILLISECONDS);
        }
        return null;
    }
}

缓存相关：OpcUaCache

import com.sync.entity.SyncOpcNode;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.eclipse.milo.opcua.sdk.client.OpcUaClient;
import org.eclipse.milo.opcua.stack.core.types.builtin.NodeId;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
@Slf4j

public class OpcUaCache {
    /**
     * 服务器列表
     */
    public static Map<String, String> urls = new ConcurrentHashMap<>();
    /**
     * 订阅的节点列表
     */
    public static Map<String, Map<String,SyncOpcNode>> nodes = new ConcurrentHashMap<>();

    public static Map<String, SyncOpcNode> nodeMap = new ConcurrentHashMap<>();

    /**
     * 连接的客户端列表
     */
    public static Map<String, OpcUaClient> clients = new ConcurrentHashMap<>();

    /**
     * opc缓存数据:key为opc地址，value为订阅的数据
     */
    public static Map<String,Object> data = new ConcurrentHashMap<>();

    public static OpcUaClient getOpcUaClientByNode(String node){
        if(nodeMap.containsKey(node)){
            SyncOpcNode syncOpcNode = nodeMap.get(node);
            String opcId = syncOpcNode.getOpcId();
            if(urls.containsKey(opcId)){
                String url = urls.get(opcId);
                if(clients.containsKey(url)){
                    return clients.get(url);
                }
            }
            throw new RuntimeException("PLC connect error,opc url is null");
        }
        throw new RuntimeException("node is invalid,node:"+node);
    }

    public static NodeId getNodeIdByNode(String node){
        if(nodeMap.containsKey(node)){
            SyncOpcNode syncOpcNode = nodeMap.get(node);
            String identifier = syncOpcNode.getIdentifier();
            if(!StringUtils.isBlank(identifier)){
                if ("Integer".equalsIgnoreCase(syncOpcNode.getNodeType())) {
                    return new NodeId(syncOpcNode.getNameSpace(), Integer.parseInt(identifier));
                }else{
                    return new NodeId(syncOpcNode.getNameSpace(), identifier);
                }
            }else {
                return new NodeId(syncOpcNode.getNameSpace(), syncOpcNode.getRealAddress());
            }
        }
        throw new RuntimeException("未找到节点");
    }
}

工具类：OpcUaClientUtils

在此类中提供了获取连接的客户端、连接客户端、关闭客户端、获取单个节点值、写变量、创建订阅等方法。

import com.sync.entity.SyncOpcNode;
import lombok.extern.slf4j.Slf4j;
import org.eclipse.milo.opcua.sdk.client.OpcUaClient;
import org.eclipse.milo.opcua.sdk.client.api.subscriptions.UaSubscription;
import org.eclipse.milo.opcua.stack.core.AttributeId;
import org.eclipse.milo.opcua.stack.core.Stack;
import org.eclipse.milo.opcua.stack.core.types.builtin.*;
import org.eclipse.milo.opcua.stack.core.types.builtin.unsigned.UInteger;
import org.eclipse.milo.opcua.stack.core.types.enumerated.MonitoringMode;
import org.eclipse.milo.opcua.stack.core.types.enumerated.TimestampsToReturn;
import org.eclipse.milo.opcua.stack.core.types.structured.MonitoredItemCreateRequest;
import org.eclipse.milo.opcua.stack.core.types.structured.MonitoringParameters;
import org.eclipse.milo.opcua.stack.core.types.structured.ReadValueId;
import java.util.*;
import java.util.concurrent.ExecutionException;

@Slf4j
public class OpcUaClientUtils {

	/**
	 * 	获取连接的客户端
	 * @param url opc url
	 * @return OpcUaClient
	 */
	public static OpcUaClient getClient(String url) {
		if(OpcUaCache.clients.containsKey(url)) {
			return OpcUaCache.clients.get(url);
		}
		return connect(url);
	}
	
	/**
	 * 	连接客户端
	 * @param url opc url
	 * @return 200 连接成功 201 存在连接 500 连接失败
	 */
	private static OpcUaClient connect(String url) {
		Client client = new Client(url);
		return new ClientRunner(client).run();
	}
	
	
	/**
	 * 关闭客户端
	 * @param url url
	 */
	public static void closeClient(String url) {
		if(OpcUaCache.clients.containsKey(url)) {
			OpcUaClient opcUaClient = OpcUaCache.clients.get(url);
            try {
				opcUaClient.disconnect().get();
				OpcUaCache.data.remove(url);
                log.info("{} is close success", url);
            } catch (Exception e) {
            	log.error("Error running closeOpcUaClient: {}", e.getMessage(), e);
			}
		}
	}


	/**
	 * 	获取单个节点值
	 * @param client client
	 * @param nodeId nodeId
	 */
	public static Object readValue(OpcUaClient client,NodeId nodeId){
		// 第一个参数如果设置为0的话会获取最新的值，如果maxAge设置到Int32的最大值，则尝试从缓存中读取值。
		// 第二个参数为请求返回的时间戳,第三个参数为要读取的NodeId对象。
	    DataValue value;
		try {
			value = client.readValue(0.0, TimestampsToReturn.Both, nodeId).get();
			return value.getValue().getValue();
		} catch (InterruptedException | ExecutionException e) {
			log.error("Error reading value: {}", e.getMessage(), e);
		}
		return null;
	}

	public static boolean writeValue(OpcUaClient client, NodeId nodeId, Object value) {
		try{
			Variant v = new Variant(value);
			DataValue dataValue = new DataValue(v,null,null);
			StatusCode statusCode = client.writeValue(nodeId, dataValue).get();
			if(statusCode.getValue()!=0){
				log.error("writeValue:{},={},statusCode={}",nodeId,value,statusCode.getValue());
				return false;
			}
			return true;
		}catch (Exception e){
			throw new RuntimeException(e);
		}
	}
	
	/**
	 * 写变量
	 * @param client client
	 * @param map    map
	 */
	public static void writeValues(OpcUaClient client, Map<NodeId, Object> map) throws ExecutionException, InterruptedException {
		if(map==null || map.isEmpty())
			return;
		String url = client.getConfig().getEndpoint().getEndpointUrl();
		for(Map.Entry<NodeId, Object> entry:map.entrySet()){
	        Object value = entry.getValue();  
	        Variant v = new Variant(value);
		    DataValue dataValue = new DataValue(v,null,null);
			StatusCode statusCode = client.writeValue(entry.getKey(), dataValue).get();
			if(statusCode.getValue()!=0){
                log.error("writeValues:{},={},statusCode={}", entry.getKey(), value, statusCode.getValue());
				new Thread(()->{
					NodeId key_ = entry.getKey();
					Object value_ = entry.getValue();
					Variant v_ = new Variant(value_);
					DataValue dataValue_ = new DataValue(v_,null,null);
					for(int i=0;i<5;i++){
						try {
							Thread.sleep(20);
							StatusCode statusCode_ = client.writeValue(key_, dataValue_).get();
                            log.info("url:{},writeCount:{}", url, i);
                            log.info("writeValue:{},={},statusCode={},writeCount:{}", key_, value_, statusCode_.getValue(), i);
							if(statusCode_.getValue()==0) break;
						} catch (Exception e) {
							throw new RuntimeException(e);
						}
					}

				}).start();
			}
	    }
	}

    /**
     * 	创建订阅，添加受监视的项，然后等待值到达。
	 * 	服务器断线重连，应该调用onSubscriptionTransferFailed（）回调，因为客户端重新连接服务器将无法在订阅丢失其所有状态后传输订阅。
     * @param nodeIds  创建订阅的变量
     * @param sf 订阅间隔，单位ms
	 */
	public static void createSubscription(String url,List<NodeId> nodeIds, double sf){
		OpcUaClient client = getClient(url);
		HashSet<NodeId> set = new HashSet<>(nodeIds);
		nodeIds.clear();
		nodeIds.addAll(set);
		while(client==null){
			try {
				Thread.sleep(1000);
				if(OpcUaCache.clients.containsKey(url)) {
					client = OpcUaCache.clients.get(url);
				}
			} catch (InterruptedException e) {
				log.error("Error sleeping: {}", e.getMessage(), e);
			}
		}
		try {
            log.info("{} createSubscription", url);
			OpcUaClient finalClient = client;
			client.getSubscriptionManager().addSubscriptionListener(
					new org.eclipse.milo.opcua.sdk.client.api.subscriptions.UaSubscriptionManager.SubscriptionListener() {
	            @Override
	            public void onSubscriptionTransferFailed(UaSubscription subscription, StatusCode statusCode) {
	                Stack.sharedExecutor().execute(() -> {
	                    try {
	                    	createItemAndWait(url, finalClient,nodeIds,sf);
	                    } catch (InterruptedException | ExecutionException e) {
	                        log.error("Error creating Subscription: {}", e.getMessage(), e);
	                    }
	                });
	            }
	        });
	        createItemAndWait(url,client,nodeIds,sf);
		} catch (InterruptedException | ExecutionException e) {
            log.info("{}订阅点位时发生了错误", url, e);
			throw new RuntimeException(url+"订阅点位时发生了错误");
        }
	}
	
	private static void createItemAndWait(
			String url,
			OpcUaClient client,
			List<NodeId> nodeIds,
			double sf) throws InterruptedException, ExecutionException {
		client.getSubscriptionManager().clearSubscriptions();
		//创建发布间隔sf的订阅对象
	    UaSubscription subscription = client.getSubscriptionManager().createSubscription(sf).get();
	    List<MonitoredItemCreateRequest> requests = new ArrayList<>();
        for (NodeId nodeId : nodeIds) {
            ReadValueId readValueId = new ReadValueId(
                    nodeId, AttributeId.Value.uid(), null, QualifiedName.NULL_VALUE
            );
            UInteger clientHandle = subscription.nextClientHandle();
            //	创建监控的参数
            MonitoringParameters parameters = new MonitoringParameters(
                    clientHandle, sf, null, UInteger.valueOf(10), true
            );
            //	创建监控项请求
		    //	该请求最后用于创建订阅。
            MonitoredItemCreateRequest request = new MonitoredItemCreateRequest(
                    readValueId, MonitoringMode.Reporting, parameters
            );
            requests.add(request);
        }
	    //	创建监控项，并且注册变量值改变时候的回调函数。
	    subscription.createMonitoredItems(
	    TimestampsToReturn.Both,
	    requests,
	    (item,id)-> item.setValueConsumer((item1, value)->{
			try {
				NodeId nodeId = item1.getReadValueId().getNodeId();
				Variant  variant = value.getValue();
				Map<String, SyncOpcNode> node = new HashMap<>();
				if(OpcUaCache.nodes!=null && OpcUaCache.nodes.containsKey(url)) {
					node = OpcUaCache.nodes.get(url) ;
				}
				if(node.containsKey(String.valueOf(nodeId.getIdentifier()))){
					OpcUaCache.data.put(node.get(String.valueOf(nodeId.getIdentifier())).getId(), variant.getValue());
				}
			} catch (Exception e) {
                log.error("subscription is error {}", e.getMessage());
			}
		})).get();
	}
}
springboot整合milo库实现对opc ua连接配置的动态修改
洛阳泰山的博客
11-04 436
本文主要探讨如何在Spring Boot项目中集成Eclipse Milo库，以实现对OPC UA服务器连接配置的动态修改。OPC UA（Open Platform Communications Unified Architecture）是一种工业通信协议，广泛应用于工业自动化领域，用于实现不同设备和系统之间的互操作性。Eclipse Milo是一个开源的Java库，支持OPC UA客户端和服务端的开发。 在实际应用中，静态配置OPC UA连接可能无法满足动态变化的需求，因此需要一种机制来动态调整连接参数
Springboot 实现操作OPC ua Server 的数据读写 | 代码教程
洛阳泰山的博客
05-18 3469
本次采用KEPServerEX5模拟服务端，使用milo开发的程序作为客户端 搭建服务端，KEPServerEX6的安装省略掉，下面是配置过程 设置通道、设备、标签 代码教程 pom文件引入milo客户端jar包依赖 <dependency> <groupId>org.eclipse.milo</groupId> <artifactId>sdk-client</artifac.
基于springboot实现的opc 客户端
04-28
基于springboot实现的opc 客户端，该样例经过本人亲自测试，已用于实际项目中，有疑问欢迎留言交流。
milo：Eclipse Milo:trade_mark:-OPC UA的开源实现（IEC 62541）
02-05
蚀米洛 Milo是OPC UA的开源实现。 它包括一个高性能堆栈（通道，序列化，数据结构，安全性）以及在堆栈顶部构建的客户端和服务器SDK。 堆栈溢出标签： 邮件列表： ： Maven 建筑米洛 使用JDK 8 ，从项目根目录运行mvn clean install 。 发布 版本发布到Maven Central，快照发布到Sonatype。 OPC UA客户端SDK < dependency> < groupId>org.eclipse.milo</ groupId> < artifactId>sdk-client</ artifactId> <
基于Spring Boot的OPC客户端：高效连接工业自动化
gitblog_09716的博客
10-17 629
基于Spring Boot的OPC客户端：高效连接工业自动化 【下载地址】基于SpringBoot实现的OPC客户端 本仓库提供了一个基于Spring Boot实现的OPC客户端资源文件。该样例经过本人亲自测试，并已成功应用于实际项目中。如果您在使用过程中有任何疑问或需要进一步的交流，欢迎在仓库中留言 ...
java(springboot)集成Milo实现OPCUA客户端，读取OPCUA服务端节点数据
PcZxq的博客
07-03 2009
SpringBoot 后端项目中引入 Milo 库依赖（客户端 SDK ）
springBoot--OPCUA
最新发布
m0_57764322的博客
12-05 670
OPCUA对接springBoot全攻略
SpringBoot集成milo读写OPC UA
yinjl123456的博客
08-03 2108
SpringBoot集成milo读写OPC UA。
SpringBoot集成Milo库实现OPC UA客户端：连接、遍历节点、读取、写入、订阅与批量订阅
热门推荐
Heartsuit的博客
04-15 1万+
在这篇文章中，我们将通过 SpringBoot 集成 Milo 库实现一个 OPC UA 客户端，包括连接、遍历节点、读取、写入、订阅与批量订阅等功能。
SpringBoot集成OPC协议，批量读取数据
qq_48885166的博客
11-27 1973
DCOM配置：https://www.cnblogs.com/ioufev/p/9365919.html。安装和使用：https://www.cnblogs.com/ioufev/p/9366877.html。
基于Eclipse Milo库开发。服务端采用KepServer 6.X.zip
03-23
基于Eclipse Milo库开发。服务端采用KepServer 6.X
基于Java的OPC UA Server开发指南：从零开始构建高效服务器
洛阳泰山的博客
01-23 2234
本文介绍了如何使用开源项目org.eclipse.milo创建Java OPC UA Server。通过创建Spring Boot项目，添加Milo SDK依赖，定义Namespace类，服务器启动类以及监听器，详细阐述了建立OPC UA Server服务的步骤。启动后，服务器默认监听地址为opc.tcp://localhost:12685，可使用Softing OPC Client进行连接。
Java代码实现opc ua 节点历史数据读取
洛阳泰山的博客
10-11 1384
OPC UA（Open Platform Communications Unified Architecture）·是一种工业通信协议，旨在提供安全可靠的工业数据交换。随着工业4.0和物联网技术的发展，OPC UA成为了连接各种设备和系统的重要桥梁。本文将介绍如何使用Java编程语言通过·OPC UA·协议从服务器读取历史数据。
Java使用eclipse.milo连接KEPServerEx6服务器详细步骤（匿名访问）
et4wgsf的博客
05-21 1972
其中ns代表namespace，表示节点所在的命名空间，命名空间是一种机制，用于区分不同来源的节点ID。原因2：在OPCUA配置中，URL为opc.tcp://127.0.0.1:49320的项目的安全策略配置与2.1中添加通道的安全策略配置不一样。在某些情况下，KEPServer的标记的值会持续变动（本人也不太清楚）有条件的也可以使用下面的服务端进行调试。在Java代码中只给出了基本的读单个点位数据的方法，如有需要其它多个读、写、多个写的方法的朋友，可以私信我要源码，我会直接给你的。
基于Spring Boot实现的OPC客户端
gitblog_09795的博客
10-17 371
基于Spring Boot实现的OPC客户端 【下载地址】基于SpringBoot实现的OPC客户端 本仓库提供了一个基于Spring Boot实现的OPC客户端资源文件。该样例经过本人亲自测试，并已成功应用于实际项目中。如果您在使用过程中有任何疑问或需要进一步的交流，欢迎在仓库中留言 ...
Springboot集成Milo实现OPCUA客户端，读取OPCUA服务端节点数据
chen_lay的博客
07-18 2616
使用KEPServerEX6.4模拟OPCUA服务端数据一、安装KEPServerEX6.4安装包地址：链接：https://pan.baidu.com/s/1Ku_NcK1xk8bP-n1Ch3nM3A 提取码：rqs6二、配置KEPServerEX6.4，模拟OPCUA服务端数据1、设置-用户管理器 新建用户（1）右键点击图标，选择设置（2）添加OPC_UA服务器用户，我的是my_opc_ua，设置密码后，点击确定和应用2、OPCUA配置。
Java使用Milo实现OPC UA客户端，封装spring boot starter
kangaroo的博客
05-05 7815
本文介绍基于eclipse milo 封装的spring boot starter，yml配置OPC UA地址，是否匿名等信息，即可连接OPC UA服务器。
springboot-opc_ua实现客户端通讯
qq_47848696的博客
04-15 2104
spring boot opc通讯
springboot 整合opc
05-01
可以使用 Eclipse Milo 这个开源库来实现 Spring Boot 与 OPC UA 的集成。Eclipse Milo 提供了 OPC UA 的客户端和服务器实现，同时还提供了一些基本的工具和示例代码。 下面是一些大致的步骤： 1. 在 Maven 或 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

loser.with.m

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值