本文的目的是介绍SpringRestTemplate详解的详细情况，特别关注spring的resttemplate的相关信息。我们将通过专业的研究、有关数据的分析等多种方式，为您呈现一个全面的了解Sp

本文的目的是介绍Spring RestTemplate详解的详细情况，特别关注spring的resttemplate的相关信息。我们将通过专业的研究、有关数据的分析等多种方式，为您呈现一个全面的了解Spring RestTemplate详解的机会，同时也不会遗漏关于RestTemplate详解、Spring boot 之 RestTemplate、Spring Boot 的 TestRestTemplate 使用、Spring Boot的TestRestTemplate使用的知识。

• Spring RestTemplate详解（spring的resttemplate）
• RestTemplate详解
• Spring boot 之 RestTemplate
• Spring Boot 的 TestRestTemplate 使用
• Spring Boot的TestRestTemplate使用

Spring RestTemplate详解（spring的resttemplate）

RestTemplate详解

RestTemplate详解
-Get请求
    在RestTemplate中通过如下两个方法进行调用
        --第一种：getForEntity()函数
            返回：ResponseEntity（对HTTP响应的封装，重要元素：HTTP请求状态的枚举对象HttpStatus，
                 HTTP请求头信息对象HttpHeaders,泛型的请求体对象）
            
            例如：
                RestTemplate restTemplate = new RestTemplate();
                ResponseEntity<String> responseEntity = restTemplate.getForEntity("http://USER-SERVICE
                /user?name={1}", String.class, "didi");
                String body = responseEntity.getBody();
            解析：该请求是访问USER-SERVICE服务的/user请求，同时最后一个请求参数"didi"会替换url中的{1}的占位符，而返回的
                 ResponseEntity对象中的body内容会根据第二个参数转换成String类型

            例如：
                RestTemplate restTemplate = new RestTemplate();
                ResponseEntity<User> responseEntity = restTemplate.getForEntity("http://SERVICE-
                USER/user?name={1}", User.class, "didi");
                User body = responseEntity.getBidy();
            解析：该请求访问USER-SERVICE服务的/user请求，同时最后一个请求参数"didi"会替换url中的{1}的占位符，而返回的
                ResponseEntity对象中的body内容会根据第二个参数转换成User类型
            
            三个重载方法：
                getForEntity(String url, Class<T> responseType, Object... uriVariables)
                    解析： url为请求地址，responseType为请求响应体body的包装类型，uriVariables为url中的参数绑定
                    注意：uriVariables是一个数组，所以他的顺序会对应url中占位符定义的数字的顺序

                getForEntity(String url, Class<T> responseType, Map<String, ?> uriVariables)
                    解析：这里只有uriVariables这个参数不同，这里使用了Map类型，
                    注意：使用该方法进行参数绑定时需要在占位符中指定Map的key
                    例如：
                        RestTemplate restTemplate = new RestTemplate();
                        Map<String, String> params = new HashMap<>();
                        params.put("name","dada");
                        ResponseEntity<String> responseEntity = restTemplate.getForEntity("http://SERVICE-
                        USER/user?name={name}", String.class, params);
                getForEntity(URI url, Class<T> responseType)
                    解析：该方法使用URI替换之前的url和urlVariables参数来指定访问地址和参数绑定。
                    例如：
                        RestTemplate restTemplate = new RestTemplate();
                        UriComponents uriComponenets = UriComponentsBuilder.formUriString{
                            "http://USER-SERVICE/user?name={name}"
                            .build()
                            .expand("dodo")
                            .encode();
                        }
                        URI uri = UriComponents.toUri();
                        ResponseEntity<String> responseEntity = restTemplate.getForEntity(uri,
                        String.class).getBody();

        --第二种：getForObject()函数
            解析：它可以理解为getForEntity的进一步封装，它通过HttpMessageConverterExtractor对HTTP请求响应体body内容进行
                  对象转换，实现请求直接返回包装好的对象内容
            例如：
                RestTemplate restTemplate = new RestTemplate();
                String result = restTemplate.getForObject(uri, String.class);
                
                当body是一个User对象的时候，可以直接这样实现
                RestTemplate restsTemplate = new RestTempalte();
                User user = restTemplate.getForObject(uri, User.class);
            使用场景：当不需要关注请求响应除body外的其他内容时，该函数就非常好用，可以少一个从Response中获取body的步骤。

            三个重载方法：
                1.getForObject(String url, Class<T> responseType, Object... uriVariables)
                  解析：url指定访问的地址，responseType指定访问的地址，urlVariables为url中占位符对应的参数
                
                2.getForObject(String url, Class<T> responseType, Map<String, ?> uriVariables)
                  解析：该函数使用Map类型的urlVariables替代上面数组形式的urlVariables，因此使用时在url中需要将占位符的
                        名称与Map类型中的Key一一对应设置

                3.getForObject(URI url, Class<T> responseType)
                   解析：该方法使用URI对象来替换之前的url和urlVariabels参数使用

-Post请求
    在RestTempalte中，对POST请求时可以通过如下三个方法进行调用
        --第一种：postForEntity()函数
            解析：该方法与Get请求中的getForEntity()函数类似，返回ResponseEntity<T>对象，其中T为请求响应的body类型。
            例如：
                RestTemplate restTemplate = new RestTempalte();
                User user = new User("didi", 30);
                ResponseEntity<String> responseEntity = restTemplate.postForEntity("http://USER-SERVICE/user", 
                user, String);
                String body = responseEntity.getBody();

            三个重载方法：
                1.postForEntity(String url, Object request, Class<T> responseType, Object... uriVariables)
                2.postForEntity(String url, Object request, Class<T> responseType, Map<String, ?> uriVariables)
                3.postForEntity(URI url, Object request, Class<T> responseType)
                解析：重载函数中的uriVariables用来对url中的参数进行绑定，responseType参数是对请求响应的body内容的类型定
                     义
                注意：新增的request参数，改参数可以是一个普通的对象，也可以是一个HttpEntity对象。
                    如果request是一个普通对象时，RestTemplate会将这个普通对象转换成HttpEntity对象来处理，其中Object就是
                    request的类型，request内容会被当成一个完整的body来处理；
                    如果resuqet是一个HttpEntity对象时，那么request会被当成一个完整的HTTP请求对象来处理，这个request中不
                    仅包含了body内容，也包含了header的内容

        --第二种：postForObject()函数
            解析：它简化了postForEntity()的后续处理，通过直接将请求响应的body内容包装陈对象来简化返回使用。
            例如：
                RestTemplate restTemplate = new RestTemplate();
                User user = new User("didi", 20);
                String postResult = restTemplate.postForObject("http[://USER-SERVICE/user", user, String.class);

            三个重载方法：
                postForObject(String url, Object request, Class<T> responseType, Object... uriVariables)
                postForObject(String url, Object request, Class<T> responseType, Map<String, ?> uriVariables)
                postForObject(URI url, Object request, Class<T> responseType)
                解析：参考postForEntity说明

        --第三种：postForLocation()函数
            解析：该函数实现了以post请求提交资源，并放回新资源的URI
            例如：
                User user = new User("didi", 40);
                URI responseUri = restTemplate.postForLocation("http://USER-SERVICE/user", user);

            三个重载方法：
                postForLocation(String url, Object request, Object... uriVariables)
                postForLocation(String url, Object request, Map<String, ?> uriVariables)    
                postForLocation(URI url, Object request)
                解析：由于postForLocation函数会返回新资源的URI,该URI就相当于指定了放回类型，所以此方法实现的post请求不需
                     要像postforEntity和postForObject一样执行responseType。
                     其他参数用法相同

-Put请求
    在RestTemplate中,对PUT请求可以通过put方法进行调用实现
    例如：
        RestTemplate restTemplate = new RestTemplate();
        Long id = 100L;
        User user = new User("didi", 40);
        restTemplate.put("http://USER-SERVICE/user/{1}", user, id);

    解析:put函数返回类型为void类型，所以没有返回内容，也就没有其他函数定义的responseType参数,除此之外的其他传入参数定义和
        用法与postForObject基本一致。

-Delete请求
    在RestTemplate中，对DELETE请求可以通过delete方法进行调用实现
    例如：
        RestTemplate restTemplate = new RestTemplate();
        Long id = 100L;
        restTemplate.delete("http://USER-SERVICE/user/{1}",id);

    三个重载方法：
        delete(String url, Object... urlVariables)
        delete(String url, Map urlVariables)
        delete(URI uri)

    解析：由于我们在进行REST请求时，通常都将delete请求的唯一标识拼接在url中，所以delete请求也不需要requestType的body信
         息，就如上面三个函数一样，非常简单。
          url指定delete请求的位置，urlVariable绑定url中的参数即可。

Spring boot 之 RestTemplate

传统情况下在java代码里访问restful服务，一般使用Apache的HttpClient。不过此种方法使用起来太过繁琐。Spring提供了一种简单便捷的模板类来进行操作，这就是RestTemplate。

内置发送get post delete等请求的方法，在SpringBoot中只要导入spring-boot-starter-web的依赖可以直接使用。

为什么说是简单便捷呢？我们来看以下两种实现方式：

/**
 * @param url
 * @param param
 * @param headers
 * @param connectTimeout  milliseconds
 * @param readTimeout  milliseconds
 * @return
 */
public static String get(String url, String param, Map<String, String> headers, int connectTimeout, int readTimeout) {
    BufferedReader in = null;
    StringBuilder builder = new StringBuilder();
    try {
        String urlNameString = url;
        if (param != null) {
            urlNameString += "?" + param;
        }
        URL realUrl = new URL(urlNameString);
        // 打开和URL之间的连接
        HttpURLConnection conn = (HttpURLConnection)realUrl.openConnection();
        // 设置通用的请求属性
        conn.setRequestProperty("accept", "*/*");
        conn.setRequestProperty("connection", "Keep-Alive");
        conn.setRequestProperty("user-agent", USER_AGENT);

        if (connectTimeout > 0) {
            conn.setConnectTimeout(connectTimeout);
        }
        if (readTimeout > 0) {
            conn.setReadTimeout(readTimeout);
        }
        if (headers != null) {
            for (Entry<String, String> entry: headers.entrySet()) {
                conn.setRequestProperty(entry.getKey(), entry.getValue());
            }
        }
        conn.connect();
        if (conn.getResponseCode() == HttpURLConnection.HTTP_OK) {
            // 定义 BufferedReader输入流来读取URL的响应
            in = new BufferedReader(new InputStreamReader(
                conn.getInputStream(), DEFAULT_CHARSET));
            String line;
            while ((line = in.readLine()) != null) {
                builder.append(line).append("\n");
            }
        }
    } catch (Exception e) {
        LOGGER.error("HttpUtil.get error.", e);
    }
    // 使用finally块来关闭输入流
    finally {
        try {
            if (in != null) {
                in.close();
            }
        } catch (Exception e2) {
            LOGGER.error("HttpUtil.get finally error.", e2);
        }
    }
    return builder.toString();
}

2. 使用RestTempalte

String result = restTemplate.getForObject(url,String.class);

快速开始

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

第一步：配置RestTemplate

/**
 * RestTemplate配置
 */
@Configuration
public class RestTemplateConfig {

    @Bean
    public RestTemplate restTemplate(ClientHttpRequestFactory factory) {
        return new RestTemplate(factory);
    }

    @Bean
    public ClientHttpRequestFactory simpleClientHttpRequestFactory() {
        SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();
        //超时设置
        factory.setReadTimeout(6000);
        factory.setConnectTimeout(10000);
        return factory;
    }
}

第二步：使用RestTemplate的Api发送请求

/**
 * 测试get请求
 */
@Test
public void test1(){
    /**
     * getForObject
     *
     * 参数1 要请求的地址的url  必填项
     * 参数2 响应数据的类型 是String 还是 Map等 必填项
     * 参数3 请求携带参数 选填
     *
     * getForObject 方法的返回值就是 被调用接口响应的数据
     */
    String result = restTemplate.getForObject("http://apis.juhe.cn/mobile/get?phone=13429667914&key=1cca71876dc0669109ed3f9501a85e8a",String.class);
    System.out.println(result);
}

Get请求的API

getForObject API：参数1 url地址，参数2 响应数据类型 参数3 请求携带参数 返回值类型为String。

getForEntity API：参数1 url地址，参数2 响应数据类型 参数3 请求携带参数 返回值类型为ResponseEntity。

Get请求传递参数可以是以占位符的方式，或者是通过map传参。

/**
 * 测试get请求
 */
@Test
public void test2(){

    String result = restTemplate.getForObject("http://apis.juhe.cn/mobile/get?phone=13429667914&key=1cca71876dc0669109ed3f9501a85e8a", String.class);

    System.out.println("getForObject返回值："+result);

    ResponseEntity<String> responseEntity = restTemplate.getForEntity("http://apis.juhe.cn/mobile/get?phone=13429667914&key=1cca71876dc0669109ed3f9501a85e8a", String.class);

    System.out.println("通过ResponseEntity获取的响应状态码："+responseEntity.getStatusCode());

    System.out.println("通过ResponseEntity获取的响应数据："+responseEntity.getBody());

    /**
         * 通过Map传参
         */
    Map map= new HashMap();
    map.put("phone","13429667914");
    map.put("key","1cca71876dc0669109ed3f9501a85e8a");
    String resultId = restTemplate.getForObject("http://apis.juhe.cn/mobile/get?phone={phone}&key={key}",
                                                String.class,map);
    System.out.println("map传参" + resultId);

}

可以看到如下效果：

getForObject返回值：{"resultcode":"200","reason":"Return Successd!","result":{"province":"浙江","city":"杭州","areacode":"0571","zip":"310000","company":"移动","card":""},"error_code":0}
通过ResponseEntity获取的响应状态码：200 OK
通过ResponseEntity获取的响应数据：{"resultcode":"200","reason":"Return Successd!","result":{"province":"浙江","city":"杭州","areacode":"0571","zip":"310000","company":"移动","card":""},"error_code":0}
map传参{"resultcode":"200","reason":"Return Successd!","result":{"province":"浙江","city":"杭州","areacode":"0571","zip":"310000","company":"移动","card":""},"error_code":0}

Post请求的API

postForObject API:

参数1 url地址

参数2 通过LinkedMultiValueMap对象封装请求参数

参数3 响应数据类型返回值类型为String

postForLocation API：

参数1 url地址

参数2 通过LinkedMultiValueMap对象封装请求参数

响应值：获取返回的URI

postForLocation使用场景：在登录或注册完成，跳转到别的页面时，并获取要跳转的URI。

**注意：**postForLocation方法返回的URI实际上是指响应头的Location字段，所以，请求的接口的响应头必须要有Location字段（即请求的接口实际上是一个重定向的接口），否则返回值为null。

package com.example.restdemo.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
@RequestMapping("/test")
public class HelloController {
    /**
     * 测试 postForLocation
     */
    @PostMapping("/postLocation")
    public String testPostForLocation(String username,String password){
        System.out.println(username);
        return "redirect:/index.html";
    }
}

测试Post请求

/**
 * 测试Post请求
 */
@Test
public void test3(){
    LinkedMultiValueMap<String, String> request = new LinkedMultiValueMap<>();
    request.set("key","9363eb48d9bd745e7627322e2ae78099");
    request.set("date","2021-10-22");

    String result = restTemplate.postForObject("http://v.juhe.cn/laohuangli/d",request,String.class);
    System.out.println("通过LinkedMultiValueMap对象封装请求参数");
    System.out.println(result);

    Map map = new HashMap();
    map.put("key","9363eb48d9bd745e7627322e2ae78099");
    map.put("date","2021-10-22");

    String result2 = restTemplate.postForObject("http://v.juhe.cn/laohuangli/d?key={key}&date={date}",request,
            String.class,map);
    System.out.println("通过参数拼接的方式：");
    System.out.println(result2);

    LinkedMultiValueMap<String, String> req = new LinkedMultiValueMap<>();
    req.set("username","小明");
    req.set("password","decs3465523");
    URI uri = restTemplate.postForLocation("http://localhost:8085/test/postLocation", req);
    System.out.println("postForLocation请求到的地址为："+uri);
}

执行效果如下：

通过LinkedMultiValueMap对象封装请求参数
{"reason":"successed","result":{"id":"4190","yangli":"2021-10-22","yinli":"辛丑(牛)年九月十七","wuxing":"杨柳木 收执位","chongsha":"冲牛(丁丑)煞西","baiji":"癸不词讼理弱敌强 未不服药毒气入肠","jishen":"天恩 母仓 四相 不将 玉宇","yi":"祭祀 作灶 纳财 捕捉 畋猎 馀事勿取","xiongshen":"河魁 月刑 五虚 朱雀 触水龙","ji":"动土 破土 开市 安葬"},"error_code":0}
通过参数拼接的方式：
{"reason":"successed","result":{"id":"4190","yangli":"2021-10-22","yinli":"辛丑(牛)年九月十七","wuxing":"杨柳木 收执位","chongsha":"冲牛(丁丑)煞西","baiji":"癸不词讼理弱敌强 未不服药毒气入肠","jishen":"天恩 母仓 四相 不将 玉宇","yi":"祭祀 作灶 纳财 捕捉 畋猎 馀事勿取","xiongshen":"河魁 月刑 五虚 朱雀 触水龙","ji":"动土 破土 开市 安葬"},"error_code":0}
postForLocation请求到的地址为：http://localhost:8085/index.html

总结

本文主要向大家介绍了 RestTemplate 这样一个 HTTP 请求工具类的常见用法，并没有涉及到源码，其实内部源码很多很深，包括和解析url模板，绑定参数的UriBuilderFactory UriTemplateHandler等等，建议跟踪源码跑一遍会更加理解restTemplate。这里就简单提下。

更多技术文章

Spring Boot 的 TestRestTemplate 使用

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

public class TestRestTemplate {

    private final RestTemplateBuilder builder;

    private final HttpClientOption[] httpClientOptions;

    private final RestTemplate restTemplate;
    ...

        public void setUriTemplateHandler(UriTemplateHandler handler) {
        this.restTemplate.setUriTemplateHandler(handler);
    }

...

    @Test
    public void testGet (){
        TestRestTemplate testRestTemplate = new TestRestTemplate();
        ResponseEntity<String> response = testRestTemplate.
                getForEntity(FOO_RESOURCE_URL + "/1", String.class);

        assertThat(response.getStatusCode(), equalTo(HttpStatus.OK));
    }

TestRestTemplate testRestTemplate
 = new TestRestTemplate("user", "passwd");
ResponseEntity<String> response = testRestTemplate.
  getForEntity(URL_SECURED_BY_AUTHENTICATION, String.class);
  
assertThat(response.getStatusCode(), equalTo(HttpStatus.OK));

TestRestTemplate testRestTemplate = new TestRestTemplate("user", 
  "passwd", TestRestTemplate.HttpClientOption.ENABLE_COOKIES);
ResponseEntity<String> response = testRestTemplate.
  getForEntity(URL_SECURED_BY_AUTHENTICATION, String.class);
  
assertThat(response.getStatusCode(), equalTo(HttpStatus.OK))；

TestRestTemplate(TestRestTemplate.HttpClientOption.ENABLE_COOKIES)

TestRestTemplate testRestTemplate = new TestRestTemplate();
ResponseEntity<String> response = testRestTemplate.withBasicAuth(
  "user", "passwd").getForEntity(URL_SECURED_BY_AUTHENTICATION, 
  String.class);
  
assertThat(response.getStatusCode(), equalTo(HttpStatus.OK));

RestTemplateBuilder restTemplateBuilder = new RestTemplateBuilder();
restTemplateBuilder.configure(restTemplate);
TestRestTemplate testRestTemplate = new TestRestTemplate(restTemplateBuilder);
ResponseEntity<String> response = testRestTemplate.getForEntity(
  FOO_RESOURCE_URL + "/1", String.class);
  
assertThat(response.getStatusCode(), equalTo(HttpStatus.OK));