Java使用Milo实现OPC UA客户端

已于 2023-08-08 22:04:12 修改
阅读量2.4k 收藏 13
点赞数 5
分类专栏： java opc milo 文章标签： java
于 2023-08-08 22:01:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41697540/article/details/132175607
版权
java 同时被 3 个专栏收录
4 篇文章 0 订阅
订阅专栏
opc
1 篇文章 0 订阅
订阅专栏
milo
1 篇文章 0 订阅
订阅专栏

文章目录

一、前置条件
二、KEPServerEX 6的配置
三、OPC 客户端开发
四、测试
五、注意点

一、前置条件

jdk:1.8、maven:3.8.1、OPC服务端:KEPServerEX 6、Milo

二、KEPServerEX 6的配置

若有下角没有图中的图标，运行KEPServerEX 6 Administration

维护服务器端点信息：

        指定url和相应的安全策略

url:opc.tcp://127.0.0.1:49320
安全策略:None、Basic128Rsa15、Basic256、Basic256Sha256、Aes128_Sha256_RsaOaep、Aes256_Sha256_RsaPss

 添加完指定的用户信息，如下图：

运行项目后选择允许访问的客户端名称对应的证书，点击信任后如下：

 

创建通道->添加设备->维护相应的标记(根据项目需要指定相应的类型和访问权限)

三、OPC 客户端开发

        1 引入Milo库


		<dependency>
			<groupId>org.eclipse.milo</groupId>
			<artifactId>sdk-client</artifactId>
			<version>0.6.10</version>
		</dependency>
		<dependency>
			<groupId>org.bouncycastle</groupId>
			<artifactId>bcpkix-jdk15on</artifactId>
			<version>1.69</version>
		</dependency>
		<dependency>
			<groupId>org.eclipse.milo</groupId>
			<artifactId>sdk-server</artifactId>
			<version>0.6.10</version>
		</dependency>

         2.创建OPC客户端

package com.example.opc;

import com.example.opc.service.OpcUAClientService;
import lombok.extern.slf4j.Slf4j;
import org.eclipse.milo.opcua.sdk.client.OpcUaClient;
import org.eclipse.milo.opcua.stack.core.Stack;
import org.eclipse.milo.opcua.stack.core.types.builtin.LocalizedText;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;

import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;

import static org.eclipse.milo.opcua.stack.core.types.builtin.unsigned.Unsigned.uint;

/**
 * @License : (C) Copyright, MaxSense (Shanghai) Technology Co., Ltd.
 *
 * @file    : OpcUAClientRunner.java
 *
 * @desc    : 
 *
 * @author  : xxx
 *
 * @date    : 2023/8/3 11:44
 *
 * @version : V1.0
 *
 */
@Slf4j
@Service("OpcUAClientRunner")
public class OpcUAClientRunner {
    private final Logger logger = LoggerFactory.getLogger(getClass());
    private final CompletableFuture<OpcUaClient> future = new CompletableFuture<>();
    private final OpcUAClientService opcUAClientService;

    public OpcUAClientRunner(OpcUAClientService opcUAClientService) {
        this.opcUAClientService = opcUAClientService;
    }

    /**
     * OPC UA的运行入口程序
     */
    public void run() {
        try {
            // 创建OPC UA客户端
            OpcUaClient opcUaClient = createClient();
            // future执行完毕后，异步判断状态
            future.whenCompleteAsync((c, ex) -> {
                if (ex != null) {
                    logger.error("连接OPC UA服务错误: {}", ex.getMessage(), ex);
                }
                // 关闭OPC UA客户端
                try {
                    opcUaClient.disconnect().get();
                    Stack.releaseSharedResources();
                } catch (InterruptedException | ExecutionException e) {
                    logger.error("OPC UA服务关闭错误: {}", e.getMessage(), e);
                }
            });
            try {
                // 获取OPC UA服务器的数据
                opcUAClientService.run(opcUaClient, future);
                future.get(5, TimeUnit.SECONDS);
            } catch (Throwable t) {
                logger.error("OPC UA客户端运行错误: {}", t.getMessage(), t);
                future.completeExceptionally(t);
            }
        } catch (Throwable t) {
            logger.error("OPC UA客户端创建错误: {}", t.getMessage(), t);
            future.completeExceptionally(t);
        }
    }

    /**
     * 创建OPC UA的服务连接对象
     */
    private OpcUaClient createClient() throws Exception {
        Path securityTempDir = Paths.get(System.getProperty("java.io.tmpdir"), "client", "security");
        Files.createDirectories(securityTempDir);
        if (!Files.exists(securityTempDir)) {
            throw new Exception("unable to create security dir: " + securityTempDir);
        }
        KeyStoreLoader loader = new KeyStoreLoader().load(securityTempDir);
        // 创建OPC UA客户端
        return OpcUaClient.create(
                opcUAClientService.getEndpointUrl(),
                endpoints ->
                        endpoints.stream()
                                .filter(opcUAClientService.endpointFilter())
                                .findFirst(),
                configBuilder ->
                        configBuilder
                                .setApplicationName(LocalizedText.english("eclipse milo opc-ua client"))
                                .setApplicationUri("urn:eclipse:milo:client")
                                .setKeyPair(loader.getClientKeyPair())
                                .setCertificate(loader.getClientCertificate())
                                .setCertificateChain(loader.getClientCertificateChain())
//                                .setCertificateValidator(certificateValidator)
                                .setIdentityProvider(opcUAClientService.getIdentityProvider())
                                .setRequestTimeout(uint(5000))
                                .build()
        );
    }
}

         3.创建opc客户端证书

package com.example.opc;

import lombok.extern.slf4j.Slf4j;
import org.eclipse.milo.opcua.sdk.server.util.HostnameUtil;
import org.eclipse.milo.opcua.stack.core.util.SelfSignedCertificateBuilder;
import org.eclipse.milo.opcua.stack.core.util.SelfSignedCertificateGenerator;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.InputStream;
import java.io.OutputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.security.*;
import java.security.cert.X509Certificate;
import java.util.Arrays;
import java.util.regex.Pattern;

/**
 * @License : (C) Copyright, MaxSense (Shanghai) Technology Co., Ltd.
 *
 * @file    : KeyStoreLoader.java
 *
 * @desc    :
 *
 * @author  : xxx
 *
 * @date    : 2023/8/3 11:45
 *
 * @version : V1.0
 *
 */
@Slf4j
public class KeyStoreLoader {

    private static final Pattern IP_ADDR_PATTERN = Pattern.compile(
            "^(([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\.){3}([01]?\\d\\d?|2[0-4]\\d|25[0-5])$");

    private static final String CLIENT_ALIAS = "client-ai";
    private static final char[] PASSWORD = "milo".toCharArray();

    private final Logger logger = LoggerFactory.getLogger(getClass());

    private X509Certificate[] clientCertificateChain;
    private X509Certificate clientCertificate;
    private KeyPair clientKeyPair;

    KeyStoreLoader load(Path baseDir) throws Exception {
        KeyStore keyStore = KeyStore.getInstance("PKCS12");

        Path serverKeyStore = baseDir.resolve("milo-client.pfx");

        logger.info("Loading KeyStore at {}", serverKeyStore);

        if (!Files.exists(serverKeyStore)) {
            keyStore.load(null, PASSWORD);

            KeyPair keyPair = SelfSignedCertificateGenerator.generateRsaKeyPair(2048);

            SelfSignedCertificateBuilder builder = new SelfSignedCertificateBuilder(keyPair)
                    .setCommonName("Eclipse Milo Client")
                    .setOrganization("digitalpetri")
                    .setOrganizationalUnit("dev")
                    .setLocalityName("Folsom")
                    .setStateName("CA")
                    .setCountryCode("CN")
                    .setApplicationUri("urn:eclipse:milo:client")
                    .addDnsName("localhost")
                    .addIpAddress("127.0.0.1");

            // Get as many hostnames and IP addresses as we can listed in the certificate.
            for (String hostname : HostnameUtil.getHostnames("0.0.0.0")) {
                if (IP_ADDR_PATTERN.matcher(hostname).matches()) {
                    builder.addIpAddress(hostname);
                } else {
                    builder.addDnsName(hostname);
                }
            }

            X509Certificate certificate = builder.build();

            keyStore.setKeyEntry(CLIENT_ALIAS, keyPair.getPrivate(), PASSWORD, new X509Certificate[]{certificate});
            try (OutputStream out = Files.newOutputStream(serverKeyStore)) {
                keyStore.store(out, PASSWORD);
            }
        } else {
            try (InputStream in = Files.newInputStream(serverKeyStore)) {
                keyStore.load(in, PASSWORD);
            }
        }

        Key clientPrivateKey = keyStore.getKey(CLIENT_ALIAS, PASSWORD);
        if (clientPrivateKey instanceof PrivateKey) {
            clientCertificate = (X509Certificate) keyStore.getCertificate(CLIENT_ALIAS);

            clientCertificateChain = Arrays.stream(keyStore.getCertificateChain(CLIENT_ALIAS))
                    .map(X509Certificate.class::cast)
                    .toArray(X509Certificate[]::new);

            PublicKey serverPublicKey = clientCertificate.getPublicKey();
            clientKeyPair = new KeyPair(serverPublicKey, (PrivateKey) clientPrivateKey);
        }

        return this;
    }

    X509Certificate getClientCertificate() {
        return clientCertificate;
    }

    public X509Certificate[] getClientCertificateChain() {
        return clientCertificateChain;
    }

    KeyPair getClientKeyPair() {
        return clientKeyPair;
    }
}

        四.opc客户端服务类

package com.example.opc.service;

import org.eclipse.milo.opcua.sdk.client.OpcUaClient;
import org.eclipse.milo.opcua.sdk.client.api.identity.IdentityProvider;
import org.eclipse.milo.opcua.sdk.client.api.identity.UsernameProvider;
import org.eclipse.milo.opcua.stack.core.UaException;
import org.eclipse.milo.opcua.stack.core.security.SecurityPolicy;
import org.eclipse.milo.opcua.stack.core.types.structured.EndpointDescription;

import java.util.concurrent.CompletableFuture;
import java.util.function.Predicate;

/**
 * @License : (C) Copyright, MaxSense (Shanghai) Technology Co., Ltd.
 *
 * @file    : OpcUAClientService.java
 *
 * @desc    : 
 *
 * @author  : xxx
 *
 * @date    : 2023/8/3 12:24
 *
 * @version : V1.0
 *
 */
public interface OpcUAClientService {

    /**
     * OPC UA服务器地址和接口
     */
    default String getEndpointUrl() {
        return "opc.tcp://127.0.0.1:49320";
    }

    /**
     * 过滤返回的server endpoint
     */
    default Predicate<EndpointDescription> endpointFilter() {
        return e -> getSecurityPolicy().getUri().equals(e.getSecurityPolicyUri());
    }

    /**
     * 连接服务器的安全策略
     * <p>
     *     opc客户端指定的安全策略必须被包含在opc服务端指定安全策略中
     *     否则抛{@link UaException} no endpoint selected
     * </p>
     * None、Basic128Rsa15、Basic256、Basic256Sha256、Aes128_Sha256_RsaOaep、Aes256_Sha256_RsaPss
     */
    default SecurityPolicy getSecurityPolicy() {
        return SecurityPolicy.Basic256;
    }

    /**
     * 提供身份验证
     * <p>
     *     username和password需求服务端创建然后提供
     * </p>
     */
    default IdentityProvider getIdentityProvider() {
        return new UsernameProvider("jfy", "123456");
    }

    /**
     * 实际操作服务、由实现类重写实现
     */
    void run(OpcUaClient client, CompletableFuture<OpcUaClient> future) throws Exception;
}

        五.opc客户端实现类

package com.example.opc.service.impl;

import com.example.opc.service.OpcUAClientService;
import com.google.common.collect.ImmutableList;
import lombok.extern.slf4j.Slf4j;
import org.eclipse.milo.opcua.sdk.client.OpcUaClient;
import org.eclipse.milo.opcua.sdk.client.nodes.UaNode;
import org.eclipse.milo.opcua.sdk.client.nodes.UaVariableNode;
import org.eclipse.milo.opcua.stack.core.Identifiers;
import org.eclipse.milo.opcua.stack.core.UaException;
import org.eclipse.milo.opcua.stack.core.types.builtin.DataValue;
import org.eclipse.milo.opcua.stack.core.types.builtin.NodeId;
import org.eclipse.milo.opcua.stack.core.types.enumerated.ServerState;
import org.eclipse.milo.opcua.stack.core.types.enumerated.TimestampsToReturn;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.concurrent.CompletableFuture;

import static com.example.opc.opcenum.UaNodeEnum.CHANNEL_1;

/**
 * @License : (C) Copyright, MaxSense (Shanghai) Technology Co., Ltd.
 *
 * @file    : OpcUAClientServiceImpl.java
 *
 * @desc    : 
 *
 * @author  : xxx
 *
 * @date    : 2023/8/3 12:24
 *
 * @version : V1.0
 *
 */
@Slf4j
@Service("OpcUAClientService")
public class OpcUAClientServiceImpl implements OpcUAClientService {

    /**
     * 覆盖接口的方法，建立和OPC UA的服务
     */
    @Override
    public void run(OpcUaClient client, CompletableFuture<OpcUaClient> future) throws Exception {
        // 同步建立连接
        client.connect().get();
        // synchronous read request via VariableNode
        UaVariableNode node = client.getAddressSpace().getVariableNode(Identifiers.Server_ServerStatus_StartTime);
        DataValue value = node.readValue();

        log.info("StartTime={}", value.getValue().getValue());

        // 异步读取数据
        readTagData(client).thenAccept(values -> {
            DataValue nodeId_Tag1 = values.get(0);
            DataValue nodeId_Tag2 = values.get(1);

            System.out.println("#########Tag1=" + nodeId_Tag1.getValue().getValue());
            System.out.println("#########Tag2=" + nodeId_Tag2.getValue().getValue());

            log.info("State={}", ServerState.from((int) nodeId_Tag1.getStatusCode().getValue()));
            log.info("CurrentTime={}", nodeId_Tag1.getServerTime().getJavaDate());

            future.complete(client);
        });
    }

    /**
     * 读取标签点的数据
     */
    private CompletableFuture<List<DataValue>> readTagData(OpcUaClient client) throws UaException {
        // 获取节点列表
        // Identifiers.RootFolder-->Milo库预定义的根目录
        final List<? extends UaNode> nodes = new ArrayList<>();
        browseNode(0, "", client, Identifiers.RootFolder, (List<UaNode>) nodes);

        NodeId nodeId_Tag1 = new NodeId(2, "通道 1.Device1.Tag1");
        NodeId nodeId_Tag2 = new NodeId(2, "通道 1.Device1.Tag2");
        List<NodeId> nodeIds = ImmutableList.of(nodeId_Tag1, nodeId_Tag2);
        return client.readValues(0.0, TimestampsToReturn.Both, nodeIds);
    }

    /**
     * 遍历树形节点
     * @param deep
     * @param indent
     * @param client
     * @param browseRoot
     * @param nodes
     * @return
     */
    private List<? extends UaNode> browseNode(final int deep, final String indent, final OpcUaClient client, final NodeId browseRoot, final List<UaNode> nodes) {
        try {
            List<? extends UaNode> nodeList = client.getAddressSpace().browseNodes(browseRoot);
            for (final UaNode node : nodeList) {
                //排除系统性节点，这些系统性节点名称一般都是以"_"开头
                if (Objects.requireNonNull(node.getBrowseName().getName()).contains("_")) continue;
                // 匹配指定节点的数据(包含对应的子节点)
                log.info("{}--{} Node={}", deep, indent, node.getBrowseName().getName());
                if (deep == 1 && !CHANNEL_1.getName().equals(node.getBrowseName().getName())) continue;
                nodes.add(node);
                // recursively browse to children
                browseNode(deep + 1, indent + "  ", client, node.getNodeId(), nodes);
            }
        } catch (UaException e) {
            log.error("Browsing nodeId={} failed: {}", browseRoot, e.getMessage(), e);
        }
        return nodes;
    }

    private CompletableFuture<List<DataValue>> readServerStateAndTime(OpcUaClient client) {
        List<NodeId> nodeIds = ImmutableList.of(
                Identifiers.Server_ServerStatus_State,
                Identifiers.Server_ServerStatus_CurrentTime);
        return client.readValues(0.0, TimestampsToReturn.Both, nodeIds);
    }
}

 四、测试

五、注意点

1、opc服务端更新过配置后需要初始化

 2、创建OPC客户端时，下图中的ApplicationUri需和KeyStoreLoader中的保持一致，不然抛异常，

 3、url、安全策略、用户名和密码需要配置正确

三木为柯
关注
  • 5
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 8
    评论
专栏目录
Java代码实现OPC UA Client直接与PLC通讯
洛阳泰山的博客
07-03 4270
在现代制造业中，PLC（可编程逻辑控制器）被广泛应用于控制工厂设备和流程。而OPC UA（OLE for Process Control Unified Architecture）则成为了工业自动化领域中的通信协议标准。本教程将教你如何使用Java编写一个OPC UA Client来实现直接与PLC通讯。
第5 章 Consul服务注册与发现
a13763926743的博客
04-22 747
consul官网地址。
基于springboot实现的opc 客户端
04-28
基于springboot实现的opc 客户端，该样例经过本人亲自测试，已用于实际项目中，有疑问欢迎留言交流。
java实现opc ua server实例，使用milo库
02-03
milo库官方给出的示例无法直接运行，这是我修改过的示例，里面已经有了默认添加的几个节点
Java使用Milo实现OPC UA客户端，封装spring boot starter
kangaroo的博客
05-05 4244
本文介绍基于eclipse milo 封装的spring boot starter，yml配置OPC UA地址，是否匿名等信息，即可连接OPC UA服务器。
【OPCUA】使用Java开源项目milo连接KEPServerEX6服务器并读取值
MarcherXL的博客
11-07 2548
使用Java开源项目milo连接KEPServerEX6服务器并读取值，提供项目小demo，帮助解决问题
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> <
Java实现OPCUA通信
qq_27615455的博客
11-07 5811
在 linux 上看教程到还可以。🍄 设备的出现的各种状况（比如上线，某个组件出故障，某个参数超标），就是：物模型的事件，Java 中的事件，OPCUA中订阅。，服务发现时，服务端返回的断点描述的主机名或者本地IP，远程是访问不到的，按照解答参考，修改端点的主机名为远程IP地址即可。🍄 设备的参数，就是：物模型的属性值，Java 中类的属性（也可以叫变量，字段），OPCUA 中的节点的变量。🍄 设备的操作方法，就是：物模型的功能，Java 中类的方法（也可以叫函数），OPCUA 中的方法。
JAVA 使用 Milo 实现 OPCUA 客户端
lululuyang的博客
01-07 5269
JAVA使用Milo实现OPCUA客户端
springboot 整合milo连接opcua
PcZxq的博客
11-02 389
此依赖在很多帖子中没有导入 了解到此依赖是谷歌的一个工具类 疑惑的是跟opcua 的连接又有什么联系 可能是本身导入的依赖出现了版本问题或者是冲突 不管咋说希望大家养成一个文件管理的好习惯。我在上面尝试了很多方式建立连接 始终没有获取到节点的值 网上很多帖子没有这个依赖。
java实现opc ua连接及操作的代码工具包Demo
07-05
基于开源org.eclipse.milo版本 0.6.11，java实现opc ua server服务器模拟连接及客户端操作读写的代码工具包Demo
OPC UA 的java开发工具包
09-11
ＯＰＣ　ＵＡ-java源代码及示例，OPC UA之前的访问规范都是基于微软的COM/DCOM技术， 这会给新增层面的通信带来不可根除的弱点。加上传统OPC技术不够灵活、平台局限等问题的逐渐凸显， OPC基金会 (OPC Foundation) 发布了最新的数据通讯统一方法——OPC统一架构 (OPC UA)， 涵盖了OPC 实时数据访问规范 (OPC DA)、OPC历史数据访问规范 (OPC HDA)、 OPC 报警事件访问规范 (OPC A&E) 和OPC安全协议 (OPC Security) 的不同方面， 但在其基础之上进行了功能扩展。
Java通过UA协议操作OPC的demo和客户端工具
11-05
因工作需要，研究了OPC ua协议，使用Java语言连接操作OPC。本资源里面包括了代码和连接工具，以及.Net的运行环境。
java -opc ua 连接kepserver 源码
04-20
maven架构 idea编辑器 包含读取、写入、订阅、批量订阅、断点续传等功能、 下载后可直接运行 内容很简单，就一个类，采用匿名登录的方式，代码和测试全在一个类里面 注释很详细
mybatisPlus使用MetaObjectHandler对字段进行更新
最新发布
m0_56356631的博客
04-23 262
都是符合我们的预期的。
string模拟实现
m0_73969414的博客
04-23 1392
c++中string的模拟实现，面试必会知识点
实现自定义注解、实现自定义幂等性注解
qq_44721738的博客
04-23 520
添加 Spring AOP 依赖。创建自定义注解。创建一个新的 Java 注解类，通过@interface关键字来定义，并可以添加元注解以及属性。@Target(ElementType.METHOD) //表示作用于方法上@Retention(RetentionPolicy.RUNTIME) // 表示这个注解在运行时是可见的，这样 AOP 代理才能在运行时读取到这个注解编写 AOP 拦截（自定义注解）的逻辑代码。@Aspect@Component// 方法执行前的处理。
javaweb-SpringBoot基础
kussm_的博客
04-20 1291
Spring的官网(Spring的简介：Spring makes Java simple。Spring Boot 可以帮助我们非常快速的构建应用程序、简化开发、提高效率。创建一个子包controller。
java 连接opc ua的代码
06-13
下面是一个简单的 Java 代码示例，用于连接 OPC UA 服务器和读取其中的数据。这个代码示例使用 Eclipse Milo 库来实现 OPC UA 功能。 ```java import org.eclipse.milo.opcua.sdk.client.OpcUaClient; import org.eclipse.milo.opcua.sdk.client.api.identity.UsernameProvider; import org.eclipse.milo.opcua.sdk.client.model.nodes.objects.ServerNode; import org.eclipse.milo.opcua.stack.core.types.builtin.DataValue; import org.eclipse.milo.opcua.stack.core.types.builtin.NodeId; import org.eclipse.milo.opcua.stack.core.types.builtin.Variant; import java.util.concurrent.CompletableFuture; import java.util.concurrent.ExecutionException; public class OpcUaClientExample { public static void main(String[] args) throws InterruptedException, ExecutionException { // 创建 OPC UA 客户端 OpcUaClient client = OpcUaClient.create("opc.tcp://localhost:12686/UA/MyLittleServer"); // 设置用户凭证（如果需要） client.setIdentityProvider(new UsernameProvider("user", "password".toCharArray())); // 连接 OPC UA 服务器 CompletableFuture<OpcUaClient> future = client.connect(); future.get(); // 读取 OPC UA 服务器上的节点数据，例如服务器版本号 NodeId nodeId = new NodeId(2, "i=2261"); CompletableFuture<DataValue> readFuture = client.readValue(0, null, nodeId); DataValue dataValue = readFuture.get(); Variant variant = dataValue.getValue(); Object value = variant.getValue(); System.out.println("Server version: " + value); // 关闭 OPC UA 客户端 client.disconnect().get(); } } ``` 在上面的代码示例中，我们首先创建了一个 OPC UA 客户端对象，然后设置了 OPC UA 服务器的 URL 地址和用户凭证（如果需要）。接着，我们使用 `connect()` 方法连接 OPC UA 服务器，这个方法返回一个 `CompletableFuture<OpcUaClient>` 对象，我们需要使用 `get()` 方法等待连接成功。连接成功后，我们就可以使用客户端对象的各种方法来读取 OPC UA 服务器上的节点数据。在上面的代码示例中，我们读取了服务器版本号，并将其打印到控制台上。最后，我们使用 `disconnect()` 方法关闭了 OPC UA 客户端。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值