Complete Enum Implementation for HTTP Response Codes in Java

Current State of HTTP Response Code Implementations in Java

In Java development, handling HTTP response codes is a common requirement. Developers typically prefer using enum types to represent these codes for better type safety and code readability. However, the Java standard library has certain limitations in this area.

Limitations of Standard Java Libraries

javax.ws.rs.core.Response.Status is an enum type defined in the JAX-RS specification that provides symbolic constants for some HTTP status codes. This enum implements the Response.StatusType interface and supports bidirectional conversion between status codes and integer values.

Let's examine its basic usage through a code example:

// Get all defined Status enum values
for (Response.Status status : Response.Status.values()) {
    System.out.println(status.getStatusCode() + ": " + status.getReasonPhrase());
}

// Get the corresponding Status enum from status code
Response.Status status = Response.Status.fromStatusCode(200);
if (status != null) {
    System.out.println("Status family: " + status.getFamily());
    System.out.println("Reason phrase: " + status.getReasonPhrase());
}

However, as mentioned in the question, Response.Status only defines approximately half of the valid HTTP response codes. For instance, it lacks important status codes like HTTP 100 Continue and HTTP 102 Processing. This incompleteness can cause issues in practical development scenarios.

Shortcomings of Alternative Standard Library Solutions

The java.net.HttpURLConnection class provides static constants for some HTTP status codes, but these are similarly incomplete. For example, it misses important codes like HTTP 100 Continue. Moreover, these constants are simple integer definitions that lack the type safety features of enums.

The javax.servlet.http.HttpServletResponse interface defines int constants for all HTTP response codes, named in the format SC_<description>. While this interface contains a complete set of status codes, they remain primitive data types and cannot provide the advanced features of enums.

Complete Solution with Apache HttpComponents

The Apache HttpComponents project offers the most comprehensive implementation of HTTP status code enums. The org.apache.http.HttpStatus enum includes all standard HTTP status codes, providing complete coverage from 1xx to 5xx series.

Here's a typical usage example of this enum:

import org.apache.http.HttpStatus;

public class HttpStatusExample {
    public void processResponse(int statusCode) {
        // Check if it's a successful status code
        if (statusCode >= HttpStatus.SC_OK && statusCode < HttpStatus.SC_MULTIPLE_CHOICES) {
            System.out.println("Request successful");
        }
        
        // Handle specific status codes
        switch (statusCode) {
            case HttpStatus.SC_CONTINUE:
                System.out.println("Client should continue sending request body");
                break;
            case HttpStatus.SC_OK:
                System.out.println("Request successful");
                break;
            case HttpStatus.SC_NOT_FOUND:
                System.out.println("Resource not found");
                break;
            case HttpStatus.SC_INTERNAL_SERVER_ERROR:
                System.out.println("Internal server error");
                break;
        }
    }
    
    public String getReasonPhrase(int statusCode) {
        // In practical applications, return corresponding reason phrases
        return "Status code: " + statusCode;
    }
}

Status Code Category Processing

HTTP status codes are categorized into five classes based on their first digit, a classification reflected in the Response.Status.Family enum:

public void handleStatusByFamily(Response.Status status) {
    Response.Status.Family family = status.getFamily();
    
    switch (family) {
        case INFORMATIONAL:
            System.out.println("Informational response");
            break;
        case SUCCESSFUL:
            System.out.println("Successful response");
            break;
        case REDIRECTION:
            System.out.println("Redirection response");
            break;
        case CLIENT_ERROR:
            System.out.println("Client error");
            break;
        case SERVER_ERROR:
            System.out.println("Server error");
            break;
        case OTHER:
            System.out.println("Other status");
            break;
    }
}

Practical Implementation Recommendations

When choosing an HTTP status code implementation solution, consider the following factors:

1. Project Dependencies: If the project already uses JAX-RS, Response.Status might be appropriate, but be aware of its incompleteness
2. Completeness Requirements: For complete HTTP status code support, Apache HttpComponents is the best choice
3. Performance Considerations: For simple status code checks, using integer constants might be more efficient
4. Type Safety: Enums provide compile-time type checking, reducing runtime errors

Custom Enum Implementation

If existing solutions don't meet requirements, developers can consider implementing custom HTTP status code enums:

public enum CustomHttpStatus {
    CONTINUE(100, "Continue"),
    SWITCHING_PROTOCOLS(101, "Switching Protocols"),
    PROCESSING(102, "Processing"),
    OK(200, "OK"),
    CREATED(201, "Created"),
    // ... other status code definitions
    
    private final int code;
    private final String reason;
    
    CustomHttpStatus(int code, String reason) {
        this.code = code;
        this.reason = reason;
    }
    
    public int getCode() { return code; }
    public String getReason() { return reason; }
    
    public static CustomHttpStatus fromCode(int code) {
        for (CustomHttpStatus status : values()) {
            if (status.code == code) {
                return status;
            }
        }
        return null;
    }
}

Conclusion

The Java ecosystem offers multiple implementations for HTTP status codes, each with its own advantages and disadvantages. javax.ws.rs.core.Response.Status provides good type safety but incomplete coverage, while Apache HttpComponents' org.apache.http.HttpStatus offers the most comprehensive implementation. Developers should make informed decisions based on specific project requirements and existing technology stacks.