How to get request URI without context path?

java

servlet

front-controller

urlpathhelper

byAnton Shumikhin·Jan 28, 2025

Cut to the chase with the HttpServletRequest class, wield getRequestURI() and snip off the context path using getContextPath().length():

String uri = request.getRequestURI().substring(request.getContextPath().length());
// Like a barber giving a precision haircut

This snippet yields the URI sans the context path, delivering exactly what you are after.

Plunging into alternate methods

The `getPathInfo()` route

If you're navigating a servlet, getPathInfo() gives you the part of the URI following the context path and servlet path. It's a handy tool in your kit when dealing with a Front Controller pattern:

String uri = request.getPathInfo();
// Felt cute. Might delete context path later.

Mind the fact that this can return null if the request hits the exact servlet mapping:

String uri = request.getPathInfo();
if (uri == null) {
   uri = request.getServletPath();
   // Backup dancer to the rescue!
}

Crafting the URI in a filter

In a filter? Brace for nulls and wayward mappings. Try casting to HttpServletRequest and using the reliable getServletPath():

String uri = ((HttpServletRequest) request).getServletPath();
// Cast away, Tom Hanks. Cast away.

Resort to additional parsing if getServletPath() falls short of expectations.

Navigating frameworks and server idiosyncrasies

Enlisting Spring's helper

When in Spring, the UrlPathHelper can make your path extraction journey a breeze:

UrlPathHelper urlPathHelper = new UrlPathHelper();
String uri = urlPathHelper.getPathWithinApplication((HttpServletRequest) request);
// Springing into action!

Jostling with server eccentricities

Servers can play tricks at times. If getPathInfo() behaves oddly, might be due to some server-specific bugs. Consider hitting the server documentation or forums before throwing in the towel.

Mastering complex mapping strategies

Decoding servlet mappings

Servlet mappings are often a Gordian knot. The getPathInfo() output can vary based on your web application's mapping configuration. So, dot your 'i's and cross your 't's in understanding how URI sections are processed.

The Front Controller gambit

With a Front Controller servlet, getPathInfo() can bypass context path subtraction for a more accurate URI portion, like taking the expressway instead of local roads.

Surveying alternate solutions and potential snags

When standard options fall short

Server issues or intricate routing? A custom parsing solution can solve this Rubik's cube:

String uri = customParsePath(request.getRequestURI(), request.getContextPath());
// A Jedi uses the Parse, Luke!

Keeping track of Filter-Servlet relay

Filters and servlets may pass the URI processing baton differently. Keep an eye on their order to avoid any stumbles.

Safeguarding against null returns

When getPathInfo() or getServletPath() come back null, it's like a "ghost in the shell" error — silent but troublesome. Always use non-null fallbacks or condition checks:

String pathInfo = request.getPathInfo();
String servletPath = request.getServletPath();
String uri = (pathInfo != null ? pathInfo : servletPath);
// Null-check, or it didn't happen.