基于JSON文件的JMeter脚本开发：多请求数据处理需求

1. 读取与解析目标JSON文件 #

使用JSR223 Sampler（Groovy语言）读取指定JSON文件并解析为对象，方便后续处理：

def jsonSlurper = new groovy.json.JsonSlurper()
def jsonData = jsonSlurper.parse(new File("绝对路径/目标文件.json"))
vars.putObject("rootJson", jsonData)

2. 提取目标节点并关联元数据 #

编写递归函数遍历JSON结构，收集所有含子节点（排除attributes字段本身）的节点，同时记录节点的attributes、父节点标识：

def collectTargetNodes(def node, def parentKey = null) {
    def nodeList = []
    node.each { key, value ->
        if (key != "attributes") {
            // 判断当前节点是否含有效子节点（非仅attributes）
            if (value instanceof Map && value.size() > 0 && !value.keySet().every { it == "attributes" }) {
                def nodeMeta = [
                    nodeKey: key,
                    postData: value.findAll { k, v -> k != "attributes" },
                    attributes: value.attributes ?: [:],
                    parentKey: parentKey
                ]
                nodeList.add(nodeMeta)
                // 递归处理子节点
                nodeList.addAll(collectTargetNodes(value, key))
            }
        }
    }
    return nodeList
}

def allTargetNodes = collectTargetNodes(vars.getObject("rootJson"))
vars.putObject("targetNodes", allTargetNodes)
vars.put("totalNodeCount", allTargetNodes.size().toString())

3. 批量执行POST请求创建节点 #

添加Loop Controller，循环次数设置为${totalNodeCount}，在循环内完成以下操作：

• JSR223 PreProcessor构造POST请求体：

  def nodes = vars.getObject("targetNodes")
  def currentIdx = vars.get("__jm__Loop Controller__idx") as int
  def currentNode = nodes.get(currentIdx)
  vars.put("postBody", new groovy.json.JsonBuilder(currentNode.postData).toPrettyString())
  

• HTTP Request配置POST接口，请求体引用${postBody}
• JSON Extractor提取创建后的节点id，保存为created_node_${__jm__Loop Controller__idx}_id
• JSR223 PostProcessor关联节点id与元数据：

  def nodeMap = vars.getObject("nodeIdMap") ?: [:]
  def currentIdx = vars.get("__jm__Loop Controller__idx") as int
  def currentNode = vars.getObject("targetNodes").get(currentIdx)
  nodeMap.put(currentNode.nodeKey, [
      id: vars.get("created_node_${currentIdx}_id"),
      attributes: currentNode.attributes,
      parentKey: currentNode.parentKey
  ])
  vars.putObject("nodeIdMap", nodeMap)
  

4. 批量执行PATCH请求更新属性 #

复用或新增Loop Controller（循环次数${totalNodeCount}），循环内操作：

• JSR223 PreProcessor构造属性更新的PATCH请求体：

  def nodeMap = vars.getObject("nodeIdMap")
  def nodes = vars.getObject("targetNodes")
  def currentIdx = vars.get("__jm__Loop Controller__idx") as int
  def currentNodeKey = nodes.get(currentIdx).nodeKey
  def targetMeta = nodeMap.get(currentNodeKey)
  
  vars.put("targetNodeId", targetMeta.id)
  vars.put("attrPatchBody", new groovy.json.JsonBuilder(targetMeta.attributes).toPrettyString())
  

• HTTP Request配置PATCH接口，URL中引用${targetNodeId}指定更新对象，请求体引用${attrPatchBody}

5. 批量执行PATCH请求添加子节点 #

筛选出有父节点的子节点，新增Loop Controller处理：

• 先在前置JSR223 Sampler中统计子节点数量：

  def nodeMap = vars.getObject("nodeIdMap")
  def childNodes = nodeMap.findAll { it.value.parentKey != null }.values().toList()
  vars.putObject("childNodes", childNodes)
  vars.put("childNodeCount", childNodes.size().toString())
  

• Loop Controller循环次数设为${childNodeCount}，循环内：

  def childNodes = vars.getObject("childNodes")
  def nodeMap = vars.getObject("nodeIdMap")
  def currentIdx = vars.get("__jm__Loop Controller__idx") as int
  def currentChild = childNodes.get(currentIdx)
  def parentMeta = nodeMap.get(currentChild.parentKey)
  
  vars.put("parentNodeId", parentMeta.id)
  vars.put("childNodeId", currentChild.id)
  // 按接口要求构造添加子节点的请求体
  vars.put("addChildBody", new groovy.json.JsonBuilder([childId: currentChild.id]).toPrettyString())
  

• HTTP Request配置PATCH接口，URL引用${parentNodeId}，请求体引用${addChildBody}

核心优化点 #

• 多层子节点支持：通过递归遍历JSON结构，自动识别所有层级的目标节点
• 请求数量匹配：Loop Controller循环次数与节点数量绑定，确保每个节点对应完整的创建-更新-关联流程
• 合并请求支持：若接口允许，可将属性更新与子节点添加的JSON数据合并，用单个PATCH请求完成操作

内容的提问来源于stack exchange，提问作者Michele Scianatico