Web开发 之使用Spring提供的RestTemplate访问服务

已于 2022-04-25 16:52:28 修改
阅读量409 收藏
点赞数
分类专栏： Web开发 文章标签： 开发语言
于 2019-06-20 15:25:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/const_/article/details/93044229
版权

文章目录

RestTemplate简介

RestTemplate是Spring3.0后开始提供的用于访问 Rest 服务的轻量级客户端，相较于传统的HttpURLConnection、Apache HttpClient、OkHttp等框架，RestTemplate大大简化了发起HTTP请求以及处理响应的过程。

RestTemplate只是对其它Rest客户端的一个封装，本身并没有自己的实现。
RestTemplate默认实现是HttpURLConnection，这是JDK自带的REST客户端实现。
引入哪种Http客户端的Jar包，就会使用哪种Http客户端的实现。

相关Http客户端Maven依赖

<dependency>
    <groupId>com.squareup.okhttp3</groupId>
    <artifactId>okhttp</artifactId>
    <version>4.4.0</version>
</dependency>

<dependency>
    <groupId>org.apache.httpcomponents</groupId>
    <artifactId>httpclient</artifactId>
    <version>4.5.11</version>
</dependency>

RestTemplate配置

RestTemplate包含以下几个部分：

  • HttpMessageConverter 对象转换器
  • ClientHttpRequestFactory 默认是 JDK的HttpURLConnection
  • ResponseErrorHandler 异常处理
  • ClientHttpRequestInterceptor 请求拦截器

在这里插入图片描述

使用HttpClient作为实现

首先需要引入HttpClient的Maven依赖。

import org.apache.http.client.HttpClient;
import org.apache.http.config.Registry;
import org.apache.http.config.RegistryBuilder;
import org.apache.http.conn.socket.ConnectionSocketFactory;
import org.apache.http.conn.socket.PlainConnectionSocketFactory;
import org.apache.http.conn.ssl.NoopHostnameVerifier;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.impl.client.DefaultHttpRequestRetryHandler;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.ssl.SSLContextBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.converter.StringHttpMessageConverter;
import org.springframework.web.client.DefaultResponseErrorHandler;
import org.springframework.web.client.RestTemplate;

import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.SSLContext;
import java.nio.charset.StandardCharsets;
import java.security.KeyManagementException;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.util.List;

@Configuration
public class RestClientConfig {

    private static final Logger logger = LoggerFactory.getLogger(RestClientConfig.class);

    // 连接池的最大连接数默认为0
    @Value("${remote.maxTotalConnect:0}")
    private int maxTotalConnect;
    // 单个主机的最大连接数
    @Value("${remote.maxConnectPerRoute:200}")
    private int maxConnectPerRoute;
    // 连接超时默认2s
    @Value("${remote.connectTimeout:2000}")
    private int connectTimeout;
    // 读取超时默认30s
    @Value("${remote.readTimeout:30000}")
    private int readTimeout;

    @Bean
    public RestTemplate restTemplate() {
        RestTemplate restTemplate = new RestTemplate();
        restTemplate.setRequestFactory(clientHttpRequestFactory());
        restTemplate.setErrorHandler(new DefaultResponseErrorHandler());
        // 设置编码格式为UTF-8
        List<HttpMessageConverter<?>> converterList = restTemplate.getMessageConverters();
        HttpMessageConverter<?> converterTarget = null;
        for (HttpMessageConverter<?> item : converterList) {
            if (item.getClass() == StringHttpMessageConverter.class) {
                converterTarget = item;
                break;
            }
        }
        if (converterTarget != null) {
            converterList.remove(converterTarget);
        }
        HttpMessageConverter<?> converter = new StringHttpMessageConverter(StandardCharsets.UTF_8);
        converterList.add(1, converter);
        logger.info("-----restTemplate-----初始化完成");
        return restTemplate;
    }

    @Bean
    public HttpComponentsClientHttpRequestFactory clientHttpRequestFactory() {
        try {
            HttpClientBuilder httpClientBuilder = HttpClientBuilder.create();
            SSLContext sslContext = new SSLContextBuilder().loadTrustMaterial(null, (arg0, arg1) -> true).build();
            httpClientBuilder.setSSLContext(sslContext);
            HostnameVerifier hostnameVerifier = NoopHostnameVerifier.INSTANCE;
            SSLConnectionSocketFactory sslConnectionSocketFactory = new SSLConnectionSocketFactory(sslContext, hostnameVerifier);
            // 注册http和https请求
            Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory>create()
                    .register("http", PlainConnectionSocketFactory.getSocketFactory())
                    .register("https", sslConnectionSocketFactory).build();
            // 开始设置连接池
            PoolingHttpClientConnectionManager poolingHttpClientConnectionManager = new PoolingHttpClientConnectionManager(socketFactoryRegistry);
            // 最大连接数
            poolingHttpClientConnectionManager.setMaxTotal(maxTotalConnect);
            // 同路由的并发数，路由是对maxTotal的细分
            poolingHttpClientConnectionManager.setDefaultMaxPerRoute(maxConnectPerRoute);
            httpClientBuilder.setConnectionManager(poolingHttpClientConnectionManager);
            httpClientBuilder.setRetryHandler(new DefaultHttpRequestRetryHandler(3, true)); // 重试次数
            HttpClient httpClient = httpClientBuilder.build();
            // 数据读取超时时间
            HttpComponentsClientHttpRequestFactory clientHttpRequestFactory = new HttpComponentsClientHttpRequestFactory(httpClient); // httpClient连接配置
            // 连接超时
            clientHttpRequestFactory.setConnectTimeout(connectTimeout);
            // 读取超时
            clientHttpRequestFactory.setReadTimeout(readTimeout);
            // 连接不够用的等待时间
            clientHttpRequestFactory.setConnectionRequestTimeout(20000);
            return clientHttpRequestFactory;
        } catch (KeyManagementException | NoSuchAlgorithmException | KeyStoreException e) {
            logger.error("初始化HTTP连接池出错", e);
        }
        return null;
    }
}

使用OkHttp作为实现

首先需要引入OkHttp的Maven依赖。

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.client.ClientHttpRequestFactory;
import org.springframework.http.client.OkHttp3ClientHttpRequestFactory;
import org.springframework.web.client.RestTemplate;

@Configuration
public class RestTemplateConfig {

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

    @Bean
    public OkHttp3ClientHttpRequestFactory okHttp3ClientHttpRequestFactory(){
        OkHttp3ClientHttpRequestFactory factory = new OkHttp3ClientHttpRequestFactory();
        // 单位：毫秒
        factory.setConnectTimeout(10000);
        factory.setReadTimeout(10000);
        factory.setWriteTimeout(10000);
        return factory;
    }
}

发送GET请求

// 1-getForObject()
User user1 = this.restTemplate.getForObject(uri, User.class);

// 2-getForEntity()
ResponseEntity<User> responseEntity1 = this.restTemplate.getForEntity(uri, User.class);
HttpStatus statusCode = responseEntity1.getStatusCode();
HttpHeaders header = responseEntity1.getHeaders();
User user2 = responseEntity1.getBody();
  
// 3-exchange()
RequestEntity requestEntity = RequestEntity.get(new URI(uri)).build();
ResponseEntity<User> responseEntity2 = this.restTemplate.exchange(requestEntity, User.class);
User user3 = responseEntity2.getBody();

发送POST请求

// 1-postForObject()
User user1 = this.restTemplate.postForObject(uri, user, User.class);

// 2-postForEntity()
ResponseEntity<User> responseEntity1 = this.restTemplate.postForEntity(uri, user, User.class);

// 3-exchange()
RequestEntity<User> requestEntity = RequestEntity.post(new URI(uri)).body(user);
ResponseEntity<User> responseEntity2 = this.restTemplate.exchange(requestEntity, User.class);

设置HTTP Header

// 1-Content-Type
RequestEntity<User> requestEntity = RequestEntity
        .post(new URI(uri))
        .contentType(MediaType.APPLICATION_JSON)
        .body(user);

// 2-Accept
RequestEntity<User> requestEntity = RequestEntity
        .post(new URI(uri))
        .accept(MediaType.APPLICATION_JSON)
        .body(user);

// 3-Other
RequestEntity<User> requestEntity = RequestEntity
        .post(new URI(uri))
        .header("Authorization", "Basic " + base64Credentials)
        .body(user);

发送文件

MultiValueMap<String, Object> multiPartBody = new LinkedMultiValueMap<>();
multiPartBody.add("file", new ClassPathResource("/tmp/user.txt"));
RequestEntity<MultiValueMap<String, Object>> requestEntity = RequestEntity
        .post(uri)
        .contentType(MediaType.MULTIPART_FORM_DATA)
        .body(multiPartBody);

下载文件

// 小文件
RequestEntity requestEntity = RequestEntity.get(uri).build();
ResponseEntity<byte[]> responseEntity = restTemplate.exchange(requestEntity, byte[].class);
byte[] downloadContent = responseEntity.getBody();
  
// 大文件  
ResponseExtractor<ResponseEntity<File>> responseExtractor = new ResponseExtractor<ResponseEntity<File>>() {
    @Override
    public ResponseEntity<File> extractData(ClientHttpResponse response) throws IOException {
        File rcvFile = File.createTempFile("rcvFile", "zip");
        FileCopyUtils.copy(response.getBody(), new FileOutputStream(rcvFile));
        return ResponseEntity.status(response.getStatusCode()).headers(response.getHeaders()).body(rcvFile);
    }
};
File getFile = this.restTemplate.execute(targetUri, HttpMethod.GET, null, responseExtractor);

构建测试用的Http服务

import lombok.Data;
@Data
public class User {
    private Long id;
    private String username;
    private Integer age;
}

import com.google.gson.Gson;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/")
@Slf4j
public class DemoController {

    @GetMapping("demo/{id}/{userName}")
    public User get(@PathVariable Long id, @PathVariable String userName, Integer age){
        log.info("id:{}, userName:{}, age:{}", id, userName, age);
        User user = new User();
        user.setId(id);
        user.setUsername(userName);
        user.setAge(age);
        return user;
    }

    @PostMapping("demo")
    public User post(@RequestBody String json){
        log.info("json:{}", json);
        Gson gson = new Gson();
        User user = gson.fromJson(json, User.class);
        return user;
    }
}

RestTemplate使用

GET请求

在RestTemplate中，发送一个GET请求，有两种方式：getForObject()和getForEntity()。

getForEntity

getForEntity方法的返回值是一个ResponseEntity<T>，ResponseEntity<T>是Spring对HTTP请求响应的封装，包括了几个重要的元素，如响应码、contentType、contentLength、响应消息体等。
在这里插入图片描述
示例：

String url = "http://127.0.0.1:8080/demo/{id}/{userName}?age=18";

// 方式一
ResponseEntity<User> userResponseEntity = restTemplate.getForEntity(url, User.class, 1001L, "Tom");
User user = userResponseEntity.getBody();
HttpStatus statusCode = userResponseEntity.getStatusCode();
int statusCodeValue = userResponseEntity.getStatusCodeValue();
HttpHeaders headers = userResponseEntity.getHeaders();
System.out.println("user = " + user + "; statusCode = " + statusCode + "; statusCodeValue = " + statusCodeValue + "; headers = " + headers);

// 方式二
Map<String, Object> urlParams = new HashMap<>();
urlParams.put("id", 1001L);
urlParams.put("userName", "James");
ResponseEntity<User> userResponseEntity2 = restTemplate.getForEntity(url, User.class, urlParams);

// 方式三
UriComponents uriComponents = UriComponentsBuilder.fromUriString(url).build().expand(1001L, "James").encode();
URI uri = uriComponents.toUri();
ResponseEntity<User> entity = restTemplate.getForEntity(uri, User.class);

getForObject

getForObject函数实际上是对getForEntity函数的进一步封装，如果你只关注返回的消息体的内容，对其他信息都不关注，此时可以使用getForObject。
在这里插入图片描述
示例：

//URL中的{id}占位符最终将会用方法的id参数来填充
String url = "http://127.0.0.1:8083/demo/{id}/{userName}?age=18";
Long id = 1001L;
String userName = "Tom";

//方式一：最后一个参数是大小可变的参数列表，每个参数都会按出现顺序插入到指定URL的占位符中
User user = restTemplate.getForObject(url, User.class, id, userName);

//方式二：将id参数放到Map中，并以id作为key，然后将这个Map作为最后一个参数
Map<String, Object> urlParams = new HashMap<>();
urlParams.put("id", id);
urlParams.put("userName", userName);
User user2 = restTemplate.getForObject(url, User.class, urlParams);

//方式二：参考getForEntity案例

POST请求

POST请求对应三个方法，postForObject()、postForEntity()和postForLocation()，每个方法同样对应有三个具体的重载方法。postForObject()、postForEntity()类似于getForObject()和postForEntity()，postForLocation()返回的是一个URI对象。

postForEntity

在这里插入图片描述

String url = "http://localhost:8080/demo2/{address}";
// 方式一
User user = new User();
user.setAge(25);
user.setUsername("王五");
// 第4个参数可以是Object... uriVariables 或者 Map<String, ?> uriVariables
ResponseEntity<User> userResponseEntity = restTemplate.postForEntity(url, user, User.class, "SH");
User userBody = userResponseEntity.getBody();
HttpStatus statusCode = userResponseEntity.getStatusCode();
int statusCodeValue = userResponseEntity.getStatusCodeValue();
HttpHeaders headers = userResponseEntity.getHeaders();
System.out.println("user = " + userBody + "; statusCode = " + statusCode + "; statusCodeValue = " + statusCodeValue + "; headers = " + headers);

postForObject

如果你只关注，返回的消息体，可以直接使用postForObject。用法和getForObject一致。
在这里插入图片描述

exchange通用请求

String getUrl = "http://127.0.0.1:8083/demo/{id}/{userName}?age=18";

//GET资源
//参数3是请求头部分；参数4是响应数据要转成对象；最后一个参数用于替换URL中的占位符
ResponseEntity<User> userResponseEntity = restTemplate.exchange(getUrl, HttpMethod.GET, null, User.class, 1001L, "Tom");
System.out.println("exchange = " + userResponseEntity + "; response body = " + userResponseEntity.getBody());

String postUrl = "http://localhost:8083/demo2";

//POST资源
HttpHeaders headers = new HttpHeaders();
headers.setContentType(MediaType.APPLICATION_JSON);
String jsonParams = "{\"username\":\"123\",\"age\":23}";
HttpEntity<User> httpEntity = new HttpEntity(jsonParams, headers);
ResponseEntity<User> responseEntity = restTemplate.exchange(postUrl, HttpMethod.POST, httpEntity, User.class);
System.out.println("exchange = " + responseEntity + "; response body = " + responseEntity.getBody());

POST请求，from-data传参

String url = "http://localhost:8083/demo2";
HttpHeaders headers = new HttpHeaders();
headers.setContentType(MediaType.MULTIPART_FORM_DATA);
MultiValueMap map = new LinkedMultiValueMap();
map.add("id",1001L);
HttpEntity httpEntity = new HttpEntity(map, headers);
ResponseEntity<User> responseEntity = restTemplate.postForEntity(url, httpEntity, User.class);
System.out.println(responseEntity.getBody());

RestTemplate携带参数和header头信息

String url="http://www.baidu.com";
MultiValueMap<String, String> map = new LinkedMultiValueMap<>();
map.add("id",id);
HttpHeaders header = new HttpHeaders();
// 需求需要传参为form-data格式
header.setContentType(MediaType.MULTIPART_FORM_DATA);
HttpEntity<MultiValueMap<String, String>> httpEntity = new HttpEntity<>(map, header);
JSONObject response = restTemplate.postForObject(url, httpEntity, JSONObject.class);

URI 使用

URI uri = new URIBuilder().setScheme("http").setHost(ip).setPort(port).setPath("/platform/service")
            .addParameter("user", "")
            .addParameter("service", "")
            .build();
            
UriComponents uriComponents = UriComponentsBuilder.fromUriString(url).build().expand(1001L, "James").encode();
URI uri = uriComponents.toUri();

RestTemplate封装

package com.demo.spring;

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.http.ResponseEntity;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import org.springframework.web.client.RestTemplate;
import sun.misc.BASE64Encoder;

import java.io.UnsupportedEncodingException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.HashMap;
import java.util.Map;

@Component
public class RestUtil {

    @Autowired
    private RestTemplate restTemplate;

    //一些自定义的请求头参数
    public static final String supplierID = "";
    public static final String interfacekey = "";

    /**
     * DLT专用执行方法
     *
     * @param param  请求参数：可以添加一些常量请求值
     * @param url    访问的url
     * @param method 请求的方法
     * @return
     */
    public String execute(Map<String, Object> param, String url, HttpMethod method) {
        HttpHeaders headers = this.getDefaultHeader();
        Map<String, Object> requestor = this.getDefaultParam();
        param.put("requestor", requestor);
        param.put("supplierID", supplierID);
        HttpEntity<Map<String, Object>> requestEntity = new HttpEntity<>(param, headers);
        ResponseEntity<String> response = restTemplate.exchange(url, method, requestEntity, String.class);
        return response.getBody();
    }

    /**
     * 获取默认的头请求信息
     *
     * @return
     */
    public HttpHeaders getDefaultHeader() {
        String timestamp = "" + System.currentTimeMillis();
        String signature = EncoderByMd5(supplierID + timestamp + interfacekey);
        HttpHeaders headers = new HttpHeaders();
        headers.add("signature", signature);
        headers.add("timestamp", timestamp);
        return headers;
    }
    
    /**
     * 获取默认的参数
     *
     * @return
     */
    public Map<String, Object> getDefaultParam() {
        Map<String, Object> defParam = new HashMap<>();
        defParam.put("invoker", "xx");
        defParam.put("operatorName", "xx");
        return defParam;
    }
    
    /**
     * 通过MD5加密
     *
     * @param str
     * @return
     */
    public static String EncoderByMd5(String str) {
        if (str == null) {
            return null;
        }
        try {
            // 确定计算方法
            MessageDigest md5 = MessageDigest.getInstance("MD5");
            BASE64Encoder base64en = new BASE64Encoder();
            // 加密后的字符串
            return base64en.encode(md5.digest(str.getBytes("utf-8"))).toUpperCase();
        } catch (NoSuchAlgorithmException | UnsupportedEncodingException e) {
            return null;
        }
    }
    
    /**
     * get请求
     *
     * @param url      请求的url
     * @param jsonData 请求的json
     * @return
     */
    public String restGet(String url, String jsonData) {
        return request(url, jsonData, HttpMethod.GET);
    }

    /**
     * @param url        请求的url
     * @param jsonData   json数据
     * @param httpMethod
     * @return
     */
    private String request(String url, String jsonData, HttpMethod httpMethod) {
        ResponseEntity<String> response = null;

        try {
            if (StringUtils.isEmpty(url)) {
                throw new IllegalArgumentException();
            }
            HttpEntity<String> requestEntity = new HttpEntity<String>(jsonData);
            response = restTemplate.exchange(url, httpMethod, requestEntity, String.class);

        } catch (Exception ex) {
            ex.printStackTrace();
            return "";
        }
        return response.getBody();
    }

    /**
     * Get请求获取实体类
     *
     * @param url          请求的url
     * @param responseType 返回的类型
     * @param parms        不限定个数的参数
     * @param <T>          泛型
     * @return
     */
    public <T> T getForEntity(String url, Class<T> responseType, Object... parms) {
        return (T) restTemplate.getForEntity(url, responseType, parms);

    }

    /**
     * Get请求
     *
     * @param url
     * @param parm
     * @return
     */
    public String get(String url, Map<String, Object> parm) {
        return restTemplate.getForEntity(url, String.class, parm).getBody();
    }
}

手动指定转换器(HttpMessageConverter)

调用reseful接口传递的数据内容是json格式的字符串，返回的响应也是json格式的字符串。然而restTemplate.postForObject方法的请求参数RequestBean和返回参数ResponseBean却都是java类。是RestTemplate通过HttpMessageConverter自动帮我们做了转换的操作。

默认情况下RestTemplate自动帮我们注册了一组HttpMessageConverter用来处理一些不同的contentType的请求。

  • StringHttpMessageConverter来处理text/plain
  • MappingJackson2HttpMessageConverter来处理application/json
  • MappingJackson2XmlHttpMessageConverter来处理application/xml

可以在org.springframework.http.converter包下找到所有spring帮我们实现好的转换器。
如果现有的转换器不能满足我们的需求，我们还可以实现org.springframework.http.converter.HttpMessageConverter接口自己写一个。

选好一个HttpMessageConverter后并注册到我们的RestTemplate中：

RestTemplate restTemplate = new RestTemplate();
//获取RestTemplate默认配置好的所有转换器
List<HttpMessageConverter<?>> messageConverters = restTemplate.getMessageConverters();
//默认的MappingJackson2HttpMessageConverter在第7个 先把它移除掉
messageConverters.remove(6);
//添加上GSON的转换器
messageConverters.add(6, new GsonHttpMessageConverter());

<dependency>
	<groupId>com.google.code.gson</groupId>
	<artifactId>gson</artifactId>
	<version>2.8.5</version>
</dependency>

上面的例子使用GsonHttpMessageConverter替换掉默认用来处理application/json的MappingJackson2HttpMessageConverter。

设置底层连接方式

创建一个RestTemplate的实例，可以像上述例子中简单地调用默认的无参数构造函数。这将使用java.net包中的标准Java类作为底层实现来创建HTTP请求。
但很多时候我们需要像传统的HttpClient那样设置HTTP请求的一些属性。RestTemplate使用了一种很偷懒的方式实现了这个需求，那就是直接使用一个HttpClient作为底层实现。

//生成一个设置了连接超时时间、请求超时时间、异常最大重试次数的httpClient
RequestConfig config = RequestConfig.custom()
        .setConnectionRequestTimeout(10000)
        .setConnectTimeout(10000)
        .setSocketTimeout(30000).build();
HttpClientBuilder builder = HttpClientBuilder.create()
        .setDefaultRequestConfig(config)
        .setRetryHandler(new DefaultHttpRequestRetryHandler(5, false));
HttpClient httpClient = builder.build();
//使用httpClient创建一个ClientHttpRequestFactory的实现
ClientHttpRequestFactory requestFactory = new HttpComponentsClientHttpRequestFactory(httpClient);
//ClientHttpRequestFactory作为参数构造一个使用作为底层的RestTemplate
RestTemplate restTemplate = new RestTemplate(requestFactory);

设置拦截器(ClientHttpRequestInterceptor)

有时候我们需要对请求做一些通用的拦截设置，这就可以使用拦截器进行处理。拦截器需要我们实现org.springframework.http.client.ClientHttpRequestInterceptor接口自己写。

举个简单的例子，写一个在header中根据请求内容和地址添加令牌的拦截器。

import org.springframework.http.HttpRequest;
import org.springframework.http.client.ClientHttpRequestExecution;
import org.springframework.http.client.ClientHttpRequestInterceptor;
import org.springframework.http.client.ClientHttpResponse;

import java.io.IOException;

public class TokenInterceptor implements ClientHttpRequestInterceptor {
    @Override
    public ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution) throws IOException {
        //请求地址
        String checkTokenUrl = request.getURI().getPath();
        //请求内容
        String requestBody = new String(body);
        //生成令牌
        String token = "token";
        //将令牌放入请求header中
        request.getHeaders().add("X-Auth-Token",token);
        request.getHeaders().add("X-Auth-Token","yq");
        return execution.execute(request, body);
    }
}

RestTemplate原理

参考

Spring RestTemplate中几种常见的请求方式
RestTemplate原理与使用
springboot集成restTemplate，http连接池
如何使用RestTemplate访问restful服务
spring的RestTemplate使用指南

Springboot 使用RestTemplate
SpringBoot——RestTemplate使用指南

yyangqqian
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RestTemplate调用rest接口
kehan666的博客
06-08 836
RestTemplate调用rest接口 应用层：HTTP 传输层：TCP（传输控制协议） 保证通信数据有序可靠 端口号：80 网络层：IP地址 DNS域名服务器解析域名 数据链路层&物理层：完成数据传输 一次http请求的过程： 1，域名解析为ip地址 2，向服务器ip+端口号建立TCP连接 连接成功 3，发送http请求，并得到响应 4，浏览器渲染并展示HTML URL的组成http://www.example.com/ http: schema协议 可以省略（浏览器默认的） 域名后面可以跟
RestTemplate使用进阶
吾乃南华老仙的博客
01-11 1071
官方文档：https://docs.spring.io/spring-framework/docs/5.0.0.RELEASE/spring-framework-reference/integration.html#rest-resttemplate-uri 通过RequestEntity设置请求格式、请求体、Headers 代码示例1： 使用RequestEntity设置请求方式、请求体、请求格式、header等，然后调用restTemplate的exchange方法进行请求，从而得到Reque.
RestTemplate详细使用
奔跑入坑大数据
09-20 984
参考文章：https://blog.csdn.net/qq_31491785/article/details/80249917 RestTemplate 是Spring用于同步client端的核心类，简化了与http服务的通信，并满足RestFul原则，程序代码可以给它提供URL，并提取结果。默认情况下，RestTemplate默认依赖jdk的HTTP连接工具。当然你也可以 通过setRequ...
RestTemplate调用post请求（requestParam参数和requestBody参数）
u012534163的博客
03-16 1万+
public void test() throws Exception{ RestTemplate restTemplate = SpringContextHolder.getBean(RestTemplate.class); HttpEntity requestEntity = null; HttpHeaders headers = new Http...
RestTemplate使用详解
Java+GO+JS全栈工程师-鹤冲天的博客：编程辅导~商务合作~技术交流
05-21 2905
在项目中，当我们需要远程调用一个 HTTP 接口时，我们经常会用到 RestTemplate 这个类。这个类是 Spring 框架提供的一个工具类。RestTemplate 是一个同步的 Rest API 客户端。下面我们就来介绍下 RestTemplate 的常用功能。
基于Spring Boot应用RestTemplate调用http请求
zhangbeizhen18的博客
07-22 2702
记录：288 场景：基于Spring Boot应用RestTemplate调用http请求。使用RestTemplate调用服务端发布的POST、GET、HEAD、PUT、PATCH、DELETE、OPTIONS请求，以及对TRACE请求的验证。使用RestTemplate提供的不同方法调用服务端发布的POST、GET请求。......
RestTemplate实现服务间调用demo案例
03-10
可以使用Spring Security或OAuth2等安全框架来保护接口，确保只有授权的请求才能访问。 总结来说，RestTemplate是Spring提供的一个强大的HTTP客户端工具，适用于微服务架构中的简单服务间调用。在实际应用中，我们...
038-retrieve-file-spring-resttemplate
05-20
在IT行业中，Spring框架是Java开发中的一个核心组件，它为构建Web应用程序提供了全面的解决方案。其中，`RestTemplate`是Spring提供的一种用于执行RESTful（Representational State Transfer）服务客户端的方法。本...
springcloud服务注册
09-27
SpringCloud是中国Java开发人员广泛使用的微服务框架，它提供了一系列工具来简化分布式系统开发，如服务发现、配置管理、断路器模式等。本项目主要关注的是“服务注册”这一核心功能，它允许服务实例向注册中心注册...
《Web服务开发学习实录》源代码
09-27
《Web服务开发学习实录》源代码是一份涵盖了从基础到高级的Web服务开发实践教程的配套资源。这本书旨在帮助读者深入理解Web服务的概念、原理和技术，通过实际操作提升技能。源代码包含了从第一章到第十五章的所有...
使用httpclient方式和RestTemplate方式调用http及https接口
03-25
本主题将深入探讨如何使用HttpClient和Spring的RestTemplate工具来实现这一目标。这两种方法都是可靠的，但在不同场景下各有优缺点。 首先，让我们了解HTTP和HTTPS的基本概念。HTTP（超文本传输协议）是用于在Web上...
RestTemplate 最详解
HakuMaster的博客
11-08 1839
通过 RestTemplate，我们可以非常方便的进行 Rest API 调用。但是在 Spring 5 中已经不再建议使用 RestTemplate，而是建议使用 WebClient。WebClient 是一个支持异步调用的 Client。所以喜欢研究新东西的同学可以开始研究下新东西了。
RestTemplate详解
时光钟摆
06-20 5461
RestTemplate与httpClient类似，都是java中可以模拟http请求的封装。httpClient的使用，已经在另一篇文章中有所论述，但是RestTemplate比httpClient更优雅，它是spring中的一个封装功能。
springboot中RestTemplate设置通用header
陈阿刚的博客
05-04 5184
目录一、概述二、实现1. 原理2. 代码实现ClientHttpRequestInterceptor接口将自定义拦截器添加到RestTemplate实例具体使用 一、概述 RestTemplate很多请求都需要用到相似或者相同的Http Header； 如果在每次请求之前都把Header填入HttpEntity/RequestEntity，这样的代码会显得十分冗余。 二、实现 1. 原理 Sp...
SpringBoot 使用RestTemplate实现调用服务
BigpotR
08-02 2万+
SpringBoot的搭建可以看一下我之前写的一篇博客 https://blog.csdn.net/cwr452829537/article/details/81351987 准备工作 要使用RestTemplate需要引入依赖，web依赖也可以在创建项目时选择Web -&gt; Web &lt;!-- web --&gt; &lt;dependency&gt; &lt;groupI......
restTemplate 发送post请求
热门推荐
dj1955的博客
03-25 5万+
restTemplate 发送get/post请求 restemplate发送post请求获取阿里云短信验证码向阿里云发送post请求获取短信验证码测试 java.lang.IllegalStateException: No instances available for dfsns.market.alicloudapi.com
精讲RestTemplate-POST请求方法使用详解
m0_45270667的博客
11-02 1万+
前言： 其实POST请求方法和GET请求方法上大同小异，RestTemplate的POST请求也包含两个主要方法： postForObject() postForEntity() 二者的主要区别在于，postForObject()返回值是HTTP协议的响应体。postForEntity()返回的是ResponseEntity，ResponseEntity是对HTTP响应的封装，除了包含响应体，还包含HTTP状态码、contentType、contentLength、Header等信息。 一、post
RestTemplate中post请求实用分析
慕容雪_的博客
06-23 3786
RestTemplate中post请求实用分析 1、最近在做相关平台对接工作。对接第一步需要在后端完成认证，拿到对方平台的access_token。由于对方文档不是很详细，根据认证需要的参数进行了多种尝试。顺带学习一下RestTemplate发post的请求的各种姿势。记录在此，以便查看。 2、往后端发post请求一般分为两种， 一种是普通的表单提交(Content-Type: application/x-www-form-urlencoded)。 另一种是JSON提交(Content-Type: a
RestTemplateUtil工具类
AlbenXie的博客
11-28 1007
【代码】RestTemplateUtil工具类。
Spring RestTemplate使用文档
最新发布
09-15
使用RestTemplate可以实现对RESTful Web服务的访问，支持GET、POST、PUT、DELETE等常见的HTTP请求方法。 下面是Spring RestTemplate的一些基本使用方法: 1. 创建RestTemplate实例: ```java RestTemplate ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值