Intercepting filter pattern

Intercepting Filter is a JavaEE pattern which creates pluggable filters to process common services in a standard manner without requiring changes to core request processing code. The filters intercept incoming requests and outgoing responses, allowing preprocessing and post-processing, and these filters can be added or removed unobtrusively without changing existing code.^[1] This pattern applies reusable processing transparently before and after the actual request execution by the front and page controllers.^[2]

Structure[]

Filter manager, filter chain, filters and target are components of the pattern.

Filter manager[]

This manages filter processing and creates the filter chain with the appropriate filters, in the correct order, and initiates processing.^[1]

Filter chain[]

A Filter Chain is a specific series of filters, composed so as to form a logical chain.^[1]

Filters[]

These are the individual filters that are mapped to a target and their processing is coordinated by filter chain.^[1]

Target[]

This is the resource requested by the client.^[1]

Consequences[]

Following benefits can be considered:

• Improved reusability: Common code is centralized in pluggable components enhancing reuse.
• Increased flexibility: Generic common components can be applied and removed declaratively, improving flexibility.^[1][2]

Reduced performance can be a concern, as unnecessarily long chains of interceptors and filters may hurt performance.^[2]

Sample code[]

Sample code implementation for filters with custom filter strategy is given below.

Code for implementing a filter - debugging filter:

public class DebuggingFilter implements Processor {
  private Processor target;

  public DebuggingFilter(Processor myTarget) {
    target = myTarget;
  }

  public void execute(ServletRequest req, 
  ServletResponse res) throws IOException, 
    ServletException    {
    //Do some filter processing here, such as 
    // displaying request parameters
    target.execute(req, res);
  }
}

^[1]

Code for implementing a filter - core processor:

public class CoreProcessor implements Processor {
  private Processor target;
  public CoreProcessor()   {
    this(null);
  }

  public CoreProcessor(Processor myTarget)   {
    target = myTarget;
  }

  public void execute(ServletRequest req, 
      ServletResponse res) throws IOException, 
      ServletException   {
    //Do core processing here
  }
}

^[1]

Code for handling requests:

public void processRequest(ServletRequest req, 
  ServletResponse res) 
  throws IOException, ServletException {
  Processor processors = new DebuggingFilter( 
    new AuthenticationFilter(new CoreProcessor()));
  processors.execute(req, res);

  //Then dispatch to next resource, which is probably 
  // the View to display
  dispatcher.dispatch(req, res);
}

^[1]

Code for filter manager:

public void processRequest(ServletRequest req, 
  ServletResponse res) 
  throws IOException, ServletException {
  Processor processors = new DebuggingFilter( 
    new AuthenticationFilter(new CoreProcessor()));
  processors.execute(req, res);

  //Then dispatch to next resource, which is probably 
  // the View to display
  dispatcher.dispatch(req, res);
}

^[1]

Code for filter chain:

public class FilterChain {
  // filter chain 

    // apply filters
    for (final Filter filter : filters)
    {
      // pass request & response through various 
      // filters
      filter.execute(request, response);
    }
  }
}

^[1]

See also[]

• Front controller
• Decorator pattern
• Template method pattern
• Interceptor pattern
• Pipeline (software)

References[]