Intercepting filter pattern

From Wikipedia, the free encyclopedia
Jump to navigation Jump to search

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 unobstrusively 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[edit]

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

Intercepting filter patter class diagram
Intercepting filter patter sequence diagram

Filter manager[edit]

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

Filter chain[edit]

This is an ordered collection of independent filters.[1]

Filters[edit]

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

Target[edit]

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

Consequences[edit]

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 concerned as unnecessarily long chains of interceptors and filters may hurt performance.[2]

Sample code[edit]

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 
  private List<Filter> myFilters = new ArrayList<>();

  // Creates new FilterChain 
  public FilterChain()  {
    // plug-in default filter services for example 
    // only. This would typically be done in the 
    // FilterManager, but is done here for example 
    // purposes
    myFilters.add(new DebugFilter());
    myFilters.add(new LoginFilter());
    myFilters.add(new AuditFilter());
  }

  public void processFilter( 
    javax.servlet.http.HttpServletRequest request,
    javax.servlet.http.HttpServletResponse response)
  throws javax.servlet.ServletException, 
    java.io.IOException         {
    Filter filter;

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

[1]

See also[edit]

References[edit]

  1. ^ a b c d e f g h i j k "Core J2EE Patterns - Intercepting Filter". Oracle. Oracle. Retrieved 6 February 2016. 
  2. ^ a b c Kayal, D. (2008). Pro Java EE Spring Patterns. New York: Apress. pp. 98–106.