如何用Java的RestTemplate并发发送带JSON参数的相同请求？

第一步：修正JSON文件语法错误 #

你提供的JSON存在语法问题，无法正常解析，修正后如下（假设formType应为数组，移除重复的对象定义并补全数组元素语法）：

{
    "workflow": {
        "guid": "adadadadadadadad"
    },
    "formType": [
        {
            "guid": "adadadadadadadad",
            "svalue": "adadadadadada"
        },
        {
            "guid": "adadadadadadadad",
            "svalue": "adadadadadada"
        },
        {
            "guid": "adadadadadadadad",
            "svalue": "adadadadadada"
        }
    ]
}

将该文件保存到src/test/resources目录下，命名为request-payload.json。

第二步：创建对应Java实体类 #

创建与JSON结构匹配的实体类，用于反序列化JSON内容：

import java.util.List;

public class RequestPayload {
    private Workflow workflow;
    private List<FormType> formType;

    // getter和setter方法
    public Workflow getWorkflow() { return workflow; }
    public void setWorkflow(Workflow workflow) { this.workflow = workflow; }
    public List<FormType> getFormType() { return formType; }
    public void setFormType(List<FormType> formType) { this.formType = formType; }

    public static class Workflow {
        private String guid;
        // getter和setter
        public String getGuid() { return guid; }
        public void setGuid(String guid) { this.guid = guid; }
    }

    public static class FormType {
        private String guid;
        private String svalue;
        // getter和setter
        public String getGuid() { return guid; }
        public void setGuid(String guid) { this.guid = guid; }
        public String getSvalue() { return svalue; }
        public void setSvalue(String svalue) { this.svalue = svalue; }
    }
}

第三步：修改测试类实现需求 #

更新FetchApi测试类，实现读取JSON文件和并发发送100次POST请求的功能：

import com.fasterxml.jackson.databind.ObjectMapper;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.MediaType;
import org.springframework.web.client.RestTemplate;

import java.io.File;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

@SpringBootTest
public class FetchApi {

    private final String postUrl = "https://example/post"; // 修正原URL格式错误
    private final String token = "adadfsdfgsdgdfgdfghdhdhdhdhdhdh";
    private final RestTemplate restTemplate = new RestTemplate(); // 复用实例提升性能
    private final ObjectMapper objectMapper = new ObjectMapper();

    // 读取JSON文件并反序列化为RequestPayload
    private RequestPayload readPayloadFromJson() throws Exception {
        File jsonFile = new File("src/test/resources/request-payload.json");
        return objectMapper.readValue(jsonFile, RequestPayload.class);
    }

    // 单条POST请求逻辑
    private void sendSinglePostRequest(RequestPayload payload) {
        try {
            HttpHeaders headers = new HttpHeaders();
            headers.set("Authorization", "Bearer " + token);
            headers.setContentType(MediaType.APPLICATION_JSON);

            String jsonBody = objectMapper.writeValueAsString(payload);
            HttpEntity<String> entity = new HttpEntity<>(jsonBody, headers);

            Object response = restTemplate.exchange(postUrl, HttpMethod.POST, entity, Object.class);
            System.out.println("请求响应: " + response);
        } catch (Exception e) {
            System.err.println("请求失败: " + e.getMessage());
        }
    }

    @Test
    public void sendConcurrentPostRequests() throws Exception {
        RequestPayload payload = readPayloadFromJson();
        int requestCount = 100;

        // 创建固定线程池，线程数可根据服务器承载能力调整
        ExecutorService executorService = Executors.newFixedThreadPool(10);

        for (int i = 0; i < requestCount; i++) {
            executorService.submit(() -> sendSinglePostRequest(payload));
        }

        // 关闭线程池并等待所有任务完成
        executorService.shutdown();
        executorService.awaitTermination(5, TimeUnit.MINUTES);
    }
}

关键说明 #

• 复用RestTemplate：避免重复创建实例，减少资源开销。
• 线程池配置：使用固定线程数控制并发量，防止因线程过多耗尽系统资源。
• 异常隔离：单请求逻辑内捕获异常，避免单个请求失败导致整个并发任务终止。
• JSON解析：通过Jackson的ObjectMapper完成文件读取与对象转换，保证参数传递准确。

内容的提问来源于stack exchange，提问作者Konrad Krawczyk