点位监测更换对象+存入mongo+提取utils

fuliqi

2024-09-30 b5df1cee65f3e9dcf554efcd3f1642a8c79d1e76

点位监测更换对象+存入mongo+提取utils

 ycl-pojo/src/main/java/com/ycl/platform/domain/result/SYS/TMonitorResult.java

@@ -1,6 +1,7 @@
package com.ycl.platform.domain.result.SYS;


import com.ycl.platform.domain.entity.WorkOrder;
import com.ycl.platform.domain.result.BaseResult;
import lombok.Data;
import org.springframework.data.mongodb.core.mapping.Document;
@@ -11,14 +12,19 @@
@Data
@Document(collection = "t_monitor_online")
public class TMonitorResult extends BaseResult {
    /**
     * 部门id
     */
    /*** 部门id*/
    private Integer deptId;
    /** 在线 */
    /*** 部门id*/
    private String ip;
    /** 最近监测在线状态 */
    private Boolean online;
    /** 当日监测次数 */
    private Integer checkCount;
    /** 当日离线 */
    private Integer offLineCount;
    /** 设备类型 */
    private String monitorType;
    /** 设备名 */
    private String name;
    private WorkOrder workOrder;
}

 ycl-pojo/src/main/java/com/ycl/platform/domain/vo/OnlineThreadVO.java

@@ -17,5 +17,9 @@
    private String ip;

    private WorkOrder workOrder;
    /** 当日监测次数 */
    private Integer checkCount;
    /** 当日离线 */
    private Integer offLineCount;

}

 ycl-server/src/main/java/com/ycl/platform/mapper/TMonitorMapper.java

@@ -159,7 +159,7 @@
     *
     * @return
     */
    List<TMonitor> getDistinctIP();
    List<TMonitorResult> getDistinctIP();

    /**
     * 根据ip修改点位表的是否在线字段

 ycl-server/src/main/java/com/ycl/task/MonitorTask.java

@@ -61,18 +61,18 @@
    @Autowired
    private RedisTemplate redisTemplate;

    //同步点位在线率到mongo
    //同步点位在线率到mongo(弃用)
    public void siteOnline() {
        log.info("开始同步点位在线率到mongo");
        List<TMonitorResult> tMonitorResults = monitorMapper.selectMonitorResult(null);
        if (!CollectionUtils.isEmpty(tMonitorResults)) {
            //如果存在之前的数据先删除
            Query query = new Query(Criteria.where("mongoCreateTime").gte(DateUtils.getDayStart(new Date())).lt(DateUtils.getDayEnd(new Date())));
            DeleteResult result = mongoTemplate.remove(query, TMonitorResult.class);
            //存放在mongo中
            mongoTemplate.insertAll(tMonitorResults);
            log.info("结束同步点位在线率到mongo");
        }
//        log.info("开始同步点位在线率到mongo");
//        List<TMonitorResult> tMonitorResults = monitorMapper.selectMonitorResult(null);
//        if (!CollectionUtils.isEmpty(tMonitorResults)) {
//            //如果存在之前的数据先删除
//            Query query = new Query(Criteria.where("mongoCreateTime").gte(DateUtils.getDayStart(new Date())).lt(DateUtils.getDayEnd(new Date())));
//            DeleteResult result = mongoTemplate.remove(query, TMonitorResult.class);
//            //存放在mongo中
//            mongoTemplate.insertAll(tMonitorResults);
//            log.info("结束同步点位在线率到mongo");
//        }
    }

    //同步mongodb一机一档到数据库

 ycl-server/src/main/java/com/ycl/task/UYTask.java

@@ -7,9 +7,11 @@
import com.ycl.platform.domain.entity.WorkOrder;
import com.ycl.platform.domain.entity.YwPoint;
import com.ycl.platform.domain.param.UY.*;
import com.ycl.platform.domain.result.SYS.TMonitorResult;
import com.ycl.platform.domain.result.UY.RecordMetaDSumResult;
import com.ycl.platform.domain.result.UY.*;
import com.ycl.platform.domain.vo.OnlineThreadVO;
import com.ycl.platform.domain.vo.TMonitorVO;
import com.ycl.platform.domain.vo.UpdateOnlineVO;
import com.ycl.platform.mapper.TMonitorMapper;
import com.ycl.platform.service.UYErrorTypeCheckService;
@@ -18,6 +20,7 @@
import com.ycl.system.domain.SysConfig;
import com.ycl.system.mapper.SysConfigMapper;
import com.ycl.thread.OnlineCheckThread;
import com.ycl.utils.CheckPointUtil;
import com.ycl.utils.DateUtils;
import com.ycl.utils.http.HttpUtils;
import com.ycl.utils.http.SelfHttpUtil;
@@ -55,11 +58,9 @@
    private final UYErrorTypeCheckService uyErrorTypeCheckService;
    private final YwPointService pointService;
    private final TMonitorMapper monitorMapper;
    private final SelfHttpUtil selfHttpUtil;
    private final RedisTemplate redisTemplate;
    private final WorkOrderService workOrderService;
    private final SysConfigMapper sysConfigMapper;

    private final CheckPointUtil checkPointUtil;
    @Value("${youYun.tenantId}")
    private String tenantId;
    @Value("${youYun.apikey}")
@@ -190,15 +191,15 @@
            log.error("请配置离线次数，此次设置为默认值2");
        }
        // 先查出设备IP集合
        List<TMonitor> monitorList = monitorMapper.getDistinctIP();
        List<Future<OnlineThreadVO>> futureList = new ArrayList<>(48);
        List<OnlineThreadVO> dataList = new ArrayList<>(48);
        for (TMonitor monitor : monitorList) {
            OnlineCheckThread thread = new OnlineCheckThread(monitor, redisTemplate, selfHttpUtil, times);
            Future<OnlineThreadVO> future = executorService.submit(thread);
        List<TMonitorResult> monitorList = monitorMapper.getDistinctIP();
        List<Future<TMonitorResult>> futureList = new ArrayList<>(48);
        List<TMonitorResult> dataList = new ArrayList<>(48);
        for (TMonitorResult monitor : monitorList) {
            OnlineCheckThread thread = new OnlineCheckThread(monitor,checkPointUtil,times);
            Future<TMonitorResult> future = executorService.submit(thread);
            futureList.add(future);
        }
        for (Future<OnlineThreadVO> future : futureList) {
        for (Future<TMonitorResult> future : futureList) {
            dataList.add(future.get()); // get方法会阻塞，知道拿到结果才继续执行for
        }

@@ -216,16 +217,25 @@
        // 工单
        List<WorkOrder> workOrderList = dataList.stream()
                .filter(item -> Objects.nonNull(item.getWorkOrder()))
                .map(OnlineThreadVO::getWorkOrder)
                .map(TMonitorResult::getWorkOrder)
                .collect(Collectors.toList());
        if (CollectionUtils.isEmpty(workOrderList)) {
            return;
        }
        workOrderService.innerAddWorkOrder(workOrderList);
        //存放到mongo
        if (!CollectionUtils.isEmpty(dataList)) {
            //如果存在之前的数据先删除
            Query query = new Query(Criteria.where("mongoCreateTime").gte(DateUtils.getDayStart(new Date())).lt(DateUtils.getDayEnd(new Date())));
            DeleteResult result = mongoTemplate.remove(query, TMonitorResult.class);
            //存放在mongo中
            mongoTemplate.insertAll(dataList);
            log.info("结束同步点位在线率到mongo");
        }
        log.info("点位在线监测完成");
    }

    //点位在线率
    //（弃用）点位在线率
    public void videoOnlineTask() {
        //视频图像质量
        log.info("开始执行点位在线数据同步");
@@ -273,41 +283,41 @@
    public void recordMetaDSumTask() {
        //录像可用率
        log.info("开始执行录像可用数据同步");
//        RecordMetaDSumParam param = new RecordMetaDSumParam();
//        param.setTenantId(tenantId);
//        Calendar instance = Calendar.getInstance();
//        instance.setTime(new Date());
//        instance.add(Calendar.DAY_OF_MONTH, -1);
//        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
//        String yesterday = format.format(instance.getTime());
//        param.setStatTime(yesterday);
//        JSONObject jsonObject = uyClient.recordMetaDSumList(param);
//        if (jsonObject != null) {
//            if (ApiConstants.UYSuccessCodeStr.equals(jsonObject.getString("code"))) {
//                List<RecordMetaDSumResult> records = jsonObject.getList("data", RecordMetaDSumResult.class);
//                if (!CollectionUtils.isEmpty(records)) {
//                    //如果今天存在之前的数据先删除
//                    Query query = new Query(Criteria
//                            .where("mongoCreateTime").gte(DateUtils.getDayStart(new Date())).lt(DateUtils.getDayEnd(new Date())));
//                    DeleteResult result = mongoTemplate.remove(query, RecordMetaDSumResult.class);
//                    records.stream().forEach(item -> {
//                        if (Objects.nonNull(item.getDeviceId())) {
//                            item.setNo(item.getDeviceId());
//                        }
//                    });
//                    pointService.setDeviceTagByGB(records);
//                    //存放在mongo中
//                    mongoTemplate.insertAll(records);
//                    // 工单生成
//                    uyErrorTypeCheckService.recordMetaDSumCheck(records);
//                }
//            } else {
//                log.error("录像可用数据为空{}", jsonObject);
//            }
//        }
//         本地测试
        Query query = new Query(Criteria.where("mongoCreateTime").lt(DateUtils.getDayEnd(new Date())));
        uyErrorTypeCheckService.recordMetaDSumCheck(mongoTemplate.find(query, RecordMetaDSumResult.class));
        RecordMetaDSumParam param = new RecordMetaDSumParam();
        param.setTenantId(tenantId);
        Calendar instance = Calendar.getInstance();
        instance.setTime(new Date());
        instance.add(Calendar.DAY_OF_MONTH, -1);
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        String yesterday = format.format(instance.getTime());
        param.setStatTime(yesterday);
        JSONObject jsonObject = uyClient.recordMetaDSumList(param);
        if (jsonObject != null) {
            if (ApiConstants.UYSuccessCodeStr.equals(jsonObject.getString("code"))) {
                List<RecordMetaDSumResult> records = jsonObject.getList("data", RecordMetaDSumResult.class);
                if (!CollectionUtils.isEmpty(records)) {
                    //如果今天存在之前的数据先删除
                    Query query = new Query(Criteria
                            .where("mongoCreateTime").gte(DateUtils.getDayStart(new Date())).lt(DateUtils.getDayEnd(new Date())));
                    DeleteResult result = mongoTemplate.remove(query, RecordMetaDSumResult.class);
                    records.stream().forEach(item -> {
                        if (Objects.nonNull(item.getDeviceId())) {
                            item.setNo(item.getDeviceId());
                        }
                    });
                    pointService.setDeviceTagByGB(records);
                    //存放在mongo中
                    mongoTemplate.insertAll(records);
                    // 工单生成
                    uyErrorTypeCheckService.recordMetaDSumCheck(records);
                }
            } else {
                log.error("录像可用数据为空{}", jsonObject);
            }
        }
        // 本地测试
//        Query query = new Query(Criteria.where("mongoCreateTime").lt(DateUtils.getDayEnd(new Date())));
//        uyErrorTypeCheckService.recordMetaDSumCheck(mongoTemplate.find(query, RecordMetaDSumResult.class));
        log.info("结束执行录像可用数据同步");
    }


 ycl-server/src/main/java/com/ycl/thread/OnlineCheckThread.java

@@ -1,9 +1,9 @@
package com.ycl.thread;

import com.ycl.platform.domain.entity.TMonitor;
import com.ycl.platform.domain.entity.WorkOrder;
import com.ycl.platform.domain.result.SYS.TMonitorResult;
import com.ycl.platform.domain.vo.OnlineThreadVO;
import com.ycl.platform.domain.vo.UpdateOnlineVO;
import com.ycl.utils.CheckPointUtil;
import com.ycl.utils.http.SelfHttpUtil;
import constant.RedisConstant;
import enumeration.ErrorType;
@@ -12,13 +12,11 @@
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.util.CollectionUtils;

import java.io.IOException;
import java.net.InetAddress;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Objects;
import java.util.*;
import java.util.concurrent.Callable;

/**
@@ -26,20 +24,14 @@
 * @date：2024/9/10 11:43
 */
@Slf4j
public class OnlineCheckThread implements Callable<OnlineThreadVO> {
public class OnlineCheckThread implements Callable<TMonitorResult> {

    private TMonitor monitor;

    private RedisTemplate redisTemplate;

    private SelfHttpUtil selfHttpUtil;

    private TMonitorResult monitor;
    private CheckPointUtil checkPointUtil;
    private Integer times;

    public OnlineCheckThread(TMonitor monitor, RedisTemplate redisTemplate, SelfHttpUtil selfHttpUtil, Integer times) {
    public OnlineCheckThread(TMonitorResult monitor, CheckPointUtil checkPointUtil,Integer times) {
        this.monitor = monitor;
        this.redisTemplate = redisTemplate;
        this.selfHttpUtil = selfHttpUtil;
        this.checkPointUtil = checkPointUtil;
        this.times = times;
    }

@@ -51,79 +43,36 @@
        this.times = times;
    }

    public SelfHttpUtil getSelfHttpUtil() {
        return selfHttpUtil;
    }

    public void setSelfHttpUtil(SelfHttpUtil selfHttpUtil) {
        this.selfHttpUtil = selfHttpUtil;
    }

    public TMonitor getMonitor() {
    public TMonitorResult getMonitor() {
        return monitor;
    }

    public void setMonitor(TMonitor monitor) {
    public void setMonitor(TMonitorResult monitor) {
        this.monitor = monitor;
    }

    public RedisTemplate getRedisTemplate() {
        return redisTemplate;
    public CheckPointUtil getCheckPointUtil() {
        return checkPointUtil;
    }

    public void setRedisTemplate(RedisTemplate redisTemplate) {
        this.redisTemplate = redisTemplate;
    public void setCheckPointUtil(CheckPointUtil checkPointUtil) {
        this.checkPointUtil = checkPointUtil;
    }

    @Override
    public OnlineThreadVO call() throws Exception {
        // 先检测能否访问该ip的网页
        ResponseEntity<Object> res = null;
        OnlineThreadVO vo = new OnlineThreadVO();
        vo.setIp(monitor.getIp());
        log.info("监测IP：" + monitor.getIp());
        String prefix = "http://";
        if ("127.0.0.1".equals(monitor.getIp())) {
            vo.setOnline(Boolean.FALSE);
            return vo;
    public TMonitorResult call() throws Exception {
        TMonitorResult result = checkPointUtil.check(monitor);
        // 一天内监测到离线1次以上，生成工单
        if (result.getOffLineCount() >= times) {
            WorkOrder workOrder = new WorkOrder();
            workOrder.setSerialNumber(result.getNo());
            List<String> errList = new ArrayList<>();
            errList.add(ErrorType.DEVICE_OFFLINE.getValue());
            workOrder.setErrorTypeList(errList);
            workOrder.setStatus(WorkOrderStatusEnum.DISTRIBUTED);
            result.setWorkOrder(workOrder);
        }
        try {
            res = selfHttpUtil.get(prefix + monitor.getIp(), null, null);
            vo.setOnline(Objects.nonNull(res) && HttpStatus.OK == res.getStatusCode());
        } catch (Exception e) {
            vo.setOnline(Boolean.FALSE);
        }

        // 如果http得到的不在线，那么再ping一下
        boolean reachable = false;
        if (!vo.getOnline()) {
            try {
                reachable = InetAddress.getByName(monitor.getIp()).isReachable(3000);
            } catch (IOException e) {
                e.printStackTrace();
            }
            vo.setOnline(reachable);
        }
        if (!vo.getOnline()) {
            Integer outLineTimes = (Integer) redisTemplate.opsForHash().get(RedisConstant.ONLINE_KEY, monitor.getIp());
            if (Objects.isNull(outLineTimes)) {
                outLineTimes = 1;
            } else {
                outLineTimes += 1;
            }
            redisTemplate.opsForHash().put(RedisConstant.ONLINE_KEY, monitor.getIp(), outLineTimes);
            // 一天内监测到离线1次以上，生成工单
            if (outLineTimes >= times) {
                WorkOrder workOrder = new WorkOrder();
                workOrder.setSerialNumber(monitor.getSerialNumber());
                List<String> errList = new ArrayList<>();
                errList.add(ErrorType.DEVICE_OFFLINE.getValue());
                workOrder.setErrorTypeList(errList);
                workOrder.setStatus(WorkOrderStatusEnum.DISTRIBUTED);
                vo.setWorkOrder(workOrder);
            }
        }
        return vo;
        return result;
    }

}

 ycl-server/src/main/java/com/ycl/utils/CheckPointUtil.java

New file
@@ -0,0 +1,84 @@
package com.ycl.utils;

import com.ycl.platform.domain.result.SYS.TMonitorResult;
import com.ycl.utils.http.SelfHttpUtil;
import constant.RedisConstant;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.http.*;
import org.springframework.lang.Nullable;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
import org.springframework.util.MultiValueMap;
import org.springframework.web.client.RestTemplate;

import java.io.IOException;
import java.net.InetAddress;
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;

/**
 * @author xp
 * @date 2022/11/16
 */
@Component
@RequiredArgsConstructor
@Slf4j
public class CheckPointUtil {

    private final RedisTemplate redisTemplate;

    private final SelfHttpUtil selfHttpUtil;

    /**
     * 监测点位在线工具类
     * @return
     */
    public TMonitorResult check(TMonitorResult monitor) {
        // 先检测能否访问该ip的网页
        ResponseEntity<Object> res = null;
        log.info("监测IP：" + monitor.getIp());
        String prefix = "http://";
        if ("127.0.0.1".equals(monitor.getIp())) {
            monitor.setOnline(Boolean.FALSE);
            return monitor;
        }
        try {
            res = selfHttpUtil.get(prefix + monitor.getIp(), null, null);
            monitor.setOnline(Objects.nonNull(res) && HttpStatus.OK == res.getStatusCode());
        } catch (Exception e) {
            monitor.setOnline(Boolean.FALSE);
        }

        // 如果http得到的不在线，那么再ping一下
        boolean reachable = false;
        Integer checkTimes = 1;
        Integer offLineTimes = 0;
        Map<String, Object> map = (Map<String, Object>) redisTemplate.opsForHash().get(RedisConstant.ONLINE_KEY, monitor.getIp());
        if (!CollectionUtils.isEmpty(map)) {
            checkTimes = (Integer) map.get("checkTimes") + 1;
            offLineTimes = (Integer) map.get("offLineTimes");
        } else {
            map = new HashMap<>();
        }
        if (!monitor.getOnline()) {
            try {
                reachable = InetAddress.getByName(monitor.getIp()).isReachable(3000);
            } catch (IOException e) {
                e.printStackTrace();
            }
            monitor.setOnline(reachable);
        }
        if (!monitor.getOnline()) {
            offLineTimes++;
        }
        map.put("checkTimes", checkTimes);
        map.put("offLineTimes", offLineTimes);
        redisTemplate.opsForHash().put(RedisConstant.ONLINE_KEY, monitor.getIp(), map);
        monitor.setCheckCount(checkTimes);
        monitor.setOffLineCount(offLineTimes);
        return monitor;
    }
}

 ycl-server/src/main/resources/mapper/zgyw/TMonitorMapper.xml

@@ -637,11 +637,11 @@
              serial_number in <foreach collection="gbList" open="(" separator="," close=")" item="no">#{no}</foreach>
    </select>

    <select id="getDistinctIP" resultType="com.ycl.platform.domain.entity.TMonitor">
        SELECT
            DISTINCT ip, serial_number
        FROM
            t_monitor
    <select id="getDistinctIP" resultType="com.ycl.platform.domain.result.SYS.TMonitorResult">
        select DISTINCT m.id, m.ip,m.serial_number as no,m.name,m.camera_fun_type as monitorType,d.dept_id,p.province_tag,p.important_tag,p.important_command_image_tag,p.dept_tag,p.online
        from t_monitor m
            left join t_yw_point p on m.serial_number = p.serial_number
            left join sys_dept d on p.dept_id = d.dept_id
    </select>

    <update id="updateOnline">