jy2025/jjt-biz/src/main/java/com/jjt/biz/service/impl/BizObjMetricsServiceImpl.java

package com.jjt.biz.service.impl;

import com.alibaba.fastjson2.JSONArray;
import com.alibaba.fastjson2.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.jjt.biz.domain.*;
import com.jjt.biz.mapper.AlarmRecordMapper;
import com.jjt.biz.mapper.BizObjMetricsDataMapper;
import com.jjt.biz.mapper.BizObjMetricsMapper;
import com.jjt.biz.service.*;
import com.jjt.common.exception.ServiceException;
import com.jjt.common.utils.DateUtils;
import com.jjt.common.utils.StringUtils;
import com.jjt.hl.domain.HlEvent;
import com.jjt.hl.mapper.HlEventMapper;
import com.jjt.hl.service.IHlEventService;
import com.jjt.system.service.ISysConfigService;
import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.session.ExecutorType;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.time.LocalDateTime;
import java.util.*;
import java.util.stream.Collectors;

/**
 * 业务对象指标Service业务层处理
 *
 * @author jjt
 * @date 2024-08-09
 */
@Service
@Slf4j
public class BizObjMetricsServiceImpl implements IBizObjMetricsService {
    @Resource
    private BizObjMetricsMapper bizObjMetricsMapper;
    @Resource
    private IMetricsTplDetailService detailService;
    @Resource
    private IBizObjPpService ppService;
    @Resource
    private IBizObjService objService;
    @Resource
    private IBizObjAppService appService;
    @Resource
    private IPinpointService pinpointService;
    @Resource
    private IPrometheusService prometheusService;
    @Resource
    private IBizObjTplService objTplService;
    @Resource
    private SqlSessionFactory factory;
    @Resource
    private IAlarmRecordService alarmRecordService;
    @Resource
    private IBizObjMetricsDataService metricsDataService;
    @Resource
    private IHlEventService eventService;
    @Resource
    private ISysConfigService configService;
    @Resource
    private IBizObjMcService mcService;

    /**
     * 查询业务对象指标
     *
     * @param objMetricsId 业务对象指标主键
     * @return 业务对象指标
     */
    @Override
    public BizObjMetrics selectBizObjMetricsByObjMetricsId(Long objMetricsId) {
        return bizObjMetricsMapper.selectBizObjMetricsByObjMetricsId(objMetricsId);
    }

    /**
     * 查询业务对象指标列表
     *
     * @param bizObjMetrics 业务对象指标
     * @return 业务对象指标
     */
    @Override
    public List<BizObjMetrics> selectBizObjMetricsList(BizObjMetrics bizObjMetrics) {
        return bizObjMetricsMapper.selectBizObjMetricsList(bizObjMetrics);
    }

    /**
     * 新增业务对象指标
     *
     * @param bizObjMetrics 业务对象指标
     * @return 结果
     */
    @Override
    public int insertBizObjMetrics(BizObjMetrics bizObjMetrics) {
        bizObjMetrics.setCreateTime(DateUtils.getNowDate());
        return bizObjMetricsMapper.insertBizObjMetrics(bizObjMetrics);
    }

    /**
     * 修改业务对象指标
     *
     * @param bizObjMetrics 业务对象指标
     * @return 结果
     */
    @Override
    public int updateBizObjMetrics(BizObjMetrics bizObjMetrics) {
        //插入数据记录表
        bizObjMetrics.setUpdateTime(DateUtils.getNowDate());
        return bizObjMetricsMapper.updateBizObjMetrics(bizObjMetrics);
    }

    /**
     * 批量删除业务对象指标
     *
     * @param objMetricsIds 需要删除的业务对象指标主键
     * @return 结果
     */
    @Override
    public int deleteBizObjMetricsByObjMetricsIds(Long[] objMetricsIds) {
        return bizObjMetricsMapper.deleteBizObjMetricsByObjMetricsIds(objMetricsIds);
    }

    /**
     * 删除业务对象指标信息
     *
     * @param objMetricsId 业务对象指标主键
     * @return 结果
     */
    @Override
    public int deleteBizObjMetricsByObjMetricsId(Long objMetricsId) {
        return bizObjMetricsMapper.deleteBizObjMetricsByObjMetricsId(objMetricsId);
    }

    /**
     * 选择指标，除去当前对象已选择的
     *
     * @param objId 对象ID
     * @return 结果
     */
    @Override
    public List<MetricsDef> selectMetricsDefList(Long objId) {
        return bizObjMetricsMapper.selectMetricsDefList(objId);
    }

    /**
     * 添加指标
     *
     * @param objId      对象ID
     * @param metricsIds 指标IDS
     * @return 结果
     */
    @Override
    public int insertMetricsDetails(Long objId, Long[] metricsIds) {
        BizObj obj = objService.selectBizObjByObjId(objId);
        String suffix = "/" + obj.getObjAddr() + ":" + obj.getObjPort();
        return bizObjMetricsMapper.insertMetricsDetails(objId, suffix, metricsIds);
    }

    /**
     * 通过objId查询列表
     *
     * @param objId 对象ID
     * @return 结果
     */
    @Override
    public List<BizObjMetrics> selectBizObjMetricsListByObjId(Long objId) {
        BizObjMetrics obj = new BizObjMetrics();
        obj.setObjId(objId);
        return selectBizObjMetricsList(obj);
    }

    /**
     * 通过对象和模板ID删除指标
     *
     * @param objId 对象ID
     * @param tplId 模板ID
     */
    @Override
    public void delete(Long objId, Long tplId) {
        QueryWrapper<BizObjMetrics> wrapper = new QueryWrapper<>();
        wrapper.eq("obj_id", objId);
        wrapper.eq("tpl_id", tplId);
        bizObjMetricsMapper.delete(wrapper);
    }

    /**
     * 通过模板ID批量插入指标
     * * @param objId 对象ID
     *
     * @param tplId 模板ID
     */
    @Override
    public void insertBatch(Long objId, Long tplId) {
        BizObj obj = objService.selectBizObjByObjId(objId);
        MetricsTplDetail query = new MetricsTplDetail();
        query.setTplId(tplId);
        List<MetricsTplDetail> list = detailService.selectMetricsTplDetailList(query);
        List<BizObjMetrics> objMetrics = new ArrayList<>();
        list.forEach(d -> {
            if ("1".equals(d.getMetricsDef().getMetricsType()) && !d.getMetricsDef().getMetricsCode().startsWith("pp.jvm.")) {
                //如果是pinpoint,并且不是jvm参数
                // 1.获取对象pinpoint组成
                List<BizObjPp> pps = ppService.selectBizObjPpListByObjId(objId);

                for (BizObjPp pp : pps) {
                    BizObjMetrics ms = new BizObjMetrics();
                    ms.setObjId(objId);
                    ms.setTplId(tplId);
                    ms.setMetricsId(d.getMetricsId());
                    ms.setMetricsName(pp.getPpType() + "/" + d.getMetricsDef().getMetricsName());
                    ms.setMetricsCode(d.getMetricsCode());
                    ms.setDataExp(ms.getMetricsCode());
                    ms.setAlarmLow(d.getAlarmLow());
                    ms.setAlarmMid(d.getAlarmMid());
                    ms.setAlarmHigh(d.getAlarmHigh());
                    ms.setEvent(d.getEvent());

                    if ("REDIS".equals(pp.getPpType())) {
                        //redis需要将1s换成100ms 3s换成300ms 5s换成500ms
                        if (d.getMetricsCode().endsWith("1s")) {
                            ms.setMetricsName(ms.getMetricsName().replace("1s", "100ms"));
                            ms.setMetricsCode(ms.getMetricsCode().replace("1s", "100ms"));
                        }
                        if (d.getMetricsCode().endsWith("3s")) {
                            ms.setMetricsName(ms.getMetricsName().replace("3s", "300ms"));
                            ms.setMetricsCode(ms.getMetricsCode().replace("3s", "300ms"));
                        }
                        if (d.getMetricsCode().endsWith("5s")) {
                            ms.setMetricsName(ms.getMetricsName().replace("5s", "500ms"));
                            ms.setMetricsCode(ms.getMetricsCode().replace("5s", "500ms"));
                        }
                    }
                    objMetrics.add(ms);
                }
            } else {
                BizObjMetrics ms = new BizObjMetrics();
                ms.setObjId(objId);
                ms.setTplId(tplId);
                ms.setMetricsId(d.getMetricsId());
                ms.setMetricsName(d.getMetricsDef().getMetricsName());
                ms.setMetricsCode(d.getMetricsCode());
                ms.setAlarmLow(d.getAlarmLow());
                ms.setAlarmMid(d.getAlarmMid());
                ms.setAlarmHigh(d.getAlarmHigh());
                ms.setEvent(d.getEvent());
                if ("1".equals(d.getMetricsDef().getMetricsType())) {
                    ms.setDataExp(d.getMetricsCode());
                } else {
                    //如果是普罗米修斯，则需要处理公式
                    ms.setDataExp(d.getDataExp().replace("${instance}", obj.getObjAddr()));
                    if ("Y".equals(d.getFindFlag())) {
                        //如果是自动发现
                        cn.hutool.json.JSONObject jsonObject = prometheusService.find(d.getFindRule());
                        cn.hutool.json.JSONArray metric = jsonObject.getByPath("data.result", cn.hutool.json.JSONArray.class);
                        for (int i = 0; i < metric.size(); i++) {
                            String v = metric.getJSONObject(i).getByPath("metric." + d.getFindKey(), String.class);
                            String name = d.getMetricsDef().getMetricsName() + "{" + d.getFindKey() + "=" + v + "}";
                            String dataExp = ms.getDataExp().replace("${key}", v);
                            ms.setDataExp(dataExp);
                            ms.setMetricsName(name);
                            objMetrics.add(ms);
                        }
                    } else {
                        objMetrics.add(ms);
                    }
                }


            }

        });
        try (SqlSession sqlSession = factory.openSession(ExecutorType.BATCH, false)) {
            BizObjMetricsMapper mapper = sqlSession.getMapper(BizObjMetricsMapper.class);
            objMetrics.forEach(mapper::insertBizObjMetrics);
            sqlSession.commit();
        }
    }

    /**
     * 根据模板指标修改
     *
     * @param detail 模板指标
     */
    @Override
    public void update(MetricsTplDetail detail) {
        BizObjMetrics om = new BizObjMetrics();
        om.setMetricsId(detail.getMetricsId());
        om.setTplId(detail.getTplId());

        List<BizObjMetrics> list = selectBizObjMetricsList(om);
//        if (list.size() > 0) {
        list.forEach(obj -> {
            //如果有则更新，没有则插入
            obj.setAlarmMid(detail.getAlarmMid());
            obj.setAlarmLow(detail.getAlarmLow());
            obj.setAlarmHigh(detail.getAlarmHigh());
            obj.setEvent(detail.getEvent());
            bizObjMetricsMapper.updateBizObjMetrics(obj);
        });
//        } else {
//            om.setAlarmLow(detail.getAlarmLow());
//            om.setAlarmMid(detail.getAlarmMid());
//            om.setAlarmHigh(detail.getAlarmHigh());
//            om.setEvent(detail.getEvent());
//            insertBizObjMetrics(om);
//        }

    }

    /**
     * 根据模板指标删除
     *
     * @param detail 模板指标
     */
    @Override
    public void del(MetricsTplDetail detail) {
        QueryWrapper<BizObjMetrics> wrapper = new QueryWrapper<>();
        wrapper.eq("metrics_id", detail.getMetricsId());
        wrapper.eq("tpl_id", detail.getTplId());
        bizObjMetricsMapper.delete(wrapper);
    }

    /**
     * 根据objId获取指标值
     *
     * @param objId 对象ID
     * @param date  数据时间
     */
    @Override
    public void pinpointMetricsValue(Long objId, Date date) {
        BizObj bizObj = objService.selectBizObjByObjId(objId);

        if ("1".equals(bizObj.getObjType())) {
            // 获取应用程序的code
            BizObjApp app = appService.selectBizObjAppByAppId(bizObj.getAppId());
            String appName = app.getAppCode();

            Long time = Long.parseLong(configService.selectConfigByKey("pp.api.time"));
            LocalDateTime endTime = LocalDateTime.now();

            LocalDateTime startTime = endTime.minusMinutes(time);
            Map<String, String> appMap = pinpointService.getApps();
            String appType = appMap.get(appName);

            // 获取监控数据
            Float tps = pinpointService.tps(appName, startTime, endTime);
            int openFiles = pinpointService.openFile(appName, startTime, endTime);
            Map<String, Object> jvmInfo = pinpointService.jvmMemory(appName, startTime, endTime);
            float heapUsage = (float) jvmInfo.get("usage");
            int gcCount = (int) jvmInfo.get("gc");

            JSONObject linkData = pinpointService.link(appName, appType, startTime, endTime);
            JSONArray nodeDataArray = linkData.getJSONObject("applicationMapData").getJSONArray("nodeDataArray");

            List<PinpointVO> pinpointVOList = new ArrayList<>();
            for (int i = 0; i < nodeDataArray.size(); i++) {
                JSONObject obj = nodeDataArray.getJSONObject(i);
                PinpointVO vo = new PinpointVO(obj);

                if (vo.getApplicationName().equals(appName)) {
                    bizObj.setAccessTimes(vo.getTot());
                    objService.updateBizObj(bizObj);
                } else {
                    pinpointVOList.add(vo);
                }
            }

            // 1.更新 BIZ_OBJ_PP 表
            updateBizObjPpTable(objId, pinpointVOList);

            // 2.更新业务对象指标表
            updateBizObjMetrics(objId, tps, openFiles, heapUsage, gcCount, pinpointVOList, date);
        }
    }

    /**
     * 根据objId获取prometheus指标值
     *
     * @param objId 对象ID
     * @param date  时间
     */
    @Override
    public void prometheusMetricsValue(Long objId, Date date) {
        List<BizObjMetrics> mList = getAllMetricsForObjIdList(objId);
        List<BizObjMetrics> metricsToUpdate = new ArrayList<>();
        List<BizObjMetricsData> dataList = new ArrayList<>();
        List<AlarmRecord> addRList = new ArrayList<>();
        List<AlarmRecord> updateRList = new ArrayList<>();
        List<HlEvent> addEList = new ArrayList<>();
        List<HlEvent> updateEList = new ArrayList<>();
        //查询当前对象所有正在告警列表
        Map<Long, AlarmRecord> recordMap = alarmRecordService.selectAlarmRecordListCurr(objId);
        //查询当前对象未结束事件列表
        Map<Long, HlEvent> eventMap = eventService.selectHlEventListCurr(objId);
        mList.stream().filter(om -> !"1".equals(om.getMetricsDef().getMetricsType())).forEach(om -> {
            if (StringUtils.isNotEmpty(om.getDataExp())) {
                //非pinpoint
                Float value = prometheusService.query(om.getDataExp());
                if (value != null) {
                    om.setDValue(BigDecimal.valueOf(value));
                    BizObjMetricsData data = new BizObjMetricsData();
                    data.setObjMetricsId(om.getObjMetricsId());
                    data.setdValue(om.getDValue());
                    data.setCreateTime(date);
                    dataList.add(data);
                    metricsToUpdate.add(om);
                    //处理告警
                    Map<String, AlarmRecord> aMap = alarmRecordService.process(om, recordMap, date);
                    if (aMap.get("add") != null) {
                        addRList.add(aMap.get("add"));
                    }
                    if (aMap.get("update") != null) {
                        updateRList.add(aMap.get("update"));
                    }

                    //处理事件
                    Map<String, HlEvent> eMap = eventService.process(om, eventMap, date);
                    if (eMap.get("add") != null) {
                        addEList.add(eMap.get("add"));
                    }
                    if (eMap.get("update") != null) {
                        updateEList.add(eMap.get("update"));
                    }
                }
            }
        });
        batchUpdate(metricsToUpdate, dataList, addRList, updateRList, addEList, updateEList);

    }

    /**
     * 使用模拟数据
     *
     * @param objId 对象ID
     * @param date  数据时间
     */
    @Override
//    @Async("threadPoolTaskExecutor")
    public void imitate(Long objId, Date date) {
        List<BizObjMetrics> mList = getAllMetricsForObjIdList(objId);
        List<BizObjMetrics> metricsToUpdate = new ArrayList<>();
        List<BizObjMetricsData> dataList = new ArrayList<>();
        List<AlarmRecord> addRList = new ArrayList<>();
        List<AlarmRecord> updateRList = new ArrayList<>();
        List<HlEvent> addEList = new ArrayList<>();
        List<HlEvent> updateEList = new ArrayList<>();
        //查询当前对象所有正在告警列表
        Map<Long, AlarmRecord> recordMap = alarmRecordService.selectAlarmRecordListCurr(objId);
        //查询当前对象未结束事件列表
        Map<Long, HlEvent> eventMap = eventService.selectHlEventListCurr(objId);

        Random random = new Random();
        mList.stream().forEach(om -> {
            double oldV = 100d;
            if (om.getDValue() != null) {
                oldV = om.getDValue().floatValue();
            }
            double modifier = oldV * 0.1;
            double randomValue = random.nextDouble() * 2 - 1; // 生成-1到1之间的随机数

            double value = oldV + modifier * randomValue;
            BigDecimal dv = BigDecimal.valueOf(value).setScale(2, RoundingMode.HALF_UP);
//            int xxx = (int) (om.getObjMetricsId() % 70);
//            float value = (float) random.nextInt(100 - xxx) + xxx;


            if (dv.doubleValue() < 10) {
                dv = dv.add(BigDecimal.valueOf(10));
            }

            if ("1".equals(om.getMetricsDef().getMetricsType())) {
                dv = dv.setScale(0, RoundingMode.HALF_UP);
            }
            if (om.getMetricsCode().endsWith("pp.tot")) {
                if (dv.doubleValue() < 50) {
                    dv = dv.add(BigDecimal.valueOf(50));
                }
            }

            if (om.getMetricsCode().endsWith("pp.error")) {
                if (dv.doubleValue() > 50) {
                    dv = dv.subtract(BigDecimal.valueOf(50));
                }
            }
            om.setDValue(dv);
            BizObjMetricsData data = new BizObjMetricsData();
            data.setObjMetricsId(om.getObjMetricsId());
            data.setdValue(om.getDValue());
            data.setCreateTime(date);
//            metricsDataService.insertBizObjMetricsData(data);
            dataList.add(data);
            metricsToUpdate.add(om);
            //处理告警
            Map<String, AlarmRecord> aMap = alarmRecordService.process(om, recordMap, date);
            if (aMap.get("add") != null) {
                addRList.add(aMap.get("add"));
            }
            if (aMap.get("update") != null) {
                updateRList.add(aMap.get("update"));
            }

            //处理事件
            Map<String, HlEvent> eMap = eventService.process(om, eventMap, date);
            if (eMap.get("add") != null) {
                addEList.add(eMap.get("add"));
            }
            if (eMap.get("update") != null) {
                updateEList.add(eMap.get("update"));
            }
        });
        batchUpdate(metricsToUpdate, dataList, addRList, updateRList, addEList, updateEList);
    }

    /**
     * 更新公式
     *
     * @param metricsList 指标列表
     * @param userName    用户名
     * @return 列表
     */
    @Override
    public String importMetrics(List<BizObjMetrics> metricsList, String userName) {
        if (StringUtils.isNull(metricsList) || metricsList.size() == 0) {
            throw new ServiceException("导入指标不能为空！");
        }
        int successNum = 0;
        int failureNum = 0;
        StringBuilder successMsg = new StringBuilder();
        StringBuilder failureMsg = new StringBuilder();
        for (BizObjMetrics om : metricsList) {
            String metricsName = om.getMetricsName();
            try {
                om.setUpdateBy(userName);
                updateBizObjMetrics(om);
                successNum++;
                successMsg.append("<br/>" + successNum + "、 " + om.getMetricsName() + " 更新成功");
            } catch (Exception e) {
                failureNum++;
                String msg = "<br/>" + failureNum + "、 " + om.getMetricsName() + " 导入失败：";
                failureMsg.append(msg + e.getMessage());
                log.error(msg, e);
            }
        }
        if (failureNum > 0) {
            failureMsg.insert(0, "很抱歉，导入失败！共 " + failureNum + " 条数据格式不正确，错误如下：");
            throw new ServiceException(failureMsg.toString());
        } else {
            successMsg.insert(0, "恭喜您，数据已全部导入成功！共 " + successNum + " 条，数据如下：");
        }
        return successMsg.toString();
    }

    /**
     * 插入自定义指标
     *
     * @param objId 对象ID
     */
    @Override
    public boolean insertMc(Long objId) {
        BizObj obj = objService.selectBizObjByObjId(objId);
        BizObjMc query = new BizObjMc();
        query.setObjId(objId);
        List<BizObjMc> list = mcService.selectBizObjMcList(query);
        List<BizObjMetrics> objMetrics = new ArrayList<>();
        for (BizObjMc d : list) {
            BizObjMetrics ms = new BizObjMetrics();
            ms.setObjId(objId);
            ms.setTplId(-1L);
            ms.setMetricsId(d.getMetricsId());
            ms.setMetricsName(d.getMetricsName());
            ms.setMetricsCode(d.getMetricsCode());
            ms.setAlarmLow(d.getAlarmLow());
            ms.setAlarmMid(d.getAlarmMid());
            ms.setAlarmHigh(d.getAlarmHigh());
            ms.setEvent(d.getEvent());
            if (StringUtils.isEmpty(d.getDataExp())) {
                return false;
            }
            //如果是普罗米修斯，则需要处理公式
            ms.setDataExp(d.getDataExp().replace("${instance}", obj.getObjAddr()));
            if ("Y".equals(d.getFindFlag())) {
                //如果是自动发现
                cn.hutool.json.JSONObject jsonObject = prometheusService.find(d.getFindRule());
                cn.hutool.json.JSONArray metric = jsonObject.getByPath("data.result", cn.hutool.json.JSONArray.class);
                for (int i = 0; i < metric.size(); i++) {
                    String v = metric.getJSONObject(i).getByPath("metric." + d.getFindKey(), String.class);
                    String name = d.getMetricsName() + "{" + d.getFindKey() + "=" + v + "}";
                    String dataExp = ms.getDataExp().replace("${key}", v);
                    ms.setDataExp(dataExp);
                    ms.setMetricsName(name);
                    objMetrics.add(ms);
                }
            } else {
                objMetrics.add(ms);
            }
        }
        try (SqlSession sqlSession = factory.openSession(ExecutorType.BATCH, false)) {
            BizObjMetricsMapper mapper = sqlSession.getMapper(BizObjMetricsMapper.class);
            objMetrics.forEach(mapper::insertBizObjMetrics);
            sqlSession.commit();
        }
        return true;
    }

    /**
     * 更新BIZ_OBJ_PP
     *
     * @param objId          对象ID
     * @param pinpointVOList PP组成
     */
    private void updateBizObjPpTable(Long objId, List<PinpointVO> pinpointVOList) {
        List<BizObjPp> existingPpList = ppService.selectBizObjPpListByObjId(objId);
        Set<String> existingNames = existingPpList.stream()
                .map(BizObjPp::getPpName)
                .collect(Collectors.toSet());

        pinpointVOList.stream()
                .filter(vo -> !existingNames.contains(vo.getApplicationName()))
                .forEach(vo -> {
                    BizObjPp pp = new BizObjPp();
                    pp.setObjId(objId);
                    pp.setPpKey(vo.getKey());
                    pp.setPpName(vo.getApplicationName());
                    pp.setPpType(vo.getCategory());
                    ppService.insertBizObjPp(pp);

                    // 根据模板更新业务对象指标表
                    updateBizObjMetricsFromTemplate(objId, pp);
                    existingPpList.add(pp);
                });
    }

    /**
     * 根据模板更新业务对象指标表
     *
     * @param objId 对象ID
     * @param pp    pp对象
     */
    private void updateBizObjMetricsFromTemplate(Long objId, BizObjPp pp) {
        List<BizObjTpl> templateList = objTplService.selectTplList4objId(objId);
        templateList.forEach(template -> insertOrUpdateMetricsFromTemplate(objId, template.getTplId(), pp));
    }

    /**
     * 更新模板中的pinpoint指标到业务对象指标
     *
     * @param objId 对象ID
     * @param tplId 模板ID
     * @param pp    pinpoint组成
     */
    private void insertOrUpdateMetricsFromTemplate(Long objId, Long tplId, BizObjPp pp) {
        MetricsTplDetail query = new MetricsTplDetail();
        query.setTplId(tplId);
        List<MetricsTplDetail> list = detailService.selectMetricsTplDetailList(query);
        List<BizObjMetrics> objMetrics = new ArrayList<>();
        list.forEach(d -> {
            if ("1".equals(d.getMetricsDef().getMetricsType()) && !d.getMetricsDef().getMetricsCode().startsWith("pp.jvm.")) {
                //如果是pinpoint,需要
                // 1.获取对象pinpoint组成
                BizObjMetrics ms = new BizObjMetrics();
                ms.setObjId(objId);
                ms.setTplId(tplId);
                ms.setMetricsId(d.getMetricsId());
                ms.setMetricsName(pp.getPpName() + "/" + d.getMetricsDef().getMetricsName());
                ms.setMetricsCode(pp.getPpName() + "/" + d.getMetricsCode());
                if (pp.getPpType().equals("REDIS")) {
                    //redis需要将1s换成100ms 3s换成300ms 5s换成500ms
                    if (d.getMetricsCode().endsWith("1s")) {
                        ms.setMetricsName(ms.getMetricsName().replace("1s", "100ms"));
                        ms.setMetricsCode(ms.getMetricsCode().replace("1s", "100ms"));
                    }
                    if (d.getMetricsCode().endsWith("3s")) {
                        ms.setMetricsName(ms.getMetricsName().replace("3s", "300ms"));
                        ms.setMetricsCode(ms.getMetricsCode().replace("3s", "300ms"));
                    }
                    if (d.getMetricsCode().endsWith("5s")) {
                        ms.setMetricsName(ms.getMetricsName().replace("5s", "500ms"));
                        ms.setMetricsCode(ms.getMetricsCode().replace("5s", "500ms"));
                    }
                }
                ms.setDataExp(ms.getMetricsCode());
                ms.setAlarmLow(d.getAlarmLow());
                ms.setAlarmMid(d.getAlarmMid());
                ms.setAlarmHigh(d.getAlarmHigh());
                objMetrics.add(ms);
            }
        });

        bizObjMetricsMapper.batchInsert(objMetrics);
    }

    /**
     * 更新指标
     *
     * @param objId          对象ID
     * @param tps            系统压力
     * @param openFiles      打开文件数量
     * @param heapUsage      堆内存使用率
     * @param gcCount        gc次数
     * @param pinpointVOList 链路列表数据
     * @param date           时间
     */
    private void updateBizObjMetrics(Long objId, Float tps, int openFiles, float heapUsage, int gcCount, List<PinpointVO> pinpointVOList, Date date) {
        updateJvmMetrics(objId, tps, heapUsage, openFiles, gcCount, date);
        updateLinkMetrics(objId, pinpointVOList, date);
    }

    /**
     * 更新jvm指标
     *
     * @param objId     对象ID
     * @param tps       系统压力
     * @param openFiles 打开文件数量
     * @param heapUsage 堆内存使用率
     * @param gcCount   gc次数
     * @param date      数据时间
     */
    private void updateJvmMetrics(Long objId, Float tps, float heapUsage, int openFiles, int gcCount, Date date) {
        BizObjMetrics jvmMetrics = new BizObjMetrics();
        jvmMetrics.setObjId(objId);
        //查询当前对象所有正在告警列表
        Map<Long, AlarmRecord> recordMap = alarmRecordService.selectAlarmRecordListCurr(objId);
        //查询当前对象未结束事件列表
        Map<Long, HlEvent> eventMap = eventService.selectHlEventListCurr(objId);
        jvmMetrics.setMetricsCode("pp.jvm.");
        List<BizObjMetrics> omList = selectBizObjMetricsList(jvmMetrics);
        updateMetricsValues(omList, "tps", BigDecimal.valueOf(tps), date, recordMap, eventMap);
        updateMetricsValues(omList, "heap.usage", BigDecimal.valueOf(heapUsage), date, recordMap, eventMap);
        updateMetricsValues(omList, "open", BigDecimal.valueOf(openFiles), date, recordMap, eventMap);
        updateMetricsValues(omList, "gc", BigDecimal.valueOf(gcCount), date, recordMap, eventMap);
    }

    /**
     * jvm指标更新
     *
     * @param omList       jvm指标列表
     * @param metricSuffix 指标后缀
     * @param value        值
     * @param date         数据时间
     */
    private void updateMetricsValues(List<BizObjMetrics> omList, String metricSuffix, BigDecimal value, Date date, Map<Long, AlarmRecord> recordMap, Map<Long, HlEvent> eventMap) {
        List<BizObjMetricsData> dataList = new ArrayList<>();
        List<AlarmRecord> addRList = new ArrayList<>();
        List<AlarmRecord> updateRList = new ArrayList<>();
        List<HlEvent> addEList = new ArrayList<>();
        List<HlEvent> updateEList = new ArrayList<>();
        omList.stream()
                .filter(om -> om.getMetricsCode().endsWith(metricSuffix))
                .forEach(om -> {
                    om.setDValue(value);
                    updateBizObjMetrics(om);
                    BizObjMetricsData data = new BizObjMetricsData();
                    data.setObjMetricsId(om.getObjMetricsId());
                    data.setCreateTime(date);
                    data.setdValue(om.getDValue());
                    dataList.add(data);
                    //处理告警
                    Map<String, AlarmRecord> aMap = alarmRecordService.process(om, recordMap, date);
                    if (aMap.get("add") != null) {
                        addRList.add(aMap.get("add"));
                    }
                    if (aMap.get("update") != null) {
                        updateRList.add(aMap.get("update"));
                    }

                    //处理事件
                    Map<String, HlEvent> eMap = eventService.process(om, eventMap, date);
                    if (eMap.get("add") != null) {
                        addEList.add(eMap.get("add"));
                    }
                    if (eMap.get("update") != null) {
                        updateEList.add(eMap.get("update"));
                    }
                });
        batchUpdate(null, dataList, addRList, updateRList, addEList, updateEList);
    }

    private void batchUpdate(List<BizObjMetrics> metricsToUpdate, List<BizObjMetricsData> dataList, List<AlarmRecord> addRList, List<AlarmRecord> updateRList, List<HlEvent> addEList, List<HlEvent> updateEList) {
        // 更新所有需要更新的BizObjMetrics对象
        try (SqlSession sqlSession = factory.openSession(ExecutorType.BATCH, false)) {
            BizObjMetricsMapper mapper = sqlSession.getMapper(BizObjMetricsMapper.class);
            if (metricsToUpdate != null && metricsToUpdate.size() > 0) {
                metricsToUpdate.forEach(mapper::updateBizObjMetrics);
            }
            if (dataList != null && dataList.size() > 0) {
                BizObjMetricsDataMapper dataMapper = sqlSession.getMapper(BizObjMetricsDataMapper.class);
                dataList.forEach(dataMapper::insertBizObjMetricsData);
            }
            AlarmRecordMapper recordMapper = sqlSession.getMapper(AlarmRecordMapper.class);
            if (addRList != null && addRList.size() > 0) {
                addRList.forEach(recordMapper::insertAlarmRecord);
            }
            if (updateRList != null && updateRList.size() > 0) {
                updateRList.forEach(recordMapper::updateAlarmRecord);
            }
            HlEventMapper eventMapper = sqlSession.getMapper(HlEventMapper.class);
            if (addEList != null && addEList.size() > 0) {
                addEList.forEach(eventMapper::insertHlEvent);
            }
            if (updateEList != null && updateEList.size() > 0) {
                updateEList.forEach(eventMapper::updateHlEvent);
            }
            sqlSession.commit();
        }
    }

    /**
     * 更新链路指标
     *
     * @param objId          对象ID
     * @param pinpointVOList 链路列表
     * @param date           时间
     */
    private void updateLinkMetrics(Long objId, List<PinpointVO> pinpointVOList, Date date) {
        Map<String, List<BizObjMetrics>> metricsMap = getAllMetricsForObjId(objId);
        pinpointVOList.forEach(vo -> updateMetricsValues(metricsMap, vo, date));
    }


    /**
     * 更新指标
     *
     * @param metricsMap 指标map
     * @param vo         pp链路对象
     * @param date       时间
     */
    private void updateMetricsValues(Map<String, List<BizObjMetrics>> metricsMap, PinpointVO vo, Date date) {
        for (String code : metricsMap.keySet()) {
            List<BizObjMetrics> list = metricsMap.get(code);
            list.forEach(om -> {
                if (om.getMetricsCode().startsWith(vo.getApplicationName() + "/")) {
                    if (vo.getTot() != 0) {
                        updateMetric(om, "pp.1s", vo.getTime1s(), date);
                        updateMetric(om, "pp.3s", vo.getTime3s(), date);
                        updateMetric(om, "pp.5s", vo.getTime5s(), date);
                        updateMetric(om, "pp.100ms", vo.getTime100ms(), date);
                        updateMetric(om, "pp.300ms", vo.getTime300ms(), date);
                        updateMetric(om, "pp.500ms", vo.getTime500ms(), date);
                        updateMetric(om, "pp.tot", vo.getTot(), date);
                        updateMetric(om, "pp.sum", vo.getSum(), date);
                        updateMetric(om, "pp.max", vo.getMax(), date);
                        updateMetric(om, "pp.avg", vo.getAvg(), date);
                        updateMetric(om, "pp.slow", vo.getSlow(), date);
                        updateMetric(om, "pp.error", vo.getError(), date);
                        BigDecimal rate = BigDecimal.valueOf(vo.getTime1s()).divide(BigDecimal.valueOf(vo.getTot()), 2, RoundingMode.HALF_UP);
                        updateMetric(om, "pp.rate", rate, date);
                    }
                }
            });
        }
//        metricsMap.values().stream()
//                .filter(om -> om.getMetricsCode().startsWith(vo.getApplicationName() + "/"))
//                .forEach(om -> {
//                    updateMetric(om, "pp.1s", vo.getTime1s(), date);
//                    updateMetric(om, "pp.3s", vo.getTime3s(), date);
//                    updateMetric(om, "pp.5s", vo.getTime5s(), date);
//                    updateMetric(om, "pp.100ms", vo.getTime100ms(), date);
//                    updateMetric(om, "pp.300ms", vo.getTime300ms(), date);
//                    updateMetric(om, "pp.500ms", vo.getTime500ms(), date);
//                    updateMetric(om, "pp.tot", vo.getTot(), date);
//                    updateMetric(om, "pp.sum", vo.getSum(), date);
//                    updateMetric(om, "pp.max", vo.getMax(), date);
//                    updateMetric(om, "pp.avg", vo.getAvg(), date);
//                    updateMetric(om, "pp.slow", vo.getSlow(), date);
//                    updateMetric(om, "pp.error", vo.getError(), date);
//                });
    }

    /**
     * 调用更新方法
     *
     * @param om     对象
     * @param suffix 前缘
     * @param value  值
     * @param date   时间
     */
    private void updateMetric(BizObjMetrics om, String suffix, Number value, Date date) {
        if (om.getMetricsCode().endsWith(suffix) && value != null) {
            om.setDValue(BigDecimal.valueOf(value.doubleValue()));
            updateBizObjMetrics(om);
            BizObjMetricsData data = new BizObjMetricsData();
            data.setObjMetricsId(om.getObjMetricsId());
            data.setdValue(om.getDValue());
            data.setCreateTime(date);
            metricsDataService.insertBizObjMetricsData(data);
        }
    }

    /**
     * 获取所有指标对象，并以code转换成map
     *
     * @param objId 对象ID
     * @return map
     */
    private Map<String, List<BizObjMetrics>> getAllMetricsForObjId(Long objId) {
        return getAllMetricsForObjIdList(objId).stream().collect(Collectors.groupingBy(BizObjMetrics::getMetricsCode));
    }

    /**
     * 根据对象ID获取所有指标
     *
     * @param objId 对象ID
     * @return
     */
    private List<BizObjMetrics> getAllMetricsForObjIdList(Long objId) {
        BizObjMetrics search = new BizObjMetrics();
        search.setObjId(objId);
        return selectBizObjMetricsList(search);
    }

}