Implementing URL Rewriting with Servlet Filters

URL rewriting is a common technique in web development for modifying incoming URLs to simplify structure, enhance security, or support specific functionalities. In Java EE, Servlet Filters provide a powerful mechanism to intercept and modify requests before they reach servlets. This article will explain step-by-step how to implement a URL rewriting Filter, with code examples and configuration details.

Implementing the Filter Interface

To implement URL rewriting, start by creating a class that implements the javax.servlet.Filter interface. In the doFilter method, cast the ServletRequest to HttpServletRequest to access HTTP-specific methods. Use getRequestURI() to retrieve the request path, then employ string operations like substring and replace to extract and construct a new path. Key steps include: checking if the URL needs rewriting, modifying the path using string methods, and using RequestDispatcher.forward() for server-side redirection or HttpServletResponse.sendRedirect() for client-side redirection. Always include conditional checks to avoid applying rewrite logic to unmatched URLs, preventing infinite loops.

Code Example

Here is a rewritten implementation of a URL rewriting Filter, optimized and explained for common use cases:

public class UrlRewriteFilter implements Filter {
    @Override
    public void init(FilterConfig config) throws ServletException {
        // Initialization code, optional
    }

    @Override
    public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException {
        HttpServletRequest request = (HttpServletRequest) req;
        String requestURI = request.getRequestURI();

        // Check if the URL starts with a specific pattern
        if (requestURI.startsWith("/Check_License/Dir_My_App/")) {
            // Extract the part to replace: from "/Dir_My_App" to the last "/"
            int startIndex = requestURI.indexOf("/Dir_My_App");
            int endIndex = requestURI.lastIndexOf("/") + 1;
            if (startIndex != -1 && endIndex != -1 && startIndex < endIndex) {
                String toReplace = requestURI.substring(startIndex, endIndex);
                String newURI = requestURI.replace(toReplace, "?Contact_Id=");
                // Use RequestDispatcher to forward to the new URL
                req.getRequestDispatcher(newURI).forward(req, res);
            } else {
                // If extraction fails, proceed normally
                chain.doFilter(req, res);
            }
        } else {
            // If URL does not match the pattern, proceed normally
            chain.doFilter(req, res);
        }
    }

    @Override
    public void destroy() {
        // Cleanup code, optional
    }
}

Explanation: This code first checks if the request URI starts with /Check_License/Dir_My_App/. If so, it extracts the portion from /Dir_My_App to the last slash and replaces it with ?Contact_Id=, converting a path-based URL to a query parameter format. Using RequestDispatcher.forward() for server-side redirection does not change the browser address bar, making it suitable for internal rewrites. If the URL does not match or extraction fails, it calls FilterChain.doFilter() to continue normal processing.

Configuration in web.xml

Register the Filter in the web.xml file to intercept all requests or specific patterns:

<filter>
    <filter-name>urlRewriteFilter</filter-name>
    <filter-class>com.example.UrlRewriteFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>urlRewriteFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

If using Servlet 3.0 or later, the @WebFilter annotation can replace XML configuration, e.g., @WebFilter("/*").

Best Practices and Considerations

When implementing URL rewriting, always include conditional checks to avoid infinite loops, such as applying rewrites only to specific patterns. Use FilterChain.doFilter() for unmodified requests. Server-side redirection is ideal for internal URL modifications, while client-side redirection changes the browser address bar and is suitable for user-facing scenarios. From the reference article, techniques like using sessions or cookies to preserve request state can be adapted, such as storing original URL parameters in SAML authentication to restore state after redirection.

Additional Insights from Reference

The reference article discusses using Filters in AEM to save request parameters, e.g., by storing the full URL in session attributes and redirecting after authentication. This can be generalized to any scenario requiring state preservation. In a URL rewriting Filter, similarly use HttpSession to temporarily store original request information, ensuring no loss of critical data after rewriting. This approach enhances Filter flexibility for complex web applications.