1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
package com.iailab.module.data.channel.kio.collector;
 
import com.iailab.module.data.common.enums.DataSourceType;
import com.iailab.module.data.common.utils.TagUtils;
import com.iailab.module.data.channel.kio.dto.ChannelKioDeviceDTO;
import com.iailab.module.data.channel.kio.service.ChannelKioDeviceService;
import lombok.extern.slf4j.Slf4j;
import javax.annotation.Resource;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
 
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.Collectors;
 
/**
 * @author PanZhibao
 * @Description
 * @createTime 2024年06月04日
 */
@Slf4j
@Component
public class KingIOCollector {
 
    @Resource
    private ChannelKioDeviceService channelKioDeviceService;
 
    private Map<String, KingIOClient> clientMap = new ConcurrentHashMap<>();
 
    private Map<String, ChannelKioDeviceDTO> deviceMap = new HashMap<>();
 
    public synchronized KingIOClient getClient(String sourceId) throws Exception {
        if (!clientMap.containsKey(sourceId)) {
            ChannelKioDeviceDTO deviceDto = channelKioDeviceService.get(sourceId);
            deviceMap.put(sourceId, deviceDto);
            KingIOClient kingIOClient = new KingIOClient(deviceDto.getInstanceName());
            clientMap.put(sourceId, kingIOClient);
            if (!kingIOClient.login(deviceDto.getAddress(), deviceDto.getPort(), deviceDto.getUsername(), deviceDto.getPassword())) {
                throw new Exception("登录异常");
            }
        }
        KingIOClient kingIOClient = clientMap.get(sourceId);
        if (!kingIOClient.isConnect()) {
            kingIOClient.reLogin();
        }
        return kingIOClient;
    }
 
    public String getTagValue(String sourceId, String tagName) throws Exception {
        KingIOClient client = this.getClient(sourceId);
        String value = client.getTagValue(tagName);
        return value;
    }
 
    public void setTagValue(String sourceId, String tagName, String newValue, String dataType) throws Exception {
        try {
            KingIOClient client = this.getClient(sourceId);
            switch (dataType) {
                case "float":
                    log.debug("Float,tagName=" + tagName + ",Value=" + Float.parseFloat(newValue));
                    client.writeFloatValue(tagName, Float.parseFloat(newValue));
                    break;
                case "int":
                    log.debug("Int,tagName=" + tagName + ",Value=" + new BigDecimal(newValue).intValue());
                    client.writeIntValue(tagName, new BigDecimal(newValue).intValue());
                    break;
                case "boolean":
                    log.debug("Boolean,tagName=" + tagName + ",Value=" + newValue);
                    client.writeBooleanValue(tagName, Boolean.parseBoolean(newValue));
                    break;
                default:
                    log.warn("##################### No DataType ####################");
                    break;
            }
        } catch (Exception ex) {
            ex.printStackTrace();
            throw ex;
        }
    }
 
    public Map<String, Object> getTagValues(List<String[]> params) {
        if (CollectionUtils.isEmpty(params)) {
            return new HashMap<>();
        }
        Map<String, Object> result = new HashMap<>(params.size());
 
        /*params.forEach(item -> {
            try {
                KingIOClient client = this.getClient(item[0]);
                String value = client.getTagValue(item[1]);
                result.put(TagUtils.genTagId(DataSourceType.KIO.getCode(), deviceMap.get(item[0]).getInstanceName(), item[1]), value);
            } catch (Exception ex) {
                ex.printStackTrace();
                result.put(TagUtils.genTagId(DataSourceType.KIO.getCode(), deviceMap.get(item[0]).getInstanceName(), item[1]), CommonConstant.BAD_VALUE);
            }
        });*/
 
        Map<String, List<String[]>> sourceGroup = new HashMap<>();
        params.forEach(item -> {
            if (sourceGroup.containsKey(item[0])) {
                sourceGroup.get(item[0]).add(item);
            } else {
                List<String[]> list = new ArrayList<>();
                list.add(item);
                sourceGroup.put(item[0], list);
            }
        });
        sourceGroup.forEach((k, v) -> {
            try {
                KingIOClient client = this.getClient(k);
                List<String> tagNames = v.stream().map(t -> {
                    return t[1];
                }).collect(Collectors.toList());
                Map<String, String> tagsValue = client.getTagsValue(tagNames);
                for (Map.Entry<String, String> tagValue : tagsValue.entrySet()) {
                    result.put(TagUtils.genTagId(DataSourceType.KIO.getCode(), deviceMap.get(k).getInstanceName(), tagValue.getKey()), tagValue.getValue());
                }
            } catch (Exception ex) {
                ex.printStackTrace();
            }
 
        });
        return result;
    }
}