使用RestTemplate模拟postman（get/post请求）

已于 2023-04-21 14:30:42 修改
阅读量1.1k 收藏
点赞数 1
分类专栏： Ashの代码之路 文章标签： java http
于 2023-03-30 17:56:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_54892309/article/details/129862751
版权

前言

项目中有个模板的功能是可以模仿postman进行http请求。 之前使用过httpClient，这次就来试试看更加模板化的RestTemplate吧~ 

关于RestTemplate的教程网上有很多，但大多都是秉着授人以渔的心态写的，也就是说在实战方面写得并不是很详细。这次我就借着模块开发的机会，来分享一下我是怎么编写http请求工具类的吧。

首先，要使用RestTemplate的exchange方法作为整个工具类的基础，借助它的可自定义配置，我们可以实现 使用任意格式的请求参数 和 返回任意格式的结果。这对于一个工具类来说是非常重要的。

需要注意的是，在RestTemplate中使用post方式请求 + 使用formdata格式传递body参数时，不能使用Map，需要要使用MultiValueMap。

实战环节

代码如下（示例）： 

/**
 * RestTemplateUtils 【http请求工具类】
 * 1. sendGet() sendPost() 是正常http请求
 * <br>
 * 2. sendGetByByte() sendPostByByte() 是用来下载字节流的
 * <br>
 * 3. 支持的请求方式：<br>
 * <b>
 * post请求 -json传参<br>
 * post请求 -formData传参<br>
 * get请求 -占位符传参<br>
 * get请求 -url拼接<br>
 * </b>
 *
 * @author xurenyi
 * @since 2023/3/29 17:36
 **/
public class RestTemplateUtils {

    private static Logger logger = LoggerFactory.getLogger("RestTemplateUtils");
    private volatile static RestTemplate restTemplate;

    /**
     * GET请求
     *
     * @param url
     * @param returnDataType 返回数据的格式 JSONObject|JSONArray.class|String.class|Map.class|ArrayList.class，可为空
     * @param requestHeaders 请求头，可为空
     * @param requestParams  求参数，可为空
     * @return 结果
     */
    public static Object sendGet(String url,
                                 @Nullable Class<?> returnDataType,
                                 @Nullable Map<String, Object> requestHeaders,
                                 @Nullable Map<String, Object> requestParams) {
        return httpRequest(url, HttpMethod.GET, requestHeaders, requestParams, null, returnDataType, JSONObject.class);
    }


    /**
     * POST请求
     *
     * @param url
     * @param returnDataType 返回数据的格式 JSONObject|JSONArray.class|String.class|Map.class|ArrayList.class，可为空
     * @param requestHeaders 请求头，可为空
     * @param requestParams  请求参数，可为空
     * @param requestBody    请求体，可为空
     * @param sendDataType   请求体格式 json|jsonArray
     * @return 结果
     */
    public static Object sendPost(String url,
                                  @Nullable Class<?> returnDataType,
                                  @Nullable Map<String, Object> requestHeaders,
                                  @Nullable Map<String, Object> requestParams,
                                  @Nullable String requestBody,
                                  Class<?> sendDataType) {
        return httpRequest(url, HttpMethod.POST, requestHeaders, requestParams, requestBody, returnDataType, sendDataType);
    }


    /**
     * POST请求 字节流
     *
     * @param url
     * @param response       http响应消息，可为空
     * @param requestHeaders 请求头，可为空
     * @param requestParams  请求参数，可为空
     * @param requestBody    请求体，可为空
     * @param sendDataType   请求体格式 json|jsonArray
     **/
    public static void sendPostByByte(String url, HttpServletResponse response,
                                      @Nullable Map<String, Object> requestHeaders,
                                      @Nullable Map<String, Object> requestParams,
                                      @Nullable String requestBody,
                                      Class<?> sendDataType) {
        download(url, HttpMethod.POST, requestHeaders, requestParams, requestBody, response, false, sendDataType);
    }

    /**
     * GET请求 字节流
     *
     * @param url
     * @param response       http响应消息，可为空
     * @param requestHeaders 请求头，可为空
     * @param requestParams  请求参数，可为空
     **/
    public static void sendGetByByte(String url, HttpServletResponse response,
                                     @Nullable Map<String, Object> requestHeaders,
                                     @Nullable Map<String, Object> requestParams) {
        download(url, HttpMethod.GET, requestHeaders, requestParams, null, response, false, JSONObject.class);
    }

    /**
     * 发送http请求
     *
     * @param url
     * @param method
     * @param requestHeaders
     * @param requestParams
     * @param requestBody
     * @param returnDataType
     * @return
     */
    public static <T> Object httpRequest(String url, HttpMethod method,
                                         @Nullable Map<String, Object> requestHeaders,
                                         @Nullable Map<String, Object> requestParams,
                                         @Nullable String requestBody,
                                         @Nullable Class<?> returnDataType,
                                         Class<?> sendDataType) {

        Map<String, Object> params = new HashMap<>();
        HttpHeaders headers = new HttpHeaders();
        // 1. post请求 -json传参
        // 2. post请求 -formData传参
        // 3. get请求 -占位符传参
        // 4. get请求 -url拼接

        // 第一步 构建httpEntity
        HttpEntity<?> entity = buildHttpEntity(sendDataType, method, requestHeaders, requestParams, requestBody, params, headers);
        // 第二步 单例调用restTemplate
        RestTemplate restTemplate = getSingleRestTemplate();
        // 第三步 初始化一个返回值
        Object r = null;
        // 第四步 执行http请求，并根据情况给返回值赋值
        try {
            Class<?> resultClass = String.class;
            if (returnDataType != null) {
                resultClass = returnDataType;
                r = handleHttpRequest(restTemplate, resultClass, url, method, params, entity);
            } else {
                handleHttpRequest(restTemplate, resultClass, url, method, params, entity);
            }

        } catch (RestClientException e) {
            logger.error("远程调用接口异常{}", e);
        }
        return r;
    }

    /**
     * 下载
     *
     * @param url
     * @param method
     * @param requestHeaders
     * @param requestParams
     * @param requestBody
     * @param response
     * @param isRespBodyOnly 是否是只需要响应体,默认true，true：只需要响应体  false：同时返回响应状态 响应头  响应体
     */
    public static void download(String url, HttpMethod method,
                                @Nullable Map<String, Object> requestHeaders,
                                @Nullable Map<String, Object> requestParams,
                                @Nullable String requestBody,
                                HttpServletResponse response,
                                @Nullable Boolean isRespBodyOnly,
                                Class<?> sendDataType) {
        if (Objects.isNull(isRespBodyOnly)) {
            isRespBodyOnly = true;
        }
        HttpHeaders headers = new HttpHeaders();
        Map<String, Object> params = new HashMap<>();

        // 第一步 构建httpEntity
        HttpEntity<?> entity = buildHttpEntity(sendDataType, method, requestHeaders, requestParams, requestBody, params, headers);
        // 第二步 单例调用restTemplate
        RestTemplate restTemplate = getSingleRestTemplate();
        // 第三步 执行http请求，并返回字节流
        handleHttpRequest(restTemplate, url, method, response, isRespBodyOnly, params, entity);
    }

    /**
     * 构建httpEntity
     *
     * @param method
     * @param requestHeaders
     * @param requestParams
     * @param requestBody
     * @param params
     * @param headers
     * @return
     */
    private static HttpEntity<?> buildHttpEntity(Class<?> sendDataType, HttpMethod method, Map<String, Object> requestHeaders, Map<String, Object> requestParams, String requestBody, Map<String, Object> params, HttpHeaders headers) {
        //1.设置请求参数
        if (requestParams != null && !requestParams.isEmpty()) {
            Iterator<Map.Entry<String, Object>> paramsIterator = requestParams.entrySet().iterator();
            Map.Entry<String, Object> nextParam = null;
            while (paramsIterator.hasNext()) {
                nextParam = paramsIterator.next();
                params.put(nextParam.getKey(), nextParam.getValue());
            }
        }
        //2.设置请求头
        if (requestHeaders != null && !requestHeaders.isEmpty()) {
            Iterator<Map.Entry<String, Object>> headersIterator = requestHeaders.entrySet().iterator();
            Map.Entry<String, Object> nextHeader = null;
            while (headersIterator.hasNext()) {
                nextHeader = headersIterator.next();
                headers.add(nextHeader.getKey(), String.valueOf(nextHeader.getValue()));
            }
        }
        //3.设置请求体
        //4.请求体 请求头封装到HttpEntity
        String contentType = String.valueOf(requestHeaders.get(EtlHttpRequestConstant.CONTENT_TYPE));
        if (requestBody != null && !requestBody.isEmpty()) {
            if (sendDataType == null || sendDataType.equals(JSONObject.class)) {
                Map<String, Object> requestBodyMap = JSONObject.parseObject(requestBody, Map.class);
                Map bodyMap;
                if (MediaType.APPLICATION_JSON_VALUE.equals(contentType) || HttpMethod.GET.equals(method)) {
                    bodyMap = setEntityBody(Map.class, requestBodyMap);
                } else {
                    bodyMap = setEntityBody(LinkedMultiValueMap.class, requestBodyMap);
                }
                return new HttpEntity<>(bodyMap, headers);
            } else if (sendDataType.equals(JSONArray.class)) {
                List<Map> requestBodyMapList = JSON.parseArray(requestBody, Map.class);
                List<Map> bodyMapList = new ArrayList<>();
                if (MediaType.APPLICATION_JSON_VALUE.equals(contentType) || HttpMethod.GET.equals(method)) {
                    requestBodyMapList.forEach(i -> bodyMapList.add(setEntityBody(Map.class, i)));
                } else {
                    requestBodyMapList.forEach(i -> bodyMapList.add(setEntityBody(LinkedMultiValueMap.class, i)));
                }
                return new HttpEntity<>(bodyMapList, headers);
            } else if (sendDataType.equals(String.class)) {
                return new HttpEntity<>(requestBody, headers);
            }

        }
        // todo 如果是其他情况，则返回null
        return new HttpEntity<>(null, headers);
    }

    /**
     * 请求http请求
     *
     * @param restTemplate
     * @param typeClass
     * @param url
     * @param method
     * @param params
     * @param entity
     * @param <T>
     * @return
     */
    private static <T> T handleHttpRequest(RestTemplate restTemplate, Class<T> typeClass, String url, HttpMethod method, Map<String, Object> params, HttpEntity<?> entity) {
        ResponseEntity<T> exchange = restTemplate.exchange(url, method, entity, typeClass, params);

        return typeClass.cast(exchange.getBody());
    }

    /**
     * 处理http请求（字节流）
     *
     * @param restTemplate
     * @param url
     * @param method
     * @param response
     * @param isRespBodyOnly
     * @param params
     * @param entity
     */
    private static void handleHttpRequest(RestTemplate restTemplate, String url, HttpMethod method, HttpServletResponse response, Boolean isRespBodyOnly, Map<String, Object> params, HttpEntity<?> entity) {
        BufferedOutputStream bos = null;
        try {
            ResponseEntity<byte[]> exchange = restTemplate.exchange(url, method, entity, byte[].class, params);
            if (!isRespBodyOnly && response != null) {
                setResponseDetails(response, exchange);
            }
            // FIXME: 2023/3/29 by.xurenyi 修改下载文件流的格式，此处有些小问题，暂定使用原接口的文件格式~~~
//            response.reset();
//            response.setContentType("pdf/plain");
//            response.setContentType("application/octet-stream;charset=UTF-8");
//            response.setHeader("Content-Type", "application/octet-stream;charset=UTF-8");
//            response.setHeader("Content-Disposition", "attachment; filename=" + "test" + ".pdf");
            //响应体
            ServletOutputStream os = response.getOutputStream();
            bos = new BufferedOutputStream(os);
            byte[] buf = exchange.getBody();
            bos.write(buf);
            bos.flush();
        } catch (IOException e) {
            logger.error("RestTemplateUtils获取接口二进制流异常");
        } catch (RestClientException e) {
            logger.error("远程调用接口异常{}", e);
        } finally {
            try {
                bos.close();
            } catch (IOException e) {
                logger.error("RestTemplateUtils流关闭异常");
            }
        }
    }

    /**
     * 设置http响应详情
     *
     * @param response
     * @param exchange
     * @param <T>
     */
    private static <T> void setResponseDetails(HttpServletResponse response, ResponseEntity<T> exchange) {
        //响应状态码
        response.setStatus(exchange.getStatusCodeValue());
        //响应头,可能存在一个key对应多个value,本方法中会将同名header合并
        HttpHeaders resHeaders = exchange.getHeaders();
        Iterator<Entry<String, List<String>>> resHeadersIterator = resHeaders.entrySet().iterator();
        while (resHeadersIterator.hasNext()) {
            Entry<String, List<String>> headersNext = resHeadersIterator.next();
            response.setHeader(headersNext.getKey(), headersNext.getValue().toString());
        }
    }

    /**
     * 设置entity
     *
     * @param beanClass
     * @param requestBody
     * @return
     */
    private static Map setEntityBody(Class<? extends Map> beanClass, Map<String, Object> requestBody) {
        Object entityBody;
        Iterator<Entry<String, Object>> bodyIterator = requestBody.entrySet().iterator();
        Entry<String, Object> bodyNext;

        if (beanClass.equals(MultiValueMap.class) || beanClass.equals(LinkedMultiValueMap.class)) {
            MultiValueMap<String, Object> map = new LinkedMultiValueMap<>();
            while (bodyIterator.hasNext()) {
                bodyNext = bodyIterator.next();
                map.add(bodyNext.getKey(), bodyNext.getValue());
            }

            entityBody = map;
        } else if (beanClass.equals(Map.class)) {
            Map<String, Object> map = new HashMap<>();
            while (bodyIterator.hasNext()) {
                bodyNext = bodyIterator.next();
                map.put(bodyNext.getKey(), bodyNext.getValue());
            }

            entityBody = map;
        } else {
            Map<String, Object> map = new HashMap<>();
            while (bodyIterator.hasNext()) {
                bodyNext = bodyIterator.next();
                map.put(bodyNext.getKey(), bodyNext.getValue());
            }

            entityBody = map;
        }

        return beanClass.cast(entityBody);
    }

    /**
     * RestTemplate 单例 懒汉 双检锁
     **/
    public static RestTemplate getSingleRestTemplate() {
        if (restTemplate == null) {
            synchronized (RestTemplateUtils.class) {
                if (restTemplate == null) {
                    restTemplate = new RestTemplate();
                }
            }
        }
        return restTemplate;
    }

}

醒盼梦惜忆甚悠
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RestTemplate工具类封装(GET和POST的各种场景)
全栈羊的搬砖日常
06-21 242
【代码】最全RestTemplate工具类封装(GET和POST的各种场景)
调用同一个API地址，相同的入参，Postman正常，但RestTemplate一直报错：{“ErrorMessage“: “(IndexError) list index out of range“
君临天下tjm的博客
01-18 908
方式二：通过postman触发springmvc的controller接口，传值后，再通过RestTemplate访问API；（报错：500 INTERNAL SERVER ERROR: "{"ErrorMessage": "(IndexError) list index out of range"}"）第三方API地址：http://124.AA.BBB.205:100。方式一：通过postman直接传参访问；
HTTP请求客户端工具类RestTemplateUtil.java
06-09
org.springframework.web.client.AsyncRestTemplate org.springframework.web.client.RestTemplate HTTP请求工具类，基于以上两个Rest请求工具模板完成封装HTTP请求，包括同步和异步请求的实现。
史上最实用的RestTemplate结合Postman让请求飞一会
qq_42257082的博客
04-10 1866
史上最实用的RestTemplate结合Postman让请求飞一会GET请求http://127.0.0.1:8888/api/getMessage?id=123&name=tomhttp://127.0.0.1:8888/api/getMessage/{aaa}/{bbb}/{id}http://127.0.0.1:8888/api/getMessage/{id}?age=100POST请求http://127.0.0.1:8888/api/getMessage + 【body-applicati
万字长文讲解调用第三方接口，RestTemplate，urlConnection使用详解，java代码模拟postman发送请求
itScholar001的博客
06-16 1679
在日常开发中，经常需要调用第三方接口，例如调用物流接口，此时需要利用urlConnection或者restTemplate模拟postman发送请求，请求支持加header ，设置content-type支持传递json；请求方式get，post，也可以需要传递文件，或者传递文件流；新建springmvc项目，项目结构图pom文件配置文件User类UserController类。
RestTemplate 的传参方式（Get、Put、Post）
Jsundoku的博客
02-24 1万+
文章目录一、RestTemplate 简介1、RestTemplate 概述2、RestTemplate 的配置项3、RestTemplate 请求方式二、RestTemplate 使用1、Get请求方式2、Post 请求方式3、Put 请求方式3、Delete 请求4、RestTemplate 其他方法 一、RestTemplate 简介 1、RestTemplate 概述 2、RestTemp...
RestTemplate的Post请求
You’re a wanderer just like me
12-09 2703
Spring中有个RestTemplate类用来发送HTTP请求很方便，请往下看。 public class RestTemplateUtil { /** * 采用POST请求，数据格式为 application/json，并且返回结果是JSON string * * @param url * @param * @return */ public static String postForJson(String url,
postman的安装与使用方法(模拟Get和Post请求)
10-18
下面将详细讲解Postman的安装和基本使用方法，以模拟GET和POST请求为例。 安装Postman 要使用Postman，首先要进行安装。用户可以通过Postman的官方网站下载安装包，下载地址为：***。根据用户所使用的操作系统，...
postman模拟访问具有Session的post请求方法
12-31
以上这篇postman模拟访问具有Session的post请求方法就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持软件开发网。 您可能感兴趣的文章:Postman模拟发送带token的请求方
Postman模拟请求
06-09
它允许研发者模拟各种HTTP请求，包括GET、POST、PUT、DELETE等多种方法，以便于验证服务器端的接口功能是否正常工作。下面将详细阐述Postman的主要特点和使用方法。 1. **请求模拟**： - GET请求：用于获取资源，...
RestTemplateUtil
LC的博客
01-08 364
都可以的请求方式： HttpHeaders headers = new HttpHeaders(); headers.add("Authorization", "Bearer"); HttpEntity entity = new HttpEntity(body.toString() , headers); ResponseEntity<Object> responseEntity = restTemplate.postForEntity("http://a1/users/{username}/p
Springboot通过RestTemplate发送post请求并且发送文件数据
最新发布
mikumiku5的博客
04-15 721
由于项目需要与外部接口对接，所以需要使用到restTemplate来发送请求，而存在某一个接口需要接受文件类型数据，这种接口参数一般都是通过form-data来接受的，实际上并不难，但是我在写的时候一直报错，最后发现是项目中配置好的restTemplate中发送post请求会将参数打印出来，而参数中包含文件，使用的是JSONObject.toJSONString()，故一直报错，于是打算写此文章记录一下。
后端通过RestTemplate发送Get、Post请求第三方API以及模拟请求响应
qq_44165122的博客
03-03 503
RestTemplate发送Get、Post请求Demo
Postman - REST测试利器
textboy的专栏
04-12 1469
Chrome下Postman安装及rest请求 http://jingyan.baidu.com/article/90808022ff18defd91c80f9a.html Postman下载 http://download.csdn.net/download/zhenghui89/8490331
RestTemplate发起POST请求 突然返回错误码500，但相同的请求再postman中是可以调用
Black794的博客
03-02 3003
今天一个之前一直跑的很正常的springboot项目，RestTemplate发起POST请求 突然一直返回错误码500，但相同的请求再postman中是可以调用的。
springboot使用restTemplate post提交值 restTemplate post值
weixin_34319817的博客
07-21 372
post提交有 FormData和Payload 两种形式： 第一种是formdata形式，在header参数里可以直接看到 payload则封装成json格式post过去，获取以后需要再解析成实体。 restTemplate post json格式 使用阿里巴巴的json包 com.alibaba.fastjson 代码demo如下： url='http:/...
restTemplate工具类
淮右布衣的博客
07-27 236
package com.cm.autooffice.util; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.http.HttpEntity; import org.springframework.http.HttpHeaders; import org.springframework.http.HttpMethod; import org.springframework.
Java——RestTemplate发送POST请求之formData形式
热门推荐
热爱生活 热爱编码
10-14 3万+
import com.alibaba.fastjson.JSON; import org.springframework.http.HttpEntity; import org.springframework.http.HttpHeaders; import org.springframework.http.MediaType; import org.springframework.http.ResponseEntity; import org.springframework.util.LinkedMul.
java模拟postman发post请求
06-06
可以使用Java中的HttpURLConnection类来模拟Postman发送POST请求。具体步骤如下： 1. 创建URL对象，指定请求的URL地址。 2. 调用URL对象的openConnection()方法，获取HttpURLConnection对象。 3. 设置请求的方法为POST，调用setRequestMethod()方法。 4. 设置请求头，调用setRequestProperty()方法。 5. 设置请求体，调用getOutputStream()方法获取输出流，将请求参数写入输出流。 6. 发送请求，调用connect()方法。 7. 获取响应，调用getInputStream()方法获取输入流，读取响应数据。 8. 关闭连接，调用disconnect()方法。 示例代码如下： ``` import java.io.*; import java.net.*; public class PostRequestDemo { public static void main(String[] args) throws Exception { String url = "http://example.com/api"; String params = "param1=value1&param2=value2"; URL obj = new URL(url); HttpURLConnection con = (HttpURLConnection) obj.openConnection(); // 设置请求方法为POST con.setRequestMethod("POST"); // 设置请求头 con.setRequestProperty("User-Agent", "Mozilla/5."); con.setRequestProperty("Accept-Language", "en-US,en;q=.5"); // 设置请求体 con.setDoOutput(true); OutputStream os = con.getOutputStream(); os.write(params.getBytes()); os.flush(); os.close(); // 发送请求 con.connect(); // 获取响应 BufferedReader in = new BufferedReader(new InputStreamReader(con.getInputStream())); String inputLine; StringBuffer response = new StringBuffer(); while ((inputLine = in.readLine()) != null) { response.append(inputLine); } in.close(); // 输出响应结果 System.out.println(response.toString()); // 关闭连接 con.disconnect(); } } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值