Patron Filtre

Le patron de filtre ou le patron de critères est un patron de conception qui permet aux développeurs de filtrer un ensemble d’objets à l’aide de différents critères et de les relier de manière découplée au moyen d’opérations logiques. Ce type de patron de conception appartient aux patrons structurels, car il combine plusieurs critères pour obtenir un seul standard.

summary

intention

Utilisé pour encapsuler le processus de filtrage des objets, permettant de filtrer dynamiquement les objets en utilisant différents critères de filtrage.

Principaux problèmes résolus

Lorsqu’un ensemble d’objets doit être filtré en fonction de plusieurs conditions ou critères différents, le patron de filtre offre un moyen flexible de définir ces conditions, en évitant de coder en dur la logique de filtrage dans le code client.

Cas d'utilisation

  • Lorsqu’une collection d’objets doit être filtrée selon différents critères.
  • Lorsque la logique de filtrage peut changer, ou lorsque plusieurs conditions de filtrage doivent être combinées dynamiquement.

Approche d'implémentation

  • Définir l’interface de filtre: Créer une interface de filtre et définir une méthode de filtrage.
  • Implémenter des filtres concrets: Implémenter l'interface de filtre pour chaque critère de filtrage, en encapsulant la logique de filtrage spécifique.
  • Filtre composite: Permettre de combiner des filtres pour former une logique de filtrage complexe.

Code clé

  • Interface de filtre: Définir la méthode de filtrage, telle quematches()。
  • Classe de filtre concrète: Implémenter l'interface de filtre et encapsuler la logique de filtrage spécifique.
  • Filtre composite: Implémenter une logique de combinaison de filtres, telle que le ET logique, le OU logique, etc.

Exemple d'application

  1. Système de gestion de livres: Filtrer des livres selon différents critères tels que l'auteur, l'année de publication et la catégorie.
  2. Plateforme d'achat en ligne: Filtrer des produits selon des conditions telles que le prix, la marque et la note des utilisateurs.

Avantages

  1. Encapsulation: La logique de filtrage est encapsulée dans des objets de filtre indépendants.
  2. Flexibilité: Les conditions de filtrage peuvent être ajoutées, modifiées ou combinées dynamiquement.
  3. Extensibilité: De nouveaux critères de filtrage peuvent être facilement ajoutés sans modifier le code existant.

Inconvénients

  • Complexité: À mesure que les conditions de filtrage augmentent, le système peut devenir complexe.
  • Problèmes de performance: Si la combinaison de filtres est trop complexe, les performances peuvent être affectées.

Suggestions d'utilisation

  • Lorsque la logique de filtrage peut changer ou que des objets doivent être filtrés dynamiquement selon différents critères, envisagez d'utiliser le patron Filter.
  • Lors de la conception, assurez-vous que l'interface de filtre et ses implémentations restent cohérentes pour faciliter la combinaison et l'extension.

Notes

  • Assurez-vous que la logique de combinaison des filtres est correcte afin d'éviter d'introduire des erreurs logiques.
  • Lors de l'implémentation, tenez compte de l'impact sur les performances, en particulier lors du traitement de grandes quantités de données.

summary

Le patron Filter comprend les rôles principaux suivants :

  • Interface de filtre (Filter/Criteria): Définir une interface pour filtrer des objets. Cette interface contient généralement une méthode pour filtrer des objets selon des conditions spécifiques.

  • Classes de filtre concrètes (Concrete Filter/Concrete Criteria): Implémenter l'interface de filtre pour définir spécifiquement les conditions et la logique de filtrage des objets.

  • Collection d'objets (éléments/objets à filtrer): La collection d'objets à filtrer. Ces objets sont généralement des instances avec des attributs communs, comme un groupe de personnes, un groupe de produits, etc.

  • Client: Utiliser des classes de filtre concrètes pour filtrer des collections d'objets. Le client combine la collection d'objets avec des filtres pour obtenir les objets qui répondent aux critères.

Implémentation

Nous allons créer unPersonObject,CriteriaL'interface et les classes d'entité qui implémentent l'interface, pour filtrerPersonliste d'objets.CriteriaPatternDemoUtilisation de la classeCriteriaobjets, filtrer selon divers critères et leurs combinaisonsPersonliste d'objets.

过滤器模式的 UML 图

Étape 1

Créez une classe à laquelle les critères sont appliqués.

Person.java

public class Person { private String name; private String gender; private String maritalStatus; public Person(String name,String gender,String maritalStatus){ this.name = name; this.gender = gender; this.maritalStatus = maritalStatus; } public String getName() { return name; } public String getGender() { return gender; } public String getMaritalStatus() { return maritalStatus; } }

Étape 2

Créer une interface pour Criteria.

Criteria.java

import java.util.List; public interface Criteria { public List<Person> meetCriteria(List<Person> persons); }

Étape 3

Créer une implémentationCriteriaclasse d'entité de l'interface.

CriteriaMale.java

import java.util.ArrayList; import java.util.List; public class CriteriaMale implements Criteria { @Override public List<Person> meetCriteria(List<Person> persons) { List<Person> malePersons = new ArrayList<Person>(); for (Person person : persons) { if(person.getGender().equalsIgnoreCase("MALE")){ malePersons.add(person); } } return malePersons; } }

CriteriaFemale.java

import java.util.ArrayList; import java.util.List; public class CriteriaFemale implements Criteria { @Override public List<Person> meetCriteria(List<Person> persons) { List<Person> femalePersons = new ArrayList<Person>(); for (Person person : persons) { if(person.getGender().equalsIgnoreCase("FEMALE")){ femalePersons.add(person); } } return femalePersons; } }

CriteriaSingle.java

import java.util.ArrayList; import java.util.List; public class CriteriaSingle implements Criteria { @Override public List<Person> meetCriteria(List<Person> persons) { List<Person> singlePersons = new ArrayList<Person>(); for (Person person : persons) { if(person.getMaritalStatus().equalsIgnoreCase("SINGLE")){ singlePersons.add(person); } } return singlePersons; } }

AndCriteria.java

import java.util.List; public class AndCriteria implements Criteria { private Criteria criteria; private Criteria otherCriteria; public AndCriteria(Criteria criteria, Criteria otherCriteria) { this.criteria = criteria; this.otherCriteria = otherCriteria; } @Override public List<Person> meetCriteria(List<Person> persons) { List<Person> firstCriteriaPersons = criteria.meetCriteria(persons); return otherCriteria.meetCriteria(firstCriteriaPersons); } }

OrCriteria.java

import java.util.List; public class OrCriteria implements Criteria { private Criteria criteria; private Criteria otherCriteria; public OrCriteria(Criteria criteria, Criteria otherCriteria) { this.criteria = criteria; this.otherCriteria = otherCriteria; } @Override public List<Person> meetCriteria(List<Person> persons) { List<Person> firstCriteriaItems = criteria.meetCriteria(persons); List<Person> otherCriteriaItems = otherCriteria.meetCriteria(persons); for (Person person : otherCriteriaItems) { if(!firstCriteriaItems.contains(person)){ firstCriteriaItems.add(person); } } return firstCriteriaItems; } }

Étape 4

Utilisez différents Criteria et leurs combinaisons pour filtrerPersonliste d'objets.

CriteriaPatternDemo.java

import java.util.ArrayList; import java.util.List; public class CriteriaPatternDemo { public static void main(String[] args) { List<Person> persons = new ArrayList<Person>(); persons.add(new Person("Robert","Male", "Single")); persons.add(new Person("John","Male", "Married")); persons.add(new Person("Laura","Female", "Married")); persons.add(new Person("Diana","Female", "Single")); persons.add(new Person("Mike","Male", "Single")); persons.add(new Person("Bobby","Male", "Single")); Criteria male = new CriteriaMale(); Criteria female = new CriteriaFemale(); Criteria single = new CriteriaSingle(); Criteria singleMale = new AndCriteria(single, male); Criteria singleOrFemale = new OrCriteria(single, female); System.out.println("Hommes: "); printPersons(male.meetCriteria(persons)); System.out.println("\nFemmes: "); printPersons(female.meetCriteria(persons)); System.out.println("\nHommes célibataires: "); printPersons(singleMale.meetCriteria(persons)); System.out.println("\nCélibataires ou femmes : "); printPersons(singleOrFemale.meetCriteria(persons)); } public static void printPersons(List<Person> persons){ for (Person person : persons) { System.out.println("Personne : [ Nom : " + person.getName() +", Genre : " + person.getGender() +", État matrimonial : " + person.getMaritalStatus() +" ]"); } } }

Étape 5

Exécutez le programme, le résultat s'affiche :

Males: 
Person : [ Name : Robert, Gender : Male, Marital Status : Single ]
Person : [ Name : John, Gender : Male, Marital Status : Married ]
Person : [ Name : Mike, Gender : Male, Marital Status : Single ]
Person : [ Name : Bobby, Gender : Male, Marital Status : Single ]

Females: 
Person : [ Name : Laura, Gender : Female, Marital Status : Married ]
Person : [ Name : Diana, Gender : Female, Marital Status : Single ]

Single Males: 
Person : [ Name : Robert, Gender : Male, Marital Status : Single ]
Person : [ Name : Mike, Gender : Male, Marital Status : Single ]
Person : [ Name : Bobby, Gender : Male, Marital Status : Single ]

Single Or Females: 
Person : [ Name : Robert, Gender : Male, Marital Status : Single ]
Person : [ Name : Diana, Gender : Female, Marital Status : Single ]
Person : [ Name : Mike, Gender : Male, Marital Status : Single ]
Person : [ Name : Bobby, Gender : Male, Marital Status : Single ]
Person : [ Name : Laura, Gender : Female, Marital Status : Married ]
autres extensions