使用java的milo框架访问OPCUA服务的过程
更新时间：2022年01月07日 16:17:57 作者：姚华军
这篇文章主要介绍了使用java的milo框架访问OPCUA服务的方法,本次采用KEPServerEX5模拟服务端，使用milo开发的程序作为客户端，具体操作使用过程跟随小编一起看看吧
最近接了一个项目，需要访问工业的实时数据库，数据库的对外开放接口是OPCUA协议的，经过多方比对，发现github上milo的评星较高，尝试了一下，还比较方便好用，现在把使用过程中的坑和大家介绍一下，网上比较全的资料不多，下面是整个过程全部的资料：
本次采用KEPServerEX5模拟服务端，使用milo开发的程序作为客户端
一、搭建服务端，KEPServerEX5的安装省略掉，下面是配置过程
设置通道、设备、标签
设置访问的用户名和密码
设置通过opc-ua访问的节点
二、使用milo的框架，开发客户端访问opcua服务
1、在pom文件中追击以下依赖
<!--start milo-->
<dependency>
<groupId>org.eclipse.milo</groupId>
<artifactId>sdk-client</artifactId>
<version>0.2.4</version>
</dependency>
<dependency>
<groupId>org.bouncycastle</groupId>
<artifactId>bcpkix-jdk15on</artifactId>
<version>1.57</version>
</dependency>
<dependency>
<groupId>org.eclipse.milo</groupId>
<artifactId>sdk-server</artifactId>
<version>0.2.4</version>
</dependency>
<!--end milo-->
2、OPC UA协议对象接口
package com.jndj.platform.common.milo;
import org.eclipse.milo.opcua.sdk.client.OpcUaClient;
import org.eclipse.milo.opcua.sdk.client.api.identity.AnonymousProvider;
import org.eclipse.milo.opcua.sdk.client.api.identity.IdentityProvider;
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;
/**
* @author yaohj
* @date 2020/7/30
* OPC UA协议对象接口
*/
public interface OpcUAClientService {
/**
* OPC UA服务器地址和接口
*/
default String getEndpointUrl() {
return "opc.tcp://127.0.0.1:49320";
}
/**
* 过滤返回的server endpoint
*/
default Predicate<EndpointDescription> endpointFilter() {
return e -> true;
}
/**
* 连接服务器的安全策略
* None、Basic128Rsa15、Basic256、Basic256Sha256、Aes128_Sha256_RsaOaep、Aes256_Sha256_RsaPss
*/
default SecurityPolicy getSecurityPolicy() {
return SecurityPolicy.None;
}
/**
* 提供身份验证
*/
default IdentityProvider getIdentityProvider() {
return new AnonymousProvider();
}
/**
* 实际操作服务、由实现类重写实现
*/
void run(OpcUaClient client, CompletableFuture<OpcUaClient> future) throws Exception;
}
3、OPC UA协议对象实体类
package com.jndj.platform.common.milo;
import com.google.common.collect.ImmutableList;
import org.eclipse.milo.opcua.sdk.client.OpcUaClient;
import org.eclipse.milo.opcua.stack.core.types.builtin.*;
import org.eclipse.milo.opcua.stack.core.types.enumerated.TimestampsToReturn;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.concurrent.CompletableFuture;
@Service("OpcUAClientService")
public class OpcUAClientServiceImpl implements OpcUAClientService {
/**
* 覆盖接口的方法，建立和OPC UA的服务
*/
@Override
public void run(OpcUaClient client, CompletableFuture<OpcUaClient> future) throws Exception {
// 同步建立连接
client.connect().get();
// 异步读取数据
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());
future.complete(client);
});
}
/**
* 读取标签点的数据
*/
private CompletableFuture<List<DataValue>> readTagData(OpcUaClient client) {
NodeId nodeId_Tag1 = new NodeId(2, "Channel1.Device1.Tag1");
NodeId nodeId_Tag2 = new NodeId(2, "Channel1.Device1.Tag2");
List<NodeId> nodeIds = ImmutableList.of(nodeId_Tag1, nodeId_Tag2);
return client.readValues(0.0, TimestampsToReturn.Both, nodeIds);
}
}
4、OPC UA协议运行对象
package com.jndj.platform.common.milo;
import org.eclipse.milo.opcua.sdk.client.OpcUaClient;
import org.eclipse.milo.opcua.sdk.client.api.config.OpcUaClientConfig;
import org.eclipse.milo.opcua.sdk.client.api.identity.UsernameProvider;
import org.eclipse.milo.opcua.stack.client.UaTcpStackClient;
import org.eclipse.milo.opcua.stack.core.Stack;
import org.eclipse.milo.opcua.stack.core.types.builtin.LocalizedText;
import org.eclipse.milo.opcua.stack.core.types.structured.EndpointDescription;
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.Arrays;
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;
@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"), "security");
Files.createDirectories(securityTempDir);
if (!Files.exists(securityTempDir)) {
throw new Exception("不能够创建安全路径: " + securityTempDir);
}
KeyStoreLoader loader = new KeyStoreLoader().load(securityTempDir);
// 获取OPC UA的服务器端节点
EndpointDescription[] endpoints =
UaTcpStackClient.getEndpoints(opcUAClientService.getEndpointUrl()).get();
EndpointDescription endpoint = Arrays.stream(endpoints)
.filter(e -> e.getEndpointUrl().equals(opcUAClientService.getEndpointUrl()))
.findFirst().orElseThrow(() -> new Exception("没有节点返回"));
// 设置OPC UA的配置信息
OpcUaClientConfig config =
OpcUaClientConfig.builder()
.setApplicationName(LocalizedText.english("OPC UA SCREEN"))
.setApplicationUri("urn:DATA-TRANSFER:OPC UA SCREEN")
.setCertificate(loader.getClientCertificate())
.setKeyPair(loader.getClientKeyPair())
.setEndpoint(endpoint)
.setIdentityProvider(new UsernameProvider("Administrator", "123456"))
.setRequestTimeout(uint(5000))
.build();
// 创建OPC UA客户端
return new OpcUaClient(config);
}
}
5、OPC UA访问证书类
package com.jndj.platform.common.milo;
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;
}
}
6、业务service类
package com.jndj.platform.phase2.service.impl;
import com.jndj.platform.common.milo.OpcUAClientRunner;
import com.jndj.platform.common.milo.OpcUAClientService;
import com.jndj.platform.phase2.service.Phase2Service;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
/**
* @author yaohj
* @date 2020/7/22
* 获取二期发电数据（三、四号机组）
*/
@Service("phase2Service")
public class Phase2ServiceImpl implements Phase2Service {
@Autowired
private OpcUAClientService opcUAClientService;
/**
* 获取二期发电数据（三、四号机组），保存到数据库中
*/
@Override
public void searchPhase2ElectricData() {
new OpcUAClientRunner(opcUAClientService).run();
}
}
7、业务Controller类、定时调度
package com.jndj.platform.phase2.controller;
import com.jndj.platform.phase2.service.Phase2Service;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Controller;
import java.text.SimpleDateFormat;
import java.util.Date;
/**
* @author yaohj
* @date 2020/7/22
* 获取二期发电数据（三、四号机组）
*/
@Controller
public class Phase2Controller {
private static final Logger logger = LoggerFactory.getLogger(Phase2Controller.class);
private static final SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy:mm:dd HH:mm:ss");
@Autowired
private Phase2Service phase2Service;
/**
* 获取二期发电数据（三、四号机组），保存到数据库中(x分钟调度一次)
*/
@Scheduled(initialDelay = 30000, fixedRate = 30000)
public void searchGasData() {
logger.info("####获取二期发电数据（三、四号机组） - 定时任务执行时间："+ dateFormat.format(new Date()));
phase2Service.searchPhase2ElectricData();
}
}
8、运行结果、定时获取到opcua服务中的数据
OK，以上是所有的源代码，大家的问题基本能够解决。
到此这篇关于使用java的milo框架访问OPCUA服务的方法的文章就介绍到这了,更多相关java访问OPCUA服务内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！
相关文章
这篇文章主要给大家介绍了关于Java中IOException异常解决的相关资料,IOException是Java中的一个受检查异常(Checked Exception),它是java.io包中定义的异常类之一,需要的朋友可以参考下2023-07-07
详解SpringCloud LoadBalancer 新一代负载均衡器
这篇文章主要为大家介绍了SpringCloud LoadBalancer新一代负载均衡器详解使用详解，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪2023-01-01
这篇文章主要介绍了Java数组的详细解释,是Java入门学习中的基础知识,需要的朋友可以参考下，希望能够给你带来帮助2021-09-09![解读nextLine().split(“[\\s]“)的意思](//img.jbzj.com/images/xgimg/bcimg3.png)
解读nextLine().split(“[\\s]“)的意思
这篇文章主要介绍了解读nextLine().split(“[\\s]“)的意思，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教2023-04-04
Spring Boot 数据校验@Valid+统一异常处理的实现
这篇文章主要介绍了Spring Boot 数据校验@Valid+统一异常处理的实现，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧2019-04-04
这篇文章主要介绍了Java多线程的用法详细介绍的相关资料,希望通过本文能帮助到大家，需要的朋友可以参考下2017-09-09
这篇文章主要为大家详细介绍了Spring使用注解方式处理事务，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下2022-08-08
本篇文章主要介绍了Spring Boot修改内置Tomcat端口号的示例，具有一定的参考价值，感兴趣的小伙伴们可以参考一下2017-08-08
本文详细介绍了如何在Spring Boot项目中实现Jar包加密,我们首先了解了Jar包加密的基本概念和作用,然后学习了如何使用Spring Boot的Jar工具和第三方库来实现Jar包的加密和解密,感兴趣的朋友一起看看吧2024-02-02
本篇文章主要介绍了java中TreeMap排序的示例代码，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧2017-11-11
![解读nextLine().split(“[\\s]“)的意思](http://img.jbzj.com/images/xgimg/bcimg3.png)
最新评论