系统全局参数进行编辑和获取（2021.11.5）

于 2021-11-23 15:29:08 发布
阅读量845 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 代码记录 文章标签： 缓存 java idea mysql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/SSHLY3/article/details/121491433

需求如下：

这是前端页面的一个小模块，当点击上面三个小标题时，下面会各自显示对应分值区间或阈值，我需要为其提供一个接口，根据用户点击的入参去数据库将各个数据查出来返回给前端，或者根据修改内容做入参修改对应数值更新到数据库

第三版（11.29最终版）

登录策略1	LoginPolicy    
评分周期1	IndexScoreCycle
评分权重1	IndexTypeRate
       
班组阈值345       LowIndexScore
星级评定345	   StarRating
成熟度123          DigitalMaturity

修改的入参：
[
    {
        "key": "DigitalMaturity1",
        "leftValue": "70",
        "rightValue": "79"
    },
    {
        "key": "DigitalMaturity2",
        "leftValue": "80",
        "rightValue": "89"
    },
    {
        "key": "DigitalMaturity3",
        "leftValue": "90",
        "rightValue": "100"
    }
]
查询的入参：
{
    "key":"IndexTypeRate"
}

登录策略1	LoginPolicy    
评分周期1	IndexScoreCycle
评分权重1	IndexTypeRate
       
班组阈值345       LowIndexScore
星级评定345	   StarRating
成熟度123          DigitalMaturity

之前的版本在”获取“和“修改”系统测试时，一共有四个接口(即单查、批量查、单改、批量改),发现完全可以合并为两个接口，减少冗余，于是把批量和单独的接口合并了

1.修改“获取系统参数”接口；将单独查询和批量查询的接口合并
2.修改“修改系统参数”接口；将单独修改和批量修改的接口合并
3.去掉了单独查询和修改系统参数的接口
4.完善字符串常量拟定

下面是测试结果：

代码： 

控制层：


    @ApiOperation(value = "查询参数配置", notes = "查询参数配置")
    @PostMapping("/getValues")
    @SysLog("查询参数配置")
    public R<List<ParameterGradeValueDTO>> getValues(@RequestBody ParameterDTO parameterDTO) {
        return baseService.getValueByKeys(parameterDTO);
    }


    @ApiOperation(value = "修改参数配置", notes = "修改参数配置")
    @PostMapping("/setValues")
    @SysLog("修改参数配置")
    public R<String> setValue(@RequestBody List<ParameterGradeValueDTO>parameterList) {
        return baseService.setValueByKey(parameterList);
    }

service:

   /**
     * 根据参数键查询参数值
     *
     */
    R<List<ParameterGradeValueDTO>> getValueByKeys(ParameterDTO parameterDTO);




    /**
     * 根据参数键和参数值修改参数值
     *
     * @return 参数值
     */
    R<String> setValueByKey(List<ParameterGradeValueDTO> parameterList);

serviceImpl:

@Slf4j
@Service

@RequiredArgsConstructor
public class ParameterServiceImpl extends SuperServiceImpl<ParameterMapper, Parameter> implements ParameterService {
    private final String LOW_INDEX_SCORE = "LowIndexScore";
    private final String LOW_INDEX_SCORE3 = "LowIndexScore3";
    private final String LOW_INDEX_SCORE4 = "LowIndexScore4";
    private final String LOW_INDEX_SCORE5 = "LowIndexScore5";

    private final String STAR_RATING = "StarRating";
    private final String STAR_RATING3 = "StarRating3";
    private final String STAR_RATING4 = "StarRating4";
    private final String STAR_RATING5 = "StarRating5";

    private final String DIGITAL_MATURITY = "DigitalMaturity";
    private final String DIGITAL_MATURITY1 = "DigitalMaturity1";
    private final String DIGITAL_MATURITY2 = "DigitalMaturity2";
    private final String DIGITAL_MATURITY3 = "DigitalMaturity3";

    private final String INDEX_TYPE_RATE = "IndexTypeRate";
    private final String INDEX_SCORE_CYCLE = "IndexScoreCycle";
    private final String LOGIN_POLICY = "LoginPolicy";

@Override
    public R<List<ParameterGradeValueDTO>> getValueByKeys(ParameterDTO parameterDTO) {
        String msg;
        List<ParameterGradeValueDTO> list = new ArrayList<>();
        String key = parameterDTO.getKey();


        String[] arr = new String[2];
        if (LOW_INDEX_SCORE.equals(key)) {

            String LowIndexScore3 = getObj(
                    Wraps.<Parameter>lbQ().select(Parameter::getValue).eq(Parameter::getKey, LOW_INDEX_SCORE3),
                    Convert::toStr
            );
            ParameterGradeValueDTO parameterGradeValueDTO1 = new ParameterGradeValueDTO();
            parameterGradeValueDTO1.setName(LOW_INDEX_SCORE3);
            parameterGradeValueDTO1.setLeftValue(LowIndexScore3);
            list.add(parameterGradeValueDTO1);
            String LowIndexScore4 = getObj(
                    Wraps.<Parameter>lbQ().select(Parameter::getValue).eq(Parameter::getKey, LOW_INDEX_SCORE4),
                    Convert::toStr
            );
            ParameterGradeValueDTO parameterGradeValueDTO2 = new ParameterGradeValueDTO();
            parameterGradeValueDTO2.setName(LOW_INDEX_SCORE4);
            parameterGradeValueDTO2.setLeftValue(LowIndexScore4);
            list.add(parameterGradeValueDTO2);
            String LowIndexScore5 = getObj(
                    Wraps.<Parameter>lbQ().select(Parameter::getValue).eq(Parameter::getKey, LOW_INDEX_SCORE5),
                    Convert::toStr
            );
            ParameterGradeValueDTO parameterGradeValueDTO3 = new ParameterGradeValueDTO();
            parameterGradeValueDTO3.setName(LOW_INDEX_SCORE5);
            parameterGradeValueDTO3.setLeftValue(LowIndexScore5);
            list.add(parameterGradeValueDTO3);
            return R.success(list);
        } else if (STAR_RATING.equals(key)) {
            String StarRating = getObj(
                    Wraps.<Parameter>lbQ().select(Parameter::getValue).eq(Parameter::getKey, STAR_RATING3),
                    Convert::toStr
            );

            arr = StarRating.split(",");
            ParameterGradeValueDTO parameterGradeValueDTO1 = new ParameterGradeValueDTO();
            parameterGradeValueDTO1.setLeftValue(arr[0]);
            parameterGradeValueDTO1.setRightValue(arr[1]);
            parameterGradeValueDTO1.setName(STAR_RATING3);
            list.add(parameterGradeValueDTO1);
            StarRating = getObj(
                    Wraps.<Parameter>lbQ().select(Parameter::getValue).eq(Parameter::getKey, STAR_RATING4),
                    Convert::toStr
            );
            arr = StarRating.split(",");
            ParameterGradeValueDTO parameterGradeValueDTO2 = new ParameterGradeValueDTO();
            parameterGradeValueDTO2.setLeftValue(arr[0]);
            parameterGradeValueDTO2.setRightValue(arr[1]);
            parameterGradeValueDTO2.setName(STAR_RATING4);
            list.add(parameterGradeValueDTO2);
            StarRating = getObj(
                    Wraps.<Parameter>lbQ().select(Parameter::getValue).eq(Parameter::getKey, STAR_RATING5),
                    Convert::toStr
            );
            arr = StarRating.split(",");
            ParameterGradeValueDTO parameterGradeValueDTO3 = new ParameterGradeValueDTO();
            parameterGradeValueDTO3.setLeftValue(arr[0]);
            parameterGradeValueDTO3.setRightValue(arr[1]);
            parameterGradeValueDTO3.setName(STAR_RATING5);
            list.add(parameterGradeValueDTO3);
            return R.success(list);
        } else if (DIGITAL_MATURITY.equals(key)) {//   private final String DIGITAL_MATURITY1 = "DigitalMaturity1";
            String DigitalMaturity = getObj(
                    Wraps.<Parameter>lbQ().select(Parameter::getValue).eq(Parameter::getKey, DIGITAL_MATURITY1),
                    Convert::toStr
            );
            arr = DigitalMaturity.split(",");
            ParameterGradeValueDTO parameterGradeValueDTO1 = new ParameterGradeValueDTO();
            parameterGradeValueDTO1.setLeftValue(arr[0]);
            parameterGradeValueDTO1.setRightValue(arr[1]);
            parameterGradeValueDTO1.setName(DIGITAL_MATURITY1);
            list.add(parameterGradeValueDTO1);
            DigitalMaturity = getObj(
                    Wraps.<Parameter>lbQ().select(Parameter::getValue).eq(Parameter::getKey, DIGITAL_MATURITY2),
                    Convert::toStr
            );
            arr = DigitalMaturity.split(",");
            ParameterGradeValueDTO parameterGradeValueDTO2 = new ParameterGradeValueDTO();
            parameterGradeValueDTO2.setLeftValue(arr[0]);
            parameterGradeValueDTO2.setRightValue(arr[1]);
            parameterGradeValueDTO2.setName(DIGITAL_MATURITY2);
            list.add(parameterGradeValueDTO2);
            DigitalMaturity = getObj(
                    Wraps.<Parameter>lbQ().select(Parameter::getValue).eq(Parameter::getKey, DIGITAL_MATURITY3),
                    Convert::toStr
            );
            arr = DigitalMaturity.split(",");
            ParameterGradeValueDTO parameterGradeValueDTO3 = new ParameterGradeValueDTO();
            parameterGradeValueDTO3.setLeftValue(arr[0]);
            parameterGradeValueDTO3.setRightValue(arr[1]);
            parameterGradeValueDTO3.setName(DIGITAL_MATURITY3);
            list.add(parameterGradeValueDTO3);
            return R.success(list);
        } else if (INDEX_TYPE_RATE.equals(key) || INDEX_SCORE_CYCLE.equals(key) || LOGIN_POLICY.equals(key)) {

            String value = getObj(Wraps.<Parameter>lbQ().select(Parameter::getValue).eq(Parameter::getKey, key), Convert::toStr);
            if (null == value) {
                return R.fail("获取失败");
            }
            ParameterGradeValueDTO parameterGradeValueDTO4 = new ParameterGradeValueDTO();
            parameterGradeValueDTO4.setKey(key);
            parameterGradeValueDTO4.setLeftValue(value);
            list.add(parameterGradeValueDTO4);
            return R.success(list);

        } else {
            msg = "请输入正确的参数值";
            log.error(msg);
            return R.fail(msg);
        }
    }


    @Override
    public R<String> setValueByKey(List<ParameterGradeValueDTO> parameterList) {

        String msg;
        if (parameterList.size() == 3) {
            String key1 = parameterList.get(0).getKey();
            String key2 = parameterList.get(1).getKey();
            String key3 = parameterList.get(2).getKey();


            if (LOW_INDEX_SCORE3.equals(key1)) {
                String value = parameterList.get(0).getLeftValue();
                String value2 = parameterList.get(1).getLeftValue();
                String value3 = parameterList.get(2).getLeftValue();
                int value1code = Integer.valueOf(value);
                int value2code = Integer.valueOf(value2);
                int value3code = Integer.valueOf(value3);

                if (value1code >= value2code || value2code > value3code) {
                    return R.fail("阈值异常，请按数值大小规范填写");
                } else if (value1code == 0 || value3code != 100) {
                    return R.fail("阈值异常，最低分不能为0，最高分必须为100");
                }

                Long parameterId1 = getId(key1);  //获取主键id
                Parameter parameter = baseMapper.selectById(parameterId1);

                parameter.setValue(value);
                if (1 != baseMapper.updateById(parameter)) {
                    msg = "修改失败";
                    log.error(msg);
                    return R.fail(msg);
                }

                Long parameterId2 = getId(key2); //获取主键id
                Parameter parameter2 = baseMapper.selectById(parameterId2);

                parameter2.setValue(value2);
                if (1 != baseMapper.updateById(parameter2)) {
                    return R.fail("修改失败");
                }

                Long parameterId3 = getId(key3); //获取主键id
                Parameter parameter3 = baseMapper.selectById(parameterId3);

                parameter3.setValue(value3);
                if (1 != baseMapper.updateById(parameter3)) {
                    return R.fail("修改失败");
                }
                return R.success("成功");


            } else if (STAR_RATING3.equals(key1) || DIGITAL_MATURITY1.equals(key1)) {
                String valueL1 = parameterList.get(0).getLeftValue();
                String valueR1 = parameterList.get(0).getRightValue();

                String valueL2 = parameterList.get(1).getLeftValue();
                String valueR2 = parameterList.get(1).getRightValue();

                String valueL3 = parameterList.get(2).getLeftValue();
                String valueR3 = parameterList.get(2).getRightValue();

                int valueL1code = Integer.valueOf(valueL1);
                int valueR1code = Integer.valueOf(valueR1);

                int valueL2code = Integer.valueOf(valueL2);
                int valueR2code = Integer.valueOf(valueR2);

                int valueL3code = Integer.valueOf(valueL3);
                int valueR3code = Integer.valueOf(valueR3);

                if (null == valueL1 || null == valueR1 || null == valueL2 || null == valueR2 || null == valueL3 || null == valueR3) {
                    return R.fail("参数不正确,不能为空，且必须有两个");

                } else if (valueL1code >= valueR1code || valueL2code > valueR2code || valueL3code > valueR3code) {
                    return R.fail("参数不正确,左值必须大于右值");

                } else if (valueR1code >= valueL2code || valueR2code >= valueL3code) {
                    return R.fail("参数不正确,数据重叠");

                } else if (valueR3code != 100) {
                    return R.fail("参数不正确,最高分必须为100");
                }

                Long parameterId1 = getId(key1);
                Parameter parameter1 = baseMapper.selectById(parameterId1);

                parameter1.setValue(valueL1 + "," + valueR1);
                if (1 != baseMapper.updateById(parameter1)) {
                    msg = "修改失败";
                    log.error(msg);
                    return R.fail(msg);
                }

                Long parameterId2 = getId(key2);
                Parameter parameter2 = baseMapper.selectById(parameterId2);
                parameter2.setValue(valueL2 + "," + valueR2);
                if (1 != baseMapper.updateById(parameter2)) {
                    msg = "修改失败";
                    log.error(msg);
                    return R.fail(msg);
                }

                Long parameterId3 = getId(key3);
                Parameter parameter3 = baseMapper.selectById(parameterId3);
                parameter3.setValue(valueL3 + "," + valueR3);
                if (1 != baseMapper.updateById(parameter3)) {
                    msg = "修改失败";
                    log.error(msg);
                    return R.fail(msg);
                }
                return R.success("成功");
            } else {
                msg = "参数值错误";
                log.error(msg);
                return R.fail(msg);
            }

        } else if (parameterList.size() == 1) {
            ParameterGradeValueDTO parameterGradeValueDTO = parameterList.get(0);

            String key = parameterGradeValueDTO.getKey();
            String valueL = parameterGradeValueDTO.getLeftValue();
            String valueR = parameterGradeValueDTO.getRightValue();

            long time = System.currentTimeMillis();
            SimpleDateFormat dateFormat = new SimpleDateFormat("YYYY");
            String day = dateFormat.format(time);

                //权重
            if (INDEX_TYPE_RATE.equals(key)) {
                int valueLeft = Integer.valueOf(valueL);
                int valueRight = Integer.valueOf(valueR);
                if (null == valueL || null == valueR) {
                    msg = "参数不正确,必须有两个";
                    log.error(msg);
                    return R.fail(msg);
                } else if (valueLeft < 0 || valueRight < 0 || valueRight + valueLeft != 100) {
                    msg = "参数不正确，两值必须在0~100之间，且之和为100";
                    log.error(msg);
                    return R.fail(msg);
                }

                //周期
            } else if (INDEX_SCORE_CYCLE.equals(key)) {
                if (null == valueL || !valueL.matches("[0-9]{4}") || Integer.valueOf(valueL) > Integer.valueOf(day)) {
                    msg = "参数不正确";
                    log.error(msg);
                    return R.fail(msg);
                }

                //登录策略
            } else if (LOGIN_POLICY.equals(key)) {
                if (null == valueL) {
                    msg = "参数不正确";
                    log.error(msg);
                    return R.fail(msg);
                }
            } else {
                msg = "参数不正确";
                log.error(msg);
                return R.fail(msg);
            }
            Long parameterId = getId(key);
            Parameter parameter = baseMapper.selectById(parameterId);

            if (INDEX_TYPE_RATE.equals(key)) { //权重
                parameter.setValue(valueL + "," + valueR);
            } else {
                parameter.setValue(valueL);
            }
            if (1 != baseMapper.updateById(parameter)) {
                msg = "修改失败";
                log.error(msg);
                return R.fail(msg);
            } else {
                return R.success("修改成功");
            }
        } else {
            msg = "参数值错误";
            log.error(msg);
            return R.fail(msg);
        }

    }


    /**
     * 根据参数键和参数值获取对应主键id
     *
     * @return 参数值
     */
    public Long getId(String keys) {
        return getObj(Wraps.<Parameter>lbQ().select(Parameter::getId).eq(Parameter::getKey, keys), Convert::toLong);
    }

第二版( )

之前的版本和前端对接后察觉不太合理，效率太低，比如查一个弱项指标阈值需要查三次，修改也得一个一个改，于是提取集成了批量查、改接口，即入参是这三个大标题（弱项指标阈值，星级评定，数字化成熟度）

测试效果

单值获取测试

 

 

 三值修改入参合法判定

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值