Comprehensive Analysis of Retrieving Full URL and Query String in Servlet for HTTP and HTTPS Requests

Problem Background and Core Challenges

In Servlet development, retrieving the complete URL of a request is a common requirement. Developers typically use HttpServletRequest.getRequestURI() and getQueryString() methods to construct URLs, but this approach encounters issues when handling HTTPS requests.

When accessing https://google.com, simple string concatenation may produce incorrect results, such as http://google.com:443google.com:443. The root cause of this problem lies in insufficient understanding of URL composition structure and misuse of Servlet API methods.

In-Depth Analysis of HttpServletRequest API

To correctly construct complete URLs, it's essential to understand the various component methods provided by HttpServletRequest:

// Example URL: https://myhost:8080/people?lastname=Fox&age=30

String scheme = request.getScheme();        // returns "https"
String serverName = request.getServerName();  // returns "myhost"
int serverPort = request.getServerPort();     // returns 8080
String requestURI = request.getRequestURI();  // returns "/people"
String queryString = request.getQueryString(); // returns "lastname=Fox&age=30"

The getScheme() method returns "http" or "https" based on the actual request protocol, which is key to solving the original problem. Compared to directly using getRequestURL(), manual URL construction provides better flexibility and control.

Complete URL Construction Solution

Based on deep understanding of the API, we provide the following complete URL construction solution:

StringBuilder urlBuilder = new StringBuilder();
urlBuilder.append(request.getScheme())
          .append("://")
          .append(request.getServerName());

// Optimize port display: default ports are not shown
int port = request.getServerPort();
String scheme = request.getScheme();
if (!(("http".equals(scheme) && port == 80) || 
      ("https".equals(scheme) && port == 443))) {
    urlBuilder.append(":").append(port);
}

urlBuilder.append(request.getRequestURI());

// Handle query string
if (request.getQueryString() != null) {
    urlBuilder.append("?").append(request.getQueryString());
}

String fullUrl = urlBuilder.toString();

This implementation offers the following advantages: correct handling of HTTP and HTTPS protocols, intelligent handling of default ports, and secure processing of query strings. Using StringBuilder avoids unnecessary string object creation, improving performance.

Special Considerations in Proxy Environments

In modern web architectures, requests often pass through proxy servers or load balancers. In such cases, original request information may be modified, requiring special handling:

// Check proxy header information
String forwardedProto = request.getHeader("X-Forwarded-Proto");
String forwardedFor = request.getHeader("X-Forwarded-For");

// If proxy headers exist, prioritize using proxy header information
if (forwardedProto != null && !forwardedProto.isEmpty()) {
    // Use protocol information provided by proxy
    scheme = forwardedProto;
}

The X-Forwarded-Proto header indicates the original request protocol, while X-Forwarded-For header shows the original client IP address. When configuring proxy servers, it's essential to ensure these headers are correctly set and transmitted.

Best Practices and Performance Optimization

In practical applications, it's recommended to encapsulate URL construction logic as reusable utility methods:

public class URLUtils {
    public static String getFullURL(HttpServletRequest request) {
        StringBuilder url = new StringBuilder();
        
        // Handle protocol and proxy
        String scheme = getRequestScheme(request);
        url.append(scheme).append("://");
        
        // Server name and port
        url.append(request.getServerName());
        
        int port = request.getServerPort();
        if (!isDefaultPort(scheme, port)) {
            url.append(":").append(port);
        }
        
        // URI and query parameters
        url.append(request.getRequestURI());
        
        String queryString = request.getQueryString();
        if (queryString != null && !queryString.isEmpty()) {
            url.append("?").append(queryString);
        }
        
        return url.toString();
    }
    
    private static String getRequestScheme(HttpServletRequest request) {
        String forwardedProto = request.getHeader("X-Forwarded-Proto");
        return (forwardedProto != null && !forwardedProto.isEmpty()) 
               ? forwardedProto : request.getScheme();
    }
    
    private static boolean isDefaultPort(String scheme, int port) {
        return ("http".equals(scheme) && port == 80) || 
               ("https".equals(scheme) && port == 443);
    }
}

This encapsulation provides better code maintainability while handling various edge cases, including proxy environments and security considerations.

Conclusion

Correctly retrieving complete URLs from Servlet requests requires deep understanding of the various component methods of the HttpServletRequest API. By separately obtaining protocol, server name, port, URI path, and query string, then appropriately combining them, accurate complete URLs can be constructed. In proxy environments, additional HTTP header information must also be considered. The complete solutions and best practices provided in this article can help developers avoid common pitfalls and build robust, reliable URL processing logic.