Recipe 18.3 Using a Filter to Alter Request Headers

Problem

You want to use a filter to change the request headers before a servlet or JSP receives the request.

Solution

Wrap the request in your own custom request class. Pass the request wrapper or decorator class to the FilterChain.doFilter( ) method, instead of the original request destination.

Discussion

The javax.servlet.http.HttpServletRequestWrapper is a convenience class that you can extend to provide additional functionality for an HTTP request. Here is how to alter and forward a request using a filter:

Create a class that extends HttpServletRequestWrapper .
Place this class in the web application's WEB-INF/classes (including package- related directories) directory or WEB-INF/lib if the class is part of a JAR file.
Create a class that implements javax.servlet.Filter , such as Example 18-3. This class uses your custom request wrapper class to enclose the ServletRequest parameter of the Filter.doFilter( ) method.
Store the filter class in WEB-INF/classes or WEB-INF/lib (if it's in a JAR).
Register the filter in web.xml . In this recipe, the filter is mapped to all of the requests in the web application with the URL mapping /* .

Example 18-3 shows the filter class that passes the request-wrapper class along the filter chain. The file is named RequestFilter ; the wrapper class is named ReqWrapper .

Example 18-3. A filter that wraps the HttpServletRequest

 package com.jspservletcookbook; import javax.servlet.*; import javax.servlet.http.*; public class RequestFilter implements Filter {          private FilterConfig config;          /** Creates new RequestFilter */   public RequestFilter( ) {}        public void  init(FilterConfig filterConfig)  throws ServletException{            this.config = filterConfig;   }      public void  doFilter(ServletRequest request,    ServletResponse response, FilterChain chain) throws java.io.IOException,     ServletException {       ReqWrapper wrapper = null;     ServletContext context = null;  //create the request wrapper object, an instance of the     //ReqWrapper class. The client request is passed into     //ReqWrapper's constructor     if (request instanceof HttpServletRequest)         wrapper = new ReqWrapper((HttpServletRequest)request);  //use the ServletContext.log method to log param names/values     if (wrapper != null){         context = config.getServletContext( );     context.log("Query: " + wrapper.getQueryString( ));}  //continue the request, response to next filter or servlet     //destination     if (wrapper != null)         chain.doFilter(wrapper,response);     else         chain.doFilter(request,response);  }//doFilter        public void destroy( ){   /*called before the Filter instance is removed          from service by the web container*/    }//destroy }

Example 18-3 uses the servlet context to log the ReqWrapper 's query string. The ReqWrapper class adds a parameter to the query string, but you could make this class implement whatever behavior you need in your own application. Example 18-4 shows the filter-mapping entries in the deployment descriptor ( web.xml ), which ensures that every application request passes through this filter.

Example 18-4. The filter mapping in web.xml

 <filter>     <filter-name>RequestFilter</filter-name>     <filter-class>com.jspservletcookbook.RequestFilter</filter-class> </filter> <filter-mapping>     <filter-name>RequestFilter</filter-name>     <url-pattern>/*</url-pattern> </filter-mapping>

The ReqWrapper is a simple example of an HttpServletRequestWrapper subclass that encapsulates the original request. This class overrides the getQueryString( ) method in order to add a parameter to the request's query string.

To access the new filter parameter, you must call getQueryString( ) on the request once it reaches its destination servlet, then parse the getQueryString( ) return value for individual parameters. Using the EL will not work with request wrappers that override getQueryString( ) :

 //does not return the new parameter value //added by the overridden getQueryString //method ${param.filter}

The request that passes through the filter is the parameter to ReqWrapper 's constructor, so the filter (in Example 18-3) wraps the request with this code:

 wrapper = new ReqWrapper((HttpServletRequest)request);

A URL sent to the application containing the query string name=Bruce displays the following text in the server log (as a result of the ServletContext.log method):

 Query: name=Bruce&filter=com.jspservletcookbook.ReqWrapper.

Example 18-5 is the code for the ReqWrapper object.

Example 18-5. The ReqWrapper class for encapsulating the HttpServletRequest

 package com.jspservletcookbook;            import javax.servlet.*;  import javax.servlet.http.HttpServletRequestWrapper;  import javax.servlet.http.HttpServletRequest;  public class ReqWrapper extends HttpServletRequestWrapper{  private static final String AMP = "&";     public ReqWrapper(HttpServletRequest request){             super(request);  }     public String getQueryString( ){         String query = null;  //get the query string from the wrapped request object       query = ((HttpServletRequest)getRequest( )).getQueryString( );       //add a 'filter' parameter to this query string with the class       //name as the value       if (query != null)           return query +AMP+"filter="+getClass( ).getName( );       else           return "filter="+getClass( ).getName( );  }//getQueryString }

The method call chain.doFilter(wrapper,response) at the end of Example 18-3 passes the request (wrapped in our own custom class) and response to the next filter, or to the destination servlet or JSP if no other filters are registered.