blame | 历史 | 补丁 | 提交 | 提交对比 | ignore whitespace
xiangpei
2024-09-10 e3eebc41e9b1e5c92fc6212fe51dcce8da366306 
 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("点位在线监测完成");


    }




    //点位在线率