监测点位在线完善

xiangpei

2024-09-10 e3eebc41e9b1e5c92fc6212fe51dcce8da366306

监测点位在线完善

 ycl-common/src/main/java/constant/RedisConstant.java

@@ -6,4 +6,8 @@
    //车辆、人脸在线率  Redis 每月数据中断次数 Hash key
    public final static String Check_Car_ViewConnect = "CarViewConnectNoData";
    public final static String Check_Face_ViewConnect = "FaceViewConnectNoData";

    /** 点位在线，hash的key */
    public final static String ONLINE_PREFIX = "ONLINE_";

}

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

New file
@@ -0,0 +1,21 @@
package com.ycl.platform.domain.vo;

import com.ycl.platform.domain.entity.WorkOrder;
import lombok.Data;

/**
 * 监测在线的线程返回对象
 *
 * @author：xp
 * @date：2024/9/10 11:44
 */
@Data
public class OnlineThreadVO {

    private Boolean online;

    private String ip;

    private WorkOrder workOrder;

}

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

@@ -155,11 +155,11 @@
     *
     * @return
     */
    List<String> getDistinctIP();
    List<TMonitor> getDistinctIP();

    /**
     * 根据ip修改点位表的是否在线字段
     * @param online
     * @param onlineList
     */
    void updateOnline(@Param("online") UpdateOnlineVO online);
    void updateOnline(@Param("onlineList") List<UpdateOnlineVO> onlineList);
}

 ycl-server/src/main/java/com/ycl/platform/service/WorkOrderService.java

@@ -26,13 +26,12 @@
public interface WorkOrderService extends IService<WorkOrder> {

    /**
     * 系统内部的添加，下发
     * 系统内部的添加
     *
     * @param workOrderList
     * @return
     */
    Boolean innerAddWorkOrder(List<WorkOrder> workOrderList);


    /**
     * 添加

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

@@ -3,24 +3,33 @@
import com.alibaba.fastjson2.JSONObject;
import com.mongodb.client.result.DeleteResult;
import com.ycl.feign.UYClient;
import com.ycl.platform.domain.entity.TMonitor;
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.UY.RecordMetaDSumResult;
import com.ycl.platform.domain.result.UY.*;
import com.ycl.platform.domain.vo.OnlineThreadVO;
import com.ycl.platform.domain.vo.UpdateOnlineVO;
import com.ycl.platform.mapper.TMonitorMapper;
import com.ycl.platform.service.UYErrorTypeCheckService;
import com.ycl.platform.service.WorkOrderService;
import com.ycl.platform.service.YwPointService;
import com.ycl.system.domain.SysConfig;
import com.ycl.system.mapper.SysConfigMapper;
import com.ycl.thread.OnlineCheckThread;
import com.ycl.utils.DateUtils;
import com.ycl.utils.http.HttpUtils;
import com.ycl.utils.http.SelfHttpUtil;
import constant.ApiConstants;
import constant.RedisConstant;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.http.HttpStatus;
import org.springframework.http.HttpStatusCode;
import org.springframework.http.ResponseEntity;
@@ -30,14 +39,10 @@
import java.io.IOException;
import java.net.InetAddress;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import java.util.Objects;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.*;
import java.util.concurrent.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

//优云对接数据任务
@Slf4j
@@ -51,6 +56,9 @@
    private final YwPointService pointService;
    private final TMonitorMapper monitorMapper;
    private final SelfHttpUtil selfHttpUtil;
    private final RedisTemplate redisTemplate;
    private final WorkOrderService workOrderService;
    private final SysConfigMapper sysConfigMapper;

    @Value("${youYun.tenantId}")
    private String tenantId;
@@ -170,44 +178,51 @@
    /**
     * 点位在线检测
     */
    public void pointOnline() {
    public void pointOnline() throws ExecutionException, InterruptedException {
        log.info("开始检测点位在线");
        // 先查出设备IP集合
        List<String> ipList = monitorMapper.getDistinctIP();
        String prefix = "http://";
        Date now = new Date();
        for (String ip : ipList) {
            executorService.submit(() -> {
                // 先检测能否访问该ip的网页
                ResponseEntity<Object> res = null;
                UpdateOnlineVO online = new UpdateOnlineVO();
                online.setIp(ip);
                if ("127.0.0.1".equals(ip)) {
                    online.setOnline(Boolean.FALSE);
                    monitorMapper.updateOnline(online);
                    return;
                }
                try {
                    res = selfHttpUtil.get(prefix + ip, null, null);
                    online.setOnline(Objects.nonNull(res) && HttpStatus.OK == res.getStatusCode());
                } catch (Exception e) {
                    online.setOnline(Boolean.FALSE);
                }
                online.setUpdateTime(now);

                // 如果http得到的不在线，那么再ping一下
                boolean reachable = false;
                if (! online.getOnline()) {
                    try {
                        reachable = InetAddress.getByName(ip).isReachable(3000);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                    online.setOnline(reachable);
                }
                monitorMapper.updateOnline(online);
            });
        Integer times = 2;
        SysConfig config = new SysConfig();
        config.setConfigKey("DAY_OF_POINT_OUTLINE_TIMES");
        SysConfig sysConfig = sysConfigMapper.selectConfig(config);
        if (Objects.nonNull(sysConfig)) {
            times = Integer.valueOf(sysConfig.getConfigValue());
        } else {
            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);
            futureList.add(future);
        }
        for (Future<OnlineThreadVO> future : futureList) {
            dataList.add(future.get()); // get方法会阻塞，知道拿到结果才继续执行for
        }

        // 更新point表的在线标识
        Date now = new Date();
        List<UpdateOnlineVO> willUpdateList = dataList.stream().map(item -> {
            UpdateOnlineVO vo = new UpdateOnlineVO();
            vo.setOnline(item.getOnline());
            vo.setIp(item.getIp());
            vo.setUpdateTime(now);
            return vo;
        }).collect(Collectors.toList());
        monitorMapper.updateOnline(willUpdateList);

        // 工单
        List<WorkOrder> workOrderList = dataList.stream()
                .filter(item -> Objects.nonNull(item.getWorkOrder()))
                .map(OnlineThreadVO::getWorkOrder)
                .collect(Collectors.toList());
        if (CollectionUtils.isEmpty(workOrderList)) {
            return;
        }
        workOrderService.innerAddWorkOrder(workOrderList);
        log.info("点位在线监测完成");
    }

    //点位在线率

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

New file
@@ -0,0 +1,129 @@
package com.ycl.thread;

import com.ycl.platform.domain.entity.TMonitor;
import com.ycl.platform.domain.entity.WorkOrder;
import com.ycl.platform.domain.vo.OnlineThreadVO;
import com.ycl.platform.domain.vo.UpdateOnlineVO;
import com.ycl.utils.http.SelfHttpUtil;
import constant.RedisConstant;
import enumeration.ErrorType;
import enumeration.general.WorkOrderStatusEnum;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;

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.concurrent.Callable;

/**
 * @author：xp
 * @date：2024/9/10 11:43
 */
@Slf4j
public class OnlineCheckThread implements Callable<OnlineThreadVO> {

    private TMonitor monitor;

    private RedisTemplate redisTemplate;

    private SelfHttpUtil selfHttpUtil;

    private Integer times;

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

    public Integer getTimes() {
        return times;
    }

    public void setTimes(Integer times) {
        this.times = times;
    }

    public SelfHttpUtil getSelfHttpUtil() {
        return selfHttpUtil;
    }

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

    public TMonitor getMonitor() {
        return monitor;
    }

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

    public RedisTemplate getRedisTemplate() {
        return redisTemplate;
    }

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

    @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;
        }
        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_PREFIX, monitor.getIp());
            if (Objects.isNull(outLineTimes)) {
                outLineTimes = 1;
            } else {
                outLineTimes += 1;
            }
            redisTemplate.opsForHash().put(RedisConstant.ONLINE_PREFIX, 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;
    }

}

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

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

    <select id="getDistinctIP" resultType="string">
    <select id="getDistinctIP" resultType="com.ycl.platform.domain.entity.TMonitor">
        SELECT
            DISTINCT ip
            DISTINCT ip, serial_number
        FROM
            t_monitor
    </select>

    <update id="updateOnline">
        update t_yw_ponit set online = #{online.online}, update_time = #{online.updateTime} WHERE EXISTS (
                                                                                                          SELECT 1 FROM t_monitor WHERE ip = #{online.ip} AND t_monitor.serial_number = t_yw_point.serial_number
                                                                                                      );
        <foreach collection="onlineList" item="online" separator=";">
            UPDATE
                t_yw_point
            SET
                online = #{online.online},
                update_time = #{online.updateTime}
            WHERE
                EXISTS (SELECT 1 FROM t_monitor WHERE ip = #{online.ip} AND t_monitor.serial_number = t_yw_point.serial_number)
        </foreach>
    </update>
</mapper>