自定义的ClientHttpRequestInterceptor添加到RestTemplate

已于 2022-05-11 14:57:05 修改
阅读量1.4k 收藏 3
点赞数
分类专栏： JAVA代码片段 文章标签： java
于 2022-03-29 09:54:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dongshaw/article/details/123812461
版权

此篇文章介绍在使用restTemplate访问另一个服务器时，需要在请求头Headers添加某个标识，比如token、sign。当然也可以直接重构restTemplate调用方法，在方法中将参数添加到请求头中；此篇文章是通过拦截HttpRequest，将参数添加请求头中。

1、自定义HeaderRequestInterceptor 

拦截HttpReqeust，并将标识添加到请求头中，相当于存在一个业务处理过程。

import com.ahdhst.commons.webmvc.exception.CommonException;
import com.ahdhst.lzz.lzt25.enums.core.ResultEnum;
import com.ahdhst.lzz.lzt25.properties.ServerSecretProperties;
import com.ahdhst.lzz.lzt25.utils.MapUtils;
import com.ahdhst.lzz.lzt25.utils.SignUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.HttpRequest;
import org.springframework.http.client.ClientHttpRequestExecution;
import org.springframework.http.client.ClientHttpRequestInterceptor;
import org.springframework.http.client.ClientHttpResponse;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.io.IOException;
import java.util.Map;
import java.util.Objects;

/**
 * <p>Description:</p>
 * Created on 2021/7/27 16:33
 *
 **/
@Component
@Slf4j
public class HeaderRequestInterceptor implements ClientHttpRequestInterceptor {

    @Resource
    private ServerSecretProperties serverSecretProperties;

    @Override
    public ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution)
            throws IOException {
        String sign = null;
        String appId = Objects.requireNonNull(request.getHeaders().get("appId")).get(0);
        Map<String,String> map;
        if (HttpMethod.GET.name().equalsIgnoreCase(Objects.requireNonNull(request.getMethod()).name())) {//地址拼接参数
           String param = request.getURI().getQuery();
           map = MapUtils.getStringToMap(param,"str");
           sign = initSecret(map,appId);
        }else{//参数作为对象
            map = MapUtils.getStringToMap(new String(body),"json");
            sign = initSecret(map,appId);
        }
        HttpHeaders headers = request.getHeaders();
        // 加入自定义字段
        headers.add("sign", sign);

        // 保证请求继续被执行
        return execution.execute(request, body);
    }
}

2、将自定义的HeaderRequestInterceptor 添加到RestTemplate

注意：创建的方法名serverRestTemplate，在引用RestTemplate时，命名规则为以方法名命名。

这样才能将自定义的HeaderRequestInterceptor 有效的添加到RestTemplate中。

import com.ahdhst.lzz.lzt25.interceptor.HeaderRequestInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;

import javax.annotation.Resource;
import java.util.Collections;

/**
 * <p>Description:</p>
 * Created on 2021/7/27 16:22
 *
 **/
@Configuration
public class ServerRestTemplateConfig {

    // 注入拦截器。拦截器也可以不声明为Bean, 直接在这里新建实例
    @Resource
    HeaderRequestInterceptor actionTrackInterceptor;

    // 声明为Bean，方便应用内使用同一实例
    @Bean
    public RestTemplate serverRestTemplate() {
        RestTemplate restTemplate = new RestTemplate();
        // 把自定义的ClientHttpRequestInterceptor添加到RestTemplate，可添加多个
        restTemplate.setInterceptors(Collections.singletonList(actionTrackInterceptor));
        return restTemplate;
    }
}

3、重构RestTemplate方法

注意：private RestTemplate serverRestTemplate; 声明规则以上述的方法名一致。

import com.ahdhst.commons.webmvc.exception.CommonException;
import com.ahdhst.lzz.lzt25.enums.core.ResultEnum;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.toolkit.Constants;
import com.github.pagehelper.PageSerializable;
import org.springframework.http.*;
import org.springframework.stereotype.Service;
import org.springframework.util.MultiValueMap;
import org.springframework.web.client.RestTemplate;

import javax.annotation.Resource;
import java.util.List;

/**
 * <p>Description:</p>
 * Created on 2021/7/29 11:00
 *
 **/
@Service
public class PubRestTemplateUtils {

    @Resource
    private RestTemplate serverRestTemplate;
    /**
     * <p>Description:get请求配置请求头,返回List</p>
     * @param url 地址
     * @param appId 服务器appId
     * @param clazz 类
     * Created on 2021/7/28 21:41
     * @return T
     **/
    public <T> List<T> getForObject(String url,  String appId, Class<T> clazz){
        JSONObject body = getData(appId,url);
        return getForObjectList(body,clazz);
    }

    /**
     * <p>Description:get请求配置请求头,返回对象</p>
     * @param url 地址
     * @param appId 服务器appId
     * @param clazz 类
     * Created on 2021/7/28 21:41
     * @return T
     **/
    public <T> T getForOnlyOneObject(String url, String appId, Class<T> clazz){
        JSONObject body = getData(appId,url);
        return getForOnlyOneData(body,clazz);
    }

    /**
     * <p>Description:post请求配置请求头,返回List</p>
     * @param url 地址
     * @param appId 服务器appId
     * @param clazz 类
     * Created on 2021/7/28 21:41
     * @return T
     **/
    public <T> List<T> postForObject(String url, String appId, Object objcet, Class<T> clazz){
        JSONObject body =postData(appId,url,objcet);
        return getForObjectList(body,clazz);
    }

    /**
     * <p>Description:post请求配置请求头,返回对象</p>
     * @param url 地址
     * @param appId 服务器appId
     * @param clazz 类
     * Created on 2021/7/28 21:41
     * @return T
     **/
    public <T> T postForOnlyOneObject(String url, String appId,Object object,Class<T> clazz){
        JSONObject body =postData(appId,url,object);
        return getForOnlyOneData(body,clazz);
    }

    /**
     * <p>Description:get请求配置请求头,返回分页对象</p>
     * @param url 地址
     * @param appId 服务器appId
     * @param clazz 类
     * Created on 2021/7/28 21:41
     * @return T
     **/
    public <T> PageSerializable<T> getForPageObject(String url, String appId, Class<T> clazz){
        JSONObject body = getData(appId,url);
        return getPageData(body, clazz);
    }

    /**
     * <p>Description: post请求配置请求头,返回分页对象</p>
     * Created on 2021/8/2 10:15
     *
     * @param url 地址
     * @param sign 签名
     * @param obj 对象
     * @param clazz 类
     * @return T
     */
    public <T> PageSerializable<T> postForPageObject(String url, String sign, Object obj, Class<T> clazz){
        JSONObject body =postData(sign,url, obj);
        return getPageData(body, clazz);
    }

    /**
     * <p>Description:处理返回数据，返回对象</p>
     * @param body 返回数据
     * @param clazz 返回对象
     * Created on 2021/8/6 10:13
     * @return T
     **/
    private <T> T getForOnlyOneData(JSONObject body, Class<T> clazz) {
        if(null != body && body.get("code").equals(Constants.ONE)){
            return body.getObject("data",clazz);
        }else{
            assert body != null;
            String msg = body.get("msg").toString();
            throw new CommonException(ResultEnum.ERROR_SERVER_EXCEPTION,msg);
        }
    }

    /**
     * <p>Description:处理返回数据，返回对象list</p>
     * @param body 响应数据
     * @param clazz 返回类型
     * Created on 2021/8/6 10:11
     * @return java.util.List<T>
     **/
    private <T> List<T> getForObjectList(JSONObject body, Class<T> clazz) {
        if(null != body && body.get("code").equals(Constants.ONE)){
            JSONArray jsonArray = body.getJSONArray("data");
            return JSON.parseArray(JSON.toJSONString(jsonArray),clazz);
        }else{
            assert body != null;
            String msg = body.get("msg").toString();
            throw new CommonException(ResultEnum.ERROR_SERVER_EXCEPTION,msg);
        }
    }



    /**
     * <p>Description: 处理返回分页数据</p>
     * Created on 2021/8/2 10:18
     *
     * @param body 返回
     * @return T
     */
    private <T> PageSerializable<T> getPageData(JSONObject body, Class<T> clazz) {
        if(null != body && body.get("code").equals(Constants.ONE)){
            JSONObject data = body.getObject("data",JSONObject.class);
            List<T> list = JSON.parseArray(JSON.toJSONString(data.getJSONArray("list")), clazz);
            PageSerializable<T> pageSerializable = new PageSerializable<>(list);
            long total = data.getObject("total",long.class);
            pageSerializable.setTotal(total);
            return pageSerializable;
        }else{
            assert body != null;
            String msg = body.get("msg").toString();
            throw new CommonException(ResultEnum.ERROR_SERVER_EXCEPTION,msg);
        }
    }

    /**
     * <p>Description:请求头设置；调转外部服务器获取数据</p>
     * @param appId 服务器
     * @param url 访问地址
     * Created on 2021/7/30 11:33
     * @return com.alibaba.fastjson.JSONObject
     **/
    private JSONObject getData(String appId,String url){
        // 请求头设置
        HttpHeaders headers = new HttpHeaders();
        headers.set("appId",appId);
        // 组装请求体
        HttpEntity<MultiValueMap<String, String>> request = new HttpEntity<>(null,headers);
        ResponseEntity<JSONObject> exchange = serverRestTemplate.exchange(url, HttpMethod.GET, request, JSONObject.class);
        return exchange.getBody();
    }

    /**
     * <p>Description:请求头设置；调转外部服务器获取数据</p>
     * @param appId 服务器
     * @param url 访问地址
     * Created on 2021/7/30 11:33
     * @return com.alibaba.fastjson.JSONObject
     **/
    private JSONObject postData(String appId,String url,Object object){
        // 请求头设置
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_JSON);
        headers.set("appId",appId);
        // 组装请求体
        HttpEntity<Object> request = new HttpEntity<>(object,headers);
        return serverRestTemplate.exchange(url, HttpMethod.POST, request,JSONObject.class,object).getBody();
    }
}

大脸猫 爱吃鱼
关注
专栏目录
SpringBoot入门教程：RestTemplate
人不风流枉少年
11-09 977
一：简介 通常在Java代码中调用其它http 接口的话会使用HttpClient，不过这个使用起来有些繁琐，Spring中推出了一个简单的RestTemplate用来调用rest api，使用起来非常简单。 二：基础示例 @RestController @RequestMapping("/user") public class UserController { @PostMapping("/regist") public User regist(@RequestBody CreateUs
使用RestTemplate发请求时自动拼接header信息（一学就会系列）
九层之台，起于垒土
04-12 1920
前言 使用SpringBoot自带的RestTemplate发送请求很方便，但是我们经常会在发送请求时带上token信息，直接拼接头信息显得不太优雅。下面使用RestTemplate自带的拦截器，去实现每次发送请求时自动带上头信息。 第一步:创建SpringBoot项目，添加依赖 <dependency> <groupId>org.springframework.boot</groupId> <
Ribbon拦截器ClientHttpRequestInterceptor-传递header
小明的博客
01-21 732
ClientHttpRequestInterceptor用来传递在header里的值，例如token等值，可以用该类对header中的属性值自定义，存入想要放入header中的值。 先实现一个自己的ClientHttpRequestInterceptor，实现intercept方法 @Slf4j @Component public class HeaderRequestInterceptor implements ClientHttpRequestInterceptor { @Autowire
Feign的拦截器RequestInterceptor
weixin_69413377的博客
08-24 3592
SpringCloud的微服务使用Feign进行服务间调用的时候可以使用RequestInterceptor统一拦截请求来完成设置header等相关请求，但RequestInterceptor和ClientHttpRequestInterceptor有点不同，它拿不到原本的请求，所以要通过其他方法来获取原本的请求。可以看到进入了我们自定义的RequestInterceptor。再查看feign调用的程序日志，可以看到设置的header信息。首先创建自定义的RequestInterceptor。
自定义requestInterceptor
像一阵风
12-31 900
主要目的，熟悉如何通过promise挂起异步，并在指定位置调用 let requests = [] let isGetOpening = false //请求拦截 async function requestInterceptor(params){ let token = false //判断条件 if (!token) { if(!isGetOpening){ isGetOpening = true //从接口获取token t
RestTemplate组件：ClientHttpRequestFactory、ClientHttpRequestInterceptor、ResponseExtractor【享学Spring MVC】
热门推荐
架构师：通透，才能写出好代码！
09-12 4万+
前言 本文为深入了解Spring提供的Rest调用客户端RestTemplate做准备，对和它相关的周边类做一个打点。 因为单词相似，请注意区分RestTemplate和RedisTemplate哦~ ClientHttpRequestFactory 它是个函数式接口，用于根据URI和HttpMethod创建出一个ClientHttpRequest来~ 说明：ClientHttpRequest...
RestTemplate 的拦截器 ClientHttpRequestInterceptor
huachangzai的博客
12-08 5785
这篇文章是 Spring Cloud Loadbalancer 模块学习的前置文章。因为 Spring Cloud loadbalancer 是通过 ClientHttpRequestInterceptor 对 RestTemplate 进行负载均衡的。因此需要对 ClientHttpRequestInterceptor 有所了解。
resttemplate
03-17
- 可以通过`ClientHttpRequestInterceptor`接口实现拦截器，自定义请求前和响应后的逻辑，例如添加全局的请求头、日志记录等。 9. **异步请求**： - Spring 4.0引入了`AsyncRestTemplate`，用于支持非阻塞的异步...
Spring boot restTemplate
xiao/du的博客
05-10 662
文章目录Spring boot jdbcTemplate上一节源码Spring boot jdbcTemplate下一节 Spring boot servlet,filter,Interceptor Spring boot jdbcTemplate 上一节 源码 Spring boot jdbcTemplate 下一节 Spring boot servlet,filter,Interceptor
Ribbon和RestTemplate使用总结
许诗宇的博客
05-25 1093
目录 RestTemplate 依赖注入 get 请求处理 getForEntity 返回一个Map 返回对象 传参调用 返回对象 post 请求处理 postForLocation 拦截器 Ribbon 自定义注解方式 配置文件 Ribbon脱离Eureka RestTemplate 依赖注入 @Bean // 开启负载均衡 @LoadBalanced RestTemplate restTemplate() { return new RestTemp.
SpringBoot常用拦截器之ClientHttpRequestInterceptor
最新发布
weixin_42594143的博客
10-31 3908
SpringBoot常用拦截器之ClientHttpRequestInterceptor
Spring RestTemplate---ClientHttpRequestInterceptor
weixin_30608131的博客
06-16 475
Spring 应用中，经常使用Spring RestTemplate作为客户端向服务端发送Restful请求，如果每次请求都需要在http Header中添加相同的信息，可以通过ClientHttpRequestInterceptor来进行实现。 public class UserContextInterceptor implements ClientHttpRequestInte...
给特别规则FeignClient增加统一的RequestInterceptor
大家都叫我菜鸡刘
02-03 1303
给特别规则FeignClient增加统一的RequestInterceptor
SpringBoot常用拦截器（HandlerInterceptor，ClientHttpRequestInterceptor，RequestInterceptor）
岸河世界
09-27 9382
SpringBoot常用拦截器（HandlerInterceptor，ClientHttpRequestInterceptor，RequestInterceptor） 上面3种拦截器，都是http拦截器，在处理业务逻辑之前对http请求信息进行处理，比如获取请求头，请求参数，设置请求头，请求参数等等 思路清晰，先说jar包: HandlerInterceptor—>spring-webmvc项目，org.springframework.web.servlet.HandlerInterceptor
通过ClientHttpRequestInterceptor实现简单的服务负载均衡调用
weixin_41998947的博客
05-05 540
最近在进行功能开发的时候遇到了一个问题，提供服务的服务器为了避免单点故障所以部署了两台服务器，由于当前的服务架构比较简单，并没有引入分布式服务架构，所以如何对这两台服务器进行负载均衡调用以及重试和熔断就需要自己来实现。本来可以引入ribbon和，但是发现引入之后需要引入springcloud框架，所以就放弃了。本着学习ribbon的原理的态度，所以准备手写一个负载均衡，满足当前的需求。使用过Ribbon的都知道，只要在Resttemplate上面加上注解就可以实现调用的负载均衡。
java网站访问日志记录,java – 用于http请求和响应日志记录的HttpLoggingInterceptor
weixin_34884417的博客
03-22 433
我正在使用retrofit2,我需要记录所有请求和响应.请求和响应工作完美,我只需要记录这些请求/响应,我尝试了几乎所有解决方案,我在这里找到,但没有找到解决方案.我不明白这里有什么不对这是我的代码class Factory {private final static OkHttpClient.Builder httpClient = new OkHttpClient.Builder();priv...
RequestInterceptor FeignClient header
英雄汉孑的博客
09-26 1万+
RequestInterceptor FeignClient
springboot resttemplate 自定义实体类添加请求头
05-12
可以通过在`RestTemplate`中使用`exchange`方法来自定义请求头，示例代码如下： ```java RestTemplate restTemplate = new RestTemplate(); HttpHeaders headers = new HttpHeaders(); headers.set("Authorization", "Bearer your_token"); HttpEntity<?> entity = new HttpEntity<>(headers); ResponseEntity<YourEntityClass> response = restTemplate.exchange( "http://your-url.com", HttpMethod.GET, entity, YourEntityClass.class ); YourEntityClass result = response.getBody(); ``` 在上面的代码中，我们首先创建了一个`HttpHeaders`对象，并设置了`Authorization`请求头的值为`your_token`。然后，我们创建了一个`HttpEntity`对象，并将`HttpHeaders`对象作为参数传入。接着，我们使用`RestTemplate`的`exchange`方法，传入请求的URL、请求方法、`HttpEntity`对象和响应实体类的类型。最后，我们从响应中获取实体类对象。 注意，如果需要设置多个请求头，可以使用`headers.set`方法多次设置。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值