Modèle de filtre d'interception

Le modèle de filtre d'interception est utilisé pour effectuer un pré-traitement/post-traitement des demandes ou des réponses d'application. Les filtres sont définis et appliqués aux demandes avant qu'elles ne soient transmises à l'application cible réelle. Les filtres peuvent effectuer une authentification/autorisation/journalisation, ou suivre les demandes, puis transmettre les demandes au gestionnaire approprié. Voici les entités de ce modèle de conception.

• Filtre - Un filtre effectue certaines tâches avant ou après que le gestionnaire de requêtes exécute la requête.

• Chaîne de filtres - Une chaîne de filtres prend plusieurs filtres et les exécute dans un ordre défini sur la cible.

• Target - L'objet Target est le gestionnaire de requêtes.

• Filter Manager - Filter Manager gère les filtres et les chaînes de filtres.

• Client - Le client est l'objet qui envoie des requêtes à l'objet cible.

En implémentant

nous créerons FilterChain, FilterManager, Target, Client comme divers objets représentant des entités. AuthenticationFilter et DebugFilter représentent des filtres d'entités.

InterceptingFilterDemo, notre classe de démonstration utilise Client pour démontrer le modèle de conception du filtre d'interception.

Étape 1

Créez l'interface de filtre Filtre.

Filter.java

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

Étape 2

Créer un filtre d'entité.

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);
   }
}

Étape 3

Créer une cible.

Target.java

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

Étape 4

Créez la chaîne de filtres.

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;
   }
}

Étape 5

Créez le gestionnaire de filtres.

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);
   }
}

Étape 6

Créer le 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);
   }
}

Étape 7

Utilisez Client pour démontrer le modèle de conception du filtre intercepteur.

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");
   }
}

Étape 8

Vérifiez la sortie.

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