远程调用（feignClient、restTemplate）设置header头信息

╰半橙微兮° 2021-11-11 19:28 1104阅读 0赞

现在基本上所有的接口都需要权限验证（token、session等），所以在远程调用时，也需要把相应的参数传递过去。

### 一、feignClient + jwt-token ###

增加拦截配置：

import org.apache.commons.lang.StringUtils;
    import feign.RequestInterceptor;
    import feign.RequestTemplate;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.web.context.request.RequestContextHolder;
    import org.springframework.web.context.request.ServletRequestAttributes;
    import lombok.extern.slf4j.Slf4j;
    import javax.servlet.http.HttpServletRequest;
    
    /**
     * @author gourd
     */
    @Configuration
    @Slf4j
    public class FeignConfig implements RequestInterceptor {
    
        @Value("${jwt.header}")
        private String tokenHeader;
    
        @Override
        public void apply(RequestTemplate requestTemplate) {
            ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
            if (attributes != null) {
                HttpServletRequest request = attributes.getRequest();
                String jwtToken = request.getHeader(tokenHeader);
                log.info("jwtToken:" + jwtToken);
                if (StringUtils.isNotBlank(jwtToken)) {
                    // header里面添加jwt-token
                    requestTemplate.header(tokenHeader, jwtToken);
                    log.info("header:" + requestTemplate.headers());
                }
            }
        }
    }

调用方法：

import com.gourd.common.data.BaseResponse;
    import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;
    import org.springframework.cloud.openfeign.FeignClient;
    import org.springframework.stereotype.Component;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.PostMapping;
    
    /**
     * @author gourd
     */
    @FeignClient(name = "gourd-service",fallback = RemoteHystrix.class)
    @Component
    public interface RemoteClient {
    
        /**
         * FeignClient测试Get请求
         *
         * @return
         */
        @GetMapping("gourd/gourd/testG")
        @HystrixCommand
        BaseResponse testServerG();
    
        /**
         * FeignClient测试Post接口
         *
         * @return
         */
        @PostMapping("gourd/gourd/testP")
        @HystrixCommand
        BaseResponse testServerP();
    
    }

import com.gourd.common.data.BaseResponse;
    import org.springframework.stereotype.Component;
    
    /**
     * @author gourd
     */
    @Component
    public class RemoteHystrix implements RemoteClient {
    
        @Override
        public BaseResponse testServerG() {
            return BaseResponse.failure("FeignClient测试Get请求失败，请稍后再试");
        }
    
        @Override
        public BaseResponse testServerP() {
            return BaseResponse.failure("FeignClient测试Post请求失败，请稍后再试");
        }
    }

### 二、restTemplate + jwt-token: ###

首先配置拦截器：

import com.gourd.common.utils.RequestHolder;
    import lombok.extern.slf4j.Slf4j;
    import org.apache.commons.lang.StringUtils;
    import org.springframework.http.HttpHeaders;
    import org.springframework.http.HttpRequest;
    import org.springframework.http.MediaType;
    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.servlet.http.HttpServletRequest;
    import java.io.IOException;
    import java.nio.charset.StandardCharsets;
    
    /**
     * 设置HTTP请求 Header
     * @author gourd
     */
    @Component
    @Slf4j
    public class ActionTrackInterceptor implements ClientHttpRequestInterceptor {
    
      private static final String JWT_TOKEN_KEY = "jwt-token";
    
      @Override
      public ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution)
          throws IOException {
        HttpServletRequest httpServletRequest = RequestHolder.getRequest();
        String jwtToken = httpServletRequest.getHeader(JWT_TOKEN_KEY);
        HttpHeaders headers = request.getHeaders();
        // 加入自定义字段
        log.info("jwtToken:" + jwtToken);
        if (StringUtils.isNotBlank(jwtToken)) {
          //header里面添加jwt-token
          headers.add(JWT_TOKEN_KEY, jwtToken);
          headers.setContentType(MediaType.APPLICATION_JSON_UTF8);
          headers.set(HttpHeaders.ACCEPT_CHARSET, StandardCharsets.UTF_8.toString());
        }
        // 保证请求继续被执行
        return execution.execute(request, body);
      }
    }

注册一个 restTemplate:

import com.gourd.common.handler.ActionTrackInterceptor;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.cloud.client.loadbalancer.LoadBalanced;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.web.client.RestTemplate;
    
    import java.util.Collections;
    
    /**
     * @author gourd
     */
    @Configuration
    public class ClientConfig {
    
      @Autowired
      ActionTrackInterceptor actionTrackInterceptor;
    
      /**
       * 这里就是创建一个负载均衡的RestTemplate Bean
       *
       * @return
       */
      @LoadBalanced
      @Bean
      public RestTemplate restTemplate() {
        RestTemplate restTemplate = new RestTemplate();
     
        // 把自定义的ClientHttpRequestInterceptor添加到RestTemplate，可添加多个
        restTemplate.setInterceptors(Collections.singletonList(actionTrackInterceptor));
        return restTemplate;
      }
    
    }

调用方法：

@Value("${spring.application.name:gourd-service}")
        private String applicationName;
    
        @Value("${server.servlet.context-path:gourd}")
        private String contextPath;
    
        @Value("${jwt.header}")
        private String tokenHeader;
    
        @Autowired
        private RestTemplate restTemplate;
    
        @GetMapping("/test")
        @ApiOperation("nacos测试接口")
        @HystrixCommand
        public BaseResponse testServerG() {
            BaseResponse response = restTemplate.getForObject( "http://"+applicationName+"/"+contextPath+"/gourd/nacos/testG", BaseResponse.class);
            log.warn("返回结果：{}",response);
            return response;
        }
        @PostMapping("/test")
        @ApiOperation("nacos测试接口")
        @ApiImplicitParams({@ApiImplicitParam(name = "jwt-token", value = "jwt-token", required = true, dataType = "string", paramType = "header")})
        @HystrixCommand
        public BaseResponse testServerP() {
            MultiValueMap<String, String> map = new LinkedMultiValueMap<>();
            map.add("id","haha");
            HttpHeaders header = new HttpHeaders();
            HttpEntity<MultiValueMap<String, String>> httpEntity = new HttpEntity<>(map, header);
            BaseResponse response = restTemplate.postForObject("http://"+applicationName+"/"+contextPath+"/gourd/nacos/testP",httpEntity, BaseResponse.class);
            log.warn("返回结果：{}",response);
            return response;
        }