【Spring】RestTemplate基础用法小结

于 2024-06-30 02:00:00 发布
阅读量49 收藏
点赞数
分类专栏： 转载 文章标签： spring java spring boot
原文链接：https://spring.hhui.top/spring-blog/2020/06/17/200617-SpringBoot%E7%B3%BB%E5%88%97RestTemplate%E5%9F%BA%E7%A1%80%E7%94%A8%E6%B3%95%E5%B0%8F%E7%BB%93/
版权

在这里插入图片描述

1.概述

转载：RestTemplate基础用法小结

在Spring项目中，通常会借助RestTemplate来实现网络请求，RestTemplate封装得很完善了，基本上可以非常简单的完成各种HTTP请求，本文主要介绍一下基本操作，最常见的GET/POST请求的使用姿势

2.项目搭建

2.1. 配置

借助SpringBoot搭建一个SpringWEB项目，提供一些用于测试的REST服务

SpringBoot版本: 2.2.1.RELEASE
核心依赖: spring-boot-stater-web

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

为了后续输出的日志更直观，这里设置了一下日志输出格式，在配置文件application.yml中，添加

logging:
  pattern:
    console: (%msg%n%n){blue}

2.2. Rest服务

添加三个接口，分别提供GET请求，POST表单，POST json对象，然后返回请求头、请求参数、cookie，具体实现逻辑相对简单，也不属于本篇重点，因此不赘述说明

package com.spring.controller;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import sun.misc.BASE64Decoder;

import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.Serializable;
import java.util.Enumeration;

@RestController
public class RestTemplateController {

    private String getHeaders(HttpServletRequest request) {
        Enumeration<String> headerNames = request.getHeaderNames();
        String name;

        JSONObject headers = new JSONObject();
        while (headerNames.hasMoreElements()) {
            name = headerNames.nextElement();
            headers.put(name, request.getHeader(name));
        }
        return headers.toJSONString();
    }

    private String getParams(HttpServletRequest request) {
        return JSONObject.toJSONString(request.getParameterMap());
    }

    private String getCookies(HttpServletRequest request) {
        Cookie[] cookies = request.getCookies();
        if (cookies == null || cookies.length == 0) {
            return "";
        }

        JSONObject ck = new JSONObject();
        for (Cookie cookie : cookies) {
            ck.put(cookie.getName(), cookie.getValue());
        }
        return ck.toJSONString();
    }

    private String buildResult(HttpServletRequest request) {
        return buildResult(request, null);
    }

    private String buildResult(HttpServletRequest request, Object obj) {
        String params = getParams(request);
        String headers = getHeaders(request);
        String cookies = getCookies(request);

        if (obj != null) {
            params += " | " + obj;
        }

        return "params: " + params + "\nheaders: " + headers + "\ncookies: " + cookies;
    }

    @GetMapping(path = "get")
    public String get(HttpServletRequest request) {
        return buildResult(request);
    }

    @PostMapping(path = "post")
    public String post(HttpServletRequest request) {
        return buildResult(request);
    }

    @Data
    @NoArgsConstructor
    public static class ReqBody implements Serializable {
        private static final long serialVersionUID = -4536744669004135021L;
        private String name;
        private Integer age;
    }

    @PostMapping(path = "body")
    public String postBody(@RequestBody ReqBody body) {
        HttpServletRequest request =
                ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        return buildResult(request, body);
    }

    @GetMapping(path = "timeout")
    public String timeOut(HttpServletRequest request) throws InterruptedException {
        Thread.sleep(60_000L);
        return buildResult(request);
    }


    /**
     * 标准的http auth验证
     *
     * @param request
     * @param response
     * @return
     */
    @GetMapping(path = "auth")
    public String auth(HttpServletRequest request, HttpServletResponse response) throws IOException, IOException {
        String auth = request.getHeader("Authorization");
        if (StringUtils.isEmpty(auth)) {
            response.setStatus(401);
            response.setHeader("WWW-Authenticate", "Basic realm=\"input username and password\"");
            return buildResult(request) + "\n>>>no auth header";
        }

        String[] userAndPass = new String(new BASE64Decoder().decodeBuffer(auth.split(" ")[1])).split(":");
        if (userAndPass.length < 2) {
            response.setStatus(401);
            response.setHeader("WWW-Authenticate", "Basic realm=\"input username and password\"");
            return buildResult(request) + "\n>>>illegal auth: " + auth;
        }

        if ("user".equalsIgnoreCase(userAndPass[0]) && "pwd".equalsIgnoreCase(userAndPass[1])) {
            return buildResult(request) + "\n>>>auth: success!";
        }

        response.setStatus(401);
        response.setHeader("WWW-Authenticate", "Basic realm=\"input username and password\"");
        return buildResult(request) + "\n>>>illegal user or pwd!";
    }

    @GetMapping(path = "atimeout")
    public String aTimeOut(HttpServletRequest request) throws InterruptedException {
        Thread.sleep(3_000L);
        return "time out!" + JSON.toJSONString(request.getParameterMap());
    }

    @GetMapping(path = "4xx")
    public String _4xx(HttpServletRequest request, HttpServletResponse response) {
        response.setStatus(401);
        return "return 401 : " + JSON.toJSONString(request.getParameterMap());
    }
}

3.RestTemplate示例

3.1. Get请求

使用RestTemplate发起GET请求，通常有两种常见的方式

  1. getForEntity: 返回的正文对象包装在HttpEntity实体中，适用于获取除了返回的正文之外，对返回头、状态码有需求的场景

  2. getForObject: 返回正文，适用于只对正文感兴趣的场景
    上面这两种方法除了返回结果不同之外，其他的使用姿势基本一样，有三种

@Nullable
public <T> T getForObject(String url, Class<T> responseType, Object... uriVariables) throws RestClientException;

@Nullable
public <T> T getForObject(String url, Class<T> responseType, Map<String, ?> uriVariables) throws RestClientException;

@Nullable
public <T> T getForObject(URI url, Class<T> responseType) throws RestClientException;

上面三个重载方法，区别仅在于GET参数如何处理，下面给出一个实例进行说明

/**
     * 基本的get请求
     */
    @Test
    public void basicGet() {
        RestTemplate restTemplate = new RestTemplate();

        HttpEntity<String> res =
                restTemplate.getForEntity("http://127.0.0.1:8082/get?name=一灰灰Blog&age=20", String.class);
        log.info("Simple getForEntity res: {}", res);

        // 直接在url中拼参数，调用的是前面对应的方法1; 当然这里也可以将url转成URI格式，这样调用的是方法3
        String response = restTemplate.getForObject("http://127.0.0.1:8082/get?name=一灰灰Blog&age=20", String.class);
        log.info("Simple getForObject res: {}", response);

        // 通过可变参数，填充url参数中的{?}, 注意顺序是对应的
        response = restTemplate.getForObject("http://127.0.0.1:8082/get?name={?}&age={?}", String.class, "一灰灰Blog", 20);
        log.info("Simple getForObject by uri params: {}", response);


        // 参数放在map中，通过map的key与url中的{}进行匹配，实现参数替换
        response = restTemplate.getForObject("http://127.0.0.1:8082/get?name={name}&age={age}", String.class,
                new HashMap<String, Object>() {
                    {
                        put("name", "一灰灰Blog");
                        put("age", 20);
                    }
                });
        log.info("Simple getForObject by uri map params: {}", response);
    }

输出结果如下:

(Simple getForEntity res: <200,params: {"name":["一灰灰Blog"],"age":["20"]}
headers: {"host":"127.0.0.1:8080","connection":"keep-alive","accept":"text/plain, application/json, application/*+json, */*","user-agent":"Java/1.8.0_171"}
cookies: ,[Content-Type:"text/plain;charset=UTF-8", Content-Length:"213", Date:"Wed, 17 Jun 2020 01:14:16 GMT"]>

(Simple getForObject res: params: {"name":["一灰灰Blog"],"age":["20"]}
headers: {"host":"127.0.0.1:8080","connection":"keep-alive","accept":"text/plain, application/json, application/*+json, */*","user-agent":"Java/1.8.0_171"}
cookies: 

(Simple getForObject by uri params: params: {"name":["一灰灰Blog"],"age":["20"]}
headers: {"host":"127.0.0.1:8080","connection":"keep-alive","accept":"text/plain, application/json, application/*+json, */*","user-agent":"Java/1.8.0_171"}
cookies: 

(Simple getForObject by uri map params: params: {"name":["一灰灰Blog"],"age":["20"]}
headers: {"host":"127.0.0.1:8080","connection":"keep-alive","accept":"text/plain, application/json, application/*+json, */*","user-agent":"Java/1.8.0_171"}
cookies:

3.2. POST表单

POST表单属于非常基础的请求方式了，根据返回结果，RestTemplate同样提供了两种姿势

postForEntity: 返回的正文封装在HttpEntity
postForObject: 直接返回正文对象

它的使用姿势一样有三种

@Nullable
public <T> T postForObject(String url, @Nullable Object request, Class<T> responseType, Object... uriVariables);

@Nullable
public <T> T postForObject(String url, @Nullable Object request, Class<T> responseType, Map<String, ?> uriVariables);

@Nullable
public <T> T postForObject(URI url, @Nullable Object request, Class<T> responseType);

请注意上面三个方法的前两个，后面的uriVariables是url参数，不是POST表单参数哦，它们之间是有区别的（虽然我们一般post提交表单时，不怎么会在url中添加参数）

下面还是根据实际的用例来查看

 /**
     * post基本请求
     *
     * 先启动主类，然后运行测试类
     */
    @Test
    public void basicPost() {
        RestTemplate restTemplate = new RestTemplate();

        HttpEntity<String> res = restTemplate
                .postForEntity("http://127.0.0.1:8080/post?name=一灰灰Blog&age=20", new LinkedMultiValueMap<>(),
                        String.class);
        log.info("Simple postForEntity res: {}", res);

        // 提交的表单参数
        MultiValueMap<String, Object> params = new LinkedMultiValueMap<>();
        params.add("name", "一灰灰Blog");
        params.add("age", 20);

        String response = restTemplate.postForObject("http://127.0.0.1:8080/post", params, String.class);
        log.info("Simple postForObject res: {}", response);
        // 这个url参数是放在url上面的哦
        response = restTemplate.postForObject("http://127.0.0.1:8080/post?urlName={?}", params, String.class, "url参数");
        log.info("Simple postForObject with urlParams res: {}", response);

        response = restTemplate.postForObject("http://127.0.0.1:8080/post?urlName={urlName}", params, String.class,
                new HashMap<String, Object>() {{
                    put("urlName", "url参数");
                }});
        log.info("Simple postForObject with map urlParams res: {}", response);
    }

测试输出如下

(Simple postForEntity res: <200,params: {"name":["一灰灰Blog"],"age":["20"]}
headers: {"content-length":"0","host":"127.0.0.1:8080","content-type":"application/x-www-form-urlencoded;charset=UTF-8","connection":"keep-alive","accept":"text/plain, application/json, application/*+json, */*","user-agent":"Java/1.8.0_171"}
cookies: ,[Content-Type:"text/plain;charset=UTF-8", Content-Length:"299", Date:"Wed, 17 Jun 2020 01:14:16 GMT"]>

(Simple postForObject res: params: {"name":["一灰灰Blog"],"age":["20"]}
headers: {"content-length":"338","host":"127.0.0.1:8080","content-type":"multipart/form-data;charset=UTF-8;boundary=URAN0wQz_s1vauFbDLFRZ40bb3NtRRwgLuII-wCk","connection":"keep-alive","accept":"text/plain, application/json, application/*+json, */*","user-agent":"Java/1.8.0_171"}
cookies: 

(Simple postForObject with urlParams res: params: {"name":["一灰灰Blog"],"age":["20"],"urlName":["url参数"]}
headers: {"content-length":"314","host":"127.0.0.1:8080","content-type":"multipart/form-data;charset=UTF-8;boundary=2h15swz9SJPfjCxv2cNOwDn_TR2nK4gF","connection":"keep-alive","accept":"text/plain, application/json, application/*+json, */*","user-agent":"Java/1.8.0_171"}
cookies: 

(Simple postForObject with map urlParams res: params: {"name":["一灰灰Blog"],"age":["20"],"urlName":["url参数"]}
headers: {"content-length":"329","host":"127.0.0.1:8080","content-type":"multipart/form-data;charset=UTF-8;boundary=QOhroKp7BE4cNF5Oi3CJLdq_ixzk0t5ZZw9ch","connection":"keep-alive","accept":"text/plain, application/json, application/*+json, */*","user-agent":"Java/1.8.0_171"}
cookies:

3.3. post body

post一个json串，也属于比较常见的一种case了，对于RestTemplate而言，要支持这种方式，需要额外处理一下请求头，设置Content-Type为application/json

使用姿势和上面相差不大，只是需要注意一下请求参数的构建

 /**
     * json表单
     */
    @Test
    public void jsonPost() {
        RestTemplate restTemplate = new RestTemplate();

        // 设置请求头
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_JSON);

        // 提交的json串
        JSONObject params = new JSONObject();
        params.put("name", "一灰灰Blog");
        params.put("age", 20);

        // 构建请求参数
        HttpEntity<String> request = new HttpEntity<>(params.toJSONString(), headers);

        String response = restTemplate.postForObject("http://127.0.0.1:8080/body", request, String.class);
        log.info("json post res: {}", response);
    }

输出如下

(json post res: params: {} | DemoRest.ReqBody(name=???Blog, age=20)
headers: {"content-length":"27","host":"127.0.0.1:8080","content-type":"application/json","connection":"keep-alive","accept":"text/plain, application/json, application/*+json, */*","user-agent":"Java/1.8.0_171"}
cookies:

请注意，提交的json串中文乱码了

4. 小结

上面主要介绍的是RestTemplate的常规用法，基础的GET/POST请求姿势，如果业务简单，不需要考虑各种复杂的异常情况，也是没有太多的问题了；那么如果需要考虑，又有哪些需要注意的呢？

上面的中文乱码问题如何解决？
自定义的请求头如何塞入（如果是爬虫，上面的User-Agent太容易被屏蔽了）
cookie设置
REST支持Basic Auth的验证方式如何发起请求
超时设置
自定义连接池替换
REST返回非200状态码的情况，能否不抛异常，自定义处理？
ssl校验
…
九师兄
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Springboot集成restTemplate过程详解
08-19
主要介绍了Springboot集成restTemplate过程详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
RestTemplate入门
qq_32267523的博客
12-24 146
RestTemplate入门1.简述RestTemplate2.RestTemplate VS HttpClient3.get请求实践4.post请求实践5.SpringBoot集成RestTemplate 1.简述RestTemplate RestTemplate是Spring提供的用于访问Rest服务的客户端，RestTemplate提供了多种便捷访问远程Http服务的方法，简化了与http服务的通信，并满足RestFul原则，程序代码可以给它提供URL，并提取结果，能够大大提高客户端的编写效率。 该类
SpringBoot使用RestTemplate发起http请求
最新发布
彭世瑜的博客
06-26 335
使用到的json输出工具类。可以替换url上的变量。
SpringBoot2_RestTemplate
有点想法的专栏
08-22 752
文章目录1.介绍2.使用2.1 服务器端准备2.2 客户端准备2.3 Get2.3.1 getForObject2.3.2 getForEntity2.4 Post2.4.1 postForObject模拟表单数据提交2.4.2 postForEntity2.4.3 postForLocation2.5 Exchange2.5.1 RESTful风格与HTTP method2.6 异常处理2.6.1 增加异常处理类2.6.2 继承默认实现类DefaultResponseErrorHandler其他 1.介绍
springboot2简单配置restTemplate
qq_41921994的博客
03-17 369
package org.example.es.config; import org.apache.http.client.config.RequestConfig; import org.apache.http.config.SocketConfig; import org.apache.http.impl.client.CloseableHttpClient; import org.apache.http.impl.client.HttpClients; import org.apache.http.im
Spring Boot2 实战系列之使用 RestTemplate
YekonGLE
05-02 1522
前言 在另一篇博文 Spring Boot2 实战系列之RESTful Web Service 中我们构建了一个 restful 风格的项目，并用 postman 来围绕 HTTP 动词 GET，POST，PUT，DELETE 对员工信息展开 CURD 操作。那么在实际项目中，如果我们想调用别人提供的 resultful api 来请求网络资源应该怎样做呢，很多人会想到用 httpclient，但...
Spring RestTemplate基本使用介绍
08-19
为了演示 RestTemplate 的使用，我们创建两个 Spring Boot 项目，一个 provider 作为 server 端，一个 consumer 作为服务调用方法。 API 方法介绍 RestTemplate 提供了多种 API 方法来访问远程 HTTP 服务，下面...
Spring RestTemplate具体使用详解
08-26
Spring RestTemplate具体使用详解 RestTemplate是Spring框架中的一种ynchronous客户端HTTP访问的核心类，简化了与HTTP服务器的通信，并强制实施RESTful原则。它处理HTTP连接，让应用程序代码提供URL（可能具有模板...
Spring学习笔记之RestTemplate使用小结
08-27
Spring学习笔记之RestTemplate使用小结 RestTemplate是Spring Framework提供的一种基于模板的HTTP客户端，它提供了一个简单的方式来访问HTTP资源。下面是关于RestTemplate的详细知识点： 一、RestTemplate基本使用...
springRestTemplate
08-03
在 Spring Boot 中，由于其内置的自动配置特性，使用 RestTemplate 更加方便。让我们深入探讨一下 RestTemplate 的核心概念、功能以及如何在实际应用中进行设置和使用。 1. **什么是 RestTemplate?** RestTemplate...
如何使用Spring RestTemplate访问restful服务
08-26
"使用Spring RestTemplate访问restful服务" Spring RestTemplate是Spring框架中的一种轻量级客户端，用于访问restful服务。它提供了一种简洁的方式来访问restful接口，简化了HTTP请求和响应处理的过程。 什么是...
SpringBoot使用RestTemplate
weixin_30399821的博客
10-16 73
SpringBoot使用RestTempate SpringBoot使用RestTemplate摘要认证 SpringBoot使用RestTemplate基础认证 设置pom引用 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0...
Springboot2.1中使用RestTemplate
qq_32234855的博客
01-08 552
Springboot2.1中使用RestTemplate pom中引用httpclient <dependency> <groupId>org.apache.httpcomponents</groupId> <artifactId>httpclient</artifactId> <version>4.5.3</ve...
SpringBoot RestTemplate 的使用
weixin_42679286的博客
11-28 1695
RestTemplate 在JDK HttpURLConnection、Apache HttpComponents、OkHttp等基础上，封装了更高级别的API，默认依赖JDK HttpURLConnection，连接方式默认长连接。
SpringBoot 2.X 整合 RestTemplate 与使用教程
m0_37641835的博客
11-20 1071
SpringBoot 2.X 整合 RestTemplate 与使用教程
SpringBoot2学习笔记（七）REST之Swagger
honhong1024的博客
06-30 614
REST，即（Resource） Representational Status Transfer，资源表现层状态转移。REST是一种WEB API的标准、规范，取代了笨重的SOAP。本文要介绍SpringBoot中的RestTemplate和集成Swagger。 一、RestTemplate RestTemplate是Spring封装了HttpClient，并提供了更为强大的对RES...
restTemplate的使用
m0_72167535的博客
11-12 8909
restTemplate的使用
SpringBoot 系列教程(十四)：SpringBoot整合RestTemplate模板3种调用方式
Thinkingcao的专栏
12-17 3149
RestTemplate是Spring提供的用于访问Rest服务的客户端，RestTemplate提供了多种便捷访问远程Http服务的方法，能够大大提高客户端的编写效率。 微服务进程间通信，微服务进程之间的通讯有 http 和 rpc 两种协议, 在 Spring Cloud 项目中一般都以 http 通信, 常用的访问框架有:
spring RestTemplate 怎么使用
05-31
Spring RestTemplate 是 Spring 提供的一个用于访问 RESTful 服务的客户端工具类。使用 RestTemplate 可以方便地向 RESTful 服务发送 HTTP 请求，并将响应结果转换为 Java 对象。 以下是使用 RestTemplate 发送 GET...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值