fix opc读取信号

hd/nladmin-system/src/main/java/org/nl/acs/device/service/impl/ConveyorDevice.java

@@ -43,16 +43,16 @@ public class ConveyorDevice {
         @SneakyThrows
         @Override
         public void run() {
-            System.out.println("test");
+//            System.out.println("test");
-            String MODE = "RD1.RD1." + id + ".mode";
+//            String MODE = "RD1.RD1." + id + ".mode";
-            String code = OpcUtl.read(MODE);
+//            String code = OpcUtl.read(MODE);
-            if ("2".equals(code)) {
+//            if ("2".equals(code)) {
-                TaskService taskserver = new TaskServiceImpl();
+//                TaskService taskserver = new TaskServiceImpl();
-                TaskDto dto = new TaskDto();
+//                TaskDto dto = new TaskDto();
-                dto.setStart_point_code(id);
+//                dto.setStart_point_code(id);
-                dto.setNext_point_code("1002");
+//                dto.setNext_point_code("1002");
-                taskserver.create(dto);
+//                taskserver.create(dto);
-            }
+//            }
         }
     }
 }

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

@@ -1,8 +1,8 @@
 package org.nl.acs.device_driver.driver;
 
 import org.nl.acs.opc.OpcConfig;
-import org.nl.modules.udw.UnifiedDataAccessor;
+import org.nl.acs.udw.UnifiedDataAccessor;
-import org.nl.modules.udw.UnifiedDataAccessorFactory;
+import org.nl.acs.udw.UnifiedDataAccessorFactory;
 
 public class AbstractOpcDeviceDriver extends AbstractDeviceDriver implements OpcDeviceDriver {
     UnifiedDataAccessor opcUdw;

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

@@ -5,7 +5,7 @@ import net.sf.json.JSONObject;
 import org.nl.acs.device_driver.DeviceDriver;
 import org.nl.acs.opc.Device;
 import org.nl.acs.opc.OpcItemDto;
-import org.nl.modules.udw.UnifiedDataAccessor;
+import org.nl.acs.udw.UnifiedDataAccessor;
 import org.nl.wql.core.bean.WQLObject;
 
 import java.util.ArrayList;

hd/nladmin-system/src/main/java/org/nl/acs/device_driver/standard_scanner/StandardScannerDeviceDriver.java

@@ -8,8 +8,8 @@ import org.nl.acs.device_driver.DeviceDriver;
 import org.nl.acs.device_driver.ScannerDeviceDriver;
 import org.nl.acs.device_driver.driver.AbstractDeviceDriver;
 import org.nl.acs.socket.SocketConfig;
-import org.nl.modules.udw.UnifiedDataAccessor;
+import org.nl.acs.udw.UnifiedDataAccessor;
-import org.nl.modules.udw.UnifiedDataAccessorFactory;
+import org.nl.acs.udw.UnifiedDataAccessorFactory;
 
 
 /**

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

@@ -4,8 +4,8 @@ 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.modules.udw.UnifiedDataAccessor;
+import org.nl.acs.udw.UnifiedDataAccessor;
-import org.nl.modules.udw.UnifiedDataAccessorFactory;
+import org.nl.acs.udw.UnifiedDataAccessorFactory;
 import org.openscada.opc.lib.da.Group;
 import org.openscada.opc.lib.da.Item;
 import org.openscada.opc.lib.da.ItemState;

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

@@ -1,81 +1,267 @@
 package org.nl.acs.opc;
 
-import cn.hutool.core.util.ObjectUtil;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.lucene.util.NamedThreadFactory;
+import org.nl.acs.udw.UnifiedDataAccessor;
+import org.nl.acs.udw.UnifiedDataAppService;
 import org.nl.start.auto.run.AbstractAutoRunnable;
+import org.nl.utils.SpringContextHolder;
+import org.openscada.opc.lib.da.Group;
+import org.openscada.opc.lib.da.Item;
+import org.openscada.opc.lib.da.ItemState;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
+import org.nl.acs.udw.UnifiedDataAccessorFactory;
 
-import java.util.Iterator;
+import java.util.*;
-import java.util.List;
+import java.util.concurrent.*;
-import java.util.Map;
-import java.util.Set;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
 
 /**
  * OPC设备同步启动
  */
 @Component
+@Slf4j
 public class DeviceOpcSynchronizeAutoRun extends AbstractAutoRunnable {
-    ExecutorService executorService = Executors.newCachedThreadPool();
+    static boolean isRun = true;
     @Autowired
     private DeviceAppService deviceAppService;
     @Autowired
     private OpcServerManageService opcServerManageService;
 
-    @Override
+    static ExecutorService executorService;
+    public static Map<String, OpcServerManageDto> opcServersConfig;
+    public static Map<String, OpcItemDto> itemCodeOpcItemDtoMapping = new ConcurrentHashMap();
+
+    static boolean canRefreshOpcEntity = true;
+    private long lastRefreshOpcEntityTime;
+    static UnifiedDataAccessor udw;
+    private static Map<String, Boolean> canReadOpcValues;
+    private static volatile Map<String, OpcEntity> opcCodeOpcEntityMapping;
+
+    public DeviceOpcSynchronizeAutoRun() {
+        this.lastRefreshOpcEntityTime = 0L;
+    }
+
     public String getCode() {
         return DeviceOpcSynchronizeAutoRun.class.getSimpleName();
     }
 
-    @Override
     public String getName() {
         return "opc设备同步器";
     }
 
-    @Override
+    static Group getGroup(String opcCode) throws Exception {
-    public void autoRun() throws Exception {
+        OpcServerService opcServerService = SpringContextHolder.getBean(OpcServerService.class);
-        {
+        return opcServerService.getServer(opcCode);
+    }
 
-            Map<String, OpcServerManageDto> servers = this.opcServerManageService.queryAllServerMap();
+    static void submitTimeLimitTask(Runnable runnable, String opcCode) {
-            Map<String, List<List<OpcItemDto>>> pros;
+        CompletableFuture<Void> future = CompletableFuture.runAsync(runnable, executorService);
-             do{
-                 Thread.sleep(1000L);
-                 pros = this.deviceAppService.findAllFormatProtocolFromDriver();
-             }while (ObjectUtil.isEmpty(pros));
-            Set<String> keys = pros.keySet();
-            Iterator var4 = keys.iterator();
-            System.out.println("test:" + var4.hasNext());
-            //代码执行一次
-            while (var4.hasNext()) {
-                String key = (String) var4.next();
-                List<List<OpcItemDto>> list = (List) pros.get(key);
-                OpcServerManageDto opcServer = (OpcServerManageDto) servers.get(key);
-                Iterator var8 = list.iterator();
-                System.out.println("test2:" + var8.hasNext());
 
-                while (var8.hasNext()) {
+//        try {
-                    List<OpcItemDto> groupProtols = (List) var8.next();
+//            future.get(10L, TimeUnit.SECONDS);
-                    DeviceOpcProtocolRunable runable = new DeviceOpcProtocolRunable();
+//        } catch (InterruptedException var9) {
-                    runable.setProtocols(groupProtols);
+//            Thread.currentThread().interrupt();
-                    runable.setOpcServer(opcServer);
+//        } catch (ExecutionException var10) {
-                    this.executorService.submit(runable);
+//            var10.printStackTrace();
-                }
+//        } catch (TimeoutException var11) {
+//            itemCodeOpcItemDtoMapping.keySet().forEach((key) -> {
+//                udw.setValue(key, (Object) null);
+//            });
+//            canReadOpcValues = new ConcurrentHashMap<>();
+//            System.out.println("opc设备同步器 任务执行超时，取消任务...");
+//            future.cancel(true);
+//        } finally {
+//            canRefreshOpcEntity = true;
+//            if (opcCode != null) {
+//                canReadOpcValues.put(opcCode, true);
+//            }
+//
+//        }
+    }
+
+    private ExecutorService createThreadPool() {
+        ThreadPoolExecutor executor = new ThreadPoolExecutor(32, 32, 10L, TimeUnit.SECONDS, new LinkedBlockingQueue<>(), new NamedThreadFactory("opc-sync"));
+        executor.allowCoreThreadTimeOut(true);
+        return executor;
+    }
+
+    public void autoRun() {
+        OpcStartTag.is_run = true;
+        opcServersConfig = this.opcServerManageService.queryAllServerMap();
+        executorService = this.createThreadPool();
+        opcCodeOpcEntityMapping = new ConcurrentHashMap();
+        itemCodeOpcItemDtoMapping.keySet().forEach((key) -> {
+            udw.setValue(key, (Object) null);
+        });
+        canRefreshOpcEntity = true;
+        canReadOpcValues.clear();
+
+        while (true) {
+            this.refreshOpcEntity();
+            Iterator var1 = opcServersConfig.keySet().iterator();
+
+            while (var1.hasNext()) {
+                String opcCode = (String) var1.next();
+                submitTimeLimitTask(() -> {
+                    boolean in = false;
+                    try {
+                        if (canReadOpcValues.computeIfAbsent(opcCode, (key) -> true)) {
+                            in = true;
+                            canReadOpcValues.put(opcCode, false);
+                            this.readOpcValues(opcCode);
+                        }
+                    } catch (Exception var3) {
+                        var3.printStackTrace();
+                    } finally {
+                        canRefreshOpcEntity = true;
+                        if (opcCode != null && in) {
+                            canReadOpcValues.put(opcCode, true);
+                        }
+                    }
+                }, opcCode);
             }
 
-            // 同步无光电设备信号
+            ThreadUtl.sleep((long) OpcConfig.synchronized_millisecond);
-            //Map<String, List<List<OpcItemDto>>> pros1 = this.deviceAppService.findAllFormatProtocolFromDriver();
+        }
-            //List<DeviceDriver> opcDrivers = this.deviceAppService.findDeviceDriver(DeviceDriver.class);
+    }
 
-            while (true) {
+    private void readOpcValues(String opcCode) throws Exception {
-                Thread.sleep(3000L);
+        synchronized (opcCode.intern()) {
+            OpcEntity opcEntity = (OpcEntity) opcCodeOpcEntityMapping.get(opcCode);
+            if (opcEntity != null) {
+                if (opcEntity.getItems().size() != 0) {
+                    long begin = System.currentTimeMillis();
+                    if (log.isTraceEnabled()) {
+                        log.trace("opc {} 开始计时{}", opcCode, begin);
+                    }
+
+                    new HashMap();
+
+                    Map<Item, ItemState> itemStatus;
+                    try {
+                        itemStatus = opcEntity.readAll();
+                    } catch (Exception var15) {
+                        itemStatus = opcEntity.readDividually();
+                    }
+
+                    long end = System.currentTimeMillis();
+                    long duration = end - begin;
+                    if (log.isTraceEnabled()) {
+                        log.trace("opc {} 读取耗时：{}", opcCode, duration);
+                    }
+
+                    if (duration > 1000L) {
+                        log.warn("opc {} 读取超时 : {}", opcCode, duration);
+                    }
+
+//                    boolean allNull = itemStatus.entrySet().stream().map((map) -> {
+//                        return OpcUtl.getValue((Item)map.getKey(), (ItemState)map.getValue());
+//                    }).allMatch(Objects::isNull);
+//                    if (allNull) {
+//                        opcEntity.getItems().clear();
+//                    }
+
+                    UnifiedDataAccessor udw = opcEntity.getUdw();
+
+
+                    Set<Item> items = itemStatus.keySet();
+                    Iterator var18 = items.iterator();
+
+                    while (var18.hasNext()) {
+                        Item item = (Item) var18.next();
+                        ItemState itemState = (ItemState) itemStatus.get(item);
+                        Object nowValue = OpcUtl.getValue(item, itemState);
+                        String itemId = item.getId();
+                        Object historyValue = udw.getValue(itemId);
+                        if (!ObjectUtl.isEquals(itemState.getQuality(), QualityTypeValue.OPC_QUALITY_GOOD) && historyValue != null) {
+                            log.warn("opc 值不健康 item: {}, 状态: {}", itemId, itemState.getQuality());
+                        }
+                        if (!UnifiedDataAppService.isEquals(nowValue, historyValue)) {
+                            OpcItemDto itemDto = (OpcItemDto) itemCodeOpcItemDtoMapping.get(itemId);
+                            if (true) {
+                                this.logItemChanged(itemId, udw, nowValue, itemDto);
+                            }
+                            udw.setValue(itemId, nowValue);
+                        }
+
+                    }
+
+                }
             }
         }
     }
 
-    @Override
+    private void refreshOpcEntity() {
+        if (canRefreshOpcEntity) {
+            canRefreshOpcEntity = false;
+            long now = System.currentTimeMillis();
+            if (now - this.lastRefreshOpcEntityTime >= 20000L) {
+                this.lastRefreshOpcEntityTime = now;
+                submitTimeLimitTask(() -> {
+                    try {
+                        Map<String, List<List<OpcItemDto>>> protocol = this.deviceAppService.findAllFormatProtocolFromDriver();
+                        Iterator var2 = protocol.entrySet().iterator();
+
+                        while (var2.hasNext()) {
+                            Map.Entry<String, List<List<OpcItemDto>>> stringListEntry = (Map.Entry) var2.next();
+                            String opcCode = (String) stringListEntry.getKey();
+                            List<List<OpcItemDto>> opcItemDtos = (List) stringListEntry.getValue();
+                            ((OpcEntity) opcCodeOpcEntityMapping.computeIfAbsent(opcCode, OpcEntity::new)).reload(opcItemDtos);
+                        }
+                    } catch (Exception var6) {
+                        var6.printStackTrace();
+                    } finally {
+                        canRefreshOpcEntity = true;
+                    }
+
+                }, (String) null);
+            }
+        }
+    }
+
+    private void logMessage(String errorMessage) {
+        try {
+//            issueLogger.setResource(OpcConfig.resource_code, OpcConfig.resource_name).setError(StringUtl.getString(100), "设备同步通信异常").log(errorMessage, new Object[0]);
+//            businessLogger.setResource(OpcConfig.resource_code, OpcConfig.resource_name).setError(StringUtl.getString(100), "设备同步通信异常").log(errorMessage, new Object[0]);
+        } catch (Exception var5) {
+            var5.printStackTrace();
+        }
+
+    }
+
     public void after() {
-        this.executorService.shutdownNow();
+        OpcStartTag.is_run = false;
-        this.executorService = Executors.newCachedThreadPool();
+        opcCodeOpcEntityMapping.values().forEach((opcEntity) -> {
+            opcEntity.cleanUdwCache();
+            OpcServerService opcServerService = SpringContextHolder.getBean(OpcServerService.class);
+            opcServerService.cleanGroups(opcEntity.getOpcCode());
+        });
+        opcCodeOpcEntityMapping = new ConcurrentHashMap();
+        itemCodeOpcItemDtoMapping = new ConcurrentHashMap();
+        executorService.shutdownNow();
+    }
+
+    private void logItemChanged(String itemCode, UnifiedDataAccessor udw, Object value, OpcItemDto itemDto) {
+        Object his = udw.getValue(itemCode);
+        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 = udw.getValue(relate);
+                sb.append("key:").append(relate).append("value:").append(obj).append(";");
+            }
+
+        } else {
+        }
+    }
+
+    static {
+        udw = UnifiedDataAccessorFactory.getAccessor(OpcConfig.udw_opc_value_key);
+        canReadOpcValues = new ConcurrentHashMap();
+        opcCodeOpcEntityMapping = new ConcurrentHashMap();
     }
 }

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

@@ -0,0 +1,30 @@
+package org.nl.acs.opc;
+
+public class ItemValue {
+    private String item_code;
+    private Object item_value;
+
+    public ItemValue() {
+    }
+
+    public ItemValue(String item_code, Object item_value) {
+        this.item_code = item_code;
+        this.item_value = item_value;
+    }
+
+    public String getItem_code() {
+        return this.item_code;
+    }
+
+    public void setItem_code(String item_code) {
+        this.item_code = item_code;
+    }
+
+    public Object getItem_value() {
+        return this.item_value;
+    }
+
+    public void setItem_value(Object item_value) {
+        this.item_value = item_value;
+    }
+}

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

@@ -0,0 +1,73 @@
+package org.nl.acs.opc;
+
+
+
+import org.nl.exception.WDKException;
+
+import java.util.Arrays;
+import java.util.Objects;
+
+public class ObjectUtl {
+    private ObjectUtl() {
+    }
+
+    public static boolean isEquals(Object a, Object b) {
+        if (a == null && b == null) {
+            return true;
+        } else if (a != null && b != null) {
+            if (a.getClass().isArray()) {
+                if (a instanceof boolean[]) {
+                    return Arrays.equals((boolean[]) ((boolean[]) a), (boolean[]) ((boolean[]) b));
+                } else if (a instanceof byte[]) {
+                    return Arrays.equals((byte[]) ((byte[]) a), (byte[]) ((byte[]) b));
+                } else if (a instanceof int[]) {
+                    return Arrays.equals((int[]) ((int[]) a), (int[]) ((int[]) b));
+                } else if (a instanceof long[]) {
+                    return Arrays.equals((long[]) ((long[]) a), (long[]) ((long[]) b));
+                } else if (a instanceof double[]) {
+                    return Arrays.equals((double[]) ((double[]) a), (double[]) ((double[]) b));
+                } else if (a instanceof short[]) {
+                    return Arrays.equals((short[]) ((short[]) a), (short[]) ((short[]) b));
+                } else if (a instanceof char[]) {
+                    return Arrays.equals((char[]) ((char[]) a), (char[]) ((char[]) b));
+                } else if (a instanceof float[]) {
+                    return Arrays.equals((float[]) ((float[]) a), (float[]) ((float[]) b));
+                } else if (a instanceof Object[]) {
+                    return Arrays.equals((Object[]) ((Object[]) a), (Object[]) ((Object[]) b));
+                } else {
+                    throw new WDKException("未实现");
+                }
+            } else {
+                return Objects.equals(a, b);
+            }
+        } else {
+            return false;
+        }
+    }
+
+    public static boolean isTrue(Boolean boolean_) {
+        return boolean_ != null && isEquals(boolean_, true);
+    }
+
+    public static boolean isTrue(Boolean targetBoolean, boolean defaultBoolean) {
+        return targetBoolean == null ? defaultBoolean : targetBoolean;
+    }
+
+    public static boolean isFalse(Boolean boolean_) {
+        return boolean_ != null && isEquals(boolean_, false);
+    }
+
+
+
+
+
+    public static boolean isObject(Class<?> clazz) {
+        if (clazz == null) {
+            return false;
+        } else if (clazz.getClass().isArray()) {
+            return false;
+        } else {
+            return Object.class.isAssignableFrom(clazz);
+        }
+    }
+}

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

@@ -0,0 +1,176 @@
+package org.nl.acs.opc;
+
+import org.nl.acs.udw.UnifiedDataAccessor;
+import org.nl.acs.udw.UnifiedDataAccessorFactory;
+import org.nl.utils.SpringContextHolder;
+import org.openscada.opc.lib.da.Group;
+import org.openscada.opc.lib.da.Item;
+import org.openscada.opc.lib.da.ItemState;
+
+import java.util.*;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.stream.Collectors;
+
+public class OpcEntity {
+
+    OpcServerService opcServerService = SpringContextHolder.getBean(OpcServerService.class);
+    private final UnifiedDataAccessor udw;
+    private Map<String, List<Item>> items;
+    private Map<String, List<String>> someFailDevices;
+    private String opcCode;
+
+    public OpcEntity(String opcCode) {
+        this.udw = UnifiedDataAccessorFactory.getAccessor(OpcConfig.udw_opc_value_key);
+        this.items = new ConcurrentHashMap();
+        this.someFailDevices = new ConcurrentHashMap();
+        this.opcCode = opcCode;
+    }
+
+    public void reload(List<List<OpcItemDto>> opcItemDtos) {
+        Map<String, List<String>> itemCodes = new ConcurrentHashMap();
+        (opcItemDtos.stream().flatMap(Collection::stream).collect(Collectors.groupingBy(OpcItemDto::getDevice_code))).forEach((deviceCodes, opcItemDtoList) -> {
+            itemCodes.put(deviceCodes, opcItemDtoList.stream().map(OpcItemDto::getItem_code).collect(Collectors.toList()));
+        });
+        DeviceOpcSynchronizeAutoRun.itemCodeOpcItemDtoMapping.putAll((Map)opcItemDtos.stream().flatMap(Collection::stream).collect(Collectors.toMap(OpcItemDto::getItem_code, (obj) -> {
+            return obj;
+        },(k, v) -> k)));
+        if (this.items.size() == 0) {
+            itemCodes.values().stream().flatMap(Collection::stream).forEach((key) -> {
+                this.udw.setValue(key, (Object)null);
+            });
+            this.addItemsIntoGroup(itemCodes);
+        } else {
+            if (this.someFailDevices.size() > 0) {
+                this.reAddDevices();
+            }
+
+        }
+    }
+
+    private void reAddDevices() {
+        Map<String, List<Item>> addItems = new ConcurrentHashMap();
+        StringBuilder err_message = new StringBuilder();
+        this.someFailDevices.forEach((deviceCode, itemCodesList) -> {
+            itemCodesList.forEach((itemCode) -> {
+                try {
+                    Group group =  DeviceOpcSynchronizeAutoRun.getGroup(this.opcCode);
+                    ((List)addItems.computeIfAbsent(deviceCode, (key) -> {
+                        return new ArrayList();
+                    })).add(group.addItem(itemCode));
+                } catch (Exception var6) {
+                    err_message.append(itemCode).append(" 添加失败; ");
+                }
+
+            });
+            List<Item> deviceItems = (List)addItems.get(deviceCode);
+            if (deviceItems != null && deviceItems.size() == itemCodesList.size()) {
+                this.someFailDevices.remove(deviceCode);
+            } else if (itemCodesList.size() == 0) {
+                addItems.remove(deviceCode);
+            } else {
+                assert deviceItems != null;
+
+                ((List)this.someFailDevices.get(deviceCode)).removeAll(deviceItems);
+            }
+
+            synchronized(this.opcCode.intern()) {
+                this.items.putAll(addItems);
+            }
+
+            if (err_message.length() > 0) {
+                String errMsg = err_message.toString();
+                //this.log.warn("{}:{}", com.wxzd.wcs.opc.OpcConfig.resource_code, errMsg);
+            }
+
+        });
+    }
+
+    private void addItemsIntoGroup(Map<String, List<String>> itemCodes) {
+        try {
+            Group group = DeviceOpcSynchronizeAutoRun.getGroup(this.opcCode);
+            StringBuilder err_message = new StringBuilder();
+            Map<String, List<Item>> items = new ConcurrentHashMap();
+            itemCodes.forEach((deviceCode, itemCodesList) -> {
+                itemCodesList.forEach((itemCode) -> {
+                    try {
+                        ((List)items.computeIfAbsent(deviceCode, (key) -> {
+                            return new ArrayList();
+                        })).add(group.addItem(itemCode));
+                    } catch (Exception var7) {
+                        ((List)this.someFailDevices.computeIfAbsent(deviceCode, (key) -> {
+                            return new ArrayList();
+                        })).add(itemCode);
+                        this.udw.setValue(itemCode, (Object)null);
+                        err_message.append(itemCode).append(" 添加失败; ");
+                    }
+
+                });
+                List<Item> deviceItems = (List)items.get(deviceCode);
+                if (deviceItems != null && deviceItems.size() != itemCodesList.size()) {
+                    items.remove(deviceCode);
+                    this.someFailDevices.put(deviceCode, itemCodesList);
+                }
+
+            });
+            synchronized(this.opcCode.intern()) {
+                this.items = items;
+            }
+
+            if (err_message.length() > 0) {
+                String errMsg = err_message.toString();
+//                this.log.warn("{}:{}", OpcConfig.resource_code, errMsg);
+            }
+        } catch (Exception var8) {
+            var8.printStackTrace();
+        }
+
+    }
+
+    public void cleanUdwCache() {
+        this.items.values().stream().flatMap(Collection::stream).map(Item::getId).forEach((key) -> {
+            this.udw.setValue(key, (Object)null);
+        });
+    }
+
+    public Map<Item, ItemState> readAll() throws Exception {
+        return opcServerService.getServer(this.opcCode).read(true, (Item[])this.items.values().stream().flatMap(Collection::stream).toArray((x$0) -> {
+            return new Item[x$0];
+        }));
+    }
+
+    public Map<Item, ItemState> readDividually() {
+        Map<Item, ItemState> result = new HashMap();
+        CompletableFuture[] futures = (CompletableFuture[])this.items.entrySet().stream().map((entry) -> {
+            return CompletableFuture.runAsync(() -> {
+                try {
+                    Group group = DeviceOpcSynchronizeAutoRun.getGroup(this.opcCode);
+                    result.putAll(group.read(true, (Item[])((List)entry.getValue()).toArray(new Item[0])));
+                } catch (Exception var5) {
+                    String deviceCode = (String)entry.getKey();
+                    // to do
+//                    this.someFailDevices.put(deviceCode, ((List)entry.getValue()).stream().map(Item::getId).collect(Collectors.toList()));
+                    this.items.remove(deviceCode);
+                }
+
+            }, DeviceOpcSynchronizeAutoRun.executorService);
+        }).toArray((x$0) -> {
+            return new CompletableFuture[x$0];
+        });
+        CompletableFuture.allOf(futures).join();
+        return result;
+    }
+
+
+    public UnifiedDataAccessor getUdw() {
+        return this.udw;
+    }
+
+    public Map<String, List<Item>> getItems() {
+        return this.items;
+    }
+
+    public String getOpcCode() {
+        return this.opcCode;
+    }
+}

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

@@ -0,0 +1,22 @@
+package org.nl.acs.opc;
+
+import org.openscada.opc.lib.da.Group;
+
+/**
+ * @author ldjun
+ * @version 1.0
+ * @date 2023年02月01日 11:26
+ * @desc desc
+ */
+public interface OpcServerService {
+
+    void reload();
+
+    Group getServer(String var1) throws Exception;
+
+    void writeInteger(String var1, ItemValue... var2);
+
+    void clearServer(String var1);
+
+    void cleanGroups(String var1);
+}

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

@@ -0,0 +1,191 @@
+package org.nl.acs.opc;
+
+import cn.hutool.core.util.StrUtil;
+import org.jinterop.dcom.common.JIException;
+import org.nl.exception.BadRequestException;
+import org.nl.start.auto.initial.ApplicationAutoInitial;
+import org.openscada.opc.lib.common.NotConnectedException;
+import org.openscada.opc.lib.da.Group;
+import org.openscada.opc.lib.da.Server;
+import org.openscada.opc.lib.da.UnknownGroupException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.net.UnknownHostException;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+
+/**
+ * @author ldjun
+ * @version 1.0
+ * @date 2023年02月01日 11:27
+ * @desc desc
+ */
+@Service
+public class OpcServerServiceImpl implements OpcServerService, ApplicationAutoInitial {
+
+  private static final Logger log = LoggerFactory.getLogger(OpcServerServiceImpl.class);
+  @Autowired OpcServerManageService opcServerManageService;
+  Map<String, OpcServerManageDto> opcServerManageDtos = new HashMap();
+  Map<String, Server> servers = Collections.synchronizedMap(new HashMap());
+  Map<String, Group> groups = Collections.synchronizedMap(new HashMap());
+
+  public OpcServerServiceImpl() {}
+
+  public void autoInitial() throws Exception {
+    this.reload();
+    if (OpcConfig.auto_start_opc) {
+      Thread t =
+          new Thread() {
+            public void run() {
+              Iterator var1 = OpcServerServiceImpl.this.opcServerManageDtos.values().iterator();
+
+              while (var1.hasNext()) {
+                OpcServerManageDto dto = (OpcServerManageDto) var1.next();
+
+                try {
+                  OpcServerServiceImpl.this.getServer(dto.getOpc_code());
+                  OpcServerServiceImpl.log.info("加载opc server {}", dto.getOpc_code());
+                } catch (Exception var4) {
+                  OpcServerServiceImpl.log.warn("启动无法载入servers", var4);
+                }
+              }
+            }
+          };
+      t.start();
+    }
+  }
+
+  public synchronized void reload() {
+    this.opcServerManageDtos = this.opcServerManageService.queryAllServerMap();
+    this.opcServerManageDtos = Collections.synchronizedMap(this.opcServerManageDtos);
+  }
+
+  public void cleanGroups(String opcCode) {
+    Group group = (Group)this.groups.get(opcCode);
+    if (group != null) {
+      Server server = group.getServer();
+
+      try {
+        group.remove();
+      } catch (JIException var5) {
+        var5.printStackTrace();
+      }
+
+      this.groups.remove(opcCode);
+      server.disconnect();
+      this.servers.remove(opcCode);
+    }
+
+  }
+
+  public Group getServer(String code) throws Exception {
+    synchronized(this.buildLock(code)) {
+      Group group = null;
+      group = (Group)this.groups.get(code);
+      if (group != null) {
+        label68: {
+          Group var10000;
+          try {
+            if (!group.isActive()) {
+              break label68;
+            }
+
+            var10000 = group;
+          } catch (JIException var14) {
+            log.error(code, var14);
+            break label68;
+          }
+
+          return var10000;
+        }
+      }
+
+      Server server = (Server)this.servers.get(code);
+      boolean needcreate = false;
+      String groupName = code;
+      if (server == null) {
+        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;
+    }
+  }
+
+  public void clearServer(String code) {
+    synchronized(this.buildLock(code)) {
+      try {
+        Server server = (Server)this.servers.get(code);
+        server.disconnect();
+      } catch (Exception var5) {
+      }
+
+      this.servers.remove(code);
+      this.groups.remove(code);
+    }
+  }
+
+
+  public void writeInteger(String code, ItemValue... values) {
+    try {
+      Group group = this.getServer(code);
+      OpcUtl.writeValue(group, values);
+    } catch (Exception var4) {
+      this.clearServer(code);
+      log.warn("写入出错opc server {} 重新加载", code, var4);
+      ThreadUtl.sleep(5000L);
+//      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;
+  }
+}

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

@@ -6,7 +6,7 @@ import org.openscada.opc.lib.da.Server;
 public class OpcServerUtl {
 
     public static synchronized Server getServerWithOutException(String host, String clsid, String user, String password,
-                                                                String domain) {
+                                                                String domain) throws Exception {
         if (!StrUtil.isEmpty(host) && !StrUtil.isEmpty(clsid) && !StrUtil.isEmpty(user)) {
             if (domain == null) {
                 domain = "";

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

@@ -6,11 +6,16 @@ import org.jinterop.dcom.common.JIException;
 import org.jinterop.dcom.core.*;
 import org.nl.exception.BadRequestException;
 import org.nl.exception.WDKException;
+import org.openscada.opc.dcom.list.ClassDetails;
+import org.openscada.opc.lib.common.AlreadyConnectedException;
 import org.openscada.opc.lib.common.ConnectionInformation;
 import org.openscada.opc.lib.da.*;
+import org.openscada.opc.lib.list.Categories;
+import org.openscada.opc.lib.list.Category;
+import org.openscada.opc.lib.list.ServerList;
 
-import java.util.Iterator;
+import java.net.UnknownHostException;
-import java.util.Map;
+import java.util.*;
 import java.util.concurrent.Executors;
 
 @Slf4j
@@ -19,45 +24,71 @@ public class OpcUtl {
     private static String key = "rpc.socketTimeout";
 
     public static void checkTimeout() {
-        if (Integer.getInteger(key, 0).intValue() != timeout) {
+        if (Integer.getInteger(key, 0) != timeout) {
             System.setProperty(key, String.valueOf(timeout));
         }
 
     }
 
+    private OpcUtl() {
+    }
 
-    public static void writeValue(Group group, WriteRequest... requests) {
+    public static List<Map<String, String>> showAllOpcServer(String host, String user, String password, String domain) throws  Exception {
         try {
-            Map e = group.write(requests);
+            List<Map<String, String>> listResult = new ArrayList();
-            boolean is_success = true;
+            ServerList serverList = new ServerList(host, user, password, domain);
-            StringBuilder message = new StringBuilder();
+            Collection<ClassDetails> classDetails = serverList.listServersWithDetails(new Category[]{Categories.OPCDAServer10, Categories.OPCDAServer20, Categories.OPCDAServer30}, new Category[0]);
-            Iterator arg4 = e.keySet().iterator();
+            Iterator var7 = classDetails.iterator();
 
-            while (arg4.hasNext()) {
+            while(var7.hasNext()) {
-                Item item = (Item) arg4.next();
+                ClassDetails details = (ClassDetails)var7.next();
-                Integer integer = (Integer) e.get(item);
+                Map<String, String> result = new LinkedHashMap();
-                if (integer.intValue() != 0) {
+                result.put("classId", details.getClsId());
-                    if (is_success) {
+                result.put("progId", details.getProgId());
-                        is_success = false;
+                result.put("description", details.getDescription());
-                    }
+                listResult.add(result);
-
-                    message.append(item.getId());
-                    message.append(":error code:");
-                    message.append(integer);
-                    message.append("; ");
-                }
             }
 
-            if (!is_success) {
+            return listResult;
-                // throw new BusinessException(message.toString());
+        } catch (UnknownHostException | JIException | IllegalArgumentException var10) {
-            }
+            throw new Exception(var10);
-        } catch (JIException arg7) {
-            // throw new BusinessException(arg7);
         }
     }
 
-    public static Object getValue(Item item, ItemState itemState) throws BadRequestException {
+    public static Server getServer(String host, String clsid, String user, String password, String domain) throws Exception {
-        if (NumberUtil.compare(itemState.getQuality(), Short.valueOf(QualityTypeValue.OPC_QUALITY_GOOD)) != 0) {
+        checkTimeout();
+        Server server = null;
+
+        try {
+            server = new Server(getConnection(host, clsid, user, password, domain), Executors.newSingleThreadScheduledExecutor());
+            server.connect();
+            return server;
+        } catch (UnknownHostException | JIException | AlreadyConnectedException | IllegalArgumentException var7) {
+            throw new Exception(var7);
+        }
+    }
+
+    public static Server getAutoServer(String host, String clsid, String user, String password, String domain) throws Exception {
+        checkTimeout();
+        Server server = null;
+        server = new Server(getConnection(host, clsid, user, password, domain), Executors.newSingleThreadScheduledExecutor());
+        AutoReconnectController autoReconnectController = new AutoReconnectController(server);
+        autoReconnectController.connect();
+        return server;
+    }
+
+    public static ConnectionInformation getConnection(String host, String clsid, String user, String password, String domain) {
+        ConnectionInformation connection = new ConnectionInformation();
+        connection.setHost(host);
+        connection.setClsid(clsid);
+        connection.setUser(user);
+        connection.setPassword(password);
+        connection.setDomain(domain);
+        return connection;
+    }
+
+    public static Object getValue(Item item, ItemState itemState) throws Exception {
+        if (!ObjectUtl.isEquals(itemState.getQuality(), QualityTypeValue.OPC_QUALITY_GOOD)) {
             if (item != null) {
                 log.debug("value is not good {} : {}", item.getId(), itemState.getQuality());
             } else {
@@ -71,24 +102,36 @@ public class OpcUtl {
         }
     }
 
-    public static Object getValue(JIVariant jiVariant, String id) throws BadRequestException {
+    public static int getIntegerValue(Item item, ItemState itemState) throws Exception {
+        return (Integer)getValue(item, itemState);
+    }
+
+    public static String getStringValue(Item item, ItemState itemState) throws Exception {
+        return (String)getValue(item, itemState);
+    }
+
+    public static byte[] getByteArrayValue(Item item, ItemState itemState) throws Exception {
+        return (byte[])((byte[])getValue(item, itemState));
+    }
+
+    public static Object getValue(JIVariant jiVariant, String id) {
         try {
-            Object e = jiVariant.getObject();
+            Object object = jiVariant.getObject();
-            if (e instanceof IJIUnsigned) {
+            if (object instanceof IJIUnsigned) {
-                return Integer.valueOf(((IJIUnsigned) e).getValue().intValue());
+                return ((IJIUnsigned)object).getValue().intValue();
-            } else if (e instanceof Boolean) {
+            } else if (object instanceof Boolean) {
-                return jiVariant.getObjectAsBoolean() ? Integer.valueOf(1) : Integer.valueOf(0);
+                return jiVariant.getObjectAsBoolean() ? 1 : 0;
-            } else if (e instanceof JIString) {
+            } else if (object instanceof JIString) {
-                return ((JIString) e).getString();
+                return ((JIString)object).getString();
-            } else if (!(e instanceof JIArray)) {
+            } else if (!(object instanceof JIArray)) {
-                if (e instanceof Integer) {
+                if (object instanceof Integer) {
                     return jiVariant.getObject();
-                } else if (e instanceof Short) {
+                } else if (object instanceof Short) {
                     return jiVariant.getObject();
-                } else if (e instanceof Float) {
+                } else if (object instanceof Float) {
                     return jiVariant.getObject();
                 } else {
-                    System.err.println(id + "不明类型" + e.getClass());
+                    System.err.println(id + "不明类型" + object.getClass());
                     if (jiVariant.getType() == 0) {
                         System.err.println("因类型为emtpy 返回 null");
                         return null;
@@ -100,15 +143,15 @@ public class OpcUtl {
                     }
                 }
             } else {
-                Class clazz = ((JIArray) e).getArrayClass();
+                Class<?> clazz = ((JIArray)object).getArrayClass();
                 int[] r;
                 int i;
                 if (JIUnsignedByte.class.isAssignableFrom(clazz)) {
-                    JIUnsignedByte[] arg7 = (JIUnsignedByte[]) ((JIUnsignedByte[]) ((JIArray) e).getArrayInstance());
+                    JIUnsignedByte[] array = (JIUnsignedByte[])((JIUnsignedByte[])((JIArray)object).getArrayInstance());
-                    r = new int[arg7.length];
+                    r = new int[array.length];
 
-                    for (i = 0; i < arg7.length; ++i) {
+                    for(i = 0; i < array.length; ++i) {
-                        r[i] = arg7[i].getValue().byteValue();
+                        r[i] = array[i].getValue().byteValue();
                     }
 
                     return r;
@@ -121,77 +164,141 @@ public class OpcUtl {
                         System.err.println("因类型为null 返回 null");
                         return null;
                     } else {
-                        return ((JIArray) e).getArrayInstance();
+                        return ((JIArray)object).getArrayInstance();
                     }
                 } else {
-                    JIUnsignedShort[] array = (JIUnsignedShort[]) ((JIUnsignedShort[]) ((JIArray) e)
+                    JIUnsignedShort[] array = (JIUnsignedShort[])((JIUnsignedShort[])((JIArray)object).getArrayInstance());
-                            .getArrayInstance());
                     r = new int[array.length];
 
-                    for (i = 0; i < array.length; ++i) {
+                    for(i = 0; i < array.length; ++i) {
                         r[i] = array[i].getValue().intValue();
                     }
 
                     return r;
                 }
             }
-        } catch (JIException e) {
+        } catch (JIException var7) {
-            throw new BadRequestException(e.getMessage());
+//            throw new Exception(var7);
+            var7.printStackTrace();
         }
+        return null;
     }
 
-
+    public static void writeValue(Group group, WriteRequest... requests) throws Exception {
-    public static Server getServer(String host, String clsid, String user, String password, String domain)
-            throws WDKException {
-        checkTimeout();
-        Server server = null;
-
         try {
-            server = new Server(getConnection(host, clsid, user, password, domain),
+            Map<Item, Integer> write = group.write(requests);
-                    Executors.newSingleThreadScheduledExecutor());
+            boolean is_success = true;
-            server.connect();
+            StringBuilder message = new StringBuilder();
-            return server;
+            Iterator var5 = write.keySet().iterator();
-        } catch (Exception e) {
+
-            throw new WDKException(e);
+            while(var5.hasNext()) {
+                Item item = (Item)var5.next();
+                Integer integer = (Integer)write.get(item);
+                if (integer != 0) {
+                    if (is_success) {
+                        is_success = false;
+                    }
+
+                    message.append(item.getId());
+                    message.append(":error code:");
+                    message.append(integer);
+                    message.append("; ");
+                }
+            }
+
+            if (!is_success) {
+                throw new Exception(message.toString());
+            }
+        } catch (JIException var8) {
+            throw new Exception(var8);
         }
     }
 
-    public static ConnectionInformation getConnection(String host, String clsid, String user, String password,
+    public static void writeValue(Group group, ItemValue... values) throws Exception {
-                                                      String domain) {
+        try {
-        ConnectionInformation connection = new ConnectionInformation();
+            if (values != null && values.length > 0) {
-        connection.setHost(host);
+                List<WriteRequest> ws = new ArrayList();
-        connection.setClsid(clsid);
+                ItemValue[] var3 = values;
-        connection.setUser(user);
+                int var4 = values.length;
-        connection.setPassword(password);
+
-        connection.setDomain(domain);
+                for(int var5 = 0; var5 < var4; ++var5) {
-        return connection;
+                    ItemValue value = var3[var5];
+                    Item item = group.addItem(value.getItem_code());
+                    ws.add(new WriteRequest(item, getVariant(value.getItem_value())));
+                }
+
+                writeValue(group, (WriteRequest[])ws.toArray(new WriteRequest[0]));
+            }
+
+        } catch (AddFailedException | JIException var8) {
+            throw new Exception(var8);
+        }
     }
 
-    public static String read(String item) throws Exception {
+    public static JIVariant getVariant(Object object) throws Exception {
-        System.out.println(item);
+        if (object instanceof Integer) {
-        Server server = getServer("192.168.81.251", "7bc0cc8e-482c-47ca-abdc-0fe7f9c6e729", "administrator", "Huawei@123", "");
+            return getIntegerVariant((Integer)object);
-//        String byteItemString = "RD1.RD1.1001.mode";
+        } else if (object instanceof String) {
-        Group group = server.addGroup();
+            return getStringVariant((String)object);
-        Item byteItem = group.addItem(item);
+        } else if (object instanceof byte[]) {
-        ItemState itemState = null;
+            return getByteArrayVariant((byte[])((byte[])object));
-        JIVariant value = null;
+        } else if (object instanceof Byte[]) {
-        itemState = byteItem.read(true);
+            return getByteArrayVariant((Byte[])((Byte[])object));
-        value = itemState.getValue();
+        } else if (object instanceof Boolean) {
-        String data = OpcUtl.getValue(byteItem, itemState) + "";
+            return new JIVariant((Boolean)object);
-        return data;
+        } else if (object instanceof int[]) {
+            return getByteArrayVariantxx((int[])((int[])object));
+        } else if (object instanceof Integer[]) {
+            JIArray array = new JIArray((Integer)object, false);
+            JIVariant value = new JIVariant(array);
+            return value;
+        } else if (object instanceof JIVariant) {
+            return (JIVariant)object;
+        } else {
+            throw new Exception("未实现目前支持是int,string,byte[]");
+        }
     }
 
-    public static void main(String[] args) throws Exception {
+    public static JIVariant getByteArrayVariantxx(int[] bytes) {
-        Server server = getServer("192.168.81.251", "7bc0cc8e-482c-47ca-abdc-0fe7f9c6e729", "administrator", "Huawei@123", "");
+        Integer[] byte_Data = new Integer[bytes.length];
-        String byteItemString = "RD1.RD1.1001.mode";
+
-        Group group = server.addGroup();
+        for(int i = 0; i < bytes.length; ++i) {
-        Item byteItem = group.addItem(byteItemString);
+            byte_Data[i] = bytes[i];
-        ItemState itemState = null;
+        }
-        JIVariant value = null;
+
-        System.out.println(byteItem.getId());
+        JIArray array = new JIArray(byte_Data, false);
-        itemState = byteItem.read(true);
+        JIVariant value = new JIVariant(array);
-        System.out.println(itemState.getQuality());
+        return value;
-        System.out.println(getValue(byteItem, itemState));
+    }
+
+    public static JIVariant getIntegerVariant(Integer integer) {
+        return new JIVariant(integer);
+    }
+
+    public static JIVariant getStringVariant(String string) {
+        return new JIVariant(string);
+    }
+
+    public static JIVariant getByteArrayVariant(byte[] bytes) {
+        Byte[] byte_Data = new Byte[bytes.length];
+
+        for(int i = 0; i < bytes.length; ++i) {
+            byte_Data[i] = bytes[i];
+        }
+
+        JIArray array = new JIArray(byte_Data, false);
+        JIVariant value = new JIVariant(array);
+        return value;
+    }
+
+    public static JIVariant getByteArrayVariant(Byte[] bytes) {
+        JIArray array = new JIArray(bytes, false);
+        JIVariant value = new JIVariant(array);
+        return value;
+    }
+
+    static {
+        checkTimeout();
     }
 }
 

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

@@ -0,0 +1,21 @@
+package org.nl.acs.opc;
+
+/**
+ * @author ldjun
+ * @version 1.0
+ * @date 2023年02月01日 11:28
+ * @desc desc
+ */
+public class ThreadUtl {
+    private ThreadUtl() {
+    }
+
+    public static void sleep(long times) throws RuntimeException {
+        try {
+            Thread.sleep(times);
+        } catch (InterruptedException var3) {
+            throw new RuntimeException(var3);
+        }
+    }
+}
+

hd/nladmin-system/src/main/java/org/nl/acs/socket/ClientUDWReceive.java

@@ -5,8 +5,8 @@ import org.nl.exception.BadRequestException;
 import org.nl.logger.BusinessDomain;
 import org.nl.logger.BusinessLogger;
 import org.nl.logger.BusinessLoggerFactory;
-import org.nl.modules.udw.UnifiedDataAccessor;
+import org.nl.acs.udw.UnifiedDataAccessor;
-import org.nl.modules.udw.UnifiedDataAccessorFactory;
+import org.nl.acs.udw.UnifiedDataAccessorFactory;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 

hd/nladmin-system/src/main/java/org/nl/acs/udw/UdwConfig.java

@@ -1,4 +1,4 @@
-package org.nl.modules.udw;
+package org.nl.acs.udw;
 
 public class UdwConfig {
 

hd/nladmin-system/src/main/java/org/nl/acs/udw/UnifiedData.java

@@ -1,4 +1,4 @@
-package org.nl.modules.udw;
+package org.nl.acs.udw;
 
 import lombok.Data;
 

hd/nladmin-system/src/main/java/org/nl/acs/udw/UnifiedDataAccessor.java

@@ -1,4 +1,4 @@
-package org.nl.modules.udw;
+package org.nl.acs.udw;
 
 import java.util.List;
 

hd/nladmin-system/src/main/java/org/nl/acs/udw/UnifiedDataAccessorFactory.java

@@ -1,7 +1,7 @@
-package org.nl.modules.udw;
+package org.nl.acs.udw;
 
-import org.nl.modules.udw.service.impl.UnifiedDataAccessorImpl;
+import org.nl.acs.udw.service.impl.UnifiedDataAccessorImpl;
-import org.nl.modules.udw.service.impl.UnifiedDataAppServiceImpl;
+import org.nl.acs.udw.service.impl.UnifiedDataAppServiceImpl;
 
 public class UnifiedDataAccessorFactory {
     public UnifiedDataAccessorFactory() {

hd/nladmin-system/src/main/java/org/nl/acs/udw/UnifiedDataAppService.java

@@ -1,7 +1,7 @@
-package org.nl.modules.udw;
+package org.nl.acs.udw;
 
 import cn.hutool.core.util.ObjectUtil;
-import org.nl.modules.udw.service.impl.UnifiedDataUnit;
+import org.nl.acs.udw.service.impl.UnifiedDataUnit;
 
 import java.util.List;
 

hd/nladmin-system/src/main/java/org/nl/acs/udw/dto/UdwDto.java

@@ -1,4 +1,4 @@
-package org.nl.modules.udw.dto;
+package org.nl.acs.udw.dto;
 
 import lombok.Data;
 

hd/nladmin-system/src/main/java/org/nl/acs/udw/service/UdwManageService.java

@@ -1,7 +1,7 @@
-package org.nl.modules.udw.service;
+package org.nl.acs.udw.service;
 
-import net.sf.json.JSONObject;
+import com.alibaba.fastjson.JSONObject;
-import org.nl.modules.udw.dto.UdwDto;
+import org.nl.acs.udw.dto.UdwDto;
 
 import java.util.List;
 

hd/nladmin-system/src/main/java/org/nl/acs/udw/service/impl/UdwManagerServiceImpl.java

@@ -1,8 +1,8 @@
-package org.nl.modules.udw.service.impl;
+package org.nl.acs.udw.service.impl;
 
-import net.sf.json.JSONObject;
+import com.alibaba.fastjson.JSONObject;
-import org.nl.modules.udw.dto.UdwDto;
+import org.nl.acs.udw.dto.UdwDto;
-import org.nl.modules.udw.service.UdwManageService;
+import org.nl.acs.udw.service.UdwManageService;
 import org.springframework.stereotype.Service;
 
 import java.util.List;

hd/nladmin-system/src/main/java/org/nl/acs/udw/service/impl/UnifiedDataAccessorImpl.java

@@ -1,8 +1,8 @@
-package org.nl.modules.udw.service.impl;
+package org.nl.acs.udw.service.impl;
 
-import org.nl.modules.udw.UnifiedData;
+import org.nl.acs.udw.UnifiedData;
-import org.nl.modules.udw.UnifiedDataAccessor;
+import org.nl.acs.udw.UnifiedDataAccessor;
-import org.nl.modules.udw.UnifiedDataAppService;
+import org.nl.acs.udw.UnifiedDataAppService;
 
 import java.util.List;
 

hd/nladmin-system/src/main/java/org/nl/acs/udw/service/impl/UnifiedDataAppServiceImpl.java

@@ -1,10 +1,10 @@
-package org.nl.modules.udw.service.impl;
+package org.nl.acs.udw.service.impl;
 
 import lombok.extern.slf4j.Slf4j;
+import org.nl.acs.udw.UdwConfig;
+import org.nl.acs.udw.UnifiedData;
+import org.nl.acs.udw.UnifiedDataAppService;
 import org.nl.exception.BadRequestException;
-import org.nl.modules.udw.UdwConfig;
-import org.nl.modules.udw.UnifiedData;
-import org.nl.modules.udw.UnifiedDataAppService;
 
 import java.util.*;
 

hd/nladmin-system/src/main/java/org/nl/acs/udw/service/impl/UnifiedDataUnit.java

@@ -1,7 +1,7 @@
-package org.nl.modules.udw.service.impl;
+package org.nl.acs.udw.service.impl;
 
 import lombok.Data;
-import org.nl.modules.udw.UnifiedData;
+import org.nl.acs.udw.UnifiedData;
 
 import java.util.Collections;
 import java.util.HashMap;