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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
package com.ard.alarm.camera.service.impl;
 
import java.util.*;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
 
import com.ard.alarm.camera.domain.ArdCameras;
import com.ard.alarm.camera.mapper.ArdCamerasMapper;
import com.ard.alarm.camera.service.IArdCamerasService;
import com.ard.alarm.external.domain.ArdEquipExternal;
import com.ard.alarm.external.mapper.ArdEquipExternalMapper;
import com.ard.utils.hiksdk.service.impl.HikClientUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Service;
 
import javax.annotation.PostConstruct;
import javax.annotation.Resource;
 
/**
 * 相机设备Service业务层处理
 *
 * @author 刘苏义
 * @date 2023-02-11
 */
@Service
@Slf4j(topic = "camera")
@Order(4)
public class ArdCamerasServiceImpl implements IArdCamerasService, ApplicationRunner {
    private final static ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
 
    public static List<ArdCameras> ardCameraList = new ArrayList<>();
 
    @Resource
    private ArdCamerasMapper ardCamerasMapper;
 
    @Override
    public void run(ApplicationArguments args) {
        //加载sdk库
        HikClientUtil.loadHCNetSDKLib();
        //获取全部海康光电尝试登录
        ardCameraList = ardCamerasMapper.selectArdCamerasList(new ArdCameras());
        HikClientUtil.loginAllCamera(ardCameraList);
        syncTask();
    }
 
    /**
     * 同步任务
     * 刘苏义
     * 2023/8/11 9:09:27
     */
    private void syncTask() {
        scheduler.scheduleAtFixedRate(() -> {
            try {
                //region 定时同步相机
                List<ArdCameras> newArdCameraList = ardCamerasMapper.selectArdCamerasList(new ArdCameras());
                //需要更新的数据
                List<ArdCameras> updateList = sameListWithDifferent(ardCameraList, newArdCameraList);
                if (updateList.size() > 0) {
                    HikClientUtil.logoutAllCamera(updateList);
                    HikClientUtil.loginAllCamera(updateList);
                    ardCameraList.clear();
                    ardCameraList.addAll(newArdCameraList);
                }
                //需要删除的数据
                List<ArdCameras> delList = diffList(ardCameraList, newArdCameraList);
                if (delList.size() > 0) {
                    HikClientUtil.logoutAllCamera(delList);
                    for (ArdCameras ardCameras : delList) {
                        ardCameraList.remove(ardCameras);
                    }
                }
                //需要新增的数据
                List<ArdCameras> inserList = diffList(newArdCameraList, ardCameraList);
                if (inserList.size() > 0) {
                    HikClientUtil.loginAllCamera(inserList);
                    for (ArdCameras ardCameras : inserList) {
                        ardCameraList.add(ardCameras);
                    }
                }
                //endregion
            } catch (Exception e) {
                log.error("同步相机任务执行出错" + e.getMessage());
            }
        }, 10, 10, TimeUnit.SECONDS);
    }
 
    /**
     * 查询相机设备
     *
     * @param id 相机设备主键
     * @return 相机设备
     */
    @Override
    public ArdCameras selectArdCamerasById(String id) {
        return ardCamerasMapper.selectArdCamerasById(id);
    }
 
    /**
     * 查询相机设备列表
     *
     * @param ardCameras 相机设备
     * @return 相机设备
     */
    @Override
    public List<ArdCameras> selectArdCamerasList(ArdCameras ardCameras) {
        return ardCamerasMapper.selectArdCamerasList(ardCameras);
    }
 
 
    //  求两个对象List的差集
    private List<ArdCameras> diffList(List<ArdCameras> oldArrayList, List<ArdCameras> newArrayList) {
        List<ArdCameras> resultList = oldArrayList.stream()
                .filter(item -> !newArrayList.stream().map(e -> e.getId()).collect(Collectors.toList()).contains(item.getId()))
                .collect(Collectors.toList());
        return resultList;
    }
 
    //求两个对象List的交集字段不同Id相同
    private List<ArdCameras> sameListWithDifferent(List<ArdCameras> oldList, List<ArdCameras> newList) {
        List<ArdCameras> differentFieldsList = newList.stream()
                .filter(newItem -> {
                    ArdCameras oldItem = oldList.stream()
                            .filter(item -> item.getId().equals(newItem.getId()))
                            .findFirst()
                            .orElse(null);
 
                    return oldItem == null ||
                            !Objects.equals(oldItem.getUpdateTime(), newItem.getUpdateTime()) ||
                            !Objects.equals(oldItem.getIp(), newItem.getIp()) ||
                            !Objects.equals(oldItem.getPort(), newItem.getPort()) ||
                            !Objects.equals(oldItem.getUsername(), newItem.getUsername()) ||
                            !Objects.equals(oldItem.getPassword(), newItem.getPassword());
 
                })
                .collect(Collectors.toList());
 
        return differentFieldsList;
    }
}