实现一个行为类似nginx的Undertow反向代理

Question

出于开发目的，不是每个人都可以在自己的机器上安装nginx（就像我们在Windows环境中的开发人员一样），但我们希望能够做一个行为类似nginx的反向代理。

这是我们非常具体的案例：

• 我们有一个spring-boot REST服务正在运行http://0.0.0.0:8081
• 我们有spring-boot web应用程序运行在http://0.0.0.0:8082

我们希望从http://0.0.0.0:8080

所以我们想把它绘制成这样：

• 请求http://0.0.0.0:8080/获得代理http://0.0.0.0:8082
• 请求http://0.0.0.0:8080/api获得代理http://0.0.0.0:8081

这样一来，它的工作方式就像nginx的url重写反向代理一样。

我查看了Undertow的源代码和示例，甚至还有这个特定的示例：反向代理示例，但这是一个负载均衡器示例，我没有找到任何涵盖我需要的示例。

此外，我知道Undertow能够做到这一点，因为我们知道我们可以通过Undertow组件配置配置WildFly来覆盖这一特定情况，而不会出现问题，但我们希望将其作为本地开发的轻量级解决方案自行实现。

有人知道这样做的例子吗？或者任何有足够信息来实现这一点的文档？因为我也读过Undertow关于反向代理的文档，它一点帮助都没有。

感谢

Answer 1

这应该可以完成任务。

它是Java8，所以有些部分可能无法在您的设置中工作。

你可以用与你在问题中提到的例子类似的方式开始。

package com.company
import com.google.common.collect.ImmutableMap;
import io.undertow.client.ClientCallback;
import io.undertow.client.ClientConnection;
import io.undertow.client.UndertowClient;
import io.undertow.server.HttpServerExchange;
import io.undertow.server.ServerConnection;
import io.undertow.server.handlers.proxy.ProxyCallback;
import io.undertow.server.handlers.proxy.ProxyClient;
import io.undertow.server.handlers.proxy.ProxyConnection;
import org.xnio.IoUtils;
import org.xnio.OptionMap;
import java.io.IOException;
import java.net.URI;
import java.util.concurrent.TimeUnit;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
 * Start the ReverseProxy with an ImmutableMap of matching endpoints and a default
 * 
 * Example:
 * mapping: ImmutableMap("api" -> "http://some-domain.com")
 * default: "http://default-domain.com"
 * 
 * Request 1: localhost:8080/foo -> http://default-domain.com/foo
 * Request 2: localhost:8080/api/bar -> http://some-domain.com/bar
 */
public class ReverseProxyClient implements ProxyClient {
    private static final ProxyTarget TARGET = new ProxyTarget() {};
    private final UndertowClient client;
    private final ImmutableMap<String, URI> mapping;
    private final URI defaultTarget;
    public ReverseProxyClient(ImmutableMap<String, URI> mapping, URI defaultTarget) {
        this.client = UndertowClient.getInstance();
        this.mapping = mapping;
        this.defaultTarget = defaultTarget;
    }
    @Override
    public ProxyTarget findTarget(HttpServerExchange exchange) {
        return TARGET;
    }
    @Override
    public void getConnection(ProxyTarget target, HttpServerExchange exchange, ProxyCallback<ProxyConnection> callback, long timeout, TimeUnit timeUnit) {
        URI targetUri = defaultTarget;
        Matcher matcher = Pattern.compile("^/(\w+)(/.*)").matcher(exchange.getRequestURI());
        if (matcher.find()) {
            String firstUriSegment = matcher.group(1);
            String remaininguri = matcher.group(2);
            if (mapping.containsKey(firstUriSegment)) {
                // If the first uri segment is in the mapping, update the targetUri
                targetUri = mapping.get(firstUriSegment);
                // Strip the request uri from the part that is used to map upon.
                exchange.setRequestURI(remaininguri);
            }
        }
        client.connect(
            new ConnectNotifier(callback, exchange),
            targetUri,
            exchange.getIoThread(),
            exchange.getConnection().getByteBufferPool(),
            OptionMap.EMPTY);
    }
    private final class ConnectNotifier implements ClientCallback<ClientConnection> {
        private final ProxyCallback<ProxyConnection> callback;
        private final HttpServerExchange exchange;
        private ConnectNotifier(ProxyCallback<ProxyConnection> callback, HttpServerExchange exchange) {
            this.callback = callback;
            this.exchange = exchange;
        }
        @Override
        public void completed(final ClientConnection connection) {
            final ServerConnection serverConnection = exchange.getConnection();
            serverConnection.addCloseListener(serverConnection1 -> IoUtils.safeClose(connection));
            callback.completed(exchange, new ProxyConnection(connection, "/"));
        }
        @Override
        public void failed(IOException e) {
            callback.failed(exchange);
        }
    }
}

Answer 2

根据M.Deinum的评论建议，我将使用Zuul Spring Boot组件，而不是尝试使用Undertow来完成此任务，因为它更适合此任务。

这里有一个教程的链接：

https://spring.io/guides/gs/routing-and-filtering/

希望这能帮助到其他人，因为这是一个很常见的情况，而且我不知道Spring Boot上的Zuul。