Java使用milo读写OPC UA源代码示例
OPC UA客户端工具Softing OPC Client使用_推荐使用
Milo官方源代码地址:
https://github.com/eclipse/milo.git
下载源代码
git clone https://github.com/eclipse/milo.git
OPC UA读取测试
修改部分需要连接的OPC UA服务代码
读取OPC UA服务的状态和当前时间
package org.eclipse.milo.examples.client;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import com.google.common.collect.ImmutableList;
import org.eclipse.milo.opcua.sdk.client.OpcUaClient;
import org.eclipse.milo.opcua.sdk.client.nodes.UaVariableNode;
import org.eclipse.milo.opcua.stack.core.Identifiers;
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.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class ReadExample implements ClientExample {
public static void main(String[] args) throws Exception {
ReadExample example = new ReadExample();
// new ClientExampleRunner(example, true).run(); //启动opcua服务
new ClientExampleRunner(example, false).run();
}
private final Logger logger = LoggerFactory.getLogger(getClass());
@Override
public void run(OpcUaClient client, CompletableFuture<OpcUaClient> future) throws Exception {
// synchronous connect
client.connect().get();
// synchronous read request via VariableNode
UaVariableNode node = client.getAddressSpace().getVariableNode(Identifiers.Server_ServerStatus_StartTime);
DataValue value = node.readValue();
logger.info("StartTime======{}", value.getValue().getValue());
// asynchronous read request
readServerStateAndTime(client).thenAccept(values -> {
DataValue v0 = values.get(0);
DataValue v1 = values.get(1);
logger.info("State====={}", ServerState.from((Integer) v0.getValue().getValue()));
logger.info("CurrentTime===={}", v1.getValue().getValue());
future.complete(client);
});
}
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);
}
}
OPC UA测点写入值
package org.eclipse.milo.examples.client;
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.NodeClass;
import org.eclipse.milo.opcua.stack.core.types.structured.AddNodesItem;
import org.eclipse.milo.opcua.stack.core.types.structured.AddNodesResponse;
import org.eclipse.milo.opcua.stack.core.types.structured.ObjectAttributes;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import static org.eclipse.milo.opcua.stack.core.types.builtin.unsigned.Unsigned.ubyte;
import static org.eclipse.milo.opcua.stack.core.types.builtin.unsigned.Unsigned.uint;
public class WriteExample implements ClientExample {
public static void main(String[] args) throws Exception {
WriteExample example = new WriteExample();
new ClientExampleRunner(example, false).run();
}
private final Logger logger = LoggerFactory.getLogger(getClass());
@Override
public void run(OpcUaClient client, CompletableFuture<OpcUaClient> future) throws Exception {
//write(client);
//addNode(client);
// writeList(client);
// synchronous connect
client.connect().get();
//kepserver opcua 写入成功
List<NodeId> nodeIds = ImmutableList.of(new NodeId(2, "tongdao.tag1.aaa"));
// List<NodeId> nodeIds = ImmutableList.of(new NodeId(2, "HelloWorld/ScalarTypes/Int32"));
// List<NodeId> nodeIds = ImmutableList.of(new NodeId(5, "abcd"));
for (int i = 0; i < 10; i++) {
Thread.sleep(500);
Variant v = new Variant(i);
// don't write status or timestamps
DataValue dv = new DataValue(v, null, null);
// write asynchronously....
CompletableFuture<List<StatusCode>> f =
client.writeValues(nodeIds, ImmutableList.of(dv));
// ...but block for the results so we write in order
List<StatusCode> statusCodes = f.get();
StatusCode status = statusCodes.get(0);
if (status.isGood()) {
logger.info("Wrote '{}' to nodeId={}", v, nodeIds.get(0));
}
}
future.complete(client);
}
private void writeList(OpcUaClient client) throws Exception {
client.connect().get();
List<NodeId> nodeIds = new ArrayList<>();
nodeIds.add(new NodeId(5, "aaa"));
nodeIds.add(new NodeId(5, "bbb"));
nodeIds.add(new NodeId(5, "ccc"));
// don't write status or timestamps
List<DataValue> dataValues = new ArrayList<>();
Variant v1 = new Variant(111);
dataValues.add(new DataValue(v1, null, null));
Variant v2 = new Variant(222);
dataValues.add(new DataValue(v2, null, null));
Variant v3 = new Variant(333);
dataValues.add(new DataValue(v3, null, null));
// write asynchronously....
CompletableFuture<List<StatusCode>> f =
client.writeValues(nodeIds, dataValues);
// ...but block for the results so we write in order
List<StatusCode> statusCodes = f.get();
statusCodes.forEach(statusCode -> {
logger.info("Wrote '{}' to nodeId={},{},{}", statusCode.getValue(), statusCode.isGood(),
statusCode.isBad(), statusCode.toString());
});
}
private void write(OpcUaClient opcUaClient) throws Exception {
opcUaClient.connect().get();
//写入值
int v = 1000;
NodeId nodeId = new NodeId(5,"abcd");
Variant value = new Variant(v);
DataValue dataValue = new DataValue(value,null,null);
StatusCode statusCode = opcUaClient.writeValue(nodeId,dataValue).get();
//打印true 写入成功
System.out.println(statusCode.isGood());
}
private void addNode (OpcUaClient opcUaClient) throws Exception {
opcUaClient.connect().get();
// List<NodeId> list = new ArrayList<>();
NodeId nodeId1 = new NodeId(5,"www");
// list.add(nodeId1);
// //这个没用 不能创建
// CompletableFuture<RegisterNodesResponse> rrr = opcUaClient.registerNodes(list);
// RegisterNodesResponse rng = rrr.get();
// System.out.println(rng.getRegisteredNodeIds().length);
// DataValue valuenode = opcUaClient.readValue(0.0, TimestampsToReturn.Both, nodeId1).get();
// System.out.println("www=====" + valuenode.getValue().getValue().toString());
//https://github.com/eclipse/milo/issues/531
// milo 有人留言, 也没创建成功
ObjectAttributes attributes = new ObjectAttributes(
uint(0b11111),
LocalizedText.english("My Object"),
LocalizedText.english("Description of My Object"),
uint(0),
uint(0),
ubyte(0)
);
ExtensionObject encodedAttributes = ExtensionObject.encode(
opcUaClient.getSerializationContext(),
attributes
);
// ExpandedNodeId parentNodeId = new ExpandedNodeId(Identifiers.Server);
ExpandedNodeId requestNewNodeID = new ExpandedNodeId(nodeId1.getNamespaceIndex(), null, "www");
QualifiedName browserName = new QualifiedName(0, "testObject");
NodeClass nodeClass = NodeClass.Object;
// ExtensionObject extensionObject = ExtensionObject.encode(opcUaClient.getSerializationContext(),
// new ByteString("attr".getBytes()), Identifiers.CreateSessionRequest_Encoding_DefaultBinary,
// OpcUaDefaultBinaryEncoding.getInstance());
// ExpandedNodeId typeDe = new ExpandedNodeId(Identifiers.BaseObjectType);
AddNodesItem add = new AddNodesItem(null, nodeId1, requestNewNodeID, browserName,
nodeClass, encodedAttributes, null);
List<AddNodesItem> list = new ArrayList<>();
list.add(add);
CompletableFuture<AddNodesResponse> re = opcUaClient.addNodes(list);
AddNodesResponse addNodesResponse = re.get();
System.out.println(addNodesResponse);
//报错
//status=Bad_ServiceUnsupported, description=The server does not support the requested service.
}
}
milo订阅OPC UA测点数据
package org.eclipse.milo.examples.client;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;
import org.eclipse.milo.opcua.sdk.client.OpcUaClient;
import org.eclipse.milo.opcua.sdk.client.api.subscriptions.UaMonitoredItem;
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.Identifiers;
import org.eclipse.milo.opcua.stack.core.types.builtin.ExtensionObject;
import org.eclipse.milo.opcua.stack.core.types.builtin.NodeId;
import org.eclipse.milo.opcua.stack.core.types.builtin.QualifiedName;
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.ContentFilter;
import org.eclipse.milo.opcua.stack.core.types.structured.EventFilter;
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 org.eclipse.milo.opcua.stack.core.types.structured.SimpleAttributeOperand;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import static com.google.common.collect.Lists.newArrayList;
import static org.eclipse.milo.opcua.stack.core.types.builtin.unsigned.Unsigned.uint;
public class EventSubscriptionExample implements ClientExample {
public static void main(String[] args) throws Exception {
EventSubscriptionExample example = new EventSubscriptionExample();
// new ClientExampleRunner(example, true).run();
new ClientExampleRunner(example, false).run();
}
private final Logger logger = LoggerFactory.getLogger(getClass());
private final AtomicLong clientHandles = new AtomicLong(1L);
@Override
public void run(OpcUaClient client, CompletableFuture<OpcUaClient> future) throws Exception {
// synchronous connect
client.connect().get();
// create a subscription and a monitored item
UaSubscription subscription = client.getSubscriptionManager()
.createSubscription(1000.0).get();
// ReadValueId readValueId = new ReadValueId(
// Identifiers.Server,
// AttributeId.EventNotifier.uid(),
// null,
// QualifiedName.NULL_VALUE
// );
//创建订阅的变量
NodeId nodeId22 = new NodeId(5,"Counter1");
ReadValueId readValueId = new ReadValueId(nodeId22,AttributeId.EventNotifier.uid(),null,QualifiedName.NULL_VALUE);
// client handle must be unique per item
UInteger clientHandle = uint(clientHandles.getAndIncrement());
EventFilter eventFilter = new EventFilter(
new SimpleAttributeOperand[]{
new SimpleAttributeOperand(
Identifiers.BaseEventType,
new QualifiedName[]{new QualifiedName(0, "EventId")},
AttributeId.Value.uid(),
null),
new SimpleAttributeOperand(
Identifiers.BaseEventType,
new QualifiedName[]{new QualifiedName(0, "EventType")},
AttributeId.Value.uid(),
null),
new SimpleAttributeOperand(
Identifiers.BaseEventType,
new QualifiedName[]{new QualifiedName(0, "Severity")},
AttributeId.Value.uid(),
null),
new SimpleAttributeOperand(
Identifiers.BaseEventType,
new QualifiedName[]{new QualifiedName(0, "Time")},
AttributeId.Value.uid(),
null),
new SimpleAttributeOperand(
Identifiers.BaseEventType,
new QualifiedName[]{new QualifiedName(0, "Message")},
AttributeId.Value.uid(),
null)
},
new ContentFilter(null)
);
MonitoringParameters parameters = new MonitoringParameters(
clientHandle,
0.0,
ExtensionObject.encode(client.getSerializationContext(), eventFilter),
uint(10),
true
);
MonitoredItemCreateRequest request = new MonitoredItemCreateRequest(
readValueId,
MonitoringMode.Reporting,
parameters
);
List<UaMonitoredItem> items = subscription
.createMonitoredItems(TimestampsToReturn.Both, newArrayList(request)).get();
// do something with the value updates
UaMonitoredItem monitoredItem = items.get(0);
final AtomicInteger eventCount = new AtomicInteger(0);
monitoredItem.setEventConsumer((item, vs) -> {
logger.info(
"Event Received from {}",
item.getReadValueId().getNodeId());
for (int i = 0; i < vs.length; i++) {
logger.info("\tvariant[{}]: {}", i, vs[i].getValue());
}
if (eventCount.incrementAndGet() == 3) {
future.complete(client);
}
});
}
}
package org.eclipse.milo.examples.client;
public class EventSubscriptionExampleProsys extends EventSubscriptionExample {
public static void main(String[] args) throws Exception {
EventSubscriptionExampleProsys example = new EventSubscriptionExampleProsys();
new ClientExampleRunner(example, false).run();
}
@Override
public String getEndpointUrl() {
return "opc.tcp://10.211.55.4:53530/OPCUA/SimulationServer";
}
}
package org.eclipse.milo.examples.client;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.concurrent.CompletableFuture;
import java.util.function.BiConsumer;
import com.google.common.collect.ImmutableList;
import org.eclipse.milo.opcua.sdk.client.OpcUaClient;
import org.eclipse.milo.opcua.sdk.client.SessionActivityListener;
import org.eclipse.milo.opcua.sdk.client.api.UaSession;
import org.eclipse.milo.opcua.sdk.client.api.subscriptions.UaMonitoredItem;
import org.eclipse.milo.opcua.sdk.client.api.subscriptions.UaSubscription;
import org.eclipse.milo.opcua.sdk.client.api.subscriptions.UaSubscriptionManager;
import org.eclipse.milo.opcua.stack.core.AttributeId;
import org.eclipse.milo.opcua.stack.core.UaException;
import org.eclipse.milo.opcua.stack.core.serialization.SerializationContext;
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 org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class SubscriptionExample implements ClientExample {
public static void main(String[] args) throws Exception {
SubscriptionExample example = new SubscriptionExample();
new ClientExampleRunner(example).run();
}
private final Logger logger = LoggerFactory.getLogger(getClass());
@Override
public void run(OpcUaClient client, CompletableFuture<OpcUaClient> future) throws Exception {
// synchronous connect
client.connect().get();
//成功订阅
//new UsernameProvider("opcua","opcua")
testKepServerSub(client);
//成功订阅
// testSub(client);
//https://stackoverflow.com/questions/66247577/how-to-handle-resubscribing-after-server-is-disconnected-or-restarted-with-opc-u
//重连后, 成功重新订阅 opcua服务重启后,监听器触发,清除订阅,重新订阅成功
// testSub22(client);
// testSub(client);
// testSub88(client);
//成功订阅 opcua服务重启后,监听器触发,重新订阅成功(异步订阅可以)
// testSub99(client);
//不行, 重连后, 在订阅,却订阅不了(同步订阅阻塞了), 只能做在线离线状态判断
// testSub33(client);
// testSubOne(client);
// testSubTwo(client);
/* // create a subscription @ 1000ms
UaSubscription subscription = client.getSubscriptionManager().createSubscription(1000.0).get();
// subscribe to the Value attribute of the server's CurrentTime node
ReadValueId readValueId = new ReadValueId(
Identifiers.Server_ServerStatus_CurrentTime,
AttributeId.Value.uid(), null, QualifiedName.NULL_VALUE
);
//成功订阅
NodeId nodeId = new NodeId(5,"Counter1");
ReadValueId readValueId2 = new ReadValueId(nodeId, AttributeId.Value.uid(),null,null);
// IMPORTANT: client handle must be unique per item within the context of a subscription.
// You are not required to use the UaSubscription's client handle sequence; it is provided as a convenience.
// Your application is free to assign client handles by whatever means necessary.
UInteger clientHandle = subscription.nextClientHandle();
MonitoringParameters parameters = new MonitoringParameters(
clientHandle,
1000.0, // sampling interval
null, // filter, null means use default
uint(10), // queue size
true // discard oldest
);
MonitoredItemCreateRequest request = new MonitoredItemCreateRequest(
readValueId2,
MonitoringMode.Reporting,
parameters
);
// when creating items in MonitoringMode.Reporting this callback is where each item needs to have its
// value/event consumer hooked up. The alternative is to create the item in sampling mode, hook up the
// consumer after the creation call completes, and then change the mode for all items to reporting.
BiConsumer<UaMonitoredItem, Integer> onItemCreated =
(item, id) -> item.setValueConsumer(this::onSubscriptionValue);
List<UaMonitoredItem> items = subscription.createMonitoredItems(
TimestampsToReturn.Both,
newArrayList(request),
onItemCreated
).get();
for (UaMonitoredItem item : items) {
if (item.getStatusCode().isGood()) {
logger.info("item created for nodeId={}", item.getReadValueId().getNodeId());
} else {
logger.warn(
"failed to create item for nodeId={} (status={})",
item.getReadValueId().getNodeId(), item.getStatusCode());
}
}*/
// let the example run for 5 seconds then terminate
Thread.sleep(200000);
future.complete(client);
}
private void onSubscriptionValue(UaMonitoredItem item, DataValue value) {
logger.info(
"subscription value received: item={}, value={}, {}, {}, {}",
item.getReadValueId().getNodeId(), value.getValue(),
item.getReadValueId().getNodeId().getNamespaceIndex(),
item.getReadValueId().getNodeId().getType(),
item.getReadValueId().getNodeId().getIdentifier());
}
private void testKepServerSub(OpcUaClient client) throws Exception {
logger.info("-------------------------");
Double publishInterval = 1000.0;
int queueSize = 10;
//创建指定发布间隔的订阅对象
logger.info("&&&&&&&&&&&&&&&&");
System.out.println(client.connect().isDone());
logger.info("&&&&&&&&&&&&&&&&");
System.out.println(client.getSession().isDone());
ImmutableList<UaSubscription> aa = client.getSubscriptionManager().getSubscriptions();
System.out.println(aa.size());
aa.forEach(ua -> {
System.out.println(ua.getSubscriptionId());
});
//同步订阅
UaSubscription subscription = client.getSubscriptionManager().createSubscription(publishInterval).get();
logger.info("^^^^^^^^^^^^^");
//创建监控项请求集合
List<MonitoredItemCreateRequest> itemsToCreate = new ArrayList<>();
Set<String> members = new HashSet<>();
members.add("tongdao.tag1.aaa");
members.add("aaa");
logger.info("########");
for (String member : members) {
// KepServer 一个订阅器, 订阅5000点,都没报错
// for (int i = 0; i < 5000; i++) {
// NodeId nodeId = new NodeId(2, "tongdao.tag1.aaa");
NodeId nodeId = new NodeId(2, member);
ReadValueId readValueId = new ReadValueId(nodeId, AttributeId.Value.uid(),null,null);
//创建监控的参数
MonitoringParameters parameters = new MonitoringParameters(
subscription.nextClientHandle(), //监控项
publishInterval, // sampling interval
null, // filter, null means use default
UInteger.valueOf(queueSize), // queue size
true // discard oldest
);
//创建监控项请求
//该请求最后用于创建订阅。
MonitoredItemCreateRequest request = new MonitoredItemCreateRequest(readValueId, MonitoringMode.Reporting, parameters);
//添加至请求集合
itemsToCreate.add(request);
}
logger.info("**************");
BiConsumer<UaMonitoredItem, Integer> biConsumer =
(item, id) -> item.setValueConsumer(this::onSubscriptionValue);
List<UaMonitoredItem> items = subscription.createMonitoredItems(
TimestampsToReturn.Both,
itemsToCreate,
biConsumer
).get();
logger.info("==============");
for (UaMonitoredItem item : items) {
if (item.getStatusCode().isGood()) {
System.out.println("item created for nodeId={}" + item.getReadValueId().getNodeId());
} else {
System.out.println(
"failed to create item for nodeId={}" + item.getReadValueId().getNodeId() + " (status={})" + item.getStatusCode());
}
}
}
//同步订阅
private void testSub(OpcUaClient client) throws Exception {
logger.info("-------------------------");
Double publishInterval = 1000.0;
int queueSize = 10;
//创建指定发布间隔的订阅对象
logger.info("&&&&&&&&&&&&&&&&");
System.out.println(client.connect().isDone());
logger.info("&&&&&&&&&&&&&&&&");
System.out.println(client.getSession().isDone());
ImmutableList<UaSubscription> aa = client.getSubscriptionManager().getSubscriptions();
System.out.println(aa.size());
aa.forEach(ua -> {
System.out.println(ua.getSubscriptionId());
});
//同步订阅
UaSubscription subscription = client.getSubscriptionManager().createSubscription(publishInterval).get();
logger.info("^^^^^^^^^^^^^");
//创建监控项请求集合
List<MonitoredItemCreateRequest> itemsToCreate = new ArrayList<>();
Set<String> members = new HashSet<>();
members.add("Counter1");
members.add("aaa");
members.add("bbb");
members.add("fff");
members.add("error");
logger.info("########");
for (String member : members) {
NodeId nodeId = new NodeId(5, member);
ReadValueId readValueId = new ReadValueId(nodeId, AttributeId.Value.uid(),null,null);
//创建监控的参数
MonitoringParameters parameters = new MonitoringParameters(
subscription.nextClientHandle(), //监控项
publishInterval, // sampling interval
null, // filter, null means use default
UInteger.valueOf(queueSize), // queue size
true // discard oldest
);
//创建监控项请求
//该请求最后用于创建订阅。
MonitoredItemCreateRequest request = new MonitoredItemCreateRequest(readValueId, MonitoringMode.Reporting, parameters);
//添加至请求集合
itemsToCreate.add(request);
}
logger.info("**************");
BiConsumer<UaMonitoredItem, Integer> biConsumer =
(item, id) -> item.setValueConsumer(this::onSubscriptionValue);
List<UaMonitoredItem> items = subscription.createMonitoredItems(
TimestampsToReturn.Both,
itemsToCreate,
biConsumer
).get();
logger.info("==============");
for (UaMonitoredItem item : items) {
if (item.getStatusCode().isGood()) {
System.out.println("item created for nodeId={}" + item.getReadValueId().getNodeId());
} else {
System.out.println(
"failed to create item for nodeId={}" + item.getReadValueId().getNodeId() + " (status={})" + item.getStatusCode());
}
}
}
private void testSub22(OpcUaClient client) throws Exception {
client.getSubscriptionManager().addSubscriptionListener(new UaSubscriptionManager.SubscriptionListener() {
@Override
public void onKeepAlive(UaSubscription subscription, DateTime publishTime) {
}
@Override
public void onStatusChanged(UaSubscription subscription, StatusCode status) {
}
@Override
public void onPublishFailure(UaException exception) {
}
@Override
public void onNotificationDataLost(UaSubscription subscription) {
}
@Override
public void onSubscriptionTransferFailed(UaSubscription subscription, StatusCode statusCode) {
logger.info("oooooooooooooooo{}", statusCode);
//一旦连接断开，就清除诸如此类的订阅管理器, 重新订阅
client.getSubscriptionManager().clearSubscriptions();
try {
// 这个可以重新订阅到
testSub(client);
} catch (Exception e) {
e.printStackTrace();
}
}
});
client.addSessionActivityListener(new SessionActivityListener(){
@Override
public void onSessionActive(UaSession session) {
logger.info("success-----------");
System.out.println(client.connect().isDone());
System.out.println(client.getSession().isDone());
}
@Override
public void onSessionInactive(UaSession session) {
logger.info("fail-----------");
System.out.println(client.connect().isDone());
System.out.println(client.getSession().isDone());
}
});
}
private void testSub33(OpcUaClient client) throws Exception {
SessionActivityListener aa = new SessionActivityListener(){
@Override
public void onSessionActive(UaSession session) {
logger.info("11111111111111{}");
try {
//不行,重新连接后,在去订阅不了, 只能做在线判断
testSub(client);
} catch (Exception e) {
e.printStackTrace();
}
}
@Override
public void onSessionInactive(UaSession session) {
logger.info("2222222222");
//离线判断
}
};
client.addSessionActivityListener(aa);
aa.onSessionActive(client.getSession().get());
}
private void testSub99(OpcUaClient client) throws Exception {
SessionActivityListener aa = new SessionActivityListener(){
@Override
public void onSessionActive(UaSession session) {
logger.info("11111111111111{}");
try {
testSub88(client);
} catch (Exception e) {
e.printStackTrace();
}
}
@Override
public void onSessionInactive(UaSession session) {
logger.info("2222222222");
}
};
client.addSessionActivityListener(aa);
aa.onSessionActive(client.getSession().get());
}
//异步订阅
private void testSub88(OpcUaClient client) {
Double publishInterval = 1000.0;
int queueSize = 10;
//异步订阅
client.getSubscriptionManager().createSubscription(publishInterval).whenCompleteAsync(new BiConsumer<UaSubscription, Throwable>() {
@Override
public void accept(UaSubscription uaSubscription, Throwable throwable) {
if (null != throwable) {
try {
throw throwable;
} catch (Throwable throwable1) {
throwable1.printStackTrace();
}
}
//创建监控项请求集合
List<MonitoredItemCreateRequest> itemsToCreate = new ArrayList<>();
Set<String> members = new HashSet<>();
members.add("Counter1");
members.add("aaa");
members.add("bbb");
members.add("fff");
members.add("error");
for (String member : members) {
NodeId nodeId = new NodeId(5, member);
ReadValueId readValueId = new ReadValueId(nodeId, AttributeId.Value.uid(),null,null);
//创建监控的参数
MonitoringParameters parameters = new MonitoringParameters(
uaSubscription.nextClientHandle(), //监控项
publishInterval, // sampling interval
null, // filter, null means use default
UInteger.valueOf(queueSize), // queue size
true // discard oldest
);
//创建监控项请求
//该请求最后用于创建订阅。
MonitoredItemCreateRequest request = new MonitoredItemCreateRequest(readValueId, MonitoringMode.Reporting, parameters);
//添加至请求集合
itemsToCreate.add(request);
}
uaSubscription.createMonitoredItems(
TimestampsToReturn.Both,
itemsToCreate,
new UaSubscription.ItemCreationCallback() {
@Override
public void onItemCreated(SerializationContext serializationContext, UaMonitoredItem item, int index) {
item.setValueConsumer(new BiConsumer<UaMonitoredItem, DataValue>() {
@Override
public void accept(UaMonitoredItem uaMonitoredItem, DataValue dataValue) {
StatusCode statusCode = uaMonitoredItem.getStatusCode();
logger.info("StatusCode: {}", statusCode);
logger.info("aaa={}", uaMonitoredItem.getReadValueId().getNodeId().getIdentifier());
logger.info(
"subscription value received: item={}, value={}, {}, {}, {}",
item.getReadValueId().getNodeId(), dataValue.getValue(),
item.getReadValueId().getNodeId().getNamespaceIndex(),
item.getReadValueId().getNodeId().getType(),
item.getReadValueId().getNodeId().getIdentifier());
}
});
}
});
}
});
}
private void testSubOne(OpcUaClient client) throws Exception {
logger.info("----------------------------------------------");
Double publishInterval = 1000.0;
int queueSize = 10;
//创建指定发布间隔的订阅对象
logger.info("&&&&&&&&&&&&&&&&");
System.out.println(client.connect().isDone());
logger.info("&&&&&&&&&&&&&&&&");
System.out.println(client.getSession().isDone());
ImmutableList<UaSubscription> aa = client.getSubscriptionManager().getSubscriptions();
System.out.println("uasubscription" + aa.size());
//同步订阅
UaSubscription subscription = client.getSubscriptionManager().createSubscription(publishInterval).get();
System.out.println("uasubscription" + aa.size());
aa.forEach(ua -> {
System.out.println(ua.getSubscriptionId());
});
logger.info("^^^^^^^^^^^^^");
//创建监控项请求集合
List<MonitoredItemCreateRequest> itemsToCreate = new ArrayList<>();
Set<String> members = new HashSet<>();
members.add("aaa");
members.add("bbb");
members.add("testone");
logger.info("########");
for (String member : members) {
NodeId nodeId = new NodeId(5, member);
ReadValueId readValueId = new ReadValueId(nodeId, AttributeId.Value.uid(),null,null);
//创建监控的参数
MonitoringParameters parameters = new MonitoringParameters(
subscription.nextClientHandle(), //监控项
publishInterval, // sampling interval
null, // filter, null means use default
UInteger.valueOf(queueSize), // queue size
true // discard oldest
);
//创建监控项请求
//该请求最后用于创建订阅。
MonitoredItemCreateRequest request = new MonitoredItemCreateRequest(readValueId, MonitoringMode.Reporting, parameters);
//添加至请求集合
itemsToCreate.add(request);
}
logger.info("**************");
BiConsumer<UaMonitoredItem, Integer> biConsumer =
(item, id) -> item.setValueConsumer(this::onSubscriptionValue);
List<UaMonitoredItem> items = subscription.createMonitoredItems(
TimestampsToReturn.Both,
itemsToCreate,
biConsumer
).get();
logger.info("==============");
for (UaMonitoredItem item : items) {
if (item.getStatusCode().isGood()) {
System.out.println("item1111 created for nodeId={}" + item.getReadValueId().getNodeId());
} else {
System.out.println(
"failed1111 to create item for nodeId={}" + item.getReadValueId().getNodeId() + " (status={})" + item.getStatusCode());
}
}
ImmutableList<UaSubscription> bb = client.getSubscriptionManager().getSubscriptions();
System.out.println("uasubscription" + bb.size());
}
private void testSubTwo(OpcUaClient client) throws Exception {
logger.info("-------------------------------------------------------------");
Double publishInterval = 1000.0;
int queueSize = 10;
//创建指定发布间隔的订阅对象
logger.info("&&&&&&&&&&&&&&&&");
System.out.println(client.connect().isDone());
logger.info("&&&&&&&&&&&&&&&&");
System.out.println(client.getSession().isDone());
ImmutableList<UaSubscription> aa = client.getSubscriptionManager().getSubscriptions();
System.out.println("uasubscription" + aa.size());
//同步订阅
UaSubscription subscription = client.getSubscriptionManager().createSubscription(publishInterval).get();
System.out.println("uasubscription" + aa.size());
aa.forEach(ua -> {
System.out.println(ua.getSubscriptionId());
});
logger.info("^^^^^^^^^^^^^");
//创建监控项请求集合
List<MonitoredItemCreateRequest> itemsToCreate = new ArrayList<>();
Set<String> members = new HashSet<>();
members.add("Counter1");
members.add("fff");
members.add("testTwo");
logger.info("########");
for (String member : members) {
NodeId nodeId = new NodeId(5, member);
ReadValueId readValueId = new ReadValueId(nodeId, AttributeId.Value.uid(),null,null);
//创建监控的参数
MonitoringParameters parameters = new MonitoringParameters(
subscription.nextClientHandle(), //监控项
publishInterval, // sampling interval
null, // filter, null means use default
UInteger.valueOf(queueSize), // queue size
true // discard oldest
);
//创建监控项请求
//该请求最后用于创建订阅。
MonitoredItemCreateRequest request = new MonitoredItemCreateRequest(readValueId, MonitoringMode.Reporting, parameters);
//添加至请求集合
itemsToCreate.add(request);
}
logger.info("**************");
BiConsumer<UaMonitoredItem, Integer> biConsumer =
(item, id) -> item.setValueConsumer(this::onSubscriptionValue22);
List<UaMonitoredItem> items = subscription.createMonitoredItems(
TimestampsToReturn.Both,
itemsToCreate,
biConsumer
).get();
logger.info("==============");
for (UaMonitoredItem item : items) {
if (item.getStatusCode().isGood()) {
System.out.println("item2222 created for nodeId={}" + item.getReadValueId().getNodeId());
} else {
System.out.println(
"failed2222 to create item for nodeId={}" + item.getReadValueId().getNodeId() + " (status={})" + item.getStatusCode());
}
}
ImmutableList<UaSubscription> bb = client.getSubscriptionManager().getSubscriptions();
System.out.println("uasubscription" + bb.size());
}
private void onSubscriptionValue22(UaMonitoredItem item, DataValue value) {
logger.info(
"subscription222222 value received: item={}, value={}, {}, {}, {}",
item.getReadValueId().getNodeId(), value.getValue(),
item.getReadValueId().getNodeId().getNamespaceIndex(),
item.getReadValueId().getNodeId().getType(),
item.getReadValueId().getNodeId().getIdentifier());
}
}
package org.eclipse.milo.examples.client;
import com.google.common.collect.ImmutableList;
import org.eclipse.milo.opcua.sdk.client.OpcUaClient;
import org.eclipse.milo.opcua.sdk.client.SessionActivityListener;
import org.eclipse.milo.opcua.sdk.client.api.UaSession;
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.sdk.client.api.identity.UsernameProvider;
import org.eclipse.milo.opcua.sdk.client.api.subscriptions.UaMonitoredItem;
import org.eclipse.milo.opcua.sdk.client.api.subscriptions.UaSubscription;
import org.eclipse.milo.opcua.sdk.client.api.subscriptions.UaSubscriptionManager;
import org.eclipse.milo.opcua.stack.core.AttributeId;
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.DateTime;
import org.eclipse.milo.opcua.stack.core.types.builtin.NodeId;
import org.eclipse.milo.opcua.stack.core.types.builtin.StatusCode;
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 org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.function.BiConsumer;
import static org.eclipse.milo.opcua.stack.core.types.builtin.unsigned.Unsigned.uint;
/**
* @author yinjinliang
* @desc
* @date 2021/3/16
*/
public class Subscription {
private static final Logger log = LoggerFactory.getLogger(Subscription.class);
public static void main(String[] args) throws Exception{
//OpcUaClient opcUaClient = getOpcUaClient("opc.tcp://192.168.3.48:53530/OPCUA/SimulationServer", null, null);
//OpcUaClient opcUaClient2 = getOpcUaClient("opc.tcp://192.168.3.48:53530/OPCUA/SimulationServer", null, null);
List<String> members = new ArrayList<>();
members.add("Counter1");
members.add("error");
List<String> members2 = new ArrayList<>();
members2.add("aaa");
members2.add("bbb");
members2.add("error222");
// UInteger id = testSub(members, opcUaClient);
// UInteger id2 = testSub(members2, opcUaClient);
//testSub(members2, opcUaClient2);
//同一个连接,重复添加监听器,断开重连时,会触发方法,
// 清除订阅时,第2次会把上一个订阅清除, 然后重新订阅, 就只有members2的数据了
// 可以只清除指定的订阅器,多个监听器就没有问题
// addListener(id, members, opcUaClient);
// addListener(id2, members2, opcUaClient);
//addListener(members2, opcUaClient2);
//注意: 一个连接最多100个订阅器,超过会报错
// test();
// test();
testKepServer();
Thread.sleep(200000);
}
public static void testKepServer() {
//kepServer opcua设置opcua 最大连接数 10 时 超过10个连接报错
//status=Bad_TooManySessions, message=The server has reached its maximum number of sessions.
OpcUaClient client = getOpcUaClient("opc.tcp://192.168.3.56:49320", "opcua", "opcua");
// OpcUaClient client2 = getOpcUaClient("opc.tcp://192.168.3.56:49320", "opcua", "opcua");
// OpcUaClient client3 = getOpcUaClient("opc.tcp://192.168.3.56:49320", "opcua", "opcua");
// OpcUaClient client4 = getOpcUaClient("opc.tcp://192.168.3.56:49320", "opcua", "opcua");
// OpcUaClient client5 = getOpcUaClient("opc.tcp://192.168.3.56:49320", "opcua", "opcua");
// OpcUaClient client6 = getOpcUaClient("opc.tcp://192.168.3.56:49320", "opcua", "opcua");
// OpcUaClient client7 = getOpcUaClient("opc.tcp://192.168.3.56:49320", "opcua", "opcua");
// OpcUaClient client8 = getOpcUaClient("opc.tcp://192.168.3.56:49320", "opcua", "opcua");
// OpcUaClient client9 = getOpcUaClient("opc.tcp://192.168.3.56:49320", "opcua", "opcua");
// OpcUaClient client10 = getOpcUaClient("opc.tcp://192.168.3.56:49320", "opcua", "opcua");
List<String> members = new ArrayList<>();
members.add("tongdao.tag1.aaa");
if (true) {
// return;
}
Double publishInterval = 1000.0;
int queueSize = 10;
//注意: KepServer 一个连接8000个订阅器,都没报错
for (int i = 0; i < 1000; i++) {
//创建指定发布间隔的订阅对象
//同步订阅
UaSubscription subscription = null;
try {
subscription = client.getSubscriptionManager().createSubscription(publishInterval).get();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
//创建监控项请求集合
List<MonitoredItemCreateRequest> itemsToCreate = new ArrayList<>();
for (String member : members) {
NodeId nodeId = new NodeId(2, member);
ReadValueId readValueId = new ReadValueId(nodeId, AttributeId.Value.uid(),null,null);
//创建监控的参数
MonitoringParameters parameters = new MonitoringParameters(
subscription.nextClientHandle(), //监控项
publishInterval, // sampling interval
null, // filter, null means use default
UInteger.valueOf(queueSize), // queue size
true // discard oldest
);
//创建监控项请求
//该请求最后用于创建订阅。
MonitoredItemCreateRequest request = new MonitoredItemCreateRequest(readValueId, MonitoringMode.Reporting, parameters);
//添加至请求集合
itemsToCreate.add(request);
}
BiConsumer<UaMonitoredItem, Integer> biConsumer =
(item, id) -> item.setValueConsumer(new BiConsumer<UaMonitoredItem, DataValue>() {
@Override
public void accept(UaMonitoredItem uaMonitoredItem, DataValue value) {
// log.info(
// "subscription value received: item={}, value={}, {}, {}, {}",
// item.getReadValueId().getNodeId(), value.getValue(),
// item.getReadValueId().getNodeId().getNamespaceIndex(),
// item.getReadValueId().getNodeId().getType(),
// item.getReadValueId().getNodeId().getIdentifier());
log.info(
"subscription value received: item={}, value={}, t={}, so={}, ser={}",
item.getReadValueId().getNodeId().getIdentifier(),
value.getValue().getValue(),
uaMonitoredItem.getTimestamps().getValue(),
value.getSourceTime().getJavaDate().getTime(),
value.getServerTime().getJavaDate()
);
}
});
List<UaMonitoredItem> items = null;
try {
items = subscription.createMonitoredItems(
TimestampsToReturn.Both,
itemsToCreate,
biConsumer
).get();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
for (UaMonitoredItem item : items) {
if (item.getStatusCode().isGood()) {
System.out.println("item created for nodeId={}" + item.getReadValueId().getNodeId());
} else {
System.out.println(
"failed to create item for nodeId={}" + item.getReadValueId().getNodeId() + " (status={})" + item.getStatusCode());
}
}
}
}
public static void test() {
OpcUaClient client = getOpcUaClient("opc.tcp://192.168.3.48:53530/OPCUA/SimulationServer", null, null);
List<String> members = new ArrayList<>();
members.add("aaa");
Double publishInterval = 1000.0;
int queueSize = 10;
//注意: SimulationServer 一个连接最多100个订阅器,超过会报错
for (int i = 0; i < 1; i++) {
//创建指定发布间隔的订阅对象
//同步订阅
UaSubscription subscription = null;
try {
subscription = client.getSubscriptionManager().createSubscription(publishInterval).get();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
//创建监控项请求集合
List<MonitoredItemCreateRequest> itemsToCreate = new ArrayList<>();
for (String member : members) {
NodeId nodeId = new NodeId(5, member);
ReadValueId readValueId = new ReadValueId(nodeId, AttributeId.Value.uid(),null,null);
//创建监控的参数
MonitoringParameters parameters = new MonitoringParameters(
subscription.nextClientHandle(), //监控项
publishInterval, // sampling interval
null, // filter, null means use default
UInteger.valueOf(queueSize), // queue size
true // discard oldest
);
//创建监控项请求
//该请求最后用于创建订阅。
MonitoredItemCreateRequest request = new MonitoredItemCreateRequest(readValueId, MonitoringMode.Reporting, parameters);
//添加至请求集合
itemsToCreate.add(request);
}
BiConsumer<UaMonitoredItem, Integer> biConsumer =
(item, id) -> item.setValueConsumer(new BiConsumer<UaMonitoredItem, DataValue>() {
@Override
public void accept(UaMonitoredItem uaMonitoredItem, DataValue value) {
// log.info(
// "subscription value received: item={}, value={}, {}, {}, {}",
// item.getReadValueId().getNodeId(), value.getValue(),
// item.getReadValueId().getNodeId().getNamespaceIndex(),
// item.getReadValueId().getNodeId().getType(),
// item.getReadValueId().getNodeId().getIdentifier());
log.info(
"subscription value received: item={}, value={}, t={}, so={}, ser={}",
item.getReadValueId().getNodeId().getIdentifier(),
value.getValue().getValue(),
uaMonitoredItem.getTimestamps().getValue(),
value.getSourceTime().getJavaDate().getTime(),
value.getServerTime().getJavaDate()
);
}
});
List<UaMonitoredItem> items = null;
try {
items = subscription.createMonitoredItems(
TimestampsToReturn.Both,
itemsToCreate,
biConsumer
).get();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
for (UaMonitoredItem item : items) {
if (item.getStatusCode().isGood()) {
System.out.println("item created for nodeId={}" + item.getReadValueId().getNodeId());
} else {
System.out.println(
"failed to create item for nodeId={}" + item.getReadValueId().getNodeId() + " (status={})" + item.getStatusCode());
}
}
}
}
private static OpcUaClient getOpcUaClient(String endPointUrl, String username, String pwd) {
OpcUaClient opcUaClient;
//log.info("初始化OPC UA Client......{}", endPointUrl);
try {
IdentityProvider identityProvider;
if (username != null && pwd != null) {
identityProvider = new UsernameProvider(username, pwd);
} else {
identityProvider = new AnonymousProvider();
}
opcUaClient = OpcUaClient.create(
endPointUrl,
endpoints ->
endpoints.stream()
.findFirst(),
configBuilder ->
configBuilder
.setIdentityProvider(identityProvider)
.setRequestTimeout(uint(5000))
.build()
);
//log.info("初始化OPC UA Client......成功");
} catch (Exception e) {
log.error("初始化OPC UA Client失败, opcua={}, error={}", endPointUrl, e.getMessage());
return null;
}
if (!opcUaClient.getSession().isDone()) {
try {
// synchronous connect
opcUaClient.connect().get();
log.info("OPC UA Client连接connect成功");
} catch (Exception e) {
log.error("OPC UA Client连接connect失败, opcua={}, error={}", endPointUrl, e.getMessage());
opcUaClient.disconnect();
return null;
}
}
return opcUaClient;
}
private static UInteger testSub(List<String> list, OpcUaClient client) {
Double publishInterval = 1000.0;
int queueSize = 10;
//创建指定发布间隔的订阅对象
ImmutableList<UaSubscription> aa = client.getSubscriptionManager().getSubscriptions();
//同步订阅
UaSubscription subscription = null;
UInteger idaa = null;
try {
subscription = client.getSubscriptionManager().createSubscription(publishInterval).get();
idaa = subscription.getSubscriptionId();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
//创建监控项请求集合
List<MonitoredItemCreateRequest> itemsToCreate = new ArrayList<>();
for (String member : list) {
NodeId nodeId = new NodeId(5, member);
ReadValueId readValueId = new ReadValueId(nodeId, AttributeId.Value.uid(),null,null);
//创建监控的参数
MonitoringParameters parameters = new MonitoringParameters(
subscription.nextClientHandle(), //监控项
publishInterval, // sampling interval
null, // filter, null means use default
UInteger.valueOf(queueSize), // queue size
true // discard oldest
);
//创建监控项请求
//该请求最后用于创建订阅。
MonitoredItemCreateRequest request = new MonitoredItemCreateRequest(readValueId, MonitoringMode.Reporting, parameters);
//添加至请求集合
itemsToCreate.add(request);
}
BiConsumer<UaMonitoredItem, Integer> biConsumer =
(item, id) -> item.setValueConsumer(new BiConsumer<UaMonitoredItem, DataValue>() {
@Override
public void accept(UaMonitoredItem uaMonitoredItem, DataValue value) {
log.info(
"subscription value received: item={}, value={}, {}, {}, {}",
item.getReadValueId().getNodeId(), value.getValue(),
item.getReadValueId().getNodeId().getNamespaceIndex(),
item.getReadValueId().getNodeId().getType(),
item.getReadValueId().getNodeId().getIdentifier());
}
});
List<UaMonitoredItem> items = null;
try {
items = subscription.createMonitoredItems(
TimestampsToReturn.Both,
itemsToCreate,
biConsumer
).get();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
for (UaMonitoredItem item : items) {
if (item.getStatusCode().isGood()) {
System.out.println("item created for nodeId={}" + item.getReadValueId().getNodeId());
} else {
System.out.println(
"failed to create item for nodeId={}" + item.getReadValueId().getNodeId() + " (status={})" + item.getStatusCode());
}
}
return idaa;
}
private static void addListener(UInteger id, List<String> list, OpcUaClient client) {
client.getSubscriptionManager().addSubscriptionListener(new UaSubscriptionManager.SubscriptionListener() {
@Override
public void onKeepAlive(UaSubscription subscription, DateTime publishTime) {
}
@Override
public void onStatusChanged(UaSubscription subscription, StatusCode status) {
}
@Override
public void onPublishFailure(UaException exception) {
}
@Override
public void onNotificationDataLost(UaSubscription subscription) {
}
@Override
public void onSubscriptionTransferFailed(UaSubscription subscription, StatusCode statusCode) {
log.info("oooooooooooooooo{}", statusCode);
//一旦连接断开，就清除诸如此类的订阅管理器, 重新订阅
// client.getSubscriptionManager().clearSubscriptions();
//清除指定id的订阅器
client.getSubscriptionManager().deleteSubscription(id);
try {
// 这个可以重新订阅到
System.out.println("**********" + list.size());
for (String member : list) {
System.out.println(member);
}
testSub(list, client);
} catch (Exception e) {
e.printStackTrace();
}
}
});
client.addSessionActivityListener(new SessionActivityListener(){
@Override
public void onSessionActive(UaSession session) {
log.info("success-----------");
System.out.println(client.connect().isDone());
System.out.println(client.getSession().isDone());
}
@Override
public void onSessionInactive(UaSession session) {
log.info("fail-----------");
System.out.println(client.connect().isDone());
System.out.println(client.getSession().isDone());
}
});
}
}
7452
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
