请求历史特殊处理-通过历史表补充报表库数据

6c

6 天以前 ecd282bfc3f87f34ce04ec8887169b99fe04478e

请求历史特殊处理-通过历史表补充报表库数据

 product-server-data-center/src/main/java/com/product/data/center/config/ErrorCode.java

@@ -145,6 +145,12 @@
    PRODUCT_SN_TABLE_NOT_EXISTS("T_WIP_PRODUCT_SN归档表不存在", "089"),

    PRODUCT_SN_DATA_NOT_FOUND("T_WIP_PRODUCT_SN未找到相应的数据", "090"),
    REQUEST_HISTORY_SP_DEAL_FAIL("请求历史特殊处理失败", "091"),
    REQUEST_HISTORY_SP_DEAL_FAIL_NO_DB_LINK_INFO("请求历史特殊处理失败-采集提取库-未获取到子库或报表库连接信息", "092"),
    REQUEST_HISTORY_SP_DEAL_FAIL_NO_TABLE_INFO("请求历史特殊处理失败-采集提取库-未获取到子库表信息", "093"),
    REQUEST_HISTORY_SP_DEAL_FAIL_NO_SP_DEAL_INFO("请求历史特殊处理失败-采集提取库-未获取到特殊处理信息", "094"),
    REQUEST_HISTORY_SP_DEAL_FAIL_WITH_SUB_DB_DATA("请求历史特殊处理失败-子库-数据获取失败", "095"),
    REQUEST_HISTORY_SP_DEAL_FAIL_NO_TABLE_DATA("请求历史特殊处理失败-采集提取库-未获取到", "096"),

    ;


 product-server-data-center/src/main/java/com/product/data/center/service/SpDealService.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,491 @@
package com.product.data.center.service;

import com.alibaba.fastjson.JSONObject;
import com.beust.jcommander.internal.Lists;
import com.google.common.collect.Maps;
import com.product.common.lang.StringUtils;
import com.product.core.dao.BaseDao;
import com.product.core.entity.DataTableEntity;
import com.product.core.entity.FieldSetEntity;
import com.product.core.exception.BaseException;
import com.product.core.service.support.AbstractBaseService;
import com.product.core.spring.context.SpringMVCContextHolder;
import com.product.data.center.config.CmnConst;
import com.product.data.center.config.ErrorCode;
import com.product.datasource.dao.Dao;
import com.product.datasource.entity.DataBaseEntity;
import com.product.util.BaseUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.text.SimpleDateFormat;
import java.util.*;

/**
 * å®žçŽ°åŠŸèƒ½ï¼š
 *
 * @author ä½œè€…[夜丶光]
 * @version 1.0.00  2025-08-04 10:48
 */
@Service
public class SpDealService extends AbstractBaseService {
    @Autowired
    private BaseDao baseDao;
    @Autowired
    private DataArchivingService dataArchivingService;
    @Autowired
    private JournalManagerService journalManagerService;

    /*========================请求历史-start========================*/
    // æ­£åœ¨å¤„理标识
    private static boolean processingFlag = false;
    // åœæ­¢æ ‡è¯†
    private static boolean stopFlag = false;
    // æ•°æ®å­—典名称-请求历史
    private static final String DICT_NAME_REQUEST_HISTORY = "请求历史特殊处理";
    // é¡µå¤§å°
    private static int pageSize = 0;
    // å­åº“操作的表集合，需要从数据库中读取
    private static List<String> operateTableList = Lists.newArrayList();
    // æ•´æœºå­åº“ip
    private static String subDbIp = "";
    // å­åº“端口
    private static int subDbPort = 0;
    // æŠ¥è¡¨åº“ip
    private static String reportDbIp = "";
    // æŠ¥è¡¨åº“端口
    private static int reportDbPort = 0;

    /**
     * é€šå¸¸å®šæ—¶ä»»åŠ¡è§¦å‘-停止执行
     */
    public void stopExecute() {
        SpringMVCContextHolder.getSystemLogger().info("[请求历史特殊处理-停止]");
        stopFlag = true;
    }

    /**
     * é€šå¸¸å®šæ—¶ä»»åŠ¡è§¦å‘-请求历史特殊处理-测试方法
     */
    public void testRequestHistorySpDeal() {
        requestHistorySpDeal(true);
    }

    /**
     * é€šå¸¸å®šæ—¶ä»»åŠ¡è§¦å‘-请求历史特殊处理
     */
    public void requestHistorySpDeal() {
        requestHistorySpDeal(false);
    }

    /**
     * è¯·æ±‚历史特殊处理
     */
    private void requestHistorySpDeal(boolean testFlag) {
        SpringMVCContextHolder.getSystemLogger().info("[请求历史特殊处理-开始]");
        if (processingFlag) {
            SpringMVCContextHolder.getSystemLogger().info("[请求历史特殊处理-正在进行-跳过]");
            return;
        }
        synchronized ("requestHistorySpDeal") {
            DataBaseEntity subDbe = null;
            DataBaseEntity reportDbe = null;
            DataTableEntity waitInsertDte = null;
            try {
                if (processingFlag) {
                    return;
                }
                processingFlag = true;

                // èŽ·å–特殊处理信息
                JSONObject spDealInfoObj = getSpDealInfo();
                if (spDealInfoObj.isEmpty()) {
                    throw new BaseException(ErrorCode.REQUEST_HISTORY_SP_DEAL_FAIL_NO_SP_DEAL_INFO);
                }
                String tableFormat = spDealInfoObj.getString("tableFormat");

                // èŽ·å–子库和报表库连接信息
                DataTableEntity dbLinkDte = baseDao.listTable(CmnConst.PRODUCT_SYS_DATA_SYNC_MANAGER, "ip=? OR (ip=? AND port=?)", new Object[]{subDbIp, reportDbIp, reportDbPort});
                FieldSetEntity subDbFse = null;
                FieldSetEntity reportDbFse = null;
                for (int i = 0; i < dbLinkDte.getRows(); i++) {
                    FieldSetEntity singleFse = dbLinkDte.getFieldSetEntity(i);
                    if (subDbIp.equals(singleFse.getString("ip")) && !StringUtils.isEmpty(singleFse.getString("port")) && subDbPort == singleFse.getInteger("port")) {
                        subDbFse = singleFse;
                    } else if (reportDbIp.equals(singleFse.getString("ip")) && !StringUtils.isEmpty(singleFse.getString("port")) && reportDbPort == singleFse.getInteger("port")) {
                        reportDbFse = singleFse;
                    }
                }
                if (subDbFse == null || reportDbFse == null) {
                    throw new BaseException(ErrorCode.REQUEST_HISTORY_SP_DEAL_FAIL_NO_DB_LINK_INFO);
                }

                // èŽ·å–子库对应表的信息：表名，主键字段，时间字段
                JSONObject subDbTableInfoObj = getSubDbTableInfo(subDbFse.getUUID());
                if (subDbTableInfoObj.isEmpty()) {
                    throw new BaseException(ErrorCode.REQUEST_HISTORY_SP_DEAL_FAIL_NO_TABLE_INFO);
                }

                // èŽ·å–连接
                subDbe = new DataBaseEntity(subDbFse);
                reportDbe = new DataBaseEntity(reportDbFse);

                // æŒ‰ä¸»é”®æŽ’序，分页提取子库数据，对比报表库数据，不存在则插入
                if (!stopFlag) {
                    int curMaxMasterKeyValue = 0;
                    outer: for (String tableNameStr : operateTableList) {
                        SpringMVCContextHolder.getSystemLogger().info("[请求历史特殊处理-数据处理-开始]-" + tableNameStr);
                        int index = 0;
                        JSONObject singleSubDbTableInfoObj = subDbTableInfoObj.getJSONObject(tableNameStr);
                        // é‡‡é›†é…ç½®è¡¨id
                        String sourceInfo = singleSubDbTableInfoObj.getString(CmnConst.ID);
                        String tableName = String.format(tableFormat, tableNameStr);
                        String reportTableNamePrefix = String.format("da_%s", tableNameStr);
                        String orderBy = singleSubDbTableInfoObj.getString("auto_field");
                        DataArchivingService.DataArchivingServiceImpl createTableService = getDDLService(tableName, subDbe, reportDbe);
                        String masterKeyFieldName = singleSubDbTableInfoObj.getString("auto_field");
                        long initId = spDealInfoObj.getJSONObject(tableNameStr) == null ? 0 : spDealInfoObj.getJSONObject(tableNameStr).getIntValue("dealt_max_id");
                        long curId = initId;
                        int count;
                        int totalCount = 0;
                        // ç»Ÿè®¡é¡µæ•°ï¼Œæ¯å¤šå°‘页记录一次最大id
                        int statisticsPage = 10;
                        if (!testFlag) {
                            do {
                                index++;
                                if (stopFlag) {
                                    break outer;
                                }
                                DataTableEntity singlePageDataDte;
                                try {
                                    singlePageDataDte = subDbe.getDao().getList(tableName, null, masterKeyFieldName + ">?", new Object[]{curId}, orderBy, 1, pageSize);
                                } catch (Exception e) {
                                    throw new BaseException(ErrorCode.REQUEST_HISTORY_SP_DEAL_FAIL_WITH_SUB_DB_DATA.getValue(), ErrorCode.REQUEST_HISTORY_SP_DEAL_FAIL_WITH_SUB_DB_DATA.getText() + ":" + e.getMessage());
                                }
                                count = singlePageDataDte.getRows();
                                if (count > 0) {
                                    curMaxMasterKeyValue = singlePageDataDte.getFieldSetEntity(singlePageDataDte.getRows() - 1).getInteger(singleSubDbTableInfoObj.getString("auto_field"));
                                    curId = curMaxMasterKeyValue;
                                    Map<String, Map<String, FieldSetEntity>> monthMap = Maps.newHashMap();
                                    dealSubDbData(singlePageDataDte, singleSubDbTableInfoObj, monthMap);

                                    // æ£€æŸ¥æ˜¯å¦æ‰€æœ‰è¡¨éƒ½å­˜åœ¨ï¼Œè‹¥æ˜¯ä¸å­˜åœ¨ï¼Œé‚£ä¹ˆåˆ›å»º
                                    checkTableIfNoThenCreate(monthMap.keySet(), reportTableNamePrefix, createTableService);

                                    String querySql = joinReportDbQuerySql(monthMap, reportTableNamePrefix, sourceInfo);
                                    DataTableEntity reportDbExistsDte = reportDbe.getDao().getList(querySql);
                                    for (int i = 0; i < reportDbExistsDte.getRows(); i++) {
                                        FieldSetEntity reportDbExistsFse = reportDbExistsDte.getFieldSetEntity(i);
                                        for (Map<String, FieldSetEntity> singleMonthMap : monthMap.values()) {
                                            singleMonthMap.remove(reportDbExistsFse.getString("pre_master_key"));
                                        }
                                    }
                                    for (Map.Entry<String, Map<String, FieldSetEntity>> entry : monthMap.entrySet()) {
                                        String insertTableName = String.format("%s_%s", reportTableNamePrefix, entry.getKey());
                                        waitInsertDte = getSingleMonthInsertDte(entry.getValue(), insertTableName, sourceInfo);
                                        reportDbe.getDao().addBatch(waitInsertDte);
                                        totalCount += waitInsertDte.getRows();
                                    }
                                    if (index % statisticsPage == 0) {
                                        // æ›´æ–°å½“前操作的表统计日志信息，每指定页数更新一次
                                        updateOperateTableInfo(tableNameStr, initId, curMaxMasterKeyValue, totalCount);
                                    }
                                }
                            } while (count > 0);
                            if (index % statisticsPage != 0) {
                                // æ›´æ–°å½“前操作的表统计日志信息，若是不是倍数，那么需要额外执行一次
                                updateOperateTableInfo(tableNameStr, initId, curMaxMasterKeyValue, totalCount);
                            }
                        }
                    }
                }
            } catch (Exception e) {
                recordErrorLog(waitInsertDte, e);
                throw e;
            } finally {
                stop(subDbe, reportDbe);
                SpringMVCContextHolder.getSystemLogger().info("[请求历史特殊处理-结束]");
            }
        }
    }

    /**
     * è®°å½•é”™è¯¯æ—¥å¿—
     * @param waitInsertDte ç­‰å¾…插入的数据dte
     * @param e             é”™è¯¯
     */
    private void recordErrorLog(DataTableEntity waitInsertDte, Exception e) {
        String errorInfo = journalManagerService.getStackTrace(e);
        String groupUUID = UUID.randomUUID().toString();
        Date curTime = new Date();
        if (!DataTableEntity.isEmpty(waitInsertDte)) {
            // è®°å½•å½“前报错的信息
            DataTableEntity logDte = new DataTableEntity();
            for (int i = 0; i < waitInsertDte.getRows(); i++) {
                FieldSetEntity singlePageDataFse = waitInsertDte.getFieldSetEntity(i);
                FieldSetEntity logFse = new FieldSetEntity("product_sys_sp_deal_log");
                logFse.setValue("content", BaseUtil.fieldSetEntityToJson(singlePageDataFse).toJSONString());
                logFse.setValue("error", errorInfo);
                logFse.setValue("group_uuid", groupUUID);
                logFse.setValue("created_utc_datetime", curTime);
                logDte.addFieldSetEntity(logFse);
            }
            baseDao.add(logDte);
        } else {
            FieldSetEntity logFse = new FieldSetEntity("product_sys_sp_deal_log");
            logFse.setValue("content", "非数据处理阶段出错");
            logFse.setValue("error", errorInfo);
            logFse.setValue("group_uuid", groupUUID);
            logFse.setValue("created_utc_datetime", curTime);
            baseDao.add(logFse);
        }
    }

    /**
     * èŽ·å–单月插入dte
     * @param singleMonthMap  å•æœˆæ•°æ®map
     * @param insertTableName æŠ¥è¡¨åº“表名
     * @param sourceInfo      é‡‡é›†é…ç½®è¡¨id
     * @return  å•æ‰¹æ¬¡ä¸­å•æœˆï¼ˆå› ä¸ºæŒ‰æœˆåˆ†è¡¨ï¼‰å¾…插入的dte
     */
    private DataTableEntity getSingleMonthInsertDte(Map<String, FieldSetEntity> singleMonthMap, String insertTableName, String sourceInfo) {
        DataTableEntity waitInsertDte = new DataTableEntity();
        for (Map.Entry<String, FieldSetEntity> entry : singleMonthMap.entrySet()) {
            FieldSetEntity waitInsertFse = entry.getValue();
            waitInsertFse.setTableName(insertTableName);
            waitInsertFse.setValue("pre_master_key", entry.getKey());
            waitInsertFse.setValue("source_info", sourceInfo);
            waitInsertDte.addFieldSetEntity(waitInsertFse);
        }
        return waitInsertDte;
    }

    /**
     * èŽ·å–创建表的service
     * @param tableName     è¡¨åï¼Œå­åº“历史表表名
     * @param subDbe        å­åº“数据库连接实例
     * @param reportDbe     æŠ¥è¡¨æ•°æ®åº“连接实例
     * @return  èƒ½å¤Ÿæ‰§è¡Œåˆ›å»ºè¡¨DDL语句的service
     */
    private DataArchivingService.DataArchivingServiceImpl getDDLService(String tableName, DataBaseEntity subDbe, DataBaseEntity reportDbe) {
        Dao sourceDao = subDbe.getDao();
        Dao targetDao = reportDbe.getDao();
        String sourceDbName = subDbe.getDbName();
        String targetDbName = reportDbe.getDbName();
        return dataArchivingService.new DataArchivingServiceImpl(sourceDao, targetDao, tableName, "requestHistory", sourceDbName, targetDbName);
    }

    /**
     * æ£€æŸ¥æ˜¯å¦æ‰€æœ‰è¡¨éƒ½å­˜åœ¨ï¼Œè‹¥æ˜¯ä¸å­˜åœ¨ï¼Œé‚£ä¹ˆåˆ›å»º
     * @param tableTailSet          è¡¨å°¾ç¼€é›†åˆï¼Œæ—¶é—´
     * @param reportTableNamePrefix æŠ¥è¡¨åº“表名前缀
     * @param createTableService    åˆ›å»ºè¡¨çš„service
     */
    private void checkTableIfNoThenCreate(Set<String> tableTailSet, String reportTableNamePrefix, DataArchivingService.DataArchivingServiceImpl createTableService) {
        for (String tableTail : tableTailSet) {
            createTableService.createTable(reportTableNamePrefix, tableTail, null);
        }
    }

    /**
     * æ›´æ–°å½“前操作的表的统计日志信息
     * @param tableName                 è¡¨åï¼Œå­åº“正式表表名
     * @param initId                    æœ¬æ¬¡æ‰§è¡Œå‰ï¼Œé‡‡é›†åº“数据字典中参数里对应表的最大执行id
     * @param curMaxMasterKeyValue      ä»Žå­åº“中获取到的本批次数据最大的id
     * @param operateCount              æ’入报表库数据的总条数
     */
    private void updateOperateTableInfo(String tableName, long initId, int curMaxMasterKeyValue, int operateCount) {
        String maxIdDictLabel = String.format("%s_dealt_max_id", tableName);
        String latestTimeDictLabel = String.format("%s_latest_time", tableName);
        String latestOperateCountDictLabel = String.format("%s_latest_operate_count", tableName);
        DataTableEntity dictDte = baseDao.listTable(CmnConst.PRODUCT_SYS_DICT, "dict_name=? AND dict_label IN (?,?,?)", new Object[]{DICT_NAME_REQUEST_HISTORY, maxIdDictLabel, latestTimeDictLabel, latestOperateCountDictLabel});
        FieldSetEntity maxIdDictFse = null;
        FieldSetEntity latestTimeDictFse = null;
        FieldSetEntity latestOperateCountDictFse = null;
        if (!DataTableEntity.isEmpty(dictDte)) {
            for (int i = 0; i < dictDte.getRows(); i++) {
                FieldSetEntity dictFse = dictDte.getFieldSetEntity(i);
                if (maxIdDictLabel.equals(dictFse.getString("dict_label"))) {
                    maxIdDictFse = dictFse;
                } else if (latestTimeDictLabel.equals(dictFse.getString("dict_label"))) {
                    latestTimeDictFse = dictFse;
                } else if (latestOperateCountDictLabel.equals(dictFse.getString("dict_label"))) {
                    latestOperateCountDictFse = dictFse;
                }
            }
        }

        FieldSetEntity newDictFse = new FieldSetEntity(CmnConst.PRODUCT_SYS_DICT);
        newDictFse.setValue("dict_name", DICT_NAME_REQUEST_HISTORY);
        newDictFse.setValue("is_used", 1);
        newDictFse.setValue("sequence", 1);
        newDictFse.setValue("client_type", "Web");
        newDictFse.setValue("created_utc_datetime", new Date());
        newDictFse.setValue("created_by", 1);

        // æœ€å¤§id
        if (initId < curMaxMasterKeyValue) {
            saveDictFse(maxIdDictFse, newDictFse, maxIdDictLabel, curMaxMasterKeyValue);
        }
        // æœ€è¿‘执行时间
        saveDictFse(latestTimeDictFse, newDictFse, latestTimeDictLabel, new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
        // æœ€è¿‘一次执行总数
        saveDictFse(latestOperateCountDictFse, newDictFse, latestOperateCountDictLabel, operateCount);
    }

    /**
     * ä¿å­˜è¯·æ±‚历史在数据字典里面的参数fse
     * @param saveDictFse       éœ€è¦ä¿å­˜dict的fse
     * @param modelDictFse      æ¨¡æ¿fse
     * @param dictLabel         æ ‡ç­¾
     * @param dictValue         å€¼
     */
    private void saveDictFse(FieldSetEntity saveDictFse, FieldSetEntity modelDictFse, String dictLabel, Object dictValue) {
        if (saveDictFse == null) {
            saveDictFse = modelDictFse.clones();
            saveDictFse.setValue("dict_label", dictLabel);
        } else {
            saveDictFse.setValue("updated_utc_datetime", new Date());
            saveDictFse.setValue("updated_by", 1);
        }
        saveDictFse.setValue("dict_value", dictValue);
        baseDao.saveFieldSetEntity(saveDictFse);
    }

    /**
     * æ‹¼æŽ¥æŠ¥è¡¨åº“查询语句
     * @param monthMap              æœˆä»½map
     * @param reportTableNamePrefix æŠ¥è¡¨åº“表名前缀
     * @param sourceInfo            é‡‡é›†è¡¨id
     * @return  æŠ¥è¡¨åº“查询语句
     */
    private String joinReportDbQuerySql(Map<String, Map<String, FieldSetEntity>> monthMap, String reportTableNamePrefix, String sourceInfo) {
        StringBuilder sql = new StringBuilder(128);
        String model = "SELECT * FROM %s_%s WHERE source_info='%s' AND %s";
        for (Map.Entry<String, Map<String, FieldSetEntity>> entry : monthMap.entrySet()) {
            String month = entry.getKey();
            Set<String> masterKeySet = entry.getValue().keySet();
            if (sql.length() > 0) {
                sql.append("\nUNION ALL\n");
            }
            sql.append(String.format(model, reportTableNamePrefix, month, sourceInfo, BaseUtil.buildQuestionMarkFilter("pre_master_key", masterKeySet.toArray(), true)));
        }
        return sql.toString();
    }

    /**
     * èŽ·å–子库对应表的信息：表名，主键字段，时间字段等
     * @param subDbUuid     å­åº“连接配置表uuid
     * @return  JSONObject å­åº“对应表的信息
     */
    private JSONObject getSubDbTableInfo(String subDbUuid) {
        String filter = String.format("data_source=? AND %s", BaseUtil.buildQuestionMarkFilter("source_table", operateTableList.size(), true));
        List<String> paramList = Lists.newArrayList();
        paramList.add(subDbUuid);
        paramList.addAll(operateTableList);
        DataTableEntity tableDte = baseDao.listTable(CmnConst.PRODUCT_SYS_DATA_COLLECT, filter, paramList.toArray());
        JSONObject resultObj = new JSONObject();
        for (int i = 0; i < tableDte.getRows(); i++) {
            FieldSetEntity singleFse = tableDte.getFieldSetEntity(i);
            String tableName = singleFse.getString("source_table").toLowerCase(Locale.ROOT);
            resultObj.computeIfAbsent(tableName, s -> BaseUtil.fieldSetEntityToJson(singleFse));
        }
        return resultObj;
    }

    /**
     * èŽ·å–特殊处理信息 t_wip_detail_dealt_max_id
     * @return  JSONObject ç‰¹æ®Šå¤„理信息
     */
    private JSONObject getSpDealInfo() {
        DataTableEntity dictDte = baseDao.listTable(CmnConst.PRODUCT_SYS_DICT, "dict_name=?", new Object[]{DICT_NAME_REQUEST_HISTORY});
        JSONObject resultObj = new JSONObject();
        for (int i = 0; i < dictDte.getRows(); i++) {
            FieldSetEntity singleFse = dictDte.getFieldSetEntity(i);
            String dictLabel = singleFse.getString("dict_label");
            String dictValue = singleFse.getString("dict_value");
            if ("tableFormat".equals(dictLabel)) {
                if (StringUtils.isEmpty(dictValue)) {
                    throw new BaseException(ErrorCode.REQUEST_HISTORY_SP_DEAL_FAIL_NO_TABLE_DATA.getValue(), ErrorCode.REQUEST_HISTORY_SP_DEAL_FAIL_NO_TABLE_DATA.getText() + "子库历史表格式");
                }
                resultObj.put("tableFormat", singleFse.getString("dict_value"));
            } else if ("dealTables".equals(dictLabel)) {
                if (StringUtils.isEmpty(dictValue)) {
                    throw new BaseException(ErrorCode.REQUEST_HISTORY_SP_DEAL_FAIL_NO_TABLE_DATA.getValue(), ErrorCode.REQUEST_HISTORY_SP_DEAL_FAIL_NO_TABLE_DATA.getText() + "需要处理的表名");
                }
                operateTableList = Arrays.asList(dictValue.split(","));
            } else if ("pageSize".equals(dictLabel)) {
                if (StringUtils.isEmpty(dictValue)) {
                    throw new BaseException(ErrorCode.REQUEST_HISTORY_SP_DEAL_FAIL_NO_TABLE_DATA.getValue(), ErrorCode.REQUEST_HISTORY_SP_DEAL_FAIL_NO_TABLE_DATA.getText() + "单页处理页大小");
                }
                pageSize = Integer.parseInt(dictValue);
                if (pageSize <= 0) {
                    throw new BaseException(ErrorCode.REQUEST_HISTORY_SP_DEAL_FAIL_NO_TABLE_DATA.getValue(), ErrorCode.REQUEST_HISTORY_SP_DEAL_FAIL_NO_TABLE_DATA.getText() + "正确的单页处理页大小");
                }
            } else if ("subDbIp".equals(dictLabel)) {
                if (StringUtils.isEmpty(dictValue)) {
                    throw new BaseException(ErrorCode.REQUEST_HISTORY_SP_DEAL_FAIL_NO_TABLE_DATA.getValue(), ErrorCode.REQUEST_HISTORY_SP_DEAL_FAIL_NO_TABLE_DATA.getText() + "子库地址");
                }
                subDbIp = dictValue;
            } else if ("subDbPort".equals(dictLabel)) {
                if (StringUtils.isEmpty(dictValue)) {
                    throw new BaseException(ErrorCode.REQUEST_HISTORY_SP_DEAL_FAIL_NO_TABLE_DATA.getValue(), ErrorCode.REQUEST_HISTORY_SP_DEAL_FAIL_NO_TABLE_DATA.getText() + "子库端口");
                }
                subDbPort = Integer.parseInt(dictValue);
            } else if ("reportDbIp".equals(dictLabel)) {
                if (StringUtils.isEmpty(dictValue)) {
                    throw new BaseException(ErrorCode.REQUEST_HISTORY_SP_DEAL_FAIL_NO_TABLE_DATA.getValue(), ErrorCode.REQUEST_HISTORY_SP_DEAL_FAIL_NO_TABLE_DATA.getText() + "报表库地址");
                }
                reportDbIp = dictValue;
            } else if ("reportDbPort".equals(dictLabel)) {
                if (StringUtils.isEmpty(dictValue)) {
                    throw new BaseException(ErrorCode.REQUEST_HISTORY_SP_DEAL_FAIL_NO_TABLE_DATA.getValue(), ErrorCode.REQUEST_HISTORY_SP_DEAL_FAIL_NO_TABLE_DATA.getText() + "报表库端口");
                }
                reportDbPort = Integer.parseInt(dictValue);
            } else {
                String dictLabelLowerCase = dictLabel.toLowerCase(Locale.ROOT);
                for (String tableName : operateTableList) {
                    String tablenNameLowerCase = tableName.toLowerCase(Locale.ROOT);
                    if (dictLabelLowerCase.startsWith(tablenNameLowerCase)) {
                        JSONObject singleObj = (JSONObject) resultObj.computeIfAbsent(tablenNameLowerCase, s -> new JSONObject());
                        singleObj.put(dictLabelLowerCase.replace(String.format("%s_", tablenNameLowerCase), ""), singleFse.getValue("dict_value"));
                    }
                }
            }
        }
        return resultObj;
    }

    /**
     * å¤„理子库中查询到的数据，按照月份和主键分别置于不同的容器中
     * @param singlePageDataDte         å­åº“数据
     * @param singleSubDbTableInfoObj   è¡¨ä¿¡æ¯
     * @param monthMap                  å®¹å™¨ï¼šMap<yyyyMM, <masterKey, Fse>>
     */
    private void dealSubDbData(DataTableEntity singlePageDataDte, JSONObject singleSubDbTableInfoObj, Map<String, Map<String, FieldSetEntity>> monthMap) {
        String masterKeyFieldName = singleSubDbTableInfoObj.getString("auto_field");
        String timeFieldName = singleSubDbTableInfoObj.getString("time_field");
        for (int i = 0; i < singlePageDataDte.getRows(); i++) {
            FieldSetEntity singlePageDataFse = singlePageDataDte.getFieldSetEntity(i);
            String timeStr = singlePageDataFse.getDate(timeFieldName, "yyyyMM");
            String masterValue = singlePageDataFse.getString(masterKeyFieldName);
            monthMap.computeIfAbsent(timeStr, s -> Maps.newHashMap()).put(masterValue, singlePageDataFse);
        }
    }

    /**
     * åœæ­¢
     */
    private void stop(DataBaseEntity... dbeArr) {
        if (dbeArr != null) {
            for (DataBaseEntity dbe : dbeArr) {
                if (dbe != null && dbe.getDao() != null) {
                    dbe.getDao().closeConnection();
                }
            }
        }
        processingFlag = false;
        stopFlag = false;
    }
    /*========================请求历史-final========================*/
}