计算准确率通用方法修改

src/main/java/com/syjy/calculate/conotroller/test.java

@@ -2,9 +2,9 @@ package com.syjy.calculate.conotroller;
 
 import com.syjy.calculate.service.AccuarcyPassRateCalculateService;
 import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RestController;
+
 import java.math.BigDecimal;
 import java.util.*;
 
@@ -13,10 +13,11 @@ import java.util.*;
 public class test {
     @Autowired
     private AccuarcyPassRateCalculateService accuarcyPassRateCalculateService;
-    @RequestMapping (value = "/test")
+
+    @RequestMapping(value = "/test")
     public void saveElectricField() {
 
-        List<Map<String, Object>> powerData  = new ArrayList<>();
+        List<Map<String, Object>> powerData = new ArrayList<>();
         Random rd = new Random();
         for (int i = 0; i < 4; i++) {
             Map<String, Object> dataText = new HashMap<>();
@@ -25,11 +26,11 @@ public class test {
             powerData.add(dataText);
         }
 
-        BigDecimal rl  = new BigDecimal("10");
+        BigDecimal rl = new BigDecimal("10");
         String provinceEnum = "E62";
         String type = "DQ";
 
-        accuarcyPassRateCalculateService.calculate(powerData,rl,provinceEnum,type);
+        accuarcyPassRateCalculateService.calculate(powerData, rl, provinceEnum, type);
     }
 
 }

src/main/java/com/syjy/calculate/repository/CalculationFormulaRepository.java

@@ -2,6 +2,7 @@ package com.syjy.calculate.repository;
 
 import com.syjy.calculate.entity.CalculationFormula;
 import org.springframework.stereotype.Repository;
+
 import java.util.List;
 
 @Repository
@@ -9,34 +10,37 @@ public interface CalculationFormulaRepository {
 
     /**
      * 保存公式数据
+     *
      * @param calculationFormula 单条公式记录
      */
     void save(CalculationFormula calculationFormula);
 
     /**
      * 更新数据
+     *
      * @param calculationFormula 公式记录
      */
     void update(CalculationFormula calculationFormula);
 
     /**
      * 查询数据
+     *
      * @param province 省调
-     * @param type 类型
+     * @param type     类型
      * @return 返回记录
      */
-    List<CalculationFormula> findByTypeAndProvince(String province,String type );
-
+    List<CalculationFormula> findByTypeAndProvince(String province, String type);
 
     /**
      * 查询变量数据
+     *
      * @return 返回记录
      */
     List<CalculationFormula> findVariate(String provinceEnum);
 
-
     /**
      * 查询全部数据
+     *
      * @return 返回全部记录
      */
     List<CalculationFormula> findAll();

src/main/java/com/syjy/calculate/repository/repositoryImpl/CalculationFormulaRepositoryImpl.java

@@ -27,14 +27,14 @@ public class CalculationFormulaRepositoryImpl implements CalculationFormulaRepos
 
     @Override
     public List<CalculationFormula> findByTypeAndProvince( String province, String type) {
-        String sql = "SELECT * from t_calculation_formula where C_PROVINCE_ENUM = ? and C_TYPE = ? ";
+        String sql = "SELECT * from t_calculation_formula where PROVINCE_ENUM = ? and TYPE = ? ";
         List<CalculationFormula> calculationFormulaList = jdbcTemplate.query(sql,new BeanPropertyRowMapper<>(CalculationFormula.class),province,type);
         return calculationFormulaList;
     }
 
     @Override
     public List<CalculationFormula> findVariate(String provinceEnum) {
-        String sql = "SELECT * from t_calculation_formula where C_TYPE in ('VariateA','VariateB','VariateC') and C_PROVINCE_ENUM = ?";
+        String sql = "SELECT * from t_calculation_formula where TYPE in ('VariateA','VariateB','VariateC') and PROVINCE_ENUM = ?";
         List<CalculationFormula> calculationFormulaList = jdbcTemplate.query(sql,new BeanPropertyRowMapper<>(CalculationFormula.class),provinceEnum);
         return calculationFormulaList;
     }

src/main/java/com/syjy/calculate/service/AccuarcyPassRateCalculateService.java

@@ -6,6 +6,7 @@ import com.syjy.calculate.repository.CalculationFormulaRepository;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
+
 import java.math.BigDecimal;
 import java.util.ArrayList;
 import java.util.HashMap;
@@ -14,6 +15,7 @@ import java.util.Map;
 
 /**
  * 计算准确率
+ *
  * @author zcl
  * @version 1.0
  * @since 2022/8/8 9:30
@@ -21,127 +23,148 @@ import java.util.Map;
 @Service
 @Slf4j
 public class AccuarcyPassRateCalculateService {
-  BigDecimal ZERO = new BigDecimal("0");
+    BigDecimal ZERO = new BigDecimal("0");
 
-  @Autowired
-  private CalculationFormulaRepository calculationFormulaRepository;
+    @Autowired
+    private CalculationFormulaRepository calculationFormulaRepository;
 
-  /**
-   *
-   * @param powerData 功率相关数据 Map中必要字段：sj(实际功率)、yc(预测功率)
-   * @param rl 容量
-   * @param provinceEnum 省调
-   * @param type 短期、超短期
-   * @return
-   */
-  public String calculate( List<Map<String, Object>> powerData , BigDecimal rl ,String provinceEnum,String type){
-    String result;
-    // 获取公式
-    List<CalculationFormula> calculationFormulaList = getCalculationFormulaData(provinceEnum, type);
-    // 获取当前省调的公式变量值
-    Map<String, String> variateMap = getVariate(provinceEnum);
-    // 存放每步计算结果
-    Map<String, Object> resultMap = new HashMap<>();
-    // 公式
-    String formula;
-    // 循环公式，依次执行公式
-    for (CalculationFormula calculationFormula : calculationFormulaList) {
-      BigDecimal formulaResult = ZERO;
-      // 获取公式
-      formula = calculationFormula.getFormula();
-      // 如果包含求和，则进行循环求和计算
-      if (formula.contains("sum")) {
-        // 获取sum后面的公式
-        formula = formula.split(":")[1];
-        formula = replaceFormula(formula,variateMap);
-        // 循环执行sum后的公式
-        for (Map<String, Object> dataMap : powerData) {
-          // 将执行过的公式结果放入dataMap
-          dataMap.putAll(resultMap);
-          dataMap.put("rl",rl);
-          try {
-            // 求和计算 AviatorEvaluator.execute(公式，公式中的参数及值(以Map形式存放))
-            formulaResult = formulaResult.add(new BigDecimal(String.valueOf(AviatorEvaluator.execute(formula, dataMap))));
-          } catch (Exception e) {
-            e.printStackTrace();
-            log.error("计算公式:" + formula + "错误:" + e.toString());
-          }
-          log.info("计算公式：" + formula + ";计算结果：" + formulaResult);
-        }
-        // 非求和计算
-      }else{
-        if(powerData.size()>0){
-          // 获取数据
-          Map<String, Object> dataMap = powerData.get(0);
-          // 将执行过的公式结果放入dataMap
-          dataMap.putAll(resultMap);
-          // 根据公式进行计算
-          formulaResult = new BigDecimal(String.valueOf(AviatorEvaluator.execute(formula, dataMap)));
+    /**
+     * @param powerData    功率相关数据 Map中必要字段：sj(实际功率)、yc(预测功率)
+     * @param rl           容量
+     * @param provinceEnum 省调
+     * @param type         短期、超短期
+     * @return
+     */
+    public String calculate(List<Map<String, Object>> powerData, BigDecimal rl, String provinceEnum, String type) {
+        String result;
+        // 获取公式
+        List<CalculationFormula> calculationFormulaList = getCalculationFormulaData(provinceEnum, type);
+        // 获取当前省调的公式变量值
+        Map<String, String> variateMap = getVariate(provinceEnum);
+        // 存放每步计算结果
+        Map<String, Object> resultMap = new HashMap<>();
+        // 公式
+        String formula;
+        // 循环公式，依次执行公式
+        for (CalculationFormula calculationFormula : calculationFormulaList) {
+            BigDecimal formulaResult = ZERO;
+            // 获取公式
+            formula = calculationFormula.getFormula();
+            // 如果包含求和，则进行循环求和计算
+            if (formula.contains("sum")) {
+                // 获取sum后面的公式
+                formula = formula.split(":")[1];
+                formula = replaceFormula(formula, variateMap);
+                // 循环执行sum后的公式
+                for (Map<String, Object> dataMap : powerData) {
+                    // 将执行过的公式结果放入dataMap
+                    dataMap.putAll(resultMap);
+                    dataMap.put("rl", rl);
+                    try {
+                        // 求和计算 AviatorEvaluator.execute(公式，公式中的参数及值(以Map形式存放))
+                        formulaResult = formulaResult.add(new BigDecimal(String.valueOf(AviatorEvaluator.execute(formula, dataMap))));
+                    } catch (Exception e) {
+                        e.printStackTrace();
+                        log.error("计算公式:" + formula + "错误:" + e.toString());
+                    }
+                }
+                // 非求和计算
+            } else {
+                formula = replaceFormula(formula, variateMap);
+                if (powerData.size() > 0) {
+                    // 获取数据
+                    Map<String, Object> dataMap = powerData.get(0);
+                    // 将执行过的公式结果放入dataMap
+                    dataMap.putAll(resultMap);
+                    try {
+                        // 根据公式进行计算
+                        formulaResult = new BigDecimal(String.valueOf(AviatorEvaluator.execute(formula, dataMap)));
+                    } catch (Exception e) {
+                        e.printStackTrace();
+                        log.error("计算公式:" + formula + "错误:" + e.toString());
+                    }
+                }
+            }
+            // 记录本次公式的计算结果
+            resultMap.put("result" + calculationFormula.getOrder(), formulaResult);
+            log.info("result" + calculationFormula.getOrder() + ":" + formulaResult);
         }
-      }
-      // 记录本次公式的计算结果
-      resultMap.put("result" + calculationFormula.getOrder(), formulaResult);
-      System.out.println(formulaResult);
+        // 获取最后一个公式计算的结果
+        result = String.valueOf(resultMap.get("result" + calculationFormulaList.size()));
+        BigDecimal bResult = new BigDecimal(result);
+        bResult = bResult.setScale(2, BigDecimal.ROUND_HALF_UP);
+        result = bResult + "%";
+        return result;
     }
-    // 获取最后一个公式计算的结果
-    result = resultMap.get("result" + calculationFormulaList.size()) + "%";
-    return result;
-  }
 
-  /**
-   * 获取当前省调的公式列表
-   * @param provinceEnum 当前省调
-   * @param type 类型(短期、超短期)
-   * @return
-   */
-  public List<CalculationFormula> getCalculationFormulaData(String provinceEnum, String type) {
-    List<CalculationFormula> calculationFormulaList = new ArrayList<>();
-    // 根据当前省调和类型(短期、超短期)从数据库中查出公式列表
-     calculationFormulaList = calculationFormulaRepository.findByTypeAndProvince(provinceEnum,type);
-    return calculationFormulaList;
-  }
+    /**
+     * 获取当前省调的公式列表
+     *
+     * @param provinceEnum 当前省调
+     * @param type         类型(短期、超短期)
+     * @return
+     */
+    public List<CalculationFormula> getCalculationFormulaData(String provinceEnum, String type) {
+        List<CalculationFormula> calculationFormulaList = new ArrayList<>();
+        // 根据当前省调和类型(短期、超短期)从数据库中查出公式列表
+        calculationFormulaList = calculationFormulaRepository.findByTypeAndProvince(provinceEnum, type);
+        return calculationFormulaList;
+    }
 
-  /**
-   * 获取当前省调的公式变量值
-   * @param provinceEnum 当前省调
-   * @return
-   */
-  public Map<String, String> getVariate(String provinceEnum) {
-    List<CalculationFormula> variateList = new ArrayList<>();
-    Map<String, String> variateMap = new HashMap<>();
-    // 从数据库中查出变量数据
-    variateList = calculationFormulaRepository.findVariate(provinceEnum);
-    // 循环组建变量Map
-    String formulaType = "";
-    for (CalculationFormula calculationFormula: variateList) {
-      formulaType = calculationFormula.getType();
-      // 循环获取3个变量的值
-      switch (formulaType) {
-        case "VariateA":
-          variateMap.put("VariateA", calculationFormula.getFormula());
-          break;
-        case "VariateB":
-          variateMap.put("VariateB", calculationFormula.getFormula());
-          break;
-        case "VariateC":
-          variateMap.put("VariateC", calculationFormula.getFormula());
-          break;
-        default:
-          break;
-      }
+    /**
+     * 获取当前省调的公式变量值
+     *
+     * @param provinceEnum 当前省调
+     * @return
+     */
+    public Map<String, String> getVariate(String provinceEnum) {
+        List<CalculationFormula> variateList = new ArrayList<>();
+        Map<String, String> variateMap = new HashMap<>();
+        // 从数据库中查出变量数据
+        variateList = calculationFormulaRepository.findVariate(provinceEnum);
+        // 循环组建变量Map
+        String formulaType = "";
+        for (CalculationFormula calculationFormula : variateList) {
+            formulaType = calculationFormula.getType();
+            // 循环获取3个变量的值
+            switch (formulaType) {
+                case "VariateA":
+                    variateMap.put("VariateA", calculationFormula.getFormula());
+                    break;
+                case "VariateB":
+                    variateMap.put("VariateB", calculationFormula.getFormula());
+                    break;
+                case "VariateC":
+                    variateMap.put("VariateC", calculationFormula.getFormula());
+                    break;
+                default:
+                    break;
+            }
+        }
+        return variateMap;
     }
-    return variateMap;
-  }
 
-  /**
-   * 将公式中的变量进行替换
-   * @param formula
-   * @param variateMap
-   * @return
-   */
-  public String replaceFormula(String formula, Map<String,String> variateMap) {
-    formula = formula.replace("VariateA", variateMap.get("variateMap")).replace("VariateB", variateMap.get("VariateB")).replace("VariateC", variateMap.get("VariateC"));
-    return formula;
-  }
+    /**
+     * 将公式中的变量进行替换
+     *
+     * @param formula
+     * @param variateMap
+     * @return
+     */
+    public String replaceFormula(String formula, Map<String, String> variateMap) {
+        String variateA = variateMap.get("VariateA");
+        String variateB = variateMap.get("VariateB");
+        String variateC = variateMap.get("VariateC");
+        if (variateA != null) {
+            formula = formula.replace("VariateA", variateA);
+        }
+        if (variateB != null) {
+            formula = formula.replace("VariateB", variateB);
+        }
+        if (variateC != null) {
+            formula = formula.replace("VariateC", variateC);
+        }
+        return formula;
+    }
 
 }