Get Host Name With Port From a HTTP or HTTPS Request in Java

1. Overview

When we build web applications, we often need to extract the scheme, hostname, and port from an incoming HTTP or HTTPS request. For example, we may require it to generate absolute links, build redirect URLs, or log detailed request information for debugging.

In this tutorial, we’ll explore different ways to get the hostname with port from a request in Java. We’ll start with the standard HttpServletRequest approach, move on to Spring’s helper utilities, and also discuss how to handle real-world scenarios like proxies.

2. Using the HttpServletRequest API

The most straightforward way is to use HttpServletRequest, which provides the scheme, host, and port directly:

public static String getHostWithPort(HttpServletRequest request) {
    String scheme = request.getScheme();
    String serverName = request.getServerName();
    int serverPort = request.getServerPort();

    boolean isDefaultPort = ("http".equals(scheme) && serverPort == 80) || ("https".equals(scheme) && serverPort == 443);

    if (isDefaultPort) {
        return String.format("%s://%s", scheme, serverName);
    } else {
        return String.format("%s://%s:%d", scheme, serverName, serverPort);
    }
}

Here, we check whether the port is a default one (80 or 443) and omit it if so. This keeps our URLs clean and consistent.

3. Using HttpServletRequest.getRequestURL()

If we want the entire URL, including path and query parameters, we can use getRequestURL():

public static String getHostWithPortFromRequestUrl(HttpServletRequest request) {
    try {
        URL url = new URL(request.getRequestURL().toString());
        return url.getPort() == -1 
          ? String.format("%s://%s", url.getProtocol(), url.getHost())
          : String.format("%s://%s:%d", url.getProtocol(), url.getHost(), url.getPort());
    } catch (MalformedURLException e) {
        throw new RuntimeException("Invalid request URL", e);
    }
}

This method is simple and works with both HTTP and HTTPS, but it’s slightly less efficient since it involves parsing the URL string.

4. Using Spring’s ServletUriComponentsBuilder

If we’re using Spring Boot or Spring MVC, ServletUriComponentsBuilder provides a neat API to build URLs from the current request:

public static String getBaseUrl() {
    return ServletUriComponentsBuilder.fromCurrentRequestUri()
      .replacePath(null)
      .build()
      .toUriString();
}

This way, we can automatically handle ports and HTTPS. It is a clean, declarative syntax. But it works only within a Spring web context.

5. Handling Reverse Proxies (X-Forwarded-* Headers)

In production, our app often sits behind a reverse proxy, such as Nginx, AWS ELB, or Cloudflare. These proxies may alter the host and port before forwarding the request.

To handle that correctly, we can use forwarded headers:

public static String getForwardedHost(HttpServletRequest request) {
    String forwardedHost = request.getHeader("X-Forwarded-Host");
    String forwardedProto = request.getHeader("X-Forwarded-Proto");
    String forwardedPort = request.getHeader("X-Forwarded-Port");

    String scheme = forwardedProto != null ? forwardedProto : request.getScheme();
    String host = forwardedHost != null ? forwardedHost : request.getServerName();
    String port = forwardedPort != null ? forwardedPort : String.valueOf(request.getServerPort());

    boolean isDefaultPort = ("http".equals(scheme) && "80".equals(port))
      || ("https".equals(scheme) && "443".equals(port));

    return isDefaultPort ? String.format("%s://%s", scheme, host) : String.format("%s://%s:%s", scheme, host, port);
}

This way of getting the host and port reflects the real client-facing URL. It works well with load balancers and CDNs. But it depends on the proxy configuration. We can also include request.getContextPath() if we need to get the complete root URL of the Servlet.

For Spring Boot apps, enabling the ForwardedHeaderFilter makes this automatic.

6. Conclusion

In this article, we explored several ways to extract the scheme, hostname, and port from an HTTP or HTTPS request in Java. Each approach serves a specific use case; the HttpServletRequest API offers a simple, portable solution. getRequestURL() works well when we already need the full URL, ServletUriComponentsBuilder is ideal for Spring MVC or Spring Boot applications, and proxy headers like X-Forwarded-* are essential when our app runs behind a load balancer or reverse proxy.

In most scenarios, either the servlet-based or Spring-based methods are sufficient, while proxy support becomes crucial in production setups.

As always, the code presented in this article is available over on GitHub.