The Java Servlet specification version 2.3 introduces a new component type, called a filter. A filter dynamically intercepts requests and responses to transform or use the information contained in the requests or responses. Filters typically do not themselves create responses, but instead provide universal functions that can be “attached” to any type of servlet or JSP page.

Filters are important for a number of reasons. First, they provide the ability to encapsulate recurring tasks in reusable units. Organized developers are constantly on the lookout for ways to modularize their code. Modular code is more manageable and documentable, is easier to debug, and if done well, can be reused in another setting.

Second, filters can be used to transform the response from a servlet or a JSP page. A common task for the web application is to format data sent back to the client. Increasingly the clients require formats (for example, WML) other than just HTML. To accommodate these clients, there is usually a strong component of transformation or filtering in a fully featured web application. Many servlet and JSP containers have introduced proprietary filter mechanisms, resulting in a gain for the developer that deploys on that container, but reducing the reusability of such code. With the introduction of filters as part of the Java Servlet specification, developers now have the opportunity to write reusable transformation components that are portable across containers.

Filters can perform many different types of functions. We’ll discuss examples of the italicized items in this paper:

  • Authentication-Blocking requests based on user identity.
  • Logging and auditing-Tracking users of a web application.
  • Image conversion-Scaling maps, and so on.
  • Data compression-Making downloads smaller.
  • Localization-Targeting the request and response to a particular locale.
  • XSL/T transformations of XML content-Targeting web application responses to more that one type of client.

These are just a few of the applications of filters. There are many more, such as encryption, tokenizing, triggering resource access events, mime-type chaining, and caching.

In this paper we’ll first discuss how to program filters to perform the following types of tasks:

  • Querying the request and acting accordingly
  • Blocking the request and response pair from passing any further.
  • Modifying the request headers and data. You do this by providing a customized version of the request.
  • Modifying the response headers and data. You do this by providing a customized version of the response.
  • We’ll outline the filter API, and describe how to develop customized requests and responses.

Programming the filter is only half the job of using filters-you also need to configure how they are mapped to servlets when the application is deployed in a web container. This decoupling of programming and configuration is a prime benefit of the filter mechanism:

  • You don’t have to recompile anything to change the input or output of your web application. You just edit a text file or use a tool to change the configuration. For example, adding compression to a PDF download is just a matter of mapping a compression filter to the download servlet.
  • You can experiment with filters easily because they are so easy to configure.

The last section of this paper shows how to use the very flexible filter configuration mechanism. Once you have read this paper, you will be armed with the knowledge to implement your own filters and have a handy bag of tricks based on some common filter types.

Programming Filters

The filter API is defined by the Filter, FilterChain, and FilterConfig interfaces in the javax.servlet package. You define a filter by implementing the Filter interface. A filter chain, passed to a filter by the container, provides a mechanism for invoking a series of filters. A filter config contains initialization data.

The most important method in the Filter interface is the doFilter method, which is the heart of the filter. This method usually performs some of the following actions:

  • Examines the request headers
  • Customizes the request object if it wishes to modify request headers or data or block the request entirely
  • Customizes the response object if it wishes to modify response headers or data
  • Invokes the next entity in the filter chain. If the current filter is the last filter in the chain that ends with the target servlet, the next entity is the resource at the end of the chain; otherwise, it is the next filter that was configured in the WAR. It invokes the next entity by calling the doFilter method on the chain object (passing in the request and response it was called with, or the wrapped versions it may have created). Alternatively, it can choose to block the request by not making the call to invoke the next entity. In the latter case, the filter is responsible for filling out the response.
  • Examines response headers after it has invoked the next filter in the chain
  • Throws an exception to indicate an error in processing

In addition to doFilter, you must implement the init and destroy methods. The in it method is called by the container when the filter is instantiated. If you wish to pass initialization parameters to the filter you retrieve them from the FilterConfig object passed to init.

Example: Logging Servlet Access

Now that you know what the main elements of the filter API are, let’s take a look at a very simple filter that does not block requests, transform responses, or anything fancy-a good place to start learning the basic concepts of the API.

Consider web sites that track the number of users. To add this capability to an existing web application without changing any servlets you could use a logging filter.

HitCounterFilter increments and logs the value of a counter when a servlet is accessed. In the doFilter method, HitCounterFilter first retrieves the servlet context from the filter configuration object so that it can access the counter, which is stored as a context attribute. After the filter retrieves, increments, and writes the counter to a log, it invokes doFilter on the filter chain object passed into the original doFilter method.

               
public final class HitCounterFilter implements Filter {
   private FilterConfig filterConfig = null;
   public void init(FilterConfig filterConfig) 
      throws ServletException {
      this.filterConfig = filterConfig;
   }
   public void destroy() {
      this.filterConfig = null;
   }
   public void doFilter(ServletRequest request,
      ServletResponse response, FilterChain chain) 
      throws IOException, ServletException {
      if (filterConfig == null)
         return;
      StringWriter sw = new StringWriter();
      PrintWriter writer = new PrintWriter(sw);
      Counter counter = (Counter)filterConfig.
         getServletContext().
         getAttribute("hitCounter");
      writer.println();
      writer.println("===============");
      writer.println("The number of hits is: " +
         counter.incCounter());
      writer.println("===============");

      // Log the resulting string
      writer.flush();
      filterConfig.getServletContext().
         log(sw.getBuffer().toString());
      ...
      chain.doFilter(request, wrapper);
      ...
   }
}

Specifying Filter Configuration

Now that we have seen how to program a filter, the last step is to specify how to apply it to a web component or a set of web components. To map a filter to a servlet you:

Declare the filter using the element in the web application deployment descriptor. This element creates a name for the filter and declares the filter’s implementation class and initialization parameters.
Map the filter to a servlet by defining a element in the deployment descriptor. This element maps a filter name to a servlet by name or by URL pattern.
The following elements show how to specify the elements needed for the compression filter. To define the compression filter you provide a name for the filter, the class that implements the filter, and name and value of the threshold initialization parameter.

<filter>
   <filter-name>HitCounterFilter</filter-name>
   <filter-class>org.madbit.filter.HitCounterFilter</filter-class>
</filter>

Note: It’s possible pass some parameters to the filter including the following lines in the filter declaration:

<filter>
   ...
   <init-param>
      <param-name>param1</param-name>
      <param-value>some value</param-value>
   </init-param>
</filter>

The filter-mapping element maps the compression filter to the servlet CompressionTest. The mapping could also have specified the URL pattern /CompressionTest. Note that the filter, filter-mapping, servlet, and servlet-mapping elements must appear in the web application deployment descriptor in that order.

<filter-mapping>
   <filter-name>HitCounterFilter</filter-name>
   <servlet-name>HitCounterServlet</servlet-name>
</filter-mapping>
<servlet>
   <servlet-name>HitCounterServlet</servlet-name>
   <servlet-class>hitCounterServlet</servlet-class>
</servlet>
<servlet-mapping>
   <servlet-name>hitCounterServlet</servlet-name>
   <url-pattern>/hitCounter</url-pattern>
</servlet-mapping>

Note that this mapping causes the filter to be called for all requests to the HitCounterServlet servlet and to any servlet JSP or static content mapped to the URL pattern /hitCounter.

If you want to log every request to a web application, you would map the hit counter filter to the URL pattern /*. Here’s the deployment descriptor distributed with the examples:

<?xml version="1.0" encoding="ISO-8859-1"?>

<!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web  Application 2.3//EN" "http://java.sun.com/dtd/web-app_2_3.dtd">
<web-app>
   <filter>
      <filter-name>XSLTFilter</filter-name>
      <filter-class>XSLTFilter</filter-class>
   </filter>
   <filter>
      <filter-name>HitCounterFilter</filter-name>
      <filter-class>HitCounterFilter</filter-class>
   </filter>
   <filter-mapping>
      <filter-name>HitCounterFilter</filter-name>
      <url-pattern>/*</url-pattern>
   </filter-mapping>  
   <filter-mapping>
      <filter-name>XSLTFilter</filter-name>
      <servlet-name>FilteredFileServlet</servlet-name>
   </filter-mapping>  
   <servlet>
      <servlet-name>FilteredFileServlet</servlet-name>
      <servlet-class>FileServlet</servlet-class>
   </servlet>
   <servlet-mapping>
      <servlet-name>FilteredFileServlet</servlet-name>
      <url-pattern>/ffs</url-pattern>
   </servlet-mapping>
</web-app>

Conclusion

The filter mechanism provides a way to encapsulate common functionality in a component that can reused in many different contexts. Filters are easy to write and configure as well as being portable and reusable. In summary, filters are an essential element in a web developer’s toolkit.

References