• SpringEL：SpEL表达式文本转译

    目录

    1.效果展示

    2.实现方法

    在项目开发中，后端研发定义的规则表达式，由于掺杂字段定义、操作符、具体数值等，对业务运营人员比较晦涩难懂，不易理解，解释成本也比较高，为了更好将规则表达式的含义触达业务运营人员，将规则表达式转译为业务术语是一种比较好的方法，下面针对SpringEL编写的规则表达式如何进行转译提供了一种思路：

    1.效果展示

    1.     @Test
    2.     public void filterConvertComplex() {
    3.         String srcContent =
    4.                 "#data['bizRecordSource'] eq 1 and #data['paymentType'] eq 2 and ((#data['documentType'] eq 1 and #data['tradeItemType'] eq 1) or (#data['documentType'] matches '21|24' and #data['tradeItemType'] eq 6))";
    5.         String resStr = bizItemManager.convertDisplayContent(srcContent, "");
    6.         Assert.assertThat(resStr, is(
    7.                 "业务来源 = 交易履约 并且 付款方式 = 在线支付 并且 ((单据类型 = 普通销售 并且 商品行类型 = 普通商品) 或者 (单据类型 满足 (退货退款 或 仅退款) 并且 商品行类型 = 售后赠品未退回))"));
    8.  
    9.     }

    2.实现方法

    1. @Slf4j
    2. public abstract class AbstractConfigConvert {
    3.  
    4.     @Resource
    5.     private ConfigTranslateDisplayService configTranslateDisplayService;
    6.  
    7.     private Map mccFieldsMap = MccConfigUtils.getTransformDisplayOperatorFields();
    8.     private static final Pattern MATCHES_PATTERN1 = Pattern.compile("(-?\\d{1,5})((\\|)(\\-?\\d{1,5}))+");
    9.     private static final Pattern MATCHES_PATTERN2 = Pattern.compile("(\\-?\\d{1,5})(\\-)(\\-?\\d{1,5})");
    10.     private static final Pattern NUM_PATTERN = Pattern.compile("(\\-?\\d{1,5})");
    11.  
    12.     // 转译引擎
    13.     public  List convertDisplayEngine(String templateCode, List objects) {
    14.         log.info("开始进行字符串转译,templateCode = {},items = {}", templateCode, objects);
    15.         try {
    16.             // 寻找转译字段并翻译
    17.             if (!CollectionUtils.isEmpty(objects)) {
    18.                 Class clazz = objects.get(0).getClass();
    19.                 List fields = Arrays.stream(clazz.getDeclaredFields())
    20.                         .filter(field -> !field.isSynthetic() && field.getAnnotation(SwitchDisplay.class) != null)
    21.                         .collect(Collectors.toList());
    22.  
    23.                 objects = objects.stream().peek(o -> {
    24.                     for (Field field : fields) {
    25.                         field.setAccessible(true);
    26.                         SwitchDisplay switchDisplay = field.getAnnotation(SwitchDisplay.class);
    27.                         Field srcField = ReflectionUtils.findField(clazz, switchDisplay.srcFieldName());
    28.                         srcField.setAccessible(true);
    29.                         String srcContent = (String) ReflectionUtils.getField(srcField, o);
    30.                         if (StringUtils.isNotBlank(srcContent)) {
    31.                             String resContent = convertDisplayContent(srcContent, templateCode);
    32.                             log.info("转译结果：{}", resContent);
    33.                             ReflectionUtils.setField(field, o, resContent);
    34.                             // 如果不需要可以删掉
    35.                             ReflectionUtils.setField(srcField, o, resContent);
    36.                         }
    37.                     }
    38.                 }).collect(Collectors.toList());
    39.             }
    40.         } catch (Exception e) {
    41.             log.warn("过滤器转译失败,templateCode:{},objects:{}", templateCode, objects);
    42.         }
    43.         return objects;
    44.     }
    45.  
    46.     /**
    47.      * 生成转译后的展示内容
    48.      *
    49.      * @param srcContent 原始内容
    50.      * @param templateCode 模板
    51.      * @return 转移后的内容
    52.      */
    53.     public String convertDisplayContent(String srcContent, String templateCode) {
    54.         ExpressionParser parser = new SpelExpressionParser();
    55.         SpelExpression spelExpression = (SpelExpression) parser.parseExpression(srcContent);
    56.         SpelNodeImpl root = (SpelNodeImpl) spelExpression.getAST();
    57.         return travelAndTranslate(root, templateCode, srcContent);
    58.  
    59.     }
    60.  
    61.     // MCC字段转译
    62.     private String mccConfigTranslate(String mccField) {
    63.         mccField = StringUtils.isNoneBlank(mccFieldsMap.get(mccField)) ? mccFieldsMap.get(mccField) : mccField;
    64.         return mccField;
    65.     }
    66.  
    67.     /** 遍历EL表达式语义树,生成转译后的字符串 */
    68.     private String travelAndTranslate(SpelNodeImpl root, String templateCode, String srcContent) {
    69.         if (root instanceof Operator && root.getChildCount() > 1) {
    70.             Operator operator = (Operator) root;
    71.             SpelNodeImpl left = operator.getLeftOperand();
    72.             SpelNodeImpl right = operator.getRightOperand();
    73.             boolean isLeftLeaf = left instanceof CompoundExpression;
    74.             boolean isRightLeaf = right instanceof Literal || right instanceof OpMinus;
    75.             if (isLeftLeaf && isRightLeaf) {
    76.                 // 到达叶子节点
    77.                 String leftValue = (String) ((Literal) left.getChild(1).getChild(0)).getLiteralValue().getValue();
    78.                 String rightValue =
    79.                         right instanceof Literal ? String.valueOf(((Literal) right).getLiteralValue().getValue())
    80.                                 : right.toStringAST();
    81.                 // mcc转译操作符
    82.                 String operatorValue = mccConfigTranslate(operator.getOperatorName());
    83.                 String res = translateValue(leftValue, rightValue, templateCode, operatorValue);
    84.                 return replenishBrackets(res, left, right, srcContent);
    85.             }
    86.             String leftValue = travelAndTranslate((SpelNodeImpl) root.getChild(0), templateCode, srcContent);
    87.             String rightValue = travelAndTranslate((SpelNodeImpl) root.getChild(1), templateCode, srcContent);
    88.             return leftValue + " " + mccConfigTranslate(operator.getOperatorName()) + " " + rightValue;
    89.         }
    90.         return root.toStringAST();
    91.     }
    92.  
    93.     /** 转译表达式值 */
    94.     private String translateValue(String leftValue, String rightValue, String templateCode, String operatorValue) {
    95.         // 获取右边表达式集合
    96.         Map rightStringMap = regularRightExpr(rightValue);
    97.         List rightValues = (List) rightStringMap.get("rightValues");
    98.         String rightOperator = (String) rightStringMap.get("operator");
    99.         rightOperator = mccConfigTranslate(rightOperator);
    100.  
    101.         List displays;
    102.         if (CollectionUtils.isEmpty(rightValues)) {
    103.             displays = configTranslateDisplayService.queryDisplayListByFieldName(leftValue);
    104.         } else {
    105.             displays = configTranslateDisplayService.queryDisplayListByFieldNameFieldVal(leftValue, rightValues);
    106.         }
    107.         if (!CollectionUtils.isEmpty(displays)) {
    108.             List displayList = displays.stream()
    109.                     .filter(config -> config.getTemplateCode().equals(templateCode)).collect(Collectors.toList());
    110.             // 模版过滤后结果list为空，则过滤默认模版
    111.             if (CollectionUtils.isEmpty(displayList)) {
    112.                 displays =
    113.                         displays.stream()
    114.                                 .filter(configCenterTranslateDisplay -> StringUtils
    115.                                         .isEmpty(configCenterTranslateDisplay.getTemplateCode()))
    116.                                 .collect(Collectors.toList());
    117.             } else {
    118.                 displays = displayList;
    119.             }
    120.             if (displays.isEmpty()) {
    121.                 log.info("未查询到相关转译信息");
    122.                 return leftValue + " " + operatorValue + " " + rightValue;
    123.             }
    124.             leftValue = displays.get(0).getFieldDesc();
    125.  
    126.             if (!CollectionUtils.isEmpty(rightValues)) {
    127.                 if (rightValues.size() == 1) {
    128.                     rightValue = displays.get(0).getFieldValDesc();
    129.                 } else if (displays.size() < rightValues.size()) {
    130.                     // 查到转译结果数量小于要转译的数量
    131.                     rightValue = processNonCompleteFound(rightValues, displays, rightOperator);
    132.                 } else {
    133.                     rightValue = processCompleteFound(displays, rightOperator);
    134.                 }
    135.             }
    136.         }
    137.         return leftValue + " " + operatorValue + " " + rightValue;
    138.     }
    139.  
    140.     /** 补充表达式原有括号 */
    141.     private String replenishBrackets(String rawRes, SpelNodeImpl left, SpelNodeImpl right, String srcContent) {
    142.         StringBuilder res = new StringBuilder(rawRes);
    143.         // 添加左括号
    144.         for (int i = left.getStartPosition() - 1; i > -1; i--) {
    145.             if (srcContent.charAt(i) != '(') {
    146.                 break;
    147.             }
    148.             res.insert(0, '(');
    149.         }
    150.         // 添加右括号
    151.         for (int i = right.getEndPosition(); i < srcContent.length(); i++) {
    152.             if (srcContent.charAt(i) != ')') {
    153.                 break;
    154.             }
    155.             res.append(')');
    156.         }
    157.         return res.toString();
    158.     }
    159.  
    160.     /** 处理未全部查询到转译数据的情况 */
    161.     private String processNonCompleteFound(List values, List displays,
    162.             String operator) {
    163.         operator = mccConfigTranslate(operator);
    164.         if (CollectionUtils.isEmpty(displays)) {
    165.             return StringUtils.join(values, " " + operator + " ");
    166.         }
    167.         List displayValues =
    168.                 displays.stream().map(ConfigCenterTranslateDisplay::getFieldVal).collect(Collectors.toList());
    169.         values.removeAll(displayValues);
    170.         String res = joinValue(displays, operator);
    171.         return "(" + res + " " + operator + " " + StringUtils.join(values, " " + operator + " ") + ")";
    172.  
    173.     }
    174.  
    175.     /** 处理全部查询到转译数据的情况 */
    176.     private String processCompleteFound(List displays, String operator) {
    177.         return "(" + joinValue(displays, operator) + ")";
    178.     }
    179.  
    180.     /** 统一转换右侧表达式 */
    181.     private Map regularRightExpr(String rightValue) {
    182.         List rightValues = new ArrayList<>();
    183.         String operator = "|";
    184.  
    185.         Matcher m1 = MATCHES_PATTERN1.matcher(rightValue);
    186.         Matcher m2 = MATCHES_PATTERN2.matcher(rightValue);
    187.         if (m1.find()) {
    188.             // 匹配x1|x2|x3格式
    189.             Matcher numMatcher = NUM_PATTERN.matcher(rightValue);
    190.             while (numMatcher.find()) {
    191.                 rightValues.add(numMatcher.group());
    192.             }
    193.         } else if (m2.find()) {
    194.             // 匹配[a-b]格式
    195.             int leftBoundaryValue = Integer.parseInt(m2.group(1));
    196.             int rightBoundaryValue = Integer.parseInt(m2.group(3));
    197.             for (int i = leftBoundaryValue; i <= rightBoundaryValue; i++) {
    198.                 rightValues.add(String.valueOf(i));
    199.             }
    200.         } else {
    201.             rightValues.add(rightValue);
    202.         }
    203.         Map map = new HashMap<>();
    204.         map.put("rightValues", rightValues);
    205.         map.put("operator", operator);
    206.         return map;
    207.     }
    208.  
    209.     /** 拼接转译值及操作符 返回值示例: 货到付款 或 在线支付 或 帐期支付 */
    210.     private String joinValue(List displays, String operator) {
    211.         return StringUtils.join(
    212.                 displays.stream().map(ConfigCenterTranslateDisplay::getFieldValDesc).collect(Collectors.toList()),
    213.                 " " + operator + " ");
    214.     }
    215. }

    关注2点：

    1.操作符转译名称映射配置在配置中心上；

    2.字段转译映射配置在Mysql数据库中（包括字段名称描述以及关联的字段枚举值描述）

    由上，通过对SpringEL表达式抽象语法树的遍历，完成对规则表达式的转译；

  • 相关阅读:
    文件的上传和下载
    一文了解GCC（GNU C）语法
    线路位宽与 CPU 位宽
    Oracle EBS 重新打开库存会期间
    西电软件体系结构CH4：理解质量属性
    [数据可视化] 漏斗图(Funnel Chart)
    07 数据库查询（1） | OushuDB 数据库使用入门
    A tour of gRPC：08 - gRPC 反射 与 Evans 客户端
    面试题：Java中为什么只有值传递？
    Kaggle 专利匹配比赛赛后总结
  • 原文地址：https://blog.csdn.net/supzhili/article/details/133750774