❮ Interpreter Pattern Decorator Pattern ❯

Intercepting Filter Pattern

The Intercepting Filter Pattern is used to perform preprocessing/postprocessing on application requests or responses. Filters are defined and applied to the request before it is passed to the actual target application. Filters can perform tasks such as authentication/authorization/logging, or tracking requests, and then pass the request to the corresponding handler. The following are the entities of this design pattern.

Filter - A filter performs certain tasks before or after the request handler executes the request.
Filter Chain - A filter chain contains multiple filters and executes them in the defined order on the Target.
Target - The Target object is the request handler.
Filter Manager - The Filter Manager manages filters and the filter chain.
Client - The Client is the object that sends requests to the Target object.

Implementation

We will create FilterChain, FilterManager, Target, Client as various objects representing entities. AuthenticationFilter and DebugFilter represent entity filters.

The InterceptingFilterDemo class uses Client to demonstrate the Intercepting Filter design pattern.

Step 1

Create the Filter interface.

Filter.java

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

Step 2

Create the entity filters.

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 the Target.

Target.java

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

Step 4

Create the 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 the 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 the 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

Use Client to demonstrate the Intercepting Filter design pattern.

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

Execute the program, output result:

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

❮ Interpreter Pattern Decorator Pattern ❯