Question

我正在使用spring-boot服务编写一个基于微服务的应用程序。

对于通信，我使用REST（带有hateoas链接）。每个服务都注册了eureka，因此我提供的链接基于这些名称，因此功能区增强的resttemplates可以使用堆栈的负载平衡和故障转移功能。

这适用于内部通信，但我有一个单页管理应用程序，通过基于zuul的反向代理访问服务。当链接使用真实的主机名和端口时，链接被正确地重写以匹配从外部可见的URL。这当然不适用于内部需要的符号链接......

所以在内部我有像：

这样的链接

http://adminusers/myfunnyusername

zuul代理应该将其重写为

http://localhost:8090/api/adminusers/myfunnyusername

是否有一些我在zuul或某处的某处遗漏的东西会让这更容易？

现在我正在考虑如何在没有附带损害的情况下可靠地重写网址。

应该有一种更简单的方法，对吧？

Answer 1

很明显，Zuul无法将符号尤里卡名称的链接重写为“外部链接”。

为此我只写了一个Zuul过滤器来解析json响应，并查找“链接”节点并重写指向我的模式的链接。

例如，我的服务名称为：adminusers和restaurants 该服务的结果包含http://adminusers/ {id}和http://restaurants/cuisine/ {id}

等链接

然后它会被重写 http://localhost:8090/api/adminusers/ {id}和http://localhost:8090/api/restaurants/cuisine/ {id}

private String fixLink(String href) {
    //Right now all "real" links contain ports and loadbalanced links not
    //TODO: precompile regexes
    if (!href.matches("http[s]{0,1}://[a-zA-Z0-9]+:[0-9]+.*")) {
        String newRef = href.replaceAll("http[s]{0,1}://([a-zA-Z0-9]+)", BasicLinkBuilder.linkToCurrentMapping().toString() + "/api/$1");
        LOG.info("OLD: {}", href);
        LOG.info("NEW: {}", newRef);
        href = newRef;
    }
    return href;
}

（这需要稍微优化一下，因为你只能编译一次regexp，一旦我确定这是我从长远来看真的需要的话，我会这样做）

更新

托马斯要求提供完整的过滤器代码，所以在这里。请注意，它会对URL做出一些假设！我假设内部链接不包含端口并且将servicename作为主机，这是基于eureka的应用程序的有效假设，因为功能区等能够与这些应用程序一起使用。我将其重写为$ PROXY / api / $ SERVICENAME / ... 随意使用此代码。

import com.fasterxml.jackson.databind.ObjectMapper;
import com.google.common.base.Throwables;
import com.google.common.collect.ImmutableSet;
import com.google.common.io.CharStreams;
import com.netflix.util.Pair;
import com.netflix.zuul.ZuulFilter;
import com.netflix.zuul.context.RequestContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.hateoas.mvc.BasicLinkBuilder;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Component;

import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Collection;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.regex.Pattern;

import static com.google.common.base.Preconditions.checkNotNull;

@Component
public final class ContentUrlRewritingFilter extends ZuulFilter {
    private static final Logger LOG = LoggerFactory.getLogger(ContentUrlRewritingFilter.class);

    private static final String CONTENT_TYPE = "Content-Type";

    private static final ImmutableSet<MediaType> DEFAULT_SUPPORTED_TYPES = ImmutableSet.of(MediaType.APPLICATION_JSON);

    private final String replacement;
    private final ImmutableSet<MediaType> supportedTypes;
    //Right now all "real" links contain ports and loadbalanced links not
    private final Pattern detectPattern = Pattern.compile("http[s]{0,1}://[a-zA-Z0-9]+:[0-9]+.*");
    private final Pattern replacePattern;

    public ContentUrlRewritingFilter() {
        this.replacement = checkNotNull("/api/$1");
        this.supportedTypes = ImmutableSet.copyOf(checkNotNull(DEFAULT_SUPPORTED_TYPES));
        replacePattern = Pattern.compile("http[s]{0,1}://([a-zA-Z0-9]+)");
    }

    private static boolean containsContent(final RequestContext context) {
        assert context != null;
        return context.getResponseDataStream() != null || context.getResponseBody() != null;
    }

    private static boolean supportsType(final RequestContext context, final Collection<MediaType> supportedTypes) {
        assert supportedTypes != null;
        for (MediaType supportedType : supportedTypes) {
            if (supportedType.isCompatibleWith(getResponseMediaType(context))) return true;
        }
        return false;
    }

    private static MediaType getResponseMediaType(final RequestContext context) {
        assert context != null;
        for (final Pair<String, String> header : context.getZuulResponseHeaders()) {
            if (header.first().equalsIgnoreCase(CONTENT_TYPE)) {
                return MediaType.parseMediaType(header.second());
            }
        }
        return MediaType.APPLICATION_OCTET_STREAM;
    }

    @Override
    public String filterType() {
        return "post";
    }

    @Override
    public int filterOrder() {
        return 100;
    }

    @Override
    public boolean shouldFilter() {
        final RequestContext context = RequestContext.getCurrentContext();
        return hasSupportedBody(context);
    }

    public boolean hasSupportedBody(RequestContext context) {
        return containsContent(context) && supportsType(context, this.supportedTypes);
    }

    @Override
    public Object run() {
        try {
            rewriteContent(RequestContext.getCurrentContext());
        } catch (final Exception e) {
            Throwables.propagate(e);
        }
        return null;
    }

    private void rewriteContent(final RequestContext context) throws Exception {
        assert context != null;
        String responseBody = getResponseBody(context);
        if (responseBody != null) {
            ObjectMapper mapper = new ObjectMapper();
            LinkedHashMap<String, Object> map = mapper.readValue(responseBody, LinkedHashMap.class);
            traverse(map);
            String body = mapper.writeValueAsString(map);
            context.setResponseBody(body);
        }
    }

    private String getResponseBody(RequestContext context) throws IOException {
        String responseData = null;
        if (context.getResponseBody() != null) {
            context.getResponse().setCharacterEncoding("UTF-8");
            responseData = context.getResponseBody();

        } else if (context.getResponseDataStream() != null) {
            context.getResponse().setCharacterEncoding("UTF-8");
            try (final InputStream responseDataStream = context.getResponseDataStream()) {
                //FIXME What about character encoding of the stream (depends on the response content type)?
                responseData = CharStreams.toString(new InputStreamReader(responseDataStream));
            }
        }
        return responseData;
    }

    private void traverse(Map<String, Object> node) {
        for (Map.Entry<String, Object> entry : node.entrySet()) {
            if (entry.getKey().equalsIgnoreCase("links") && entry.getValue() instanceof Collection) {
                replaceLinks((Collection<Map<String, String>>) entry.getValue());
            } else {
                if (entry.getValue() instanceof Collection) {
                    traverse((Collection) entry.getValue());
                } else if (entry.getValue() instanceof Map) {
                    traverse((Map<String, Object>) entry.getValue());
                }
            }
        }
    }

    private void traverse(Collection<Map> value) {
        for (Object entry : value) {
            if (entry instanceof Collection) {
                traverse((Collection) entry);
            } else if (entry instanceof Map) {
                traverse((Map<String, Object>) entry);
            }
        }
    }

    private void replaceLinks(Collection<Map<String, String>> value) {
        for (Map<String, String> node : value) {
            if (node.containsKey("href")) {
                node.put("href", fixLink(node.get("href")));
            } else {
                LOG.debug("Link Node did not contain href! {}", value.toString());
            }
        }
    }

    private String fixLink(String href) {
        if (!detectPattern.matcher(href).matches()) {
            href = replacePattern.matcher(href).replaceAll(BasicLinkBuilder.linkToCurrentMapping().toString() + replacement);
        }
        return href;
    }
}

欢迎改进： - ）

Answer 2

查看HATEOAS paths are invalid when using an API Gateway in a Spring Boot app

如果配置正确，ZUUL应该为所有转发的请求添加“X-Forwarded-Host”标头，Spring-hateoas会尊重并适当修改链接。

在zuul代理中重写基于内部eureka的外部链接链接

2 个答案: