<p>Intercepting filter Design Pattern is one of the Java EE patterns. It is capable of creating pluggable filters which are responsible for processing common services. These services are processed in such a manner that there no changes required by the core request processing code. These filters are set to seize the requests coming in and responses going out, which allow the system pre and post processing. These filters can be removed or added in an unnoticeable manner which does not need the existing code to be altered. The intercepting filter pattern implicates the processing transparently which is also reusable after and before the standard request executes by page and front controllers.</p>
<div style="background-color: #f2f9fc; border-radius: 3px; border: 1px solid #c9e6f2; line-height: 1.45; padding: 16px 16px 16px 16px;">
<h2 dir="ltr">Spring 5 Design Pattern Book</h2>
<div dir="ltr" style="color: #20124d; font-family: 'calibri' , sans-serif; font-size: 13pt; text-align: justify;">You could purchase my <strong>Spring 5 book</strong> that is with title name &#8220;<strong>Spring 5 Design Patterns</strong>&#8220;. This book is available on the <a href="https://www.amazon.in/Spring-Design-Patterns-Dinesh-Rajput/dp/1788299450/ref=sr_1_1?ie=UTF8&;qid=1507925340&;sr=8-1&;keywords=spring+5+design+pattern" target="_blank" rel="noopener"><strong>Amazon</strong></a> and <a href="https://www.packtpub.com/application-development/spring-5-design-patterns" target="_blank" rel="noopener"><strong>Packt</strong></a> publisher website. Learn various <strong>design patterns</strong> and <strong>best practices</strong> in Spring 5 and use them to solve common design problems. You could use author discount to purchase this book by using code- &#8220;<strong>AUTHDIS40</strong>&#8220;.</div>
<div dir="ltr"></div>
<div dir="ltr"><a href="https://www.amazon.in/Spring-Design-Patterns-Dinesh-Rajput/dp/1788299450/ref=sr_1_1?s=books&;ie=UTF8&;qid=1512607966&;sr=1-1&;keywords=dinesh+rajput" target="_blank" rel="noopener"><img class="aligncenter wp-image-3053 size-medium" title="Spring-5-Design-Pattern" src="https://dineshonjava.com/wp-content/uploads/2013/03/Spring-5-design-pattern-243x300.jpg" width="243" height="300" /></a></div>
</div>
<h2><strong>Intercepting filter Design Pattern</strong></h2>
<p>The intercepting filters are applied and defined on a particular request before it passes the request to the actual aimed application. These filters are capable of authorizing, authenticating, tracking or logging the request. It then passes these request to their corresponding handlers. The structure of intercept design pattern is such that it has a filter, filter chain, filter manager, target, and client. Each of these handles their own part of the system.</p>
<div style="text-align: left;">
<blockquote>
<p><strong>also read:</strong></p>
<ul style="text-align: left;">
<li><a title="https://dineshonjava.com/context-object-design-pattern/" href="https://dineshonjava.com/context-object-design-pattern/">Context Object Pattern</a></li>
<li><a title="https://dineshonjava.com/front-controller-design-pattern/" href="https://dineshonjava.com/front-controller-design-pattern/">Front Controller Pattern</a></li>
<li><a title="https://dineshonjava.com/application-controller-design-pattern/" href="https://dineshonjava.com/application-controller-design-pattern/">Application Controller Pattern</a></li>
<li><a title="https://dineshonjava.com/view-helper-design-pattern/" href="https://dineshonjava.com/view-helper-design-pattern/">View Helper Pattern</a></li>
<li><a title="https://dineshonjava.com/composite-view-design-pattern/" href="https://dineshonjava.com/composite-view-design-pattern/">Composite View Pattern</a></li>
<li><a title="https://dineshonjava.com/dispatcher-view-design-pattern/" href="https://dineshonjava.com/dispatcher-view-design-pattern/">Dispatcher View Pattern</a></li>
<li><a title="https://dineshonjava.com/service-to-worker/" href="https://dineshonjava.com/service-to-worker/">Service to Worker Pattern</a></li>
</ul>
</blockquote>
</div>
<h3><strong>Filter </strong></h3>
<p>The filter is responsible for performing a particular task before or after the execution of the request by its request handler.</p>
<h3><strong>Target</strong></h3>
<p>The target is, in fact, the target object- a request handler.</p>
<h3><strong>Filter chain</strong></h3>
<p>Filter chain carries a chain of filters which are to be implemented on the target, in different and defined order.</p>
<h3><strong>Filter manager</strong></h3>
<p>Filter manager is responsible for managing the filters and filter chain.</p>
<h3><strong>Client</strong></h3>
<p>The client is the object which sends the requests to the Target object.<br />
<img class="aligncenter wp-image-3590 size-full" src="https://dineshonjava.com/wp-content/uploads/2017/12/Intercepting_filter_pattern_class_diagram.gif" alt="Intercepting filter design pattern class diagram" width="401" height="248" /></p>
<h2><strong>Implementation and Use cases of Intercepting Filter Pattern</strong></h2>
<p>When an intercepting filter is sent a particular task to perform, it, after receiving the request, perform certain tasks on it. It passes the data to another filter object so that it filters it. That object, then, sends the filtered data back to the filter and the normal execution is continued. After, all this process, a requested output is produced.</p>
<h3>Use Cases</h3>
<p>These filters are required when the user need to perform logging or authentication. It enhances the security of the system. There are certain conditions, in which the user might need to implement the intercepting filter pattern. These conditions include; when an additional function is required to be added to the current web application when the main process is needed to be decorated, when the user needs to debug or when the preprocessing and post-processing is required for a particular client. It uncompresses the incoming request. The filter can be added or removed transparently and it can be triggered automatically. It gives the benefit of improved re-usability. It composes the deployment time. The intercepting filter pattern centralizes the control of the system. In the filter chain, every filter is coupled loosely and are, therefore, not efficient for sharing the information. The pattern offers improved flexibility within the system- the users are able to add or remove the common components flexibly and declaratively. The unnecessarily long filter chains with a large number of interceptors or filters can cause the performance efficiency to be reduced.</p>
<h3>Implementation Filter strategies</h3>
<p>The process is the intercepting filter pattern is such that, the client invokes a request and sends it to the filter manager. The filter manager is the creator of both, the filter chain and the filter object and it manages both as well. There is an exchange of processed and the processed data between filter object and filter chain. Filter chain then invokes the processed request back to the target (request handler).</p>
<p>There are certain strategies for implementing an intercepting filter. Some of them are; <strong><em>standard filter strategy</em></strong>,<em><strong> base filter strategy</strong></em>, <em><strong>template filter strategy</strong></em>, <em><strong>web services</strong> <strong>and</strong> <strong>message handling strategies</strong></em> and <em><strong>custom filter strategies</strong></em>.</p>
<h2><strong>Sample Implementation</strong></h2>
<p>We are going to create a FilterChain, FilterManager, Target, Client as various objects representing our entities. AuthenticationFilter and DebugFilter represent concrete filters.</p>
<h3>Step 1 : Create Filter interface.<br />
Filter.java</h3>
<pre class="highlight">public interface Filter { 
 public void execute(ServletRequest request); 
} 
</pre>
<h3>Step 2 : Create Filter&#8217;s implementation classes.<br />
DebuggingFilter.java</h3>
<pre class="highlight">public class DebuggingFilter implements Filter{ 
 public void execute(ServletRequest request) { 
 //Do some filter processing here, such as 
 // displaying request parameters 
 System.out.println("request log: " + request); 
 } 
</pre>
<h3>AuthenticationFilter.java</h3>
<pre class="highlight">public class AuthenticationFilter implements Filter { 
 public void execute(ServletRequest request){ 
 //Do some filter processing here, such as 
 // displaying request parameters 
 System.out.println("Authenticating request: " + request); 
 } 
} 
</pre>
<h3>Step 3 : Create Target class.<br />
Target.java</h3>
<pre class="highlight">public class Target { 
 public void execute(ServletRequest request){ 
 System.out.println("Executing request: " + request); 
 } 
} 
</pre>
<h3>Step 4: Create Filter Chain class<br />
FilterChain.java</h3>
<pre class="highlight">public class FilterChain { 
 private List filters = new ArrayList(); 
 private Target target; 
 
 public void addFilter(Filter filter){ 
 filters.add(filter); 
 } 
 
 public void execute(ServletRequest request){ 
 for (Filter filter : filters) { 
 filter.execute(request); 
 } 
 target.execute(request); 
 } 
 
 public void setTarget(Target target){ 
 this.target = target; 
 } 
} 
</pre>
<h3>Step 5: Create Filter Manager class.<br />
FilterManager.java</h3>
<pre class="highlight">public class FilterManager { 
 FilterChain filterChain; 
 
 public FilterManager(Target target){ 
 filterChain = new FilterChain(); 
 filterChain.setTarget(target); 
 } 
 public void setFilter(Filter filter){ 
 filterChain.addFilter(filter); 
 } 
 
 public void filterRequest(ServletRequest request){ 
 filterChain.execute(request); 
 } 
} 
</pre>
<h3>Step 6: Create client class<br />
Client.java</h3>
<pre class="highlight">public class Client { 
 FilterManager filterManager; 
 
 public void setFilterManager(FilterManager filterManager){ 
 this.filterManager = filterManager; 
 } 
 
 public void sendRequest(ServletRequest request){ 
 filterManager.filterRequest(request); 
 } 
} 
</pre>
<h3>Create 7: Create a demo class<br />
InterceptingFilterDemo.java</h3>
<pre class="highlight">public class InterceptingFilterDemo { 
 public static void main(String[] args) { 
 ServletRequest request = //request object. 
 FilterManager filterManager = new FilterManager(new Target()); 
 filterManager.setFilter(new AuthenticationFilter()); 
 filterManager.setFilter(new DebugFilter()); 
 
 Client client = new Client(); 
 client.setFilterManager(filterManager); 
 client.sendRequest(request); 
 } 
} 
</pre>
<div class="wp-post-navigation"> 
									 <div class="wp-post-navigation-pre"> 
									 <a href="https://dineshonjava.com/structural-design-patterns/">Previous</a> 
									 </div> 
									 <div class="wp-post-navigation-next"> 
									 <a href="https://dineshonjava.com/context-object-design-pattern/">Next</a> 
									 </div> 
									</div>
<script type="text/javascript">
jQuery(document).ready(function($) {
 $.post('https://dineshonjava.com/wp-admin/admin-ajax.php', {action: 'mts_view_count', id: '3589'});
});
</script>
Strategy Design Patterns We can easily create a strategy design pattern using lambda. To implement…
Decorator Pattern A decorator pattern allows a user to add new functionality to an existing…
Delegating pattern In software engineering, the delegation pattern is an object-oriented design pattern that allows…
Technology has emerged a lot in the last decade, and now we have artificial intelligence;…
Managing a database is becoming increasingly complex now due to the vast amount of data…
Overview In this article, we will explore Spring Scheduler how we could use it by…