The best Intercepting Filter pattern Tutorial In 2024, In this tutorial you can learn achieve,step 1,Step 2,Step 3,Step 4,Step 5,Step 6,Step 7,Step 8,

Intercepting Filter pattern

Intercepting Filter pattern (Intercepting Filter Pattern) for requesting an application or in response to do some pre-processing / post-processing. Define the filter, and before the request to the practical application of the target application on request. Filters can do authentication / authorization / logging or tracking request, then the request to the appropriate handler. The following is an entity of this design pattern.

• Filter (Filter) - filter before or after the execution of the request request handler to perform certain tasks.
• Filter chain (Filter Chain) - filter chain with a plurality of filters, and the implementation of these filters on Target in a defined sequence.
• Target - Target is the object request handler.
• Filter Manager (Filter Manager) - Filter Manager filters and filter chain.
• Client (Client) - Client object to Target object to send the request.

achieve

We will createFilterChain,FilterManager, Target, Client represents entities as various objects.AuthenticationFilterandDebugFilterrepresent entities filters.

InterceptingFilterDemo,we demonstrate the use ofClientclass to demonstrate the Intercepting Filter design pattern.

step 1

Create Filter Interface Filter.

Filter.java

public interface Filter {
   public void execute (String request);
}

Step 2

Create entity filter.

AuthenticationFilter.java

public class AuthenticationFilter implements Filter {
   public void execute (String request) {
      System.out.println ( "Authenticating request:" + request);
   }
}

DebugFilter.java

public class DebugFilter implements Filter {
   public void execute (String request) {
      System.out.println ( "request log:" + request);
   }
}

Step 3

Create Target.

Target.java

public class Target {
   public void execute (String request) {
      System.out.println ( "Executing request:" + request);
   }
}

Step 4

Create a filter chain.

FilterChain.java

import java.util.ArrayList;
import java.util.List;

public class FilterChain {
   private List <Filter> filters = new ArrayList <Filter> ();
   private Target target;

   public void addFilter (Filter filter) {
      filters.add (filter);
   }

   public void execute (String request) {
      for (Filter filter: filters) {
         filter.execute (request);
      }
      target.execute (request);
   }

   public void setTarget (Target target) {
      this.target = target;
   }
}

Step 5

Create Filter Manager.

FilterManager.java

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 (String request) {
      filterChain.execute (request);
   }
}

Step 6

Create a client Client.

Client.java

public class Client {
   FilterManager filterManager;

   public void setFilterManager (FilterManager filterManager) {
      this.filterManager = filterManager;
   }

   public void sendRequest (String request) {
      filterManager.filterRequest (request);
   }
}

Step 7

UseClientto demonstrate the Intercepting Filter design pattern.

FrontControllerPatternDemo.java

public class InterceptingFilterDemo {
   public static void main (String [] args) {
      FilterManager filterManager = new FilterManager (new Target ());
      filterManager.setFilter (new AuthenticationFilter ());
      filterManager.setFilter (new DebugFilter ());

      Client client = new Client ();
      client.setFilterManager (filterManager);
      client.sendRequest ( "HOME");
   }
}

Step 8

Verify output.

Authenticating request: HOME
request log: HOME
Executing request: HOME