Intercepting filter pattern

From Wikipedia, the free encyclopedia

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

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

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]

A Filter Chain is a specific series of filters, composed so as to form a logical chain.[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 a concern, 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 

        // 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.