Camunda 7.19.0中如何用ConditionQueryParameterDto实现in运算符查询？

问题背景 #

我正在使用Camunda 7.19.0版本，已实现一个接收TaskQueryDto的控制器，用于根据指定变量条件查询所有任务，控制器代码如下：

@RestController
public class RestEngineController {

    @Autowired
    private TaskCustomService taskCustomService;

    @PostMapping(value = "/rest-engine/task-with-variables", produces = MediaType.APPLICATION_JSON_VALUE)
    List<TaskWithVariables> getTasks(@RequestBody TaskQueryDto query,
                                     @RequestParam("firstResult") Integer firstResult,
                                     @RequestParam("maxResults") Integer maxResults) {
        return taskCustomService.getTasks(query, firstResult, maxResults);
    }
}

但Camunda原生的ConditionQueryParameterDto并未提供“in”运算符支持，该类相关代码片段如下：

public class ConditionQueryParameterDto {

  public ConditionQueryParameterDto() {

  }

  public static final String EQUALS_OPERATOR_NAME = "eq";
  public static final String NOT_EQUALS_OPERATOR_NAME = "neq";
  public static final String GREATER_THAN_OPERATOR_NAME = "gt";
  public static final String GREATER_THAN_OR_EQUALS_OPERATOR_NAME = "gteq";
  public static final String LESS_THAN_OPERATOR_NAME = "lt";
  public static final String LESS_THAN_OR_EQUALS_OPERATOR_NAME = "lteq";
  public static final String LIKE_OPERATOR_NAME = "like";
  public static final String NOT_LIKE_OPERATOR_NAME = "notLike";
}

解决方案 #

1. 在业务逻辑中新增“in”运算符处理 #

无需修改Camunda原生DTO，直接在TaskCustomService的查询方法中，对传入的运算符做额外判断，利用Camunda TaskQuery提供的taskVariableValueIn方法实现in查询：

import org.camunda.bpm.engine.TaskService;
import org.camunda.bpm.engine.task.Task;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

@Service
public class TaskCustomService {

    private final TaskService taskService;

    public TaskCustomService(TaskService taskService) {
        this.taskService = taskService;
    }

    public List<TaskWithVariables> getTasks(TaskQueryDto queryDto, Integer firstResult, Integer maxResults) {
        TaskQuery taskQuery = taskService.createTaskQuery();

        // 处理变量条件，新增in运算符支持
        if (queryDto.getVariables() != null) {
            for (Map.Entry<String, ConditionQueryParameterDto> varEntry : queryDto.getVariables().entrySet()) {
                String varName = varEntry.getKey();
                ConditionQueryParameterDto condition = varEntry.getValue();

                if ("in".equals(condition.getOperator())) {
                    // 确保传入的value是集合类型（如List）
                    if (condition.getValue() instanceof List) {
                        List<?> varValues = (List<?>) condition.getValue();
                        taskQuery.taskVariableValueIn(varName, varValues.toArray());
                    }
                } else {
                    // 原有其他运算符的处理逻辑（保持原代码不变）
                    switch (condition.getOperator()) {
                        case ConditionQueryParameterDto.EQUALS_OPERATOR_NAME:
                            taskQuery.taskVariableValueEquals(varName, condition.getValue());
                            break;
                        case ConditionQueryParameterDto.NOT_EQUALS_OPERATOR_NAME:
                            taskQuery.taskVariableValueNotEquals(varName, condition.getValue());
                            break;
                        // 其他运算符处理...
                        default:
                            throw new IllegalArgumentException("Unsupported operator: " + condition.getOperator());
                    }
                }
            }
        }

        // 分页设置
        taskQuery.firstResult(firstResult).maxResults(maxResults);

        // 查询任务并封装为TaskWithVariables
        List<Task> tasks = taskQuery.list();
        return tasks.stream().map(task -> {
            TaskWithVariables result = new TaskWithVariables();
            result.setTaskId(task.getId());
            result.setName(task.getName());
            // 其他任务字段赋值...
            result.setVariables(taskService.getVariables(task.getId()));
            return result;
        }).collect(Collectors.toList());
    }
}

2. 前端请求格式约定 #

前端发起请求时，需按照约定传入“in”类型的变量条件，示例JSON如下：

{
  "variables": {
    "orderStatus": {
      "operator": "in",
      "value": ["COMPLETED", "CANCELLED"],
      "type": "String"
    }
  }
}

3. 可选：扩展DTO实现强类型支持 #

如果希望在DTO层面明确支持“in”运算符，可以自定义扩展DTO：

public class ExtendedConditionQueryParameterDto extends ConditionQueryParameterDto {
    public static final String IN_OPERATOR_NAME = "in";
}

// 自定义TaskQueryDto
public class ExtendedTaskQueryDto extends TaskQueryDto {
    private Map<String, ExtendedConditionQueryParameterDto> variables;

    @Override
    public Map<String, ConditionQueryParameterDto> getVariables() {
        return Map.copyOf(variables);
    }

    public Map<String, ExtendedConditionQueryParameterDto> getExtendedVariables() {
        return variables;
    }

    public void setVariables(Map<String, ExtendedConditionQueryParameterDto> variables) {
        this.variables = variables;
    }
}

之后控制器修改为接收ExtendedTaskQueryDto：

@PostMapping(value = "/rest-engine/task-with-variables", produces = MediaType.APPLICATION_JSON_VALUE)
List<TaskWithVariables> getTasks(@RequestBody ExtendedTaskQueryDto query,
                                 @RequestParam("firstResult") Integer firstResult,
                                 @RequestParam("maxResults") Integer maxResults) {
    return taskCustomService.getTasks(query, firstResult, maxResults);
}

内容的提问来源于stack exchange，提问作者Pertsh Galstyan