java连接opcua

于 2025-03-30 13:30:56 发布
阅读量1.2k 收藏 29
点赞数 25
分类专栏： java 文章标签： java 开发语言 opc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_44732146/article/details/146761174
版权

一、前言

OPC UA（Open Platform Communications Unified Architecture）是针对工业自动化领域的跨平台通信协议标准。它在 OPC 经典版本的基础上进行优化，可以在不同操作系统、设备和编程语言之间进行安全且可靠的数据交换。对于很多工业控制、设备监控以及物联网相关项目，OPC UA 是常用的数据通信方式。

在 Java 中，我们常用的 OPC UA 客户端开发库包括：

本篇将使用 Eclipse Milo 作为示例库，演示如何在 Java 中使用匿名、用户名密码以及证书加密三种方式连接到 OPC UA 服务器。若需要使用其他 SDK，原理大同小异，API 的调用方式会有所不同。

二、准备工作

  1. JDK
    建议至少使用 JDK 8 或更高版本。

  2. Maven 或 Gradle
    便于引入 Eclipse Milo 等依赖。如果使用 Maven，请在 pom.xml 中添加以下依赖：

    <dependency>
    <groupId>org.eclipse.milo</groupId>
    <artifactId>sdk-client</artifactId>
    <version>0.6.15</version> 
    <!-- 版本号可根据需要更新 -->
</dependency>
<dependency>
         <groupId>org.eclipse.milo</groupId>
         <artifactId>server-examples</artifactId>
         <version>0.6.15</version> 
     </dependency>

    如果使用 Gradle，则在 build.gradle 中添加：

    implementation 'org.eclipse.milo:sdk-client:0.6.15'

  3. OPC UA 服务器
    本地或远程的 OPC UA 服务器环境，用于测试连接。可以在虚拟机或本地主机上安装开源的 OPC UA 服务器，也可以使用商业软件自带的模拟服务器。

  4. 证书文件（仅在证书加密方式时需要）

    • 若您在服务器上开启了证书加密，需要准备好客户端证书（public key）和客户端私钥（private key），也可能需要服务器的信任证书。
    • Eclipse Milo 提供了简单的证书管理机制，或者您也可以使用标准 Java KeyStore 的方式来存储并读取证书和私钥。

三、匿名方式连接

3.1 匿名方式简介

匿名连接是最简单的方式，不需要用户名、密码或任何证书。只要服务器允许匿名访问，就可以通过匿名方式连接。适合在测试环境或对安全要求不高的场景下使用。

3.2 示例代码

以下演示最基本的匿名连接流程，包括：

  1. 创建 OPC UA Client 配置
  2. 初始化并连接到服务器
  3. 读取或写入数据（仅作示例）

请确保替换示例中的 endpointUrl 与 nodeId 等信息为你自己的实际配置。

import org.eclipse.milo.opcua.sdk.client.OpcUaClient;
import org.eclipse.milo.opcua.stack.core.security.SecurityPolicy;
import org.eclipse.milo.opcua.sdk.client.api.config.OpcUaClientConfigBuilder;
import org.eclipse.milo.opcua.stack.core.types.structured.EndpointDescription;
import org.eclipse.milo.opcua.stack.core.types.structured.UserTokenPolicy;
import org.eclipse.milo.opcua.stack.core.types.enumerated.UserTokenType;
import org.eclipse.milo.opcua.sdk.client.api.identity.AnonymousProvider;

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

public class OpcUaAnonymousExample {

    public static void main(String[] args) {
        try {
            // OPC UA 服务器地址，例如 "opc.tcp://localhost:49320"
            String url= "opc.tcp://127.0.0.1:49320";

            // 创建 client
                OpcUaClient client = OpcUaClient.create(url,
                        endpoints ->
                                endpoints.stream()
                                        .filter(e -> e.getSecurityPolicyUri().equals(SecurityPolicy.None.getUri()))
                                        .findFirst(),
                        configBuilder ->
                                configBuilder
                                        //访问方式
                                        .setIdentityProvider(new AnonymousProvider())
                                        .setRequestTimeout(UInteger.valueOf(5000))
                                        .build());
            }

            // 连接到服务器
            CompletableFuture<OpcUaClient> future = client.connect();
            future.get(); // 等待连接完成

            System.out.println("匿名连接成功！");

            // 在此处可以进行读写操作，例如读取节点的值
            // client.readValue(0, TimestampsToReturn.Both, new ReadValueId(NodeId, ...));
            // ...

            // 最后断开连接
            client.disconnect().get();
            System.out.println("客户端断开连接。");

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

    // 简单选择一个安全策略为 None 的端点（匿名方式一般使用安全策略None，具体看服务器配置）
    private static EndpointDescription chooseSecureEndpoint(List<EndpointDescription> endpoints) {
        EndpointDescription result = null;
        for (EndpointDescription e : endpoints) {
            if (e.getSecurityPolicyUri().equals(SecurityPolicy.None.getUri())) {
                result = e;
                break;
            }
        }
        return result;
    }
}

在上述示例中，最关键的步骤是将身份认证方式设为 new AnonymousProvider() 并选择一个 SecurityPolicy 为 None 的 endpoint。这样即可使用匿名方式成功连接。

四、用户名密码方式连接

4.1 用户名密码方式简介

在实际生产环境中，常常需要使用账号密码进行身份验证，以限制访问权限、保护关键信息。与匿名方式相比，多了用户名密码的配置，但整体流程类似。

4.2 示例代码

import org.eclipse.milo.opcua.sdk.client.OpcUaClient;
import org.eclipse.milo.opcua.stack.core.security.SecurityPolicy;
import org.eclipse.milo.opcua.sdk.client.api.config.OpcUaClientConfigBuilder;
import org.eclipse.milo.opcua.stack.core.types.structured.EndpointDescription;
import org.eclipse.milo.opcua.stack.core.types.structured.UserTokenPolicy;
import org.eclipse.milo.opcua.stack.core.types.enumerated.UserTokenType;
import org.eclipse.milo.opcua.sdk.client.api.identity.UsernameProvider;

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

public class OpcUaUsernamePasswordExample {

    public static void main(String[] args) {
        try {
            String endpointUrl = "opc.tcp://127.0.0.1:4840";

            List<EndpointDescription> endpoints = OpcUaClient
                    .getEndpoints(endpointUrl).get();

            EndpointDescription endpoint = chooseUserNameEndpoint(endpoints);

            OpcUaClientConfigBuilder configBuilder = new OpcUaClientConfigBuilder();
            configBuilder.setEndpoint(endpoint);

            // 假设用户名为 "user", 密码为 "password"
            configBuilder.setIdentityProvider(new UsernameProvider("user", "password"));

            OpcUaClient client = OpcUaClient.create(configBuilder.build());

            CompletableFuture<OpcUaClient> future = client.connect();
            future.get();

            System.out.println("用户名密码方式连接成功！");

            // 进行后续读写操作
            // ...

            client.disconnect().get();
            System.out.println("客户端断开连接。");

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

    private static EndpointDescription chooseUserNameEndpoint(List<EndpointDescription> endpoints) {
        // 通常 OPC UA 服务器也支持 SecurityPolicy.None + UserName 方式
        // 也可能是 Basic128Rsa15, Basic256, etc. 具体看服务端配置
        for (EndpointDescription e : endpoints) {
            if (e.getSecurityPolicyUri().equals(SecurityPolicy.None.getUri())) {
                // 确保端点支持 UserName 类型的认证
                for (UserTokenPolicy tokenPolicy : e.getUserIdentityTokens()) {
                    if (tokenPolicy.getTokenType() == UserTokenType.UserName) {
                        return e;
                    }
                }
            }
        }
        return null;
    }
}

要点说明：

  1. 将 IdentityProvider 切换为 new UsernameProvider("username", "password")。
  2. 根据服务端提供的用户名、密码进行配置。
  3. 需要注意端点是否支持 UserName 类型认证。如果端点仅支持 Anonymous 或 Certificate，则无法使用用户名密码方式。

五、证书加密方式连接

5.1 证书加密方式简介

在实际工业环境中，安全性要求更高时通常会启用证书加密（基于 Public Key Infrastructure）。

  • 每个客户端都会持有一份证书（公钥）和对应的私钥，服务器端也有自己的证书。
  • 当客户端与服务器通信时，会先验证双方的证书签名并进行加密传输，从而保证安全性与完整性。

在这种方式下，服务端可能要求：

  1. 客户端必须提供已经被服务器信任（或在服务器端手动信任）的证书。
  2. 采用特定的安全策略（例如 Basic256Sha256）并通过相应端点连接。

5.2 证书和私钥获取

  • 可以通过第三方工具（例如 openssl、keytool 或 Eclipse Milo 提供的证书工具脚本）生成自签名证书。
  • 生成后的证书和私钥，可以存储在 Java KeyStore 中，或者存储为 .der、.pem 等格式并让应用程序读取。

下方示例假设已经拥有 ClientCert.der（客户端公钥）和 ClientKey.der（客户端私钥），并且服务器端配置了对应的信任或信任链。

OPC UA访问证书类

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.regex.Pattern;
class KeyStoreLoader {
    private final Logger logger = LoggerFactory.getLogger(getClass());
    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 = "password".toCharArray();
    // 证书对象
    private X509Certificate clientCertificate;
    // 密钥对对象
    private KeyPair clientKeyPair;
    KeyStoreLoader load(Path baseDir) throws Exception {
        // 创建一个使用`PKCS12`加密标准的KeyStore。KeyStore在后面将作为读取和生成证书的对象。
        KeyStore keyStore = KeyStore.getInstance("PKCS12");
        // PKCS12的加密标准的文件后缀是.pfx，其中包含了公钥和私钥。
        // 而其他如.der等的格式只包含公钥，私钥在另外的文件中。
        Path serverKeyStore = baseDir.resolve("example-client.pfx");
        logger.info("Loading KeyStore at {}", serverKeyStore);
        // 如果文件不存在则创建.pfx证书文件。
        if (!Files.exists(serverKeyStore)) {
            keyStore.load(null, PASSWORD);
            // 用2048位的RAS算法。`SelfSignedCertificateGenerator`为Milo库的对象。
            KeyPair keyPair = SelfSignedCertificateGenerator.generateRsaKeyPair(2048);
            // `SelfSignedCertificateBuilder`也是Milo库的对象，用来生成证书。
            // 中间所设置的证书属性可以自行修改。
            SelfSignedCertificateBuilder builder = new SelfSignedCertificateBuilder(keyPair)
                .setCommonName("Eclipse Milo Example Client")
                .setOrganization("digitalpetri")
                .setOrganizationalUnit("dev")
                .setLocalityName("Folsom")
                .setStateName("CA")
                .setCountryCode("US")
                .setApplicationUri("urn:eclipse:milo:examples: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 serverPrivateKey = keyStore.getKey(CLIENT_ALIAS, PASSWORD);
        if (serverPrivateKey instanceof PrivateKey) {
            // 获取对应别名的证书对象。
            clientCertificate = (X509Certificate) keyStore.getCertificate(CLIENT_ALIAS);
            // 获取公钥
            PublicKey serverPublicKey = clientCertificate.getPublicKey();
            // 创建Keypair对象。
            clientKeyPair = new KeyPair(serverPublicKey, (PrivateKey) serverPrivateKey);
        }
        return this;
    }
    // 返回证书
    X509Certificate getClientCertificate() {
        return clientCertificate;
    }
    // 返回密钥对
    KeyPair getClientKeyPair() {
        return clientKeyPair;
    }
}

5.3 示例代码

public static OpcUaClient initClient(String url,SecurityPolicy securityPolicy) {
        try {
            if (securityPolicy.equals(SecurityPolicy.None)){
                return OpcUaClient.create(url,
                        endpoints ->
                                endpoints.stream()
                                        .filter(e -> e.getSecurityPolicyUri().equals(securityPolicy.getUri()))
                                        .findFirst(),
                        configBuilder ->
                                configBuilder
                                        //访问方式
                                        .setIdentityProvider(new AnonymousProvider())
                                        .setRequestTimeout(UInteger.valueOf(5000))
                                        .build());
            }
            Path securityTempDir = Paths.get(System.getProperty("java.io.tmpdir"), "security");
            Files.createDirectories(securityTempDir);
            if (!Files.exists(securityTempDir)) {
                throw new Exception("unable to create security dir: " + securityTempDir);
            }
            KeyStoreLoader loader = new KeyStoreLoader().load(securityTempDir);
            File pkiDir = securityTempDir.resolve("pki").toFile();

            DefaultTrustListManager trustListManager = new DefaultTrustListManager(pkiDir);

            DefaultClientCertificateValidator certificateValidator =
                    new DefaultClientCertificateValidator(trustListManager);
            String hostName = InetAddress.getLocalHost().getHostName();
            return OpcUaClient.create(url,
                    endpoints ->
                            endpoints.stream()
                                    .map(endpoint -> {
                                        // 构建一个新的 EndpointDescription（可选修改某些字段）
                                        return new EndpointDescription(
                                                url,
                                                endpoint.getServer(),
                                                endpoint.getServerCertificate(),
                                                endpoint.getSecurityMode(), // 或者强制改为某种模式
                                                endpoint.getSecurityPolicyUri(),
                                                endpoint.getUserIdentityTokens(),
                                                endpoint.getTransportProfileUri(),
                                                endpoint.getSecurityLevel()
                                        );
                                    })
                                    .filter(e -> e.getSecurityPolicyUri().equals(securityPolicy.getUri()))
                                    .findFirst(),
                    configBuilder ->
                            configBuilder
                                    //访问方式
                                    .setApplicationName(LocalizedText.english("datacollector-driver"))
                                    .setApplicationUri(String.format("urn:%s:opcua-client", hostName))  // 必须与证书中的URI一致
                                    .setKeyPair(loader.getClientKeyPair())
                                    .setCertificate(loader.getClientCertificate())
                                    .setCertificateChain(loader.getClientCertificateChain())
                                    .setCertificateValidator(certificateValidator)
                                    .setIdentityProvider(new UsernameProvider("admin", "123456"))
                                    .setRequestTimeout(UInteger.valueOf(5000))
                                    .build());

        } catch (Exception e) {
            throw new RuntimeException(e);
        }

    }

证书路径
在这里插入图片描述
我们需要把服务器证书放在pki\trusted\certs目录下：
在这里插入图片描述

要点说明：

  1. 选择合适的安全策略（如 Basic256Sha256）。
  2. 使用客户端证书和私钥（可以自签名，也可以通过权威 CA 签发）。
  3. 服务端需信任此客户端证书（在服务器配置中添加到信任列表）。
  4. 配置 CertificateManager、CertificateValidator 以及 X509IdentityProvider。

六、常见问题与注意事项

  1. 端点选择

    • 不同 OPC UA 服务器可能同时暴露多个端点，包含不同的安全模式（Security Mode）和安全策略（Security Policy）。
    • 在匿名或用户名密码方式时，如果选择了需要证书的端点，就会出现认证失败或连接被拒的情况。
    • 在证书加密方式时，如果选择了安全策略为 None 的端点，则证书不会被使用，同样也会连接异常或者导致安全策略不匹配。

  2. 服务器信任客户端证书

    • 大多数 OPC UA 服务器在默认情况下不信任任何客户端的证书，需要在服务端管理界面或配置文件中手动将客户端证书加入白名单。
    • 记得查看服务器日志，若提示「Untrusted Certificate」，就需要在服务器端操作信任列表。

  3. 安全策略与性能

    • 加密等级越高（如 Basic256Sha256），对 CPU 资源消耗越大，通信速度会相对降低，但数据安全性更强。
    • 在测试环境或低安全需求的场景下可以先使用 SecurityPolicy.None ；正式项目上线时再切换到更高的安全策略。

  4. 兼容性

    • 不同版本的 OPC UA SDK、服务器或 Java 版本之间可能存在兼容性问题；如果连接失败，可以尝试升级或降低 Milo 版本、换用不同的 JDK 版本等。
    • OPC UA 服务器上若启用特定的加密算法（例如 AES-256），客户端也需要对应的加密套件。

  5. 断线重连

    • 工业现场环境中网络抖动常见，客户端需要实现断线重连或重试机制，以确保数据采集的连续性与稳定性。
基于Java实现OPC UA数据点位事件订阅的完整指南
洛阳泰山的博客
05-31 1295
本文介绍如何使用Java实现OPC UA数据点位事件的订阅。通过引入opcua依赖，创建订阅，准备监控项请求，创建并设置监听器，以及处理异常，详细解析了代码实现过程。
Java 使用 OPC UA
wdwwx的博客
07-02 2884
使用Eclipse Milo库可以方便地与OPC UA服务器进行通信。通过上述步骤，你可以快速开始使用Java与OPC UA进行交互。可以根据需求扩展和定制客户端的功能，如订阅数据更改、浏览节点等。
java实现的opc ua 客户端/服务端的简单例子
03-07
用java实现简单的opc ua的例子，如果刚接触opc ua想了解一下原理的可以参考一下。
Java使用Milo实现OPC UA客户端
热门推荐
逛窑子的李靖的博客
11-12 2万+
Java使用Milo实现OPC UA客户端，达到通过java读、写、订阅变量的目的。
java通过org.eclipse.milo实现OPCUA客户端进行连接和订阅
m0_71817461的博客
09-20 4560
java通过org.eclipse.milo实现OPCUA客户端进行连接和订阅，分为匿名方式、用户名加证书方式
Java使用Milo实现OPC UA客户端及服务端，操作uaexpert工具测试（史上最详细讲解）
m0_59104232的博客
12-07 2862
本文章主要讲解了如何用java使用milo实现opc ua客户端及服务端，订阅、断线重连等。包括uaexpert工具的使用，证书认证等操作。
Java对接OPC UA
最新发布
zwz1342的博客
01-14 791
Java使用Milo库对接西门子PLC字符方式
OPC UA for java
02-22
最好用的OPC UA java开源包，支持无安全策略、Base加密安全策略。
java opcua模拟代码，包含简单的客户端和服务端
09-20
java opcua模拟代码，包含简单的客户端和服务端。只是简单的模拟测试学习使用。
Java实现OPCUA通信
qq_27615455的博客
11-07 6604
在 linux 上看教程到还可以。🍄 设备的出现的各种状况（比如上线，某个组件出故障，某个参数超标），就是：物模型的事件，Java 中的事件，OPCUA中订阅。，服务发现时，服务端返回的断点描述的主机名或者本地IP，远程是访问不到的，按照解答参考，修改端点的主机名为远程IP地址即可。🍄 设备的参数，就是：物模型的属性值，Java 中类的属性（也可以叫变量，字段），OPCUA 中的节点的变量。🍄 设备的操作方法，就是：物模型的功能，Java 中类的方法（也可以叫函数），OPCUA 中的方法。
OPC UA JAVA开发包
05-09
JAVA版本的开发包,有两小时时限,可用于学习和测试.已经测试过可以使用.
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) 的不同方面， 但在其基础之上进行了功能扩展。
OPC UA Java写的服务器和客户端 Windows下的源代码SDK
05-29
OPC UA 用Java写的服务器和客户端，包含源代码，这个只有Windows下的程序
java -opc ua 连接kepserver 源码
04-20
maven架构 idea编辑器 包含读取、写入、订阅、批量订阅、断点续传等功能、 下载后可直接运行 内容很简单，就一个类，采用匿名登录的方式，代码和测试全在一个类里面 注释很详细
java实现opc ua连接及操作的代码工具包Demo
07-05
基于开源org.eclipse.milo版本 0.6.11，java实现opc ua server服务器模拟连接及客户端操作读写的代码工具包Demo
Java通过UA协议操作OPC的demo和客户端工具
11-05
OPC（OLE for Process Control）是一种在工业自动化领域中用于数据交换...在实际项目中，开发者可以通过这些工具和代码示例，学习如何创建OPC UA客户端连接，如何读写OPC UA服务器上的数据，以及如何处理OPC UA的事件。
java代码配置连接OPCUA
oThrowsException的博客
01-01 1012
pom依赖如下 <dependency> <groupId>org.eclipse.milo</groupId> <artifactId>sdk-client</artifactId> <version>0.6.9</version> </dependency> <dependency> <groupId>org.eclipse.milo</grou
【OPCUA】使用Java开源项目milo连接KEPServerEX6服务器并读取值
MarcherXL的博客
11-07 5893
使用Java开源项目milo连接KEPServerEX6服务器并读取值，提供项目小demo，帮助解决问题
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 客户端。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值