SpringCloud微服务,使Fegin请求携带原header信息

使Fegin请求携带原header信息

package com.zky.config;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import feign.RequestInterceptor;
import feign.RequestTemplate;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.annotation.PostConstruct;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;

/**
 * 使Fegin请求携带原header信息
 *
 * @author zky
 * @date 2023-05-04
 */
@Component
@Slf4j
public class FeignCommonRequestInterceptor implements RequestInterceptor {

    @Autowired
    private ObjectMapper objectMapper;

    private Set<String> excludeHeaderNames = new HashSet<>();

    @PostConstruct
    public void init() {
        excludeHeaderNames.add("Content-Type");
        excludeHeaderNames.add("Content-Length");
    }

    @Override
    public void apply(RequestTemplate template) {
        Map<String, String> header = getHeaders(getHttpServletRequest());
        if (header != null) {
            for (Map.Entry<String, String> entry : header.entrySet()) {
                if (excludeHeaderNames.stream().noneMatch(entry.getKey()::equalsIgnoreCase)) {
                    template.header(entry.getKey(), entry.getValue());
                }
            }
        }
        template.header("x-gateway-token", "true");
        // feign 不支持 GET 方法传 POJO, json body转query
        if (template.method().equals("GET") && template.body() != null) {
            try {
                //读取并清空body中的内容
                JsonNode jsonNode = objectMapper.readTree(template.body());
                template.body("");
                //获取当前查询参数
                Map<String, Collection<String>> queries = getCurrentQueries(template);
                //构造
                buildQuery(jsonNode, "", queries);
                template.queries(queries);
            } catch (IOException e) {
                log.error("feign插件处理失败,{}", e);
            }
        }

    }

	/**
     *获取Request对象
     */
    private HttpServletRequest getHttpServletRequest() {
        RequestAttributes attributes = RequestContextHolder.getRequestAttributes();
        try {
            return ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        } catch (Exception e) {
            return null;
        }
    }

	/**
     * 获取请求头属性
     */
    private Map<String, String> getHeaders(HttpServletRequest request) {
        Map<String, String> map = new LinkedHashMap<>();
        if (request == null) {
            return null;
        }
        Enumeration<String> enumeration = request.getHeaderNames();
        while (enumeration.hasMoreElements()) {
            String key = enumeration.nextElement();
            String value = request.getHeader(key);
            map.put(key, value);
        }
        return map;
    }

    /**
     * @param template
     * @return Map<String, Collection < String>>
     * @Description 获取当前查询参数 （原类型为Collections.unmodifiableMap，不可修改，故需重新创建）
     */
    private Map<String, Collection<String>> getCurrentQueries(RequestTemplate template) {
        Map<String, Collection<String>> queries = new HashMap<>();
        //获取现有的查询参数
        Map<String, Collection<String>> currentQueries = template.queries();
        //遍历构造
        for (Map.Entry<String, Collection<String>> entry : currentQueries.entrySet()) {
            String key = entry.getKey();
            Collection<String> value = entry.getValue();
            queries.put(key, value);
        }

        return queries;
    }

    /**
     * @param jsonNode
     * @param path
     * @param queries
     * @return void
     * @Description 根据body内容构建查询参数
     */
    private void buildQuery(JsonNode jsonNode, String path, Map<String, Collection<String>> queries) {
        if (!jsonNode.isContainerNode()) {   // 叶子节点
            if (jsonNode.isNull()) {
                return;
            }
            Collection<String> values = queries.get(path);
            if (null == values) {
                values = new ArrayList<>();
                queries.put(path, values);
            }
            values.add(jsonNode.asText());
            return;
        }
        if (jsonNode.isArray()) {   // 数组节点
            Iterator<JsonNode> it = jsonNode.elements();
            while (it.hasNext()) {
                buildQuery(it.next(), path, queries);
            }
        } else {
            Iterator<Map.Entry<String, JsonNode>> it = jsonNode.fields();
            while (it.hasNext()) {
                Map.Entry<String, JsonNode> entry = it.next();
                if (StringUtils.isNotBlank(path)) {
                    buildQuery(entry.getValue(), path + "." + entry.getKey(), queries);
                } else {  // 根节点
                    buildQuery(entry.getValue(), entry.getKey(), queries);
                }
            }
        }
    }
}