我有一个Vertx请求，我需要计算一个外部可见（公共）URL

Question

我将Vertx 3与Kotlin一起使用，有时我需要从公共URL的角度返回特定的URI，这与Vertx web请求认为我的URL不同。这可能是因为我的负载平衡器或代理收到一个URL，然后通过内部URL转发到我的应用程序。

所以如果我这么做：

val publicUrl = context.request().absoluteURI() 

我最终得到了一个像http://10.10.103.22:8080/some/page而不是https://app.mydomain.com/some/page。那个网址的一切都错了！

我发现了一个标题，它应该告诉我更多关于原始请求的信息，比如X-Forwarded-Host，但它只包括app。我的域名。com或有时它有端口应用程序。mydomain:80但这还不足以计算出URL的所有部分，我最终得到了类似于http://app.mydomain.com:8080/some/page这仍然不是正确的公共URL。

我不仅需要处理当前的URL，还需要处理对等URL，比如在同一服务器上的“某物/page1”页面转到“某物/page2”。当我试图解析到另一个URL时，也提到了同样的问题，因为公共URL的重要部分是无法获取的。

Vertx-web中有没有我缺少的方法来确定这个公共网址，或者一些惯用的方法来解决这个问题？

我是用Kotlin编写代码的，所以这门语言的任何例子都很棒！

注意：这个问题是由作者（自答问题）有意写和回答的，所以有趣问题的解决方案在SO中共享。

Answer 1

这是一个更复杂的问题，对于大多数应用服务器来说，如果它们还没有提供URL外部化功能，那么逻辑也是一样的。

要正确执行此操作，您需要处理所有这些头：

• X-Forwarded-Proto（或X-Forwarded-Schem： https，也许还有像X-Forwarded-Ssl： on，前端Https： on）
• X-Forwarded-Host（myhost.com或myhost.com： port）
• X-转发-端口

如果您想解析并返回一个不是当前URL，您还需要考虑：

• 部分没有主机，例如/某物/这里或下/我解决服务器公共协议，主机，端口以及该abosolute或相对路径
• 部分与主机/端口，例如//somehost.com:8983/thing将添加相同的方案（超文本传输协议/https）作为这个服务器，并保持其余的
• 完整，完全合格的URL将原封不动地返回，因此它们可以安全地传递给此函数（"超文本传输协议：//..."，"https：//..."），并且不会被修改

下面是一对到RoutingContext的扩展函数，它们将处理所有这些情况，并在负载平衡器/代理头不存在时返回，因此将在直接连接到服务器和通过中介的情况下工作。您传入绝对或相对URL（到当前页面），它将返回相同的公共版本。

// return current URL as public URL
fun RoutingContext.externalizeUrl(): String {
    return externalizeUrl(URI(request().absoluteURI()).pathPlusParmsOfUrl())
}

// resolve a related URL as a public URL
fun RoutingContext.externalizeUrl(resolveUrl: String): String {
    val cleanHeaders = request().headers().filterNot { it.value.isNullOrBlank() }
            .map { it.key to it.value }.toMap()
    return externalizeURI(URI(request().absoluteURI()), resolveUrl, cleanHeaders).toString()
}

它调用一个内部函数来完成真正的工作（由于不需要模拟RoutingContext，因此更易于测试）：

internal fun externalizeURI(requestUri: URI, resolveUrl: String, headers: Map<String, String>): URI {
    // special case of not touching fully qualified resolve URL's
    if (resolveUrl.startsWith("http://") || resolveUrl.startsWith("https://")) return URI(resolveUrl)

    val forwardedScheme = headers.get("X-Forwarded-Proto")
            ?: headers.get("X-Forwarded-Scheme")
            ?: requestUri.getScheme()

    // special case of //host/something URL's
    if (resolveUrl.startsWith("//")) return URI("$forwardedScheme:$resolveUrl")

    val (forwardedHost, forwardedHostOptionalPort) =
            dividePort(headers.get("X-Forwarded-Host") ?: requestUri.getHost())

    val fallbackPort = requestUri.getPort().let { explicitPort ->
        if (explicitPort <= 0) {
            if ("https" == forwardedScheme) 443 else 80
        } else {
            explicitPort
        }
    }
    val requestPort: Int = headers.get("X-Forwarded-Port")?.toInt()
            ?: forwardedHostOptionalPort
            ?: fallbackPort
    val finalPort = when {
        forwardedScheme == "https" && requestPort == 443 -> ""
        forwardedScheme == "http" && requestPort == 80 -> ""
        else -> ":$requestPort"
    }

    val restOfUrl = requestUri.pathPlusParmsOfUrl()
    return URI("$forwardedScheme://$forwardedHost$finalPort$restOfUrl").resolve(resolveUrl)
}

以及一些相关的辅助功能：

internal fun URI.pathPlusParmsOfUrl(): String {
    val path = this.getRawPath().let { if (it.isNullOrBlank()) "" else it.mustStartWith('/') }
    val query = this.getRawQuery().let { if (it.isNullOrBlank()) "" else it.mustStartWith('?') }
    val fragment = this.getRawFragment().let { if (it.isNullOrBlank()) "" else it.mustStartWith('#') }
    return "$path$query$fragment"
}

internal fun dividePort(hostWithOptionalPort: String): Pair<String, Int?> {
    val parts = if (hostWithOptionalPort.startsWith('[')) { // ipv6
        Pair(hostWithOptionalPort.substringBefore(']') + ']', hostWithOptionalPort.substringAfter("]:", ""))
    } else { // ipv4
        Pair(hostWithOptionalPort.substringBefore(':'), hostWithOptionalPort.substringAfter(':', ""))
    }
    return Pair(parts.first, if (parts.second.isNullOrBlank()) null else parts.second.toInt())
}

fun String.mustStartWith(prefix: Char): String {
    return if (this.startsWith(prefix)) { this } else { prefix + this }
}