fix 更新线程

acs/nladmin-system/src/main/java/org/nl/acs/device_driver/driver/AbstractOpcDeviceDriver.java

@@ -1,11 +1,13 @@
 package org.nl.acs.device_driver.driver;
 
+import lombok.extern.slf4j.Slf4j;
 import org.jinterop.dcom.common.JIException;
 import org.nl.acs.ext.wms.data.JsonUtl;
 import org.nl.acs.instruction.service.InstructionService;
 import org.nl.acs.opc.*;
 import org.nl.acs.udw.UnifiedDataAccessor;
 import org.nl.acs.udw.UnifiedDataAccessorFactory;
+import org.nl.acs.udw.UnifiedDataAppService;
 import org.nl.modules.wql.exception.WDKException;
 import org.nl.modules.wql.util.SpringContextHolder;
 import org.openscada.opc.lib.da.AddFailedException;
@@ -16,6 +18,7 @@ import org.springframework.beans.factory.annotation.Autowired;
 
 import java.util.*;
 
+@Slf4j
 public class AbstractOpcDeviceDriver extends AbstractDeviceDriver implements OpcDeviceDriver {
 
   @Autowired
@@ -135,11 +138,13 @@ public class AbstractOpcDeviceDriver extends AbstractDeviceDriver implements Opc
         sb.append(":");
         sb.append(JsonUtl.parseWithoutException(udw_value));
         sb.append(";");
-//        if (!need_write && !UnifiedDataAppService.isEquals(udw_value, write_value)) {
+        if (!need_write && !UnifiedDataAppService.isEquals(udw_value, write_value)) {
-//          need_write = true;
+          need_write = true;
-//        }
+        } else {
+          log.warn("下发信号点位{} 当前写入值:{} 与系统内存值:{} 相同，不再写入 ", code, write_value, udw_value );
+        }
       }
-      need_write = true;
+      //need_write = true;
 
       if (need_write) {
         Date date = new Date();

acs/nladmin-system/src/main/java/org/nl/acs/opc/DeviceOpcProtocolRunable.java

@@ -1,271 +1,418 @@
 package org.nl.acs.opc;
 
 import cn.hutool.core.date.DateUtil;
-import cn.hutool.core.util.ObjectUtil;
 import cn.hutool.core.util.StrUtil;
 import lombok.extern.slf4j.Slf4j;
 import org.nl.acs.udw.UnifiedDataAccessor;
 import org.nl.acs.udw.UnifiedDataAccessorFactory;
-import org.openscada.opc.lib.da.Group;
+import org.nl.acs.udw.UnifiedDataAppService;
-import org.openscada.opc.lib.da.Item;
+import org.openscada.opc.lib.da.*;
-import org.openscada.opc.lib.da.ItemState;
-import org.openscada.opc.lib.da.Server;
 
 import java.util.*;
-import java.util.concurrent.ExecutorService;
+
-import java.util.concurrent.Executors;
 
 @Slf4j
-public class DeviceOpcProtocolRunable implements Runnable {
+public class DeviceOpcProtocolRunable implements Runnable, DataCallback, ServerConnectionStateListener {
-  List<OpcItemDto> protocols;
+    List<OpcItemDto> protocols;
-  OpcServerManageDto OpcServer;
+    OpcServerManageDto OpcServer;
-  int error_num;
+    int error_num;
-  String message;
+    String message;
-  private Server server;
+    int maxResartNum;
-  //boolean flag =false;
+    private Server server;
-
+    private Group group;
-
+    boolean flag = false;
-  public DeviceOpcProtocolRunable() {
+    private int all_null;
-    this.error_num = 0;
+    private Map<String, OpcItemDto> itemSearchCache;
-    this.message = null;
-    this.server = null;
-  }
-
-  public List<OpcItemDto> getProtocols() {
-    return this.protocols;
-  }
-
-  public void setProtocols(List<OpcItemDto> protocols) {
-    this.protocols = protocols;
-  }
-
-  public OpcServerManageDto getOpcServer() {
-    return this.OpcServer;
-  }
-
-  public void setOpcServer(OpcServerManageDto opcServer) {
-    this.OpcServer = opcServer;
-  }
-
-  OpcItemDto getItem(String item) {
-    Iterator var2 = this.protocols.iterator();
-
-    OpcItemDto dto;
-    do {
-      if (!var2.hasNext()) {
-        return null;
-      }
-
-      dto = (OpcItemDto) var2.next();
-    } while (!StrUtil.equals(item, dto.getItem_code()));
-
-    return dto;
-  }
-
-  @Override
-  public void run() {
-    while (true) {
-      try {
-         this.server = OpcServerUtl.getServerWithOutException(this.OpcServer.getOpc_host(), this.OpcServer.getCls_id(), this.OpcServer.getUser(), this.OpcServer.getPassword(), this.OpcServer.getDomain());
-//        Group group = server.addGroup(this.OpcServer.getOpc_host());
-        Group group = server.addGroup(this.OpcServer.getOpc_code());
-        if(ObjectUtil.isEmpty(group)){
-          log.info("group is null ");
-        }
-        List<String> itemsString = new ArrayList();
-        Iterator it = this.protocols.iterator();
-
-        while (it.hasNext()) {
-          OpcItemDto protocol = (OpcItemDto) it.next();
-          String item = protocol.getItem_code();
-          itemsString.add(item);
-        }
-
-        Map<String, Item> itemsMap = new LinkedHashMap();
-        boolean is_error = false;
-        StringBuilder err_message = new StringBuilder();
-        Iterator var7 = itemsString.iterator();
-
-        while (var7.hasNext()) {
-          String string = (String) var7.next();
-
-          try {
-            itemsMap.put(string, group.addItem(string));
-            log.trace("添加成功 {}", string);
-          } catch (Exception var29) {
-            err_message.append(string + ":" + var29.getMessage());
-            if (!is_error) {
-              is_error = true;
-            }
-          }
-        }
-
-        if (is_error) {
-          log.info("设备OPC数据同步配置异常");
-        }
-
-        if (!OpcStartTag.is_run) {
-          OpcStartTag.is_run = true;
-        }
-
-        //线程名
-        String tag = Thread.currentThread().getName();
-        if (this.OpcServer != null) {
-          tag = tag + this.OpcServer.getOpc_code();
-        }
-        UnifiedDataAccessor accessor_value = UnifiedDataAccessorFactory.getAccessor(OpcConfig.udw_opc_value_key);
-
-        boolean time_out = false;
-
-        label97:
-        while (true) {
-          long begin = System.currentTimeMillis();
-          Map<Item, ItemState> itemStatus = null;
-          try {
-            itemStatus  = group.read(true, (Item[]) itemsMap.values().toArray(new Item[0]));
-          } catch (Exception e){
-            System.out.println("数据同步异常:"+ this.getOpcServer().getOpc_code());
-            log.trace("数据同步异常:{}", this.getOpcServer().getOpc_code());
-            //e.printStackTrace();
-          }
-          long end = System.currentTimeMillis();
-          log.trace("{} 开始记时{}", tag, DateUtil.now());
-          long duration = end - begin;
-          log.trace("{} 读取耗时：{}", tag, duration);
-          System.out.println("线程："+tag + " 读取耗时:"+ duration);
-          if (duration > 1000L) {
-            if (!time_out) {
-              log.warn(" {} 读取超时 : {}", tag, duration);
-            }
-
-            time_out = true;
-          } else {
-            time_out = false;
-          }
-
-          if(ObjectUtil.isEmpty(itemStatus)) {
-            System.out.println( tag + " :itemStatus is null");
-            log.warn(" {} 读取异常 : {} itemStatus is null", tag);
-          }
-
-
-          Set<Item> items = itemStatus.keySet();
-          Iterator var18 = items.iterator();
-
-          while (true) {
-            Item item;
-            //当前值
-            Object value;
-            //旧的值
-            Object his;
-            do {
-              if (!var18.hasNext()) {
-                end = System.currentTimeMillis();
-                log.trace("{}", itemsString);
-                log.trace("{} 计算完成耗时{}", tag, end - begin);
-                Thread.sleep((long) OpcConfig.synchronized_millisecond);
-                if (this.error_num != 0) {
-                  this.error_num = 0;
-                  this.message = null;
-                }
-                continue label97;
-              }
-
-              item = (Item) var18.next();
-              ItemState itemState = (ItemState) itemStatus.get(item);
-              value = OpcUtl.getValue(item, itemState);
-              his = accessor_value.getValue(item.getId());
-              if (!ObjectUtl.isEquals(itemState.getQuality(), QualityTypeValue.OPC_QUALITY_GOOD) && his != null) {
-                //flag = true;
-                log.warn("opc 值不健康 item: {}, 状态: {},当前读取值：{}, 系统内存值{} ", item.getId(), itemState.getQuality(), value, his);
-              }
-//              if(flag){
-//                if (this.server != null) {
-//                  try {
-//                    this.server.disconnect();
-//                  } catch (Exception var25) {
-//                    log.warn("{} : server  disconnect", var25);
-//                  }
-//                }
-//                DeviceOpcProtocolRunable runable = new DeviceOpcProtocolRunable();
-//                runable.setProtocols(protocols);
-//                runable.setOpcServer(OpcServer);
-//                ExecutorService executorService = Executors.newCachedThreadPool();
-//                executorService.submit(runable);
-//                log.warn("opc 值不健康 item: {}, 重新创建连接,当前线程名：{}", item.getId(),tag);
-//                break;
-//              }
-            } while (ObjectUtil.equal(value, his));//如果两次的值相等，不走下面的代码
-
-//            if(flag){
-//              break;
-//            }
-            OpcItemDto itemDto = this.getItem(item.getId());
-            //默认记录日志
-            if (true) {
-              StringBuilder sb = new StringBuilder();
-              //设备的ITEM项
-              List<String> relate_items = itemDto.getRelate_items();
-              Iterator var26 = relate_items.iterator();
-
-              while (var26.hasNext()) {
-                String relate = (String) var26.next();
-                Object obj = accessor_value.getValue(relate);
-                sb.append("key:" + relate + "value:" + obj + ";");
-              }
-
-              log.warn("信号{}变更从{}->{};信号快照：{}", new Object[]{item.getId(), his, value, sb});
-
-            }
-//            accessor_value.setValueWithPersistence(item.getId(),accessor_value.getValue(item.getId()));
-//            accessor_value.getHistoryUnifiedData(item.getId());
-            //设置值
-            accessor_value.setValue(item.getId(), value);
-//            if(flag){
-//              break;
-//            }
-          }
-//          if(flag){
-//            break;
-//          }
-        }
-      } catch (Exception var30) {
-        if (this.server != null) {
-          try {
-            this.server.disconnect();
-          } catch (Exception var25) {
-            log.warn("{} : server  disconnect", var25);
-          }
-        }
 
+    public DeviceOpcProtocolRunable() {
+        this.error_num = 0;
+        this.all_null = 0;
+        this.message = null;
+        this.itemSearchCache = new HashMap();
         this.server = null;
+    }
 
-        String error_message = "设备信息同步异常,"+var30;
+    public List<OpcItemDto> getProtocols() {
-        if (!StrUtil.equals(this.message, error_message)) {
+        return this.protocols;
-          log.warn("", var30);
+    }
+
+    public void setProtocols(List<OpcItemDto> protocols) {
+        this.protocols = protocols;
+    }
+
+    public OpcServerManageDto getOpcServer() {
+        return this.OpcServer;
+    }
+
+    public void setOpcServer(OpcServerManageDto opcServer) {
+        this.OpcServer = opcServer;
+    }
+
+
+    private OpcItemDto getItem(String item) {
+        OpcItemDto x = (OpcItemDto) this.itemSearchCache.get(item);
+        if (x == null) {
+            Iterator var3 = this.protocols.iterator();
+
+            while (var3.hasNext()) {
+                OpcItemDto dto = (OpcItemDto) var3.next();
+                if (StrUtil.equals(item, dto.getItem_code())) {
+                    x = dto;
+                    this.itemSearchCache.put(item, dto);
+                    break;
+                }
+            }
         }
 
+        return x;
+    }
+
+
+    @Override
+    public void run() {
+        if (OpcConfig.opc_item_read_using_callback) {
+            this.runNew();
+        } else {
+            this.runOld();
+        }
+    }
+
+
+    private void runOld() {
+        while (true) {
+            start:
+            try {
+                if (this.group != null) {
+                    group.clear();
+                    group.remove();
+                    log.trace("清理group...");
+                }
+                if (this.server != null) {
+                    server.disconnect();
+                    log.trace("清理server...");
+                }
+
+                this.server = OpcServerUtl.getServerWithOutException(this.OpcServer.getOpc_host(), this.OpcServer.getCls_id(), this.OpcServer.getUser(), this.OpcServer.getPassword(), this.OpcServer.getDomain());
+                this.server.addStateListener(this);
+                group = this.server.addGroup();
+                List<String> itemsString = new ArrayList();
+                Iterator var3 = this.protocols.iterator();
+
+                while (var3.hasNext()) {
+                    OpcItemDto protocol = (OpcItemDto) var3.next();
+                    String item = protocol.getItem_code();
+                    itemsString.add(item);
+                }
+
+                Map<String, Item> itemsMap = new LinkedHashMap();
+                boolean is_error = false;
+                StringBuilder err_message = new StringBuilder();
+                Iterator var6 = itemsString.iterator();
+
+                while (var6.hasNext()) {
+                    String string = (String) var6.next();
+
+                    try {
+                        Item item = group.addItem(string);
+                        itemsMap.put(string, item);
+                        log.trace("添加成功 {}", string);
+                    } catch (Exception var26) {
+                        err_message.append(string + ":" + var26.getMessage());
+                        if (!is_error) {
+                            is_error = true;
+                        }
+                    }
+                }
+
+                String tag;
+                if (is_error) {
+                    tag = err_message.toString();
+                    log.warn("{}:{}", OpcConfig.resource_code, tag);
+                }
+
+                if (!OpcStartTag.is_run) {
+                    OpcStartTag.is_run = true;
+                }
+
+                tag = "";
+                if (log.isWarnEnabled()) {
+                    tag = Thread.currentThread().getName();
+                    if (this.OpcServer != null) {
+                        tag = tag + this.getOpcGroupID();
+                    }
+                }
+
+                UnifiedDataAccessor accessor_value = UnifiedDataAccessorFactory.getAccessor(OpcConfig.udw_opc_value_key);
+                boolean time_out = false;
+
+                while (DeviceOpcSynchronizeAutoRun.isRun) {
+                    long begin = System.currentTimeMillis();
+                    if (log.isTraceEnabled()) {
+                        log.trace("{} 开始记时{}", tag, DateUtil.now());
+                    }
+
+                    Map<Item, ItemState> itemStatus = group.read(true, (Item[]) itemsMap.values().toArray(new Item[0]));
+                    long end = System.currentTimeMillis();
+                    long duration = end - begin;
+                    if (log.isTraceEnabled()) {
+                        log.trace("{} 读取耗时：{}", tag, duration);
+                    }
+
+                    if (duration > 1000L) {
+                        if (!time_out) {
+                            log.warn("{} 读取超时 : {}", tag, duration);
+                        }
+
+                        time_out = true;
+                    } else {
+                        time_out = false;
+                    }
+
+                    boolean valueAllNotNull = false;
+                    Set<Item> items = itemStatus.keySet();
+                    Iterator var18 = items.iterator();
+
+                    while (var18.hasNext()) {
+                        Item item = (Item) var18.next();
+                        ItemState itemState = (ItemState) itemStatus.get(item);
+                        Object value = OpcUtl.getValue(item, itemState);
+                        if (value != null) {
+                            valueAllNotNull = true;
+                        }
+
+                        String itemId = item.getId();
+                        Object his = accessor_value.getValue(itemId);
+                        if (!ObjectUtl.isEquals(itemState.getQuality(), QualityTypeValue.OPC_QUALITY_GOOD) && his != null) {
+                            log.warn("opc 值不健康 item: {}, 状态: {}", itemId, itemState.getQuality());
+                        }
+
+                        if (!UnifiedDataAppService.isEquals(value, his)) {
+                            OpcItemDto itemDto = this.getItem(itemId);
+                            if (true) {
+                                this.logItemChanged(itemId, accessor_value, value, itemDto);
+                            }
+
+                            accessor_value.setValue(itemId, value);
+                        }
+                    }
+
+                    end = System.currentTimeMillis();
+                    if (log.isTraceEnabled()) {
+                        log.trace("{}", itemsString);
+                        log.trace("{} 计算完成耗时{}", tag, end - begin);
+                    }
+
+                    ThreadUtl.sleep((long) OpcConfig.synchronized_millisecond);
+                    if (this.error_num != 0) {
+                        this.error_num = 0;
+                        this.message = null;
+                    }
+
+                    if (!valueAllNotNull) {
+                        int random = (new Random()).nextInt(10) + 1;
+                        random *= 1000;
+                        if (this.all_null < 3) {
+                            if (log.isWarnEnabled()) {
+                                log.warn("{} 所有内容都为空, all_null:{} ,暂定{}s", tag, all_null,5000 + random);
+                            }
+
+                            ThreadUtl.sleep((long) (5000 + random));
+                        } else if (this.all_null < 6) {
+                            if (log.isWarnEnabled()) {
+                                log.warn(tag + "重新创建server");
+                                log.warn("{} 所有内容都为空, all_null:{} ,暂定{}s", tag, all_null,30000 + random);
+                            }
+//                            ThreadUtl.sleep((long) (30000 + random));
+                            ThreadUtl.sleep((long) ((new Random()).nextInt(3) +1) * 1000);
+                            break start;
+                        } else if (this.all_null < 12) {
+                            if (log.isWarnEnabled()) {
+                                log.warn("{} 所有内容都为空, all_null:{} ,暂定{}ms", tag, all_null, '\uea60' + random);
+                            }
+
+                            ThreadUtl.sleep((long) ('\uea60' + random));
+                        } else {
+                            if (log.isWarnEnabled()) {
+                                log.warn("{} 所有内容都为空, all_null:{} ,暂定{}ms", tag, all_null, 120000 + random);
+                            }
+
+                            ThreadUtl.sleep((long) (120000 + random));
+                        }
+
+                        ++this.all_null;
+                    } else {
+                        this.all_null = 0;
+                    }
+//                    break start;
+
+                }
+
+                log.warn("opc线程停止。。。");
+                return;
+            } catch (Exception var27) {
+                if (this.server != null) {
+                    try {
+                        this.server.disconnect();
+                    } catch (Exception var25) {
+                    }
+                }
+
+                this.server = null;
+                if (!DeviceOpcSynchronizeAutoRun.isRun) {
+                    log.warn("opc线程停止2。。。");
+                    return;
+                }
+
+                String error_message = "设备信息同步异常";
+                if (!StrUtil.equals(this.message, error_message)) {
+                    log.warn(error_message, var27);
+                }
+
+                ThreadUtl.sleep((long) (OpcConfig.synchronized_exception_wait_second * 1000));
+                ++this.error_num;
+                if (this.error_num > 3 && !StrUtil.equals(this.message, error_message)) {
+                    this.message = error_message;
+                }
+            }
+        }
+    }
+
+
+    private void runNew() {
+        Async20Access accessor = null;
+
+        while (true) {
+            String opcGroupId = this.getOpcGroupID();
+
+            try {
+                if (this.server == null) {
+                    this.server = OpcServerUtl.getServerWithOutException(this.OpcServer.getOpc_host(), this.OpcServer.getCls_id(), this.OpcServer.getUser(), this.OpcServer.getPassword(), this.OpcServer.getDomain());
+                    this.server.addStateListener(this);
+                    accessor = new Async20Access(this.server, OpcConfig.synchronized_millisecond, true);
+                    Iterator var9 = this.protocols.iterator();
+
+                    while (var9.hasNext()) {
+                        OpcItemDto protocol = (OpcItemDto) var9.next();
+                        String itemId = protocol.getItem_code();
+                        accessor.addItem(itemId, this);
+                    }
+
+                    accessor.bind();
+                    log.info("Async20Access bind {}", opcGroupId);
+                }
+
+                Thread.sleep((long) (OpcConfig.synchronized_exception_wait_second * 1000));
+            } catch (Exception var8) {
+                if (accessor != null) {
+                    try {
+                        log.warn("Async20Access unbind {}", opcGroupId);
+                        accessor.unbind();
+                    } catch (Exception var7) {
+                        var7.printStackTrace();
+                    }
+
+                    accessor = null;
+                }
+
+                if (this.server != null) {
+                    try {
+                        this.server.disconnect();
+                    } catch (Exception var6) {
+                    }
+
+                    this.server = null;
+                }
+
+                if (var8 instanceof InterruptedException) {
+                    log.warn("OPC 同步线程(%s)被中断", opcGroupId);
+                    return;
+                }
+
+                log.warn("设备信息同步异常", var8);
+                ThreadUtl.sleep((long) (OpcConfig.synchronized_exception_wait_second * 1000));
+                String error_message = var8.getMessage();
+                if (error_message == null) {
+                    error_message = var8.toString();
+                }
+
+                ++this.error_num;
+                if (this.error_num > 3 && !StrUtil.equals(this.message, error_message)) {
+                    this.message = error_message;
+                }
+            }
+        }
+    }
+
+
+    public void connectionStateChanged(boolean connected) {
+        if (!connected) {
+            this.server = null;
+        }
+
+        log.warn("opc server {} {}", this.getOpcGroupID(), connected ? "connected" : "disconnected");
+    }
+
+    private String getOpcGroupID() {
+        String var10000 = this.OpcServer.getOpc_code();
+        return var10000 + "(" + this.protocols.size() + " items)";
+    }
+
+    public static String formatDuring(long mss) {
+        long days = mss / 86400000L;
+        long hours = mss % 86400000L / 3600000L;
+        long minutes = mss % 3600000L / 60000L;
+        long seconds = mss % 60000L / 1000L;
+        return days + " days " + hours + " hours " + minutes + " minutes " + seconds + " seconds ";
+    }
+
+
+    public void changed(Item item, ItemState itemState) {
+        String itemId = item.getId();
+
         try {
-          Thread.sleep((long) (OpcConfig.synchronized_exception_wait_second * 1000));
+            Object value = OpcUtl.getValue(item, itemState);
-        } catch (InterruptedException e) {
+            UnifiedDataAccessor accessor_value = UnifiedDataAccessorFactory.getAccessor(OpcConfig.udw_opc_value_key);
-          e.printStackTrace();
+            accessor_value.setValue(itemId, value);
-          log.warn("OPC 读取线程读取异常{} :", e);
+
-//          Thread.currentThread().interrupt();不会真正停止线程
+//            if (value != null) {
-        }
+//                if (log.isTraceEnabled()) {
-        ++this.error_num;
+//                    log.trace("Item {} new value: {}, Timestamp: {}", new Object[]{itemId, itemState.getValue(), itemState.getTimestamp().getTime()});
-        if (this.error_num > 3 && !StrUtil.equals(this.message, error_message)) {
+//                }
-          log.info("设备同步通信异常");
+//            } else if (log.isInfoEnabled()) {
-          this.message = error_message;
+//                log.info("Item {} new value: {}, Timestamp: {}, Quality: {}", new Object[]{itemId, itemState.getValue(), itemState.getTimestamp().getTime(), itemState.getQuality()});
-        }
+//            }
-      }
+            log.trace("Item {} new value: {}, Timestamp: {}", new Object[]{itemId, itemState.getValue(), itemState.getTimestamp().getTime()});
-    }
+
-  }
+            OpcItemDto itemDto = this.getItem(itemId);
+//            if (Boolean.TRUE.equals(itemDto.getNeed_log())) {
+//                this.logItemChanged(itemId, accessor_value, value, itemDto);
+//            }
+            this.logItemChanged(itemId, accessor_value, value, itemDto);
+
+        } catch (Exception var7) {
+            log.error(itemId, var7);
+        }
+
+    }
+
+    private void logItemChanged(String itemId, UnifiedDataAccessor accessor_value, Object value, OpcItemDto itemDto) {
+        Object his = accessor_value.getValue(itemId);
+        List<String> relate_items = itemDto.getRelate_items();
+        if (relate_items != null && !relate_items.isEmpty()) {
+            StringBuilder sb = new StringBuilder();
+            Iterator var8 = relate_items.iterator();
+
+            while (var8.hasNext()) {
+                String relate = (String) var8.next();
+                Object obj = accessor_value.getValue(relate);
+                sb.append("key:" + relate + "value:" + obj + ";");
+            }
+            log.warn("设备：{}信号{}变更从{}->{};信号快照：{}", new Object[]{itemDto.getDevice_code(), itemId, his, value, sb});
+//            this.businessLogger.setResource(itemDto.getDevice_code(), itemDto.getDevice_name()).log("信号{}变更从{}->{};信号快照：{}", new Object[]{itemId, his, value, sb});
+        } else {
+            log.warn("设备：{}信号{}变更从{}->{};信号快照：{}", new Object[]{itemDto.getDevice_code(), itemId, his, value});
+//            this.businessLogger.setResource(itemDto.getDevice_code(), itemDto.getDevice_name()).log("信号{}变更从{}->{}", new Object[]{itemId, his, value});
+        }
+    }
 
-  public static String formatDuring(long mss) {
-    long days = mss / 86400000L;
-    long hours = mss % 86400000L / 3600000L;
-    long minutes = mss % 3600000L / 60000L;
-    long seconds = mss % 60000L / 1000L;
-    return days + " days " + hours + " hours " + minutes + " minutes " + seconds + " seconds ";
-  }
 }

acs/nladmin-system/src/main/java/org/nl/acs/opc/OpcServerServiceImpl.java

@@ -1,8 +1,10 @@
 package org.nl.acs.opc;
 
+import cn.hutool.core.util.StrUtil;
 import org.jinterop.dcom.common.JIException;
 import org.nl.acs.auto.initial.ApplicationAutoInitial;
 import org.nl.acs.device_driver.driver.ItemValue;
+import org.nl.modules.common.exception.BadRequestException;
 import org.nl.modules.wql.exception.WDKException;
 import org.openscada.opc.lib.common.NotConnectedException;
 import org.openscada.opc.lib.da.Group;
@@ -65,79 +67,86 @@ public class OpcServerServiceImpl implements OpcServerService, ApplicationAutoIn
     this.opcServerManageDtos = Collections.synchronizedMap(this.opcServerManageDtos);
   }
 
-  public synchronized Group getServer(String code) {
+  public Group getServer(String code) {
-    Group group = null;
+    synchronized(this.buildLock(code)) {
-    group = (Group) this.groups.get(code);
+      Group group = null;
-    if (group != null) {
+      group = (Group)this.groups.get(code);
-      try {
+      if (group != null) {
-        if (group.isActive()) {
+        label68: {
-          return group;
+          Group var10000;
+          try {
+            if (!group.isActive()) {
+              break label68;
+            }
+
+            var10000 = group;
+          } catch (JIException var14) {
+            log.error(code, var14);
+            break label68;
+          }
+
+          return var10000;
         }
-      } catch (JIException var9) {
-        var9.printStackTrace();
       }
-    }
 
-    Server server = (Server) this.servers.get(code);
+      Server server = (Server)this.servers.get(code);
-    boolean needcreate = false;
+      boolean needcreate = false;
-    if (server == null) {
+      String groupName = code;
-      needcreate = true;
+      if (server == null) {
-    } else {
-      try {
-        group = server.findGroup(OpcConfig.opc_server_default_group);
-      } catch (UnknownHostException
-          | JIException
-          | UnknownGroupException
-          | NotConnectedException
-          | IllegalArgumentException var8) {
-        var8.printStackTrace();
         needcreate = true;
+      } else {
+        try {
+          group = server.findGroup(groupName);
+        } catch (UnknownHostException | JIException | UnknownGroupException | NotConnectedException | IllegalArgumentException var13) {
+          log.error(code, var13);
+          needcreate = true;
+        }
       }
+
+      if (needcreate) {
+        OpcServerManageDto dto = (OpcServerManageDto)this.opcServerManageDtos.get(code);
+        if (dto == null) {
+          throw new BadRequestException(code + "{} 不存在");
+        }
+
+        if (server == null) {
+          server = OpcServerUtl.getServerWithOutException(dto.getOpc_host(), StrUtil.trim(dto.getCls_id()), dto.getUser(), dto.getPassword(), StrUtil.trim(dto.getDomain()));
+        }
+
+        try {
+          group = server.addGroup(groupName);
+        } catch (Exception var12) {
+          this.clearServer(code);
+          ThreadUtl.sleep(5000L);
+          log.warn("获取opc出错重新获取", code, var12);
+          server = OpcServerUtl.getServerWithOutException(dto.getOpc_host(), StrUtil.trim(dto.getCls_id()), dto.getUser(), dto.getPassword(), StrUtil.trim(dto.getDomain()));
+
+          try {
+            group = server.addGroup(groupName);
+          } catch (Exception var11) {
+            var11.printStackTrace();
+          }
+        }
+
+        this.servers.put(code, server);
+        this.groups.put(code, group);
+      }
+
+      return group;
     }
-
-    if (needcreate) {
-      OpcServerManageDto dto = (OpcServerManageDto) this.opcServerManageDtos.get(code);
-      if (dto == null) {
-        throw new WDKException("code 不存在");
-      }
-
-      server = OpcServerUtl.getServerWithOutException(
-              dto.getOpc_host(),
-              dto.getCls_id(),
-              dto.getUser(),
-              dto.getPassword(),
-              dto.getDomain());
-
-//      server = OpcServerUtl.getServerWithOutException(this.OpcServer.getOpc_host(), this.OpcServer.getCls_id(), this.OpcServer.getUser(), this.OpcServer.getPassword(), this.OpcServer.getDomain());
-
-
-      try {
-        group = server.addGroup(OpcConfig.opc_server_default_group);
-      } catch (Exception var7) {
-        throw new WDKException(var7);
-      }
-
-      this.servers.put(code, server);
-      this.groups.put(code, group);
-    }
-
-    return group;
   }
 
-  public synchronized void clearServer(String code) {
+  public void clearServer(String code) {
-    try {
+    synchronized(this.buildLock(code)) {
-      Server server = (Server) this.servers.get(code);
+      try {
-      if (server!=null){
+        Server server = (Server)this.servers.get(code);
         server.disconnect();
+      } catch (Exception var5) {
       }
 
-    } catch (Exception e) {
+      this.servers.remove(code);
-      e.printStackTrace();
+      this.groups.remove(code);
-      log.error("清理server异常,",e.getMessage());
     }
-
-    this.servers.remove(code);
-    this.groups.remove(code);
   }
 
   public void writeInteger(String code, ItemValue... values) {
@@ -151,4 +160,15 @@ public class OpcServerServiceImpl implements OpcServerService, ApplicationAutoIn
       throw var4;
     }
   }
+
+  private String buildLock(String key) {
+    if (StrUtil.isEmpty(key)) {
+      key = "";
+    }
+    StringBuilder builder = new StringBuilder();
+    builder.append("OpcServerService.");
+    builder.append(key);
+    String lock = builder.toString().intern();
+    return lock;
+  }
 }