可配置化的表达式解析以及构造JSON查询数据库实体数据的设计和实现

已于 2022-06-17 11:13:09 修改
阅读量1.1k 收藏 3
点赞数 1
CC 4.0 BY-SA版权
分类专栏： Java 文章标签： json 前端 spring boot
于 2022-06-17 10:55:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/cckevincyh/article/details/125329588
本文档详细介绍了如何实现可配置的表达式解析，通过前端配置的表达式和数据，构造JSON查询数据库实体数据。利用栈数据结构解析如1AND(2OR3)的表达式，确保表达式的正确性和完整性，并通过校验避免冲突。最后，通过后端将解析后的JSON用于查询数据库，实现类似SQL的动态查询功能。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

文章目录

可配置化的表达式解析以及构造JSON查询数据库实体数据的设计和实现

之前的博文《使用Spring Boot JPA Specification实现使用JSON数据来查询实体数据》和《使用Druid SQL Parser解析SQL》中都讲到了目前业务上的需求就是以前老系统是通过配置SQL去抽取一些业务数据的，但现在新系统想通过页面的一些配置化实现跟配置SQL一样去抽取数据。

之前的后端实现逻辑已经在之前《使用Spring Boot JPA Specification实现使用JSON数据来查询实体数据》的博文中讲解了，本篇博文主要是结合前端去实现。

最终前端的可配置效果如下：

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

就是前端可以选择具体的哪些字段进行过滤，然后过滤的操作符是什么，过滤的值是什么，然后是否对当前的操作取反，比如当前的操作符如果是=,取反设置为Yes，这表示!=。然后在最下方的组合方面，可以对上面表格中的数据进行and或者or的组合，或者使用自定义的组合方式。

前端是用React写的，具体页面怎么实现这里不是重点，我们重点在于前端数据与后端交互，以及后端如何根据前端给出来的数据，构造出我们想要的json结构，然后通过之前后端实现的功能，用这个json去查询数据库实体数据。

前端传入到后端的数据其实包含两部分，一部分就是expression表达式，也就是上面的(1 AND 2) OR 3，上面的1,2,3表示的是表格中的序号，然后第二部分就是表格中的数据会以一个list数组的方式给后端。然后后端会根据表达式和整个list数组构造出来json

可配置化的表达式解析

首先在我们之前的博文说过，conditionDTO对象的json结构是如下的：

{
    "conditions": [{
        "conditions": [{
            "conditions": [],
            "operation": null,
            "conditionExpression": {
                "type": "STRING",
                "column": "name",
                "operateExpression": "=",
                "not": false,
                "operateValue": ["test"]

            }
    }, {
            "conditions": [],
            "operation": null,
            "conditionExpression": {
                "type": "NUMBER",
                "column": "age",
                "operateExpression": "=",
                "not": false,
                "operateValue": ["14"],
                "dateformat": null,
                "dateFormatFunction": null
            }
    }],
        "operation": "OR"
    }, {
        "conditions": [],
        "operation": null,
        "conditionExpression": {
            "type": "NUMBER",
            "column": "id",
            "operateExpression": "=",
            "not": false,
            "operateValue": ["1"]
        }
    }],
    "operation": "AND",
    "conditionExpression": null
}

假设我们现在有一个表达式1 AND (2 OR 3) , 其中1,2,3 是也是表达式，比如表达式1可能就是上面的json条件的name='test'

所以表达式1是一个ConditionDTO对象, 表达式(2 OR 3)也是一个ConditionDTO，只不过是组合起来的ConditionDTO对昂, 表达式1 AND (2 OR 3)也一样是一个ConditionDTO对象, 这不过它是一个更加复杂的组合。

生成出来的ConditionDTO会类似于:

{
    "conditions": [{
            "conditions": [],
            "operation": null,
            "conditionExpression": {
                "type": "STRING",
                "column": "1",
                "operateExpression": "=",
                "not": false,
                "operateValue": ["1"],
                "dateformat": null,
                "dateFormatFunction": null
            }
    },
        {
            "conditions": [{
                "conditions": [],
                "operation": null,
                "conditionExpression": {
                    "type": "STRING",
                    "column": "2",
                    "operateExpression": "=",
                    "not": false,
                    "operateValue": ["2"],
                    "dateformat": null,
                    "dateFormatFunction": null
                }
    }, {
                "conditions": [],
                "operation": null,
                "conditionExpression": {
                    "type": "STRING",
                    "column": "3",
                    "operateExpression": "=",
                    "not": false,
                    "operateValue": ["3"],
                    "dateformat": null,
                    "dateFormatFunction": null
                }
    }],
            "operation": "OR",
            "conditionExpression": null

    }],
    "operation": "AND",
    "conditionExpression": null
}

在这里插入图片描述

所以我们现在要做的就是如何去解析这样的一个表达式 1 AND (2 OR 3)

我们这里会用到栈这种数据结构来解析表达式，栈内的每一个数据，我们都把他看成一个表达式，也就是一个ConditionDTO对象

  1. 第一步我们先会预处理表达式，去掉表达式多余的空格，给表达式两边加入左右括号，通过空格隔断我们的表达式，上面的表达式在预处理之后会最终会变成( 1 AND ( 2 OR 3 ) )，然后我们通过空格把我们的表达式split分解成数组[(, 1,AND, (, 2, OR, 3,) ,)]

  2. 第二步我们会用到栈来解析表达式，我们会把上述的数组一个个入栈，当遇到右括号)的时候就开始把栈内的数据弹出，直到遇到左括号(后停止， 取出来的这部分的数据(2 OR 3)其实就是一个组合的表达式，我们就需要这个组合的表达式构造成一个新的ConditionDTO，然后再重新放入栈中，然后继续把数组剩余的数据入栈…

下面我们通过图解的方式来看看：

我们先把[(, 1,AND, (, 2, OR, 3,) ,)]的数据入栈

在这里插入图片描述

当我们遇到了右括号)这个时候就开始弹出栈顶元素，直到遇到左括号(。于是就取出来了(2 OR 3), 这个时候就会把(2 OR 3)组合成一个新的conditionDTO对象，也就是把表达式2和表达式3用OR来组合，然后变成一个新的表达式,于是变成这样一个json

{
    "conditions": [{
        "conditions": [],
        "operation": null,
        "conditionExpression": {
            "type": "STRING",
            "column": "2",
            "operateExpression": "=",
            "not": false,
            "operateValue": ["2"],
            "dateformat": null,
            "dateFormatFunction": null
        }
    }, {
        "conditions": [],
        "operation": null,
        "conditionExpression": {
            "type": "STRING",
            "column": "3",
            "operateExpression": "=",
            "not": false,
            "operateValue": ["3"],
            "dateformat": null,
            "dateFormatFunction": null
        }
    }],
    "operation": "OR",
    "conditionExpression": null

}

然后在把这个构造出来的新对象放回到栈中。

在这里插入图片描述

然后我们继续[(, 1,AND, (, 2, OR, 3,) ,)]中剩余的数据入栈

在这里插入图片描述

这个时候又遇到了)，于是就会弹出来(1 AND '(2 OR 3)'). 这个时候就把1 和之前(2 OR 3)构造出来的新对象用AND组合，形成一个新的对象，也就是变成上面最终的json

{
    "conditions": [{
            "conditions": [],
            "operation": null,
            "conditionExpression": {
                "type": "STRING",
                "column": "1",
                "operateExpression": "=",
                "not": false,
                "operateValue": ["1"],
                "dateformat": null,
                "dateFormatFunction": null
            }
    },
        {
            "conditions": [{
                "conditions": [],
                "operation": null,
                "conditionExpression": {
                    "type": "STRING",
                    "column": "2",
                    "operateExpression": "=",
                    "not": false,
                    "operateValue": ["2"],
                    "dateformat": null,
                    "dateFormatFunction": null
                }
    }, {
                "conditions": [],
                "operation": null,
                "conditionExpression": {
                    "type": "STRING",
                    "column": "3",
                    "operateExpression": "=",
                    "not": false,
                    "operateValue": ["3"],
                    "dateformat": null,
                    "dateFormatFunction": null
                }
    }],
            "operation": "OR",
            "conditionExpression": null

    }],
    "operation": "AND",
    "conditionExpression": null
}

然后继续放回去栈顶，那此刻栈顶唯一的那个元素就是我们最后构造出来的conditionDTO对象了。

在这里插入图片描述

然后我们就可以通过这个conditionDTO对象去查询我们的数据库实体数据了。

那么我们在这个过程中会有一些校验，如下:

  1. 表达式中的序号不能重复，比如不能出现(1 AND 1)

  2. 表达式中的序号要跟表格中的序号全等，也就是一样的序号，不存在哪边的多出来其他的序号

  3. 当遇到右括号的时候，需要弹出栈中的内容，当弹到栈内元素为空的时候，说明缺少左括号

  4. 当弹出栈内元素到最后，栈内元素的个数大于1，说明最后剩余的除了最后的ConditionDTO,还有剩余的左括号，所以这个时候说明缺少了右括号

  5. 当出现 (1 OR 2 AND 3) 这种括号包裹的表达式内同时存在 AND 和 OR 的操作符，则校验不通过，因为在数据库中AND的优先级会更高，所以在逻辑处理和语义上可能存在冲突，所以建议写成(1 OR (2 AND 3)) 或者(1 OR 2) AND 3)

构造JSON查询数据库实体数据

最后这里就是代码的实现了，至于最后怎么通过JSON数据去查询数据库实体数据可以参考之前的博文《使用Spring Boot JPA Specification实现使用JSON数据来查询实体数据》

@Builder
@Data
@AllArgsConstructor
@NoArgsConstructor
public class RuleDetailDTO {

  private String id;

  @NotNull
  private ColumnType type;

  @NotBlank
  private String columnName;

  @NotNull
  private OperateExpressionEnum operateExpression;

  private boolean not;

  private String operateValue;

  private String dateformat;

  private String dbDateFormat;

  @NotNull
  private Long sequence;
}


@UtilityClass
public class ExpressionParser {


  public static ConditionDTO parseExpression(String expression, List<RuleDetailDTO> ruleDetails) throws ConditionValidationException {
    if (CollectionUtils.isEmpty(ruleDetails)) {
      return null;
    }
    List<ConditionNodeDTO> expressions = preprocessExpression(expression);
    validateRuleSequence(expressions, ruleDetails);
    Deque<ConditionNodeDTO> deque = new LinkedList<>();
    for (ConditionNodeDTO exp : expressions) {
      deque.push(exp);
      if (StringUtils.equalsIgnoreCase(RIGHT_PARENTHESIS, Objects.requireNonNull(deque.peek()).getValue())) {
        deque.push(handleSubExpression(ruleDetails, deque));
      }
    }
    ConditionAssertUtils.isTrue(deque.size() == 1, INCORRECT_EXPRESSION_NOT_CLOSE_LEFT_PARENTHESES);
    return deque.pop().getCondition();
  }

  private static List<ConditionNodeDTO> preprocessExpression(String expression) {
    if (StringUtils.isEmpty(expression)) {
      return Collections.emptyList();
    }
    return Arrays.stream(getExpression(String.format("(%s)", expression)).toUpperCase(Locale.ROOT).split(StringUtils.SPACE))
        .filter(StringUtils::isNotBlank).map(StringUtils::trim)
        .map(item -> ConditionNodeDTO.builder().value(item).build()).collect(Collectors.toList());
  }


  private String getExpression(String expression) {
    return expression.replace(LEFT_PARENTHESIS, SPACES + LEFT_PARENTHESIS + SPACES)
        .replace(RIGHT_PARENTHESIS, SPACES + RIGHT_PARENTHESIS + SPACES)
        .replace(AND, SPACES + AND + SPACES)
        .replace(OR, SPACES + OR + SPACES);
  }


  private void validateRuleSequence(List<ConditionNodeDTO> expressions, List<RuleDetailDTO> ruleDetails) throws ConditionValidationException {
    List<String> sequenceList = getSequenceList(expressions).stream().map(ConditionNodeDTO::getValue).collect(Collectors.toList());
    ConditionAssertUtils.notEmpty(sequenceList, INCORRECT_EXPRESSION_NOT_INCLUDE_SEQUENCE);
    boolean hasDuplicateSequence = sequenceList.stream().distinct().count() < sequenceList.size();
    boolean isCongruent = new HashSet<>(ruleDetails.stream().map(item -> String.valueOf(item.getSequence()))
        .collect(Collectors.toList())).containsAll(sequenceList)
        && new HashSet<>(sequenceList).containsAll(ruleDetails.stream().map(item -> String.valueOf(item.getSequence()))
        .collect(Collectors.toList()));
    ConditionAssertUtils.isFalse(hasDuplicateSequence, INCORRECT_EXPRESSION_DUPLICATE_SEQUENCE);
    ConditionAssertUtils.isFalse(!isCongruent, INCORRECT_EXPRESSION_INCOMPLETE_SEQUENCE);
  }

  private List<ConditionNodeDTO> getSequenceList(List<ConditionNodeDTO> expressions) {
    return expressions.stream()
        .filter(item -> !StringUtils.equalsIgnoreCase(LEFT_PARENTHESIS, item.getValue())
            && !StringUtils.equalsIgnoreCase(RIGHT_PARENTHESIS, item.getValue())
            && !StringUtils.equalsIgnoreCase(AND, item.getValue())
            && !StringUtils.equalsIgnoreCase(OR, item.getValue())).collect(Collectors.toList());
  }


  private static ConditionNodeDTO handleSubExpression(List<RuleDetailDTO> ruleDetails, Deque<ConditionNodeDTO> deque) {
    List<ConditionNodeDTO> currentExpressions = new ArrayList<>();
    while (true) {
      ConditionNodeDTO pop = deque.pop();
      currentExpressions.add(pop);
      if (StringUtils.equalsIgnoreCase(LEFT_PARENTHESIS, pop.getValue())) {
        break;
      }
      ConditionAssertUtils.isFalse(deque.isEmpty(), INCORRECT_EXPRESSION_NOT_CLOSE_RIGHT_PARENTHESES);
    }
    return generateConditionNode(currentExpressions, ruleDetails);
  }

  private static ConditionNodeDTO generateConditionNode(List<ConditionNodeDTO> expressions, List<RuleDetailDTO> ruleDetails)
      throws ConditionValidationException {
    List<String> expressionValues = expressions.stream().map(ConditionNodeDTO::getValue).collect(Collectors.toList());
    ConditionAssertUtils.isFalse(expressionValues.contains(AND) && expressionValues.contains(OR),
        INCORRECT_EXPRESSION_NOT_SUPPORT);
    List<ConditionNodeDTO> sequenceConditionNodeListDTO = getSequenceList(expressions);
    ConditionAssertUtils.notEmpty(sequenceConditionNodeListDTO, INCORRECT_EXPRESSION_NOT_INCLUDE_SEQUENCE);
    if (sequenceConditionNodeListDTO.size() == 1 && Objects.nonNull(sequenceConditionNodeListDTO.get(0).getCondition())) {
      return sequenceConditionNodeListDTO.get(0);
    }
    OperationEnum operation = null;
    if (expressionValues.contains(AND)) {
      operation = OperationEnum.AND;
    } else if (expressionValues.contains(OR)) {
      operation = OperationEnum.OR;
    }
    ConditionAssertUtils.isFalse(Objects.isNull(operation) && ruleDetails.size() > 1, INCORRECT_EXPRESSION_MISSING_OPERATE);
    ConditionDTO condition = parseRuleDetailToConditionDTO(ruleDetails, expressionValues, operation);
    List<ConditionDTO> conditionList = expressions.stream().map(ConditionNodeDTO::getCondition).filter(Objects::nonNull)
        .collect(Collectors.toList());
    if (Objects.nonNull(condition)) {
      conditionList.add(condition);
    }
    return ConditionNodeDTO.builder().condition(ConditionDTO.getConditionDTOByOperation(conditionList, operation))
        .value(String.format("(%s)", expressions.stream().map(ConditionNodeDTO::getValue).collect(Collectors.joining(SPACES)))).build();
  }

  private static ConditionDTO parseRuleDetailToConditionDTO(List<RuleDetailDTO> ruleDetails, List<String> expressionValues,
      OperationEnum operation) {
    ConditionDTO condition;
    List<RuleDetailDTO> details = ruleDetails.stream().filter(item -> expressionValues.contains(String.valueOf(item.getSequence())))
        .collect(Collectors.toList());
    if (!CollectionUtils.isEmpty(details) && details.size() == 1) {
      condition = ConditionDTO.fromRules(details);
    } else {
      condition = ConditionDTO.fromRules(details, operation);
    }
    return condition;
  }


  @Data
  @Builder
  @AllArgsConstructor
  @NoArgsConstructor
  private static class ConditionNodeDTO {

    private String value;
    private ConditionDTO condition;
  }
}

public static final String SPACES = " ";
public static final String LEFT_PARENTHESIS = "(";
public static final String RIGHT_PARENTHESIS = ")";
public static final String AND = "AND";
public static final String OR = "OR";

public static final String INCORRECT_EXPRESSION_NOT_INCLUDE_SEQUENCE = "Please include sequence number in the expression";
public static final String INCORRECT_EXPRESSION_DUPLICATE_SEQUENCE = "The expression has duplicate sequence number";
public static final String INCORRECT_EXPRESSION_INCOMPLETE_SEQUENCE = "The sequence number in the expression is incomplete";
public static final String INCORRECT_EXPRESSION_NOT_SUPPORT = "Not support expression like: '1 AND 2 OR 3'; should be like: '(1 AND 2) OR 3' or '1 AND (2 OR 3)'";
public static final String INCORRECT_EXPRESSION_MISSING_OPERATE = "The expression must include AND or OR";
public static final String INCORRECT_EXPRESSION_NOT_CLOSE_RIGHT_PARENTHESES = "The right parentheses in the expression are not closed";
public static final String INCORRECT_EXPRESSION_NOT_CLOSE_LEFT_PARENTHESES = "The left parentheses in the expression are not closed";

最后后端在接收到前端传过来的expression表达式，和一个list的RuleDetailDTO之后就会调用ExpressionParser类的parseExpression方法去构造出最后的ConditionDTO对象。之后就可以利用这个ConditionDTO对象去查询数据了

c.
关注
专栏目录
【SpringBoot】26、SpringBoot中整合MyBatis-Plus实现数据库操作
Asurplus
07-23 21万+
MyBatis 框架相信大家都用过，虽然 MyBatis 可以直接在 xml 中通过 SQL 语句操作数据库，很是灵活。但正其操作都要通过 SQL 语句进行，就必须写大量的 xml 文件，很是麻烦。于是 MyBatis-Plus 应运而生，作为 MyBatis 的增强工具，更是为我们开发效率得到了质的飞跃。 一、简介 1、MyBatis MyBatis 是一款优秀的持久层框架，它支持自定义 SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBa
Java 解析JSON的 6 种方案
wjianwei666的专栏
05-26 780
本文对比了6种Java处理JSON的工具：1. Jackson（企业首选，功能强大但配置复杂）2. Gson（轻量易用，适合中小项目）3. FastJSON（性能最优但曾曝安全漏洞）4. JsonPath（专注字段提取）5. org.json（基础工具类）6. 手动解析（灵活但复杂）。Jackson适合企业级应用，Gson满足简单需求，FastJSON处理大数据，JsonPath提取嵌套字段，org.json适合快速操作，手动解析则用于特殊场景。选择工具需根据项目规模、性能需求及复杂度权衡，没有绝对优
数据库设计中对JSON的使用
01-24
JSON数据格式由于其简洁性，越来越多的得到了开发者的青睐，我将演示如何在数据库设计中使用JSON/JSONB的数据类型，探讨对||、array_to_json等操作符和函数的使用，以加快系统的开发效率，降低应用层的编码行数。
一个Json解析库的设计和实现
zhaojia的博客
04-05 1498
本文依照编译原理基本思想构建了一个Json解析库，包括词法分析、语法分析、树型优化和Json树生成等部分。具有参考意义。
JSONPath常用表达式
最新发布
nanzhuhe的博客
06-18 476
JSONPath是一种用于查询JSON数据的语言，其语法受到XML中XPath的启发‌。它允许通过路径表达式选择JSON文档中的节点，包括对象、数组或基本数据类型。与手动解析JSON相比，JSONPath提供了一种声明式的方法，只需描述想要的数据路径，而无需编写复杂的遍历代码‌。
一个基于XML的可配置的HTML数据解析工具
华仔----天道酬勤
04-13 216
最近做一些抓取工作，从一个行业的网站上抓取想要的信息。由于各个网站的页面各不一样，一般的实现是为某一类特定的页面编写一个解析器。如果抓取的网站少还好点，但是当网站数量多时，这就是最笨的方法了。 所以抽了点时间实现了一个基于XML的可配置的解析工具。功能只要有： 支持正则表达式抽取数据 支持SPEL运算，需要spring的相关包 支持工具类的方法调用，对抽取数据进行后续处理 xml描...
JSON的查询语法
yuanxun4683的博客
09-29 2071
目录 一、低级查询 1.基本用法 2.条件查询 3.简单查询 4.聚合查询 一、高级查询 1.子条件查询 2.复合条件查询 前言 查询的链接操作是 127.0.0.1:9200/book/_search 动作指令：POST 一、简单查询 所有的查询都是以query为关键词。 1.查询全部文档 { "query":{ "match...
可配置数据解析格式的 LoRaAppDemo@C# 应用工具
三角室专栏
12-15 1658
关于 LoRaAppDemo@C# 请参考CSND RimeLink LoRaAppDemo@C# 博文。 适用场景 可配置数据解析格式的演示版应用适用于数据上报格式固定的应用场景 。 在 LoRa 应用中，通常是按一定的周期上报采集数据，这些数据一般有着固定的字节组成结构，但不同的采集场景结构不一样。通常我们需要为每一种场景去实现其相应的解析来形成可读数据，本演示版根据常用的数据类型...
深入解析Spring Cloud Config：多样配置中心的实现与高可用策略
张彦峰的博客
02-14 167万+
这篇文章探讨了配置中心的重要性及其在分布式系统中的应用，特别关注Spring Cloud Config。文章首先介绍了配置中心的由来、功能及选择标准，然后详细阐述了Spring Cloud Config的基本实现方法，包括结合Git、关系型数据库（MySQL）和非关系型数据库（MongoDB）的方案。此外，还讨论了配置中心的高可用性、客户端自动刷新机制及安全认证等扩展功能。最后，文章对比了Spring Cloud Config与Apollo的特性，强调Apollo在企业级应用中的优势。
从业务需求到技术实现：动态工作流引擎的构建与应用
热门推荐
张彦峰的博客
12-21 172万+
本文介绍了如何实现一个动态配置执行工作流引擎，重点讲解了工作流的设计与实现过程。通过分析工作流执行上下文、任务节点定义、执行器、调度平台等核心组件，展示了如何在不同的业务场景下灵活配置和动态执行工作流。文章还通过实际案例，阐述了智能化处理和数据流转的工作流任务，如新闻内容处理、AI赋能、数据同步等。最后，文章总结了动态配置执行工作流引擎的优势，并展望了未来优化和扩展的方向。
JSON数据建模与NoSQL数据库：比较和对比
![JSON数据建模与NoSQL数据库：比较和对比]...# 1. JSON数据建模基础** JSON（JavaScript对象表示法）是一种轻量级的数据交换格式，广泛用于Web应用程序和API。JSON数据建模涉及将数据结构化为JSON文档，其中
配置数据分析与处理开发环境
m0_63336104的博客
09-25 437
数据分析与开发环境
php 如何遍历 json 数据结构,查询json的数据结构的8种方式简介
weixin_42326020的博客
03-10 426
查询json的数据结构的8种方式：JsonSQLJsonSQL实现了使用SQL select语句在json数据结构中查询的功能。主页：http://www.trentrichardson.com/jsonsql/例子：jsonsql.query("select * from json.channel.items order by title desc",json);JSONPathJSONPath...
表达式模板化配置的思路
weixin_33991727的博客
07-18 271
2019独角兽企业重金招聘Python工程师标准>>> ...
详情文案的轻量级表达式配置方案
weixin_30418341的博客
05-01 203
背景 在订单详情页中，常常有一些业务逻辑，根据不同的条件展示不同的文案。通常的写法是一堆嵌套的 if-else 语句，难以理解和维护。比如待开奖： if (Objects.equals(PAID, orderState)) { if (Objects.equals(LOTTERY, activity) { Map<String, Object> ext...
利用SPRING JDBC 和模板框架实现SQL可配置
json20080301的专栏
10-11 803
！！利用SPRING JDBC 和模板框架实现SQL可配置！ 入参是Map， 查询返回结果List 实现功能： 1.主要实现查询功能和SQL可配置化： 2.配置信息可多数据源存储（XML，DATABASE，TXT），可热部署， 3.缓存控制与刷新； 4.物理分页 与MYBATIS比较功能单一了 ， 特点：配置信息可多数据源存储（XML，DATABASE，TXT），可热部署； 简单
一种简单,轻量,高性能Json对象设计方案
布道
08-24 2760
简单,是因为只有一个类 轻量,是因为整个类代码只有300行 灵活,是因为扩展方式只需要继承重写某个方法即可 首先我将这个类称之为JsonBuilder,我希望它以StringBuilder的方式来实现Json字符串的转换 public class JsonBuilder { protected StringBuilder Buff = new Strin
五分钟爆改，把你的JSON/CSV文件打造成MySQL数据库
Tomcat那些事儿
01-03 391
生活中，你我一定都看到过这种「xx元爆改出租屋」，「爆改小汽车」之类的文章，做为IT人，折腾的劲头一点也不差。软件开发过程中，你是否有时候，会拿着业务提供的一个个CSV或者JSON的数据...
mybatis_plus 如何查询json
01-11
### MyBatis Plus 查询 JSON 示例教程 在现代应用程序开发中，处理复杂的JSON数据结构成为了一项常见任务。为了满足这一需求，在MyBatis-Plus (MP) 中可以采用特定的方式来进行JSON字段的操作。 对于想要执行基于JSON字段的查询操作而言，定义实体类时指定`typeHandler`属性是非常重要的[^2]。这使得能够通过自定义处理器来解析和序列化JSON对象到数据库中的TEXT或其他适合存储JSON字符串的数据类型。例如： ```java @TableName(value = "tb_user", autoResultMap = true) public class User { @TableField(typeHandler = JacksonTypeHandler.class) private List<String> tags; } ``` 当涉及到具体的查询逻辑实现方面，假设有一个名为`tags`的列表作为用户的标签集合，并且希望找到所有包含某个特定标签（比如："technology"）在内的用户记录，则可以在Mapper接口里编写如下方法签名： ```java import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper; import java.util.List; List<User> selectUsersWithTag(String tag); ``` 接着是在对应的XML文件或者是动态SQL构建器内完成实际的SQL语句构造工作。这里给出一种使用QueryWrapper简化条件拼接的例子： ```java // 构建查询条件 QueryWrapper<User> queryWrapper = new QueryWrapper<>(); queryWrapper.like("tags", "\"" + targetTag + "\""); // 执行查询并获取结果集 List<User> usersWithTargetTag = userMapper.selectList(queryWrapper); ``` 上述代码片段展示了如何利用`like`关键字配合双引号包裹的目标标签值进行模糊匹配查询。需要注意的是这种方法依赖于底层数据库引擎对JSON路径表达式的识别能力以及性能表现；不同版本之间可能存在差异因此建议查阅官方文档了解最新特性和支持情况[^1]。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值