RestTemplate中exchange发起请求

已于 2023-07-09 01:00:39 修改
阅读量2.1k 收藏 2
点赞数
分类专栏： springboot 工具 文章标签： spring boot spring java
于 2023-07-09 00:59:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40120559/article/details/131618296
版权

RestTemplate中exchange简单使用

简介

在项目中，我们可能需要发起HTTP请求，请求目标URL来获取响应数据做一些处理。就需要用到HTTP请求工具，常用的Java类工具有：HttpUrlConnection、Apache HttpClient、OK Http等，这些可能需要一些繁琐的配置，不太适合Spring项目的开发。Spring RestTemplate 是 Spring 提供的用于访问 Rest 服务的工具。
这里也推荐另一款HTTP请求工具：https://square.github.io/retrofit/

什么是RestTemplate

  1. RestTemplate是Spring提供的进行远程调用客户端的工具
  2. RestTemplate提供了很多远程调用的方法，能够大大提高客户端的编写效率
  3. 调用RestTemplate的默认构造函数时，RestTemplate底层通过使用java.net包下实现创建HTTP请求访问的
  4. RestTemplate创建需要ClientHttpRequestFactory，其主要的实现主要是如下三种：
  • SimpleClientHttpRequestFactory，默认的实现，使用J2SE提供的方式创建底层的Http请求连接
  • HttpComponentsClientHttpRequestFactory，底层使用HttpClient请求Http服务，可以配置连接池和证书等信息
  • OkHttp3ClientHttpRequestFactory，底层使用OkHttp访问远程的Http服务，也可以配置连接池和证书等信息

常用方法

详细介绍可参考官网：RestTemplate
在这里插入图片描述
常用的xxxForObject和xxxForEntity，是对具体请求方法的简单封装。其中，exchange和execute是功能更丰富的请求方式。

实战

引入依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

示例请求接口

package com.hzl.controller;

import com.alibaba.fastjson.JSON;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.web.bind.annotation.*;

import java.time.LocalDate;
import java.util.List;

/**
 * @Author: zhilin
 * @Date: 2023/7/3 下午11:12
 * @Description: TODO
 */
@RestController
@RequestMapping("/test")
public class TestController {

    @GetMapping("/getOne")
    public Object getOne() {

        return LocalDate.now().toString();
    }

    @GetMapping("/getTwo/{name}")
    public Object getTwo(@PathVariable String name, @RequestParam String type) {

        System.out.println(name + " = " + type);
        return String.format("%s，%s", name, LocalDate.now().toString());
    }

    @GetMapping("/getThree/{name}")
    public Object getThree(@PathVariable String name, @RequestParam Boolean isTo, @RequestParam String type, @RequestParam List<Integer> list) {

        System.out.println(name + "  " + "  " + isTo + "  " + type + "  " + list);
        return String.format("%s，%s，%s", name, type, LocalDate.now().toString());
    }

    @GetMapping("/getFour/{name}")
    public Object getFour(@PathVariable String name, @RequestParam Boolean isTo, @RequestHeader MultiValueMap map, @RequestParam String type, @RequestParam List<Integer> list) {

        System.out.println(name + "  " + isTo + "  " + map + "  " + type + "  " + list);
        int i = 1 / 0;
        return String.format("%s，%s，%s", name, type, LocalDate.now().toString());
    }

    @PostMapping("/postOne/{name}")
    public Object postOne(@PathVariable String name, @RequestParam String type, @RequestParam String color) {


        return String.format("%s==%s==%s", name, type, color);
    }

    @PostMapping("/postTwo/{name}")
    public Object postTwo(@PathVariable String name, @RequestParam Integer type, @RequestBody LinkedMultiValueMap map) {


        System.out.println("name = " + name);
        System.out.println("type = " + type);
        System.out.println("map = " + JSON.toJSONString(map));

        return String.format("%s==%s==%s", name, type, map);
    }

    @PostMapping("/postThree/{name}")
    public Object postThree(@PathVariable String name, @RequestParam Integer type, @RequestBody String json) {


        System.out.println("name = " + name);
        System.out.println("type = " + type);
        System.out.println("json = " + json);

        return String.format("%s==%s==%s", name, type, json);
    }
}

Http请求参数封装

package com.hzl.controller;

import lombok.Data;

import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

/**
 * @Author: zhilin
 * @Date: 2023/7/8 下午4:13
 * @Description: 请求参数封装
 */
@Data
public class HttpRequest {

    /**
     * 请求的地址如：http://localhost:8090/test/postTwo/{name}
     */
    private String url;

    /**
     * 请求的方法(GET/POST)
     */
    private String method;

    /**
     * 请求的格式(form/json)
     */
    private String contentType;

    /**
     * 请求头部参数
     */
    private Map<String, List<String>> headerMap;

    /**
     * 请求path参数
     */
    private Map<String, String> pathMap = new LinkedHashMap<>();

    /**
     * 请求的query参数，url中？后面的部分
     */
    private Map<String, List<String>> queryMap;

    /**
     * 使用 application/x-www-form-urlencoded时请求的body参数集合
     */
    private Map<String, List<String>> bodyMap;

    /**
     * 使用 application/json时请求body的参数
     */
    private String body;
}

封装测试工具类

package com.hzl.controller;

import org.springframework.http.*;
import org.springframework.http.client.ClientHttpResponse;
import org.springframework.http.client.SimpleClientHttpRequestFactory;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.web.client.ResponseErrorHandler;
import org.springframework.web.client.RestTemplate;
import org.springframework.web.util.UriComponents;
import org.springframework.web.util.UriComponentsBuilder;

import java.io.IOException;
import java.util.List;
import java.util.Map;

/**
 * @Author: zhilin
 * @Date: 2023/7/8 下午4:24
 * @Description: TODO
 */
public class HttpRequestUtil {

//    private HttpRequestUtil() {
//    }
//
//    public static class HttpRequestHolder {
//        public static final HttpRequestUtil INSTANCE = new HttpRequestUtil();
//    }
//
//    public static HttpRequestUtil getInstance() {
//        return HttpRequestHolder.INSTANCE;
//    }

    private static final RestTemplate RESTTEMPLATE = new RestTemplate();

    static {
        SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();
        requestFactory.setConnectTimeout(10 * 1000);
        requestFactory.setReadTimeout(30 * 1000);
        RESTTEMPLATE.setRequestFactory(requestFactory);

        RESTTEMPLATE.setErrorHandler(new AcceptResponseErrorHandler());
    }

    /**
     * 使RestTemplate能够对响应的错误消息不进行处理
     * 如：当响应码为400、500等错误时，能够不进行处理，最终用户可以获取到body数据
     */
    private static class AcceptResponseErrorHandler implements ResponseErrorHandler {

        @Override
        public boolean hasError(ClientHttpResponse response) {
//            返回false表示不管response的status是多少都返回没有错误

            return false;
        }

        @Override
        public void handleError(ClientHttpResponse response) {

//            实现你自己业务上遇到了Error进行处理逻辑
            System.out.println("response = " + response);

        }
    }


    public static void exchange(HttpRequest request) {

    }

    public static ResponseEntity get(HttpRequest request) {

        UriComponents uriComponents = UriComponentsBuilder.fromHttpUrl(request.getUrl())
                .queryParams(convertOfString(request.getQueryMap()))
                .buildAndExpand(request.getPathMap())
                .encode();


        ResponseEntity<String> entity = RESTTEMPLATE.getForEntity(uriComponents.toUri(), String.class);

        return entity;
    }

    public static ResponseEntity getOfHeader(HttpRequest request) {

        // 请求头
        HttpHeaders httpHeaders = new HttpHeaders();
        httpHeaders.setContentType(MediaType.parseMediaType(request.getContentType()));
        // 比如如下为系统参数
        httpHeaders.add("id", "666");
        httpHeaders.add("pay", "all");

        httpHeaders.addAll(convertOfString(request.getHeaderMap()));

        // 请求体
        HttpEntity httpEntity = new HttpEntity(httpHeaders);

        // uri
        UriComponentsBuilder builder = UriComponentsBuilder.fromHttpUrl(request.getUrl());
        // 填充query参数
        builder.queryParams(convertOfString(request.getQueryMap()));
        //填充path参数
        UriComponents uriComponents = builder.buildAndExpand(request.getPathMap());

        ResponseEntity<String> entity = RESTTEMPLATE.exchange(uriComponents.toUri(), HttpMethod.GET, httpEntity, String.class);

        return entity;
    }

    public static ResponseEntity post(HttpRequest request) {
        HttpHeaders httpHeaders = new HttpHeaders();
        httpHeaders.setContentType(MediaType.parseMediaType(request.getContentType()));
//        httpHeaders.setContentType(MediaType.APPLICATION_FORM_URLENCODED);
        // 比如如下为系统参数
        httpHeaders.add("id", "666");
        httpHeaders.add("pay", "all");
        httpHeaders.addAll(convertOfString(request.getHeaderMap()));

        // 请求方式为application/x-www-form-urlencoded，取bodyMap
        HttpEntity httpEntity;
        if (MediaType.APPLICATION_FORM_URLENCODED_VALUE.equals(request.getContentType())) {
            httpEntity = new HttpEntity(convertOfString(request.getBodyMap()), httpHeaders);

        } else {
            httpEntity = new HttpEntity(request.getBody(), httpHeaders);
        }


        UriComponentsBuilder builder = UriComponentsBuilder.fromHttpUrl(request.getUrl());
        builder.queryParams(convertOfString(request.getQueryMap()));
        UriComponents uriComponents = builder.buildAndExpand(request.getPathMap());

        ResponseEntity<String> entity = RESTTEMPLATE.exchange(uriComponents.toUri(), HttpMethod.POST, httpEntity, String.class);

        return entity;
    }

    public static MultiValueMap convertOfObject(Map<String, Object> map) {
        MultiValueMap<String, Object> multiValueMap = new LinkedMultiValueMap<>();
        if (map != null && !map.isEmpty()) {
            map.forEach((k, v) -> multiValueMap.add(k, v));
        }

        return multiValueMap;
    }

    public static MultiValueMap convertOfString(Map<String, List<String>> map) {
        MultiValueMap<String, String> multiValueMap = new LinkedMultiValueMap<>();
        if (map != null && !map.isEmpty()) {
            map.forEach((k, v) -> multiValueMap.addAll(k, v));
        }

        return multiValueMap;
    }
}

请求测试

package com.hzl.controller;

import com.alibaba.fastjson.JSON;
import org.springframework.http.HttpMethod;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;

import java.time.LocalDate;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * @Author: zhilin
 * @Date: 2023/7/8 下午4:48
 * @Description: 测试类
 */
public class HttpRequestTest {

    public static final String BASE_URL = "http://localhost:8090/test";

    public static String url1 = BASE_URL + "/getOne";
    public static String url2 = BASE_URL + "/getTwo/{name}";
    public static String url3 = BASE_URL + "/getThree/{name}";
    public static String url33 = BASE_URL + "/getFour/{name}";

    public static String url4 = BASE_URL + "/postOne/{name}";
    public static String url5 = BASE_URL + "/postTwo/{name}";
    public static String url55 = BASE_URL + "/postThree/{name}";


    public static void main(String[] args) {

//        getTest();

        postTest();

    }

    private static void getTest() {
        HttpRequest request = new HttpRequest();
        request.setUrl(url3);
        request.setMethod(HttpMethod.GET.name());
        request.setContentType(MediaType.APPLICATION_FORM_URLENCODED.toString());

        request.setPathMap(new LinkedHashMap<>() {{
            put("name", "zhangsan");
        }});

        request.setHeaderMap(new LinkedHashMap<>() {{
            put("sa-token", Collections.singletonList("123456"));
            put("day", Collections.singletonList(LocalDate.now().toString()));
        }});

        request.setQueryMap(new LinkedHashMap<>() {{
            put("type", Collections.singletonList("java"));
            put("list", Stream.of("1", "2", "3").collect(Collectors.toList()));
            put("isTo", Collections.singletonList("false"));
        }});

        ResponseEntity responseEntity = HttpRequestUtil.getOfHeader(request);
//        ResponseEntity responseEntity = HttpRequestUtil.get(request);

        System.out.println("responseEntity = " + JSON.toJSONString(responseEntity));
    }

    private static void postTest() {
        HttpRequest request = new HttpRequest();
        request.setUrl(url55);
        request.setMethod(HttpMethod.POST.name());
//        request.setContentType(MediaType.APPLICATION_FORM_URLENCODED.toString());
        request.setContentType(MediaType.APPLICATION_JSON.toString());


        request.setPathMap(new LinkedHashMap<>() {{
            put("name", "zhangsan");
        }});

        request.setHeaderMap(new LinkedHashMap<>() {{
            put("sa-token", Collections.singletonList("123456"));
            put("day", Collections.singletonList(LocalDate.now().toString()));
        }});

        request.setQueryMap(new LinkedHashMap<>() {{
            put("type", Collections.singletonList("999"));
            put("list", Stream.of("1", "2", "3").collect(Collectors.toList()));
            put("isTo", Collections.singletonList("false"));
        }});

        request.setBodyMap(new LinkedHashMap<>() {{
            put("hobby", Stream.of("singsong", "dance").collect(Collectors.toList()));
            put("class", Collections.singletonList("1班"));
        }});

        String bodyJson="{\n" +
                "  \"body\": \"zhangsan，java，2023-07-08\",\n" +
                "  \"statusCode\": \"OK\",\n" +
                "  \"statusCodeValue\": 200\n" +
                "}";
        request.setBody(bodyJson);

        ResponseEntity responseEntity = HttpRequestUtil.post(request);
//        ResponseEntity responseEntity = HttpRequestUtil.get(request);

        System.out.println("responseEntity = " + JSON.toJSONString(responseEntity));
    }

}

非excahnge的常用方法请求工具类

package com.hzl.util;

import lombok.extern.slf4j.Slf4j;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.ResponseEntity;
import org.springframework.http.client.SimpleClientHttpRequestFactory;
import org.springframework.web.client.RestTemplate;

import java.util.Map;

/**
 * @Author: zhilin
 * @Date: 2023/7/4 下午10:44
 * @Description: TODO
 */
@Slf4j
public class RestTemplateUtil {

    private static final RestTemplate restTemplate = new RestTemplate();

    static {
        SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();
        requestFactory.setReadTimeout(50 * 1000);
        requestFactory.setConnectTimeout(10 * 1000);

        restTemplate.setRequestFactory(requestFactory);
    }

    // ----------------------------------GET-------------------------------------------------------

    /**
     * GET请求调用方式
     *
     * @param url          请求URL
     * @param responseType 返回对象类型
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> get(String url, Class<T> responseType) {
        return restTemplate.getForEntity(url, responseType);
    }

    /**
     * GET请求调用方式
     *
     * @param url          请求URL
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，按顺序依次对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> get(String url, Class<T> responseType, Object... uriVariables) {
        return restTemplate.getForEntity(url, responseType, uriVariables);
    }

    /**
     * GET请求调用方式
     *
     * @param url          请求URL
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，与Map中的key对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> get(String url, Class<T> responseType, Map<String, ?> uriVariables) {
        return restTemplate.getForEntity(url, responseType, uriVariables);
    }

    /**
     * 带请求头的GET请求调用方式
     *
     * @param url          请求URL
     * @param headers      请求头参数
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，按顺序依次对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> get(String url, Map<String, String> headers, Class<T> responseType, Object... uriVariables) {
        HttpHeaders httpHeaders = new HttpHeaders();
        httpHeaders.setAll(headers);
        return get(url, httpHeaders, responseType, uriVariables);
    }

    /**
     * 带请求头的GET请求调用方式
     *
     * @param url          请求URL
     * @param headers      请求头参数
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，按顺序依次对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> get(String url, HttpHeaders headers, Class<T> responseType, Object... uriVariables) {
        HttpEntity<?> requestEntity = new HttpEntity<>(headers);
        return exchange(url, HttpMethod.GET, requestEntity, responseType, uriVariables);
    }

    /**
     * 带请求头的GET请求调用方式
     *
     * @param url          请求URL
     * @param headers      请求头参数
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，与Map中的key对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> get(String url, Map<String, String> headers, Class<T> responseType, Map<String, ?> uriVariables) {
        HttpHeaders httpHeaders = new HttpHeaders();
        httpHeaders.setAll(headers);
        return get(url, httpHeaders, responseType, uriVariables);
    }

    /**
     * 带请求头的GET请求调用方式
     *
     * @param url          请求URL
     * @param headers      请求头参数
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，与Map中的key对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> get(String url, HttpHeaders headers, Class<T> responseType, Map<String, ?> uriVariables) {
        HttpEntity<?> requestEntity = new HttpEntity<>(headers);
        return exchange(url, HttpMethod.GET, requestEntity, responseType, uriVariables);
    }

    // ----------------------------------POST-------------------------------------------------------

    /**
     * POST请求调用方式
     *
     * @param url          请求URL
     * @param responseType 返回对象类型
     * @return
     */
    public static <T> ResponseEntity<T> post(String url, Class<T> responseType) {
        log.info("--------------------post请求接口，地址为{}", url);
        return restTemplate.postForEntity(url, HttpEntity.EMPTY, responseType);
    }

    /**
     * POST请求调用方式
     *
     * @param url          请求URL
     * @param requestBody  请求参数体
     * @param responseType 返回对象类型
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> post(String url, Object requestBody, Class<T> responseType) {
        log.info("--------------------post请求接口，参数为{}，地址为{}", requestBody, url);
        return restTemplate.postForEntity(url, requestBody, responseType);
    }

    /**
     * POST请求调用方式
     *
     * @param url          请求URL
     * @param requestBody  请求参数体
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，按顺序依次对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> post(String url, Object requestBody, Class<T> responseType, Object... uriVariables) {
        return restTemplate.postForEntity(url, requestBody, responseType, uriVariables);
    }

    /**
     * POST请求调用方式
     *
     * @param url          请求URL
     * @param requestBody  请求参数体
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，与Map中的key对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> post(String url, Object requestBody, Class<T> responseType, Map<String, ?> uriVariables) {
        log.info("--------------------post请求接口，参数为{}，地址为{},地址变量为{}", requestBody, url, uriVariables);
        return restTemplate.postForEntity(url, requestBody, responseType, uriVariables);
    }

    /**
     * 带请求头的POST请求调用方式
     *
     * @param url          请求URL
     * @param headers      请求头参数
     * @param requestBody  请求参数体
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，按顺序依次对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> post(String url, Map<String, String> headers, Object requestBody, Class<T> responseType, Object... uriVariables) {
        HttpHeaders httpHeaders = new HttpHeaders();
        httpHeaders.setAll(headers);
        return post(url, httpHeaders, requestBody, responseType, uriVariables);
    }

    /**
     * 带请求头的POST请求调用方式
     *
     * @param url          请求URL
     * @param headers      请求头参数
     * @param requestBody  请求参数体
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，按顺序依次对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> post(String url, HttpHeaders headers, Object requestBody, Class<T> responseType, Object... uriVariables) {
        HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody, headers);
        return post(url, requestEntity, responseType, uriVariables);
    }

    /**
     * 带请求头的POST请求调用方式
     *
     * @param url          请求URL
     * @param headers      请求头参数
     * @param requestBody  请求参数体
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，与Map中的key对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> post(String url, Map<String, String> headers, Object requestBody, Class<T> responseType, Map<String, ?> uriVariables) {
        HttpHeaders httpHeaders = new HttpHeaders();
        httpHeaders.setAll(headers);
        return post(url, httpHeaders, requestBody, responseType, uriVariables);
    }

    /**
     * 带请求头的POST请求调用方式
     *
     * @param url          请求URL
     * @param headers      请求头参数
     * @param requestBody  请求参数体
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，与Map中的key对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> post(String url, HttpHeaders headers, Object requestBody, Class<T> responseType, Map<String, ?> uriVariables) {
        HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody, headers);
        return post(url, requestEntity, responseType, uriVariables);
    }

    /**
     * 自定义请求头和请求体的POST请求调用方式
     *
     * @param url           请求URL
     * @param requestEntity 请求头和请求体封装对象
     * @param responseType  返回对象类型
     * @param uriVariables  URL中的变量，按顺序依次对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> post(String url, HttpEntity<?> requestEntity, Class<T> responseType, Object... uriVariables) {
        return restTemplate.exchange(url, HttpMethod.POST, requestEntity, responseType, uriVariables);
    }

    /**
     * 自定义请求头和请求体的POST请求调用方式
     *
     * @param url           请求URL
     * @param requestEntity 请求头和请求体封装对象
     * @param responseType  返回对象类型
     * @param uriVariables  URL中的变量，与Map中的key对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> post(String url, HttpEntity<?> requestEntity, Class<T> responseType, Map<String, ?> uriVariables) {
        return restTemplate.exchange(url, HttpMethod.POST, requestEntity, responseType, uriVariables);
    }

    // ----------------------------------PUT-------------------------------------------------------

    /**
     * PUT请求调用方式
     *
     * @param url          请求URL
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，按顺序依次对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> put(String url, Class<T> responseType, Object... uriVariables) {
        return put(url, HttpEntity.EMPTY, responseType, uriVariables);
    }

    /**
     * PUT请求调用方式
     *
     * @param url          请求URL
     * @param requestBody  请求参数体
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，按顺序依次对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> put(String url, Object requestBody, Class<T> responseType, Object... uriVariables) {
        HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody);
        return put(url, requestEntity, responseType, uriVariables);
    }

    /**
     * PUT请求调用方式
     *
     * @param url          请求URL
     * @param requestBody  请求参数体
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，与Map中的key对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> put(String url, Object requestBody, Class<T> responseType, Map<String, ?> uriVariables) {
        HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody);
        return put(url, requestEntity, responseType, uriVariables);
    }

    /**
     * 带请求头的PUT请求调用方式
     *
     * @param url          请求URL
     * @param headers      请求头参数
     * @param requestBody  请求参数体
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，按顺序依次对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> put(String url, Map<String, String> headers, Object requestBody, Class<T> responseType, Object... uriVariables) {
        HttpHeaders httpHeaders = new HttpHeaders();
        httpHeaders.setAll(headers);
        return put(url, httpHeaders, requestBody, responseType, uriVariables);
    }

    /**
     * 带请求头的PUT请求调用方式
     *
     * @param url          请求URL
     * @param headers      请求头参数
     * @param requestBody  请求参数体
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，按顺序依次对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> put(String url, HttpHeaders headers, Object requestBody, Class<T> responseType, Object... uriVariables) {
        HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody, headers);
        return put(url, requestEntity, responseType, uriVariables);
    }

    /**
     * 带请求头的PUT请求调用方式
     *
     * @param url          请求URL
     * @param headers      请求头参数
     * @param requestBody  请求参数体
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，与Map中的key对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> put(String url, Map<String, String> headers, Object requestBody, Class<T> responseType, Map<String, ?> uriVariables) {
        HttpHeaders httpHeaders = new HttpHeaders();
        httpHeaders.setAll(headers);
        return put(url, httpHeaders, requestBody, responseType, uriVariables);
    }

    /**
     * 带请求头的PUT请求调用方式
     *
     * @param url          请求URL
     * @param headers      请求头参数
     * @param requestBody  请求参数体
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，与Map中的key对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> put(String url, HttpHeaders headers, Object requestBody, Class<T> responseType, Map<String, ?> uriVariables) {
        HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody, headers);
        return put(url, requestEntity, responseType, uriVariables);
    }

    /**
     * 自定义请求头和请求体的PUT请求调用方式
     *
     * @param url           请求URL
     * @param requestEntity 请求头和请求体封装对象
     * @param responseType  返回对象类型
     * @param uriVariables  URL中的变量，按顺序依次对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> put(String url, HttpEntity<?> requestEntity, Class<T> responseType, Object... uriVariables) {
        return restTemplate.exchange(url, HttpMethod.PUT, requestEntity, responseType, uriVariables);
    }

    /**
     * 自定义请求头和请求体的PUT请求调用方式
     *
     * @param url           请求URL
     * @param requestEntity 请求头和请求体封装对象
     * @param responseType  返回对象类型
     * @param uriVariables  URL中的变量，与Map中的key对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> put(String url, HttpEntity<?> requestEntity, Class<T> responseType, Map<String, ?> uriVariables) {
        return restTemplate.exchange(url, HttpMethod.PUT, requestEntity, responseType, uriVariables);
    }

    // ----------------------------------DELETE-------------------------------------------------------

    /**
     * DELETE请求调用方式
     *
     * @param url          请求URL
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，按顺序依次对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> delete(String url, Class<T> responseType, Object... uriVariables) {
        return delete(url, HttpEntity.EMPTY, responseType, uriVariables);
    }

    /**
     * DELETE请求调用方式
     *
     * @param url          请求URL
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，与Map中的key对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> delete(String url, Class<T> responseType, Map<String, ?> uriVariables) {
        return delete(url, HttpEntity.EMPTY, responseType, uriVariables);
    }

    /**
     * DELETE请求调用方式
     *
     * @param url          请求URL
     * @param requestBody  请求参数体
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，按顺序依次对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> delete(String url, Object requestBody, Class<T> responseType, Object... uriVariables) {
        HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody);
        return delete(url, requestEntity, responseType, uriVariables);
    }

    /**
     * DELETE请求调用方式
     *
     * @param url          请求URL
     * @param requestBody  请求参数体
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，与Map中的key对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> delete(String url, Object requestBody, Class<T> responseType, Map<String, ?> uriVariables) {
        HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody);
        return delete(url, requestEntity, responseType, uriVariables);
    }

    /**
     * 带请求头的DELETE请求调用方式
     *
     * @param url          请求URL
     * @param headers      请求头参数
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，按顺序依次对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> delete(String url, Map<String, String> headers, Class<T> responseType, Object... uriVariables) {
        HttpHeaders httpHeaders = new HttpHeaders();
        httpHeaders.setAll(headers);
        return delete(url, httpHeaders, responseType, uriVariables);
    }

    /**
     * 带请求头的DELETE请求调用方式
     *
     * @param url          请求URL
     * @param headers      请求头参数
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，按顺序依次对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> delete(String url, HttpHeaders headers, Class<T> responseType, Object... uriVariables) {
        HttpEntity<Object> requestEntity = new HttpEntity<Object>(headers);
        return delete(url, requestEntity, responseType, uriVariables);
    }

    /**
     * 带请求头的DELETE请求调用方式
     *
     * @param url          请求URL
     * @param headers      请求头参数
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，与Map中的key对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> delete(String url, Map<String, String> headers, Class<T> responseType, Map<String, ?> uriVariables) {
        HttpHeaders httpHeaders = new HttpHeaders();
        httpHeaders.setAll(headers);
        return delete(url, httpHeaders, responseType, uriVariables);
    }

    /**
     * 带请求头的DELETE请求调用方式
     *
     * @param url          请求URL
     * @param headers      请求头参数
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，与Map中的key对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> delete(String url, HttpHeaders headers, Class<T> responseType, Map<String, ?> uriVariables) {
        HttpEntity<Object> requestEntity = new HttpEntity<Object>(headers);
        return delete(url, requestEntity, responseType, uriVariables);
    }

    /**
     * 带请求头的DELETE请求调用方式
     *
     * @param url          请求URL
     * @param headers      请求头参数
     * @param requestBody  请求参数体
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，按顺序依次对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> delete(String url, Map<String, String> headers, Object requestBody, Class<T> responseType, Object... uriVariables) {
        HttpHeaders httpHeaders = new HttpHeaders();
        httpHeaders.setAll(headers);
        return delete(url, httpHeaders, requestBody, responseType, uriVariables);
    }

    /**
     * 带请求头的DELETE请求调用方式
     *
     * @param url          请求URL
     * @param headers      请求头参数
     * @param requestBody  请求参数体
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，按顺序依次对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> delete(String url, HttpHeaders headers, Object requestBody, Class<T> responseType, Object... uriVariables) {
        HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody, headers);
        return delete(url, requestEntity, responseType, uriVariables);
    }

    /**
     * 带请求头的DELETE请求调用方式
     *
     * @param url          请求URL
     * @param headers      请求头参数
     * @param requestBody  请求参数体
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，与Map中的key对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> delete(String url, Map<String, String> headers, Object requestBody, Class<T> responseType, Map<String, ?> uriVariables) {
        HttpHeaders httpHeaders = new HttpHeaders();
        httpHeaders.setAll(headers);
        return delete(url, httpHeaders, requestBody, responseType, uriVariables);
    }

    /**
     * 带请求头的DELETE请求调用方式
     *
     * @param url          请求URL
     * @param headers      请求头参数
     * @param requestBody  请求参数体
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，与Map中的key对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> delete(String url, HttpHeaders headers, Object requestBody, Class<T> responseType, Map<String, ?> uriVariables) {
        HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody, headers);
        return delete(url, requestEntity, responseType, uriVariables);
    }

    /**
     * 自定义请求头和请求体的DELETE请求调用方式
     *
     * @param url           请求URL
     * @param requestEntity 请求头和请求体封装对象
     * @param responseType  返回对象类型
     * @param uriVariables  URL中的变量，按顺序依次对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> delete(String url, HttpEntity<?> requestEntity, Class<T> responseType, Object... uriVariables) {
        return restTemplate.exchange(url, HttpMethod.DELETE, requestEntity, responseType, uriVariables);
    }

    /**
     * 自定义请求头和请求体的DELETE请求调用方式
     *
     * @param url           请求URL
     * @param requestEntity 请求头和请求体封装对象
     * @param responseType  返回对象类型
     * @param uriVariables  URL中的变量，与Map中的key对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> delete(String url, HttpEntity<?> requestEntity, Class<T> responseType, Map<String, ?> uriVariables) {
        return restTemplate.exchange(url, HttpMethod.DELETE, requestEntity, responseType, uriVariables);
    }

    // ----------------------------------通用方法-------------------------------------------------------

    /**
     * 通用调用方式
     *
     * @param url           请求URL
     * @param method        请求方法类型
     * @param requestEntity 请求头和请求体封装对象
     * @param responseType  返回对象类型
     * @param uriVariables  URL中的变量，按顺序依次对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity, Class<T> responseType, Object... uriVariables) {
        return restTemplate.exchange(url, method, requestEntity, responseType, uriVariables);
    }

    /**
     * 通用调用方式
     *
     * @param url           请求URL
     * @param method        请求方法类型
     * @param requestEntity 请求头和请求体封装对象
     * @param responseType  返回对象类型
     * @param uriVariables  URL中的变量，与Map中的key对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity, Class<T> responseType, Map<String, ?> uriVariables) {
        return restTemplate.exchange(url, method, requestEntity, responseType, uriVariables);
    }

    /**
     * 获取RestTemplate实例对象，可自由调用其方法
     *
     * @return RestTemplate实例对象
     */
    public static RestTemplate getRestTemplate() {
        return restTemplate;
    }


}
百木成林
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring RestTemplate介绍
Meiko记录
01-28 620
上篇文件介绍Eureka服务的文章中，我们介绍到consumer从Eureka中通过LoadBalancerClient获取到服务端地址信息后通过RestTemplate来远程调用服务的场景，本文来具体介绍下RestTemplate的使用 RestTemplate   SpringRestTemplate是Spring 提供的用于访问 Rest 服务的客端, RestTemplate提供了多种便捷访问远程Http服务的方法，能够大大提高客户端的编写效率,所以很多客户端比如Android或者第三方服务商都
springRestTemplate
08-03
- 使用 `exchange()` 或 `execute()` 方法发起请求，这两个方法都需要提供一个 URI 和请求方法。 - 设置请求头和参数。 - 处理响应，如将响应体转换为所需的对象。 6. **在 Spring Boot 中使用 RestTemplate** ...
RestTemplate.exchange用法
我的博客
08-13 998
其实自定义的对象和String调用是一样的，只需要将返回类型String.class改成DTO.class即可根据用户id获取用户信息@Data@Builder调用代码// 1.2 get请求返回对象类型id=" + id;被调用的mock代码.name("天罡" + id)ok~~请求 http://localhost:8080/demo/user?
Http请求实战 ---- 【restTemplate.exchange方法】的简单了解应用
m0_46459413的博客
03-31 1万+
1、什么是RestTemplate RestTemple是Spring提供的用于访问Http请求的客户端； 相对于apache的HTTPClient类，逻辑繁琐，代码复杂，还要自己编写使用类HttpClientUtil，封装对应的post，get，delete等方法。 RestTemplate可以通过callback回调方法和配置HttpMessageConverter 来定制，用来把对象封装到HTTP请求体，将响应信息放到一个对象中。RestTemplate提供更高等级的符合HTTP的六种主要方法，可以很
RestTemplate中的请求方式的应用
最新发布
weixin_67976657的博客
04-12 721
RestTemplate是Spring框架中的一个用于访问RESTful服务的模板类。它提供了一组方便的方法来发送HTTP请求并处理响应。RestTemplate可以用来发送GET、POST、PUT、DELETE等类型的请求，并可以处理JSON、XML等多种格式的响应数据。在Spring中使用RestTemplate可以简化与RESTful服务的交互，使得开发者可以更加方便地进行HTTP通信。GETPOST。
restTemplate的exchange请求如何实现
無言的博客
03-13 9976
为什么要用RestTemplate？？ 相信大家之前都用过apache的HTTPClient类，逻辑繁琐，代码复杂，还要自己编写使用类HttpClientUtil，封装对应的post，get，delete等方法。 RestTemplate的行为可以通过callback回调方法和配置HttpMessageConverter 来定制，用来把对象封装到HTTP请求体，将响应信息放到一个对象中。Rest...
RestTemplate源码分析
tideseng的博客
05-04 496
相信RestTemplate是我们在SpringBoot中用过的最多的http客户端，今天来分析他的源码。 一、最简单的用法 首先需要向容器中注入RestTemplate的Bean实例 @Configurationpublic class RestTemplateConfig { @Bean public RestTemplate getRestTemplate() { retur...
RestTemplate.exchange各种用法
tenc1239的博客
05-06 497
1 返回直是自定一类型。
RestTemplate例子
06-01
- 执行请求：使用`exchange()`、`getForObject()`、`postForEntity()`等方法发起HTTP请求。 - 处理响应：返回的结果可以通过`ResponseEntity`或直接转换为目标类型。 2. **HTTP方法** - GET：获取资源，例如`...
Spring Boot使用RestTemplate消费REST服务的几个问题记录
08-27
RestTemplate是Spring中对HttpClient的再次封装，简化了发起HTTP请求以及处理响应的过程，抽象层级更高，减少消费者的模板代码，使冗余代码更少。它提供了多种模板方法，隐藏了更多细节，方便开发者使用。 ...
spring rest mvc使用RestTemplate调用
04-13
总结，`RestTemplate`是Spring中实现RESTful服务间通信的强大工具，通过它我们可以方便地发起各种HTTP请求，处理响应，以及定制请求行为。在实际项目中，根据需求选择适当的HTTP方法、设置请求头、处理异常，以及...
【转】Spring中模板模式和回调模式的讲解
04-20
例如，在`RestTemplate`中，你可以看到模板方法`exchange()`，它定义了HTTP请求的基本流程，同时允许你通过回调接口（如`ResponseEntityCallback`）定制响应处理。这种方式既保持了核心逻辑的统一，又赋予了用户处理...
RestTemplate的常用总结
大唐响马的博客
12-08 1672
###post方式 //有参 请求体【body体中】json参数 JSONObject params=new JSONObject(); params.put("param1","value1"); JSONObject jsonobject=restTemplate.postForTemplate(url,params,JSONObject.class); //有参 请求体中json参数 设置header头 JSONObject param = new JSONObject();
[RestTemplate] 配置 及 调用POST GET请求 demo
hkk666123的博客
07-20 3736
目录 01. RestTemplate简介 A). 简要说明 B). RestTemplate有两个构造方法 C). ClientHttpRequestFactory的两种实现 02. Spring的RestTemplate对Post/Get的常用接口 A). Post请求API B). Get请求API 03. 配置及使用 A). 配置文件 B). 测试使用 附录及示例:...
【springboot进阶】RestTemplate进阶封装常用请求方式
06-30 4259
对RestTemplate再进一步封装出符合form-data、x-www-form-urlencoded、json格式的请求方法，配合fastjson的序列化，将请求实体bean转换为请求参数，使远程调用方式更加优雅。
详解RestTemplate的Get请求Header设置
zzy7075的专栏
08-14 9365
详解RestTemplate的Get请求Header设置
RestTemplate使用方法
大家好，我是云村的王子
09-28 3899
RestTemplate的使用方法
RestTemplate的exchange方法，post请求实现跨域操作
weixin_41876987的博客
08-26 7539
问题描述： 前台页面访问第三方接口，http的post请求，实现跨域。浏览器控制台报错如下： 处理方法： （1）前台js： （2）contoller处理： 代码详情： @RequestMapping(value = "/sjtb", method = RequestMethod.POST) @ResponseBody public JsonObject sjtb(String ywlsh,String ywfldm,Ht...
SpringMVC RestTemplate的几种请求调用
热门推荐
ThinkingLink的专栏
04-29 4万+
欢迎使用Markdown编辑器写博客本Markdown编辑器使用StackEdit修改而来，用它写博客，将会带来全新的体验哦： Markdown和扩展Markdown简洁的语法 代码块高亮 图片链接和图片上传 LaTex数学公式 UML序列图和流程图 离线写博客 导入导出Markdown文件 丰富的快捷键 快捷键 加粗 Ctrl + B 斜体 Ctrl + I 引用 Ctrl
RestTemplate发起post请求
08-19
RestTemplate是Spring Framework提供的一个用于进行HTTP请求的类库。要使用RestTemplate发起POST请求，你可以按照以下步骤进行操作： 1. 首先，你需要创建一个RestTemplate对象，可以通过在Spring容器中进行注入或者直接实例化来获取一个RestTemplate实例。 2. 创建一个表示请求体的对象，可以是一个POJO对象或者是一个Map对象，根据具体的需求来决定。 3. 如果有需要，你可以设置请求头信息，例如设置Content-Type、Authorization等。 4. 调用RestTemplate对象的postForObject()方法来发送POST请求，并且接收响应结果。 下面是一个使用RestTemplate发起POST请求的示例代码： ```java import org.springframework.http.HttpEntity; import org.springframework.http.HttpHeaders; import org.springframework.http.HttpMethod; import org.springframework.http.MediaType; import org.springframework.http.ResponseEntity; import org.springframework.web.client.RestTemplate; public class PostExample { public static void main(String[] args) { // 创建RestTemplate对象 RestTemplate restTemplate = new RestTemplate(); // 创建请求体对象 YourRequestObject requestObject = new YourRequestObject(); // 设置请求头信息 HttpHeaders headers = new HttpHeaders(); headers.setContentType(MediaType.APPLICATION_JSON); // 创建HttpEntity对象，用于封装请求体和请求头 HttpEntity<YourRequestObject> httpEntity = new HttpEntity<>(requestObject, headers); // 发送POST请求，并接收响应结果 ResponseEntity<YourResponseObject> responseEntity = restTemplate.exchange( "http://example.com/api/endpoint", // 请求URL HttpMethod.POST, // 请求方法 httpEntity, // 请求体和请求头 YourResponseObject.class // 响应结果类型 ); // 获取响应结果 YourResponseObject responseObject = responseEntity.getBody(); // 处理响应结果 } } ``` 以上代码中的`YourRequestObject`和`YourResponseObject`分别表示请求体和响应结果的自定义对象，你需要根据实际情况进行替换。另外，根据你的需求可能需要进行异常处理、日志记录等其他操作。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值