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.
![Intercepting filter patter class diagram](http://upload.wikimedia.org/wikipedia/en/c/c8/Intercepting_filter_pattern_class_diagram.gif)
![Intercepting filter patter sequence diagram](http://upload.wikimedia.org/wikipedia/en/a/ac/Intercepting_filter_pattern_sequence_diagram.png)
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);
}
}
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
}
}
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);
}
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);
}
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);
}
}
}
See also[]
- Front controller
- Decorator pattern
- Template method pattern
- Interceptor pattern
- Pipeline (software)
References[]
- Software design patterns