Filter-Muster

Das Filter-Muster oder Kriterien-Muster ist ein Entwurfsmuster, das Entwicklern ermöglicht, eine Menge von Objekten anhand unterschiedlicher Kriterien zu filtern und sie durch logische Operationen auf entkoppelte Weise miteinander zu verbinden. Diese Art von Entwurfsmuster gehört zu den Strukturmustern, da es mehrere Kriterien kombiniert, um einen einzigen Standard zu erhalten.


summary

Absicht

Wird verwendet, um den Filterprozess von Objekten zu kapseln, sodass Objekte dynamisch anhand unterschiedlicher Filterkriterien gefiltert werden können.

Wesentliche gelöste Probleme

Wenn eine Menge von Objekten anhand mehrerer unterschiedlicher Bedingungen oder Kriterien gefiltert werden muss, bietet das Filter-Muster eine flexible Möglichkeit, diese Bedingungen zu definieren, wodurch das Hartcodieren von Filterlogik im Client-Code vermieden wird.

Anwendungsfall

  • Wenn eine Objektsammlung nach unterschiedlichen Kriterien gefiltert werden muss.
  • Wenn sich die Filterlogik ändern kann oder wenn mehrere Filterbedingungen dynamisch kombiniert werden müssen.

Implementierungsansatz

  • Filter-Schnittstelle definieren: Erstelle eine Filter-Schnittstelle und definiere eine Filtermethode.
  • Konkrete Filter implementieren: Implementieren Sie die Filterschnittstelle für jedes Filterkriterium und kapseln Sie die spezifische Filterlogik.
  • Zusammengesetzter Filter: Erlauben Sie, Filter zu kombinieren, um komplexe Filterlogik zu bilden.

Schlüsselcode

  • Filterschnittstelle: Definieren Sie die Filterungsmethode, wie z. B.matches()。
  • Konkrete Filterklasse: Implementieren Sie die Filterschnittstelle und kapseln Sie die spezifische Filterlogik.
  • Zusammengesetzter Filter: Implementieren Sie Kombinationslogik für Filter, wie logisches UND, logisches ODER usw.

Anwendungsbeispiel

  1. Buchverwaltungssystem: Filtern Sie Bücher nach verschiedenen Kriterien wie Autor, Erscheinungsjahr und Kategorie.
  2. Online-Shopping-Plattform: Filtern Sie Produkte anhand von Bedingungen wie Preis, Marke und Nutzerbewertung.

Vorteile

  1. Kapselung: Die Filterlogik ist in unabhängigen Filterobjekten gekapselt.
  2. Flexibilität: Filterbedingungen können dynamisch hinzugefügt, geändert oder kombiniert werden.
  3. Erweiterbarkeit: Neue Filterkriterien können einfach hinzugefügt werden, ohne bestehenden Code zu ändern.

Nachteile

  • Komplexität: Mit zunehmenden Filterbedingungen kann das System komplex werden.
  • Leistungsprobleme: Wenn die Filterkombination zu komplex ist, kann die Leistung beeinträchtigt werden.

Verwendungshinweise

  • Wenn sich die Filterlogik ändern kann oder Objekte dynamisch nach unterschiedlichen Kriterien gefiltert werden müssen, sollten Sie das Filter-Muster in Betracht ziehen.
  • Stellen Sie während des Entwurfs sicher, dass die Filter-Schnittstelle und ihre Implementierungen konsistent bleiben, um Kombination und Erweiterung zu erleichtern.

Hinweise

  • Stellen Sie sicher, dass die Kombinationslogik der Filter korrekt ist, um logische Fehler zu vermeiden.
  • Berücksichtigen Sie während der Implementierung die Auswirkungen auf die Leistung, insbesondere bei der Verarbeitung großer Datenmengen.

summary

Das Filter-Muster umfasst die folgenden Hauptrollen:

  • Filter-Schnittstelle (Filter/Criteria): Definieren Sie eine Schnittstelle zum Filtern von Objekten. Diese Schnittstelle enthält normalerweise eine Methode zum Filtern von Objekten basierend auf bestimmten Bedingungen.

  • Konkrete Filterklassen (Concrete Filter/Concrete Criteria): Implementieren Sie die Filter-Schnittstelle, um die Bedingungen und die Logik zum Filtern von Objekten konkret zu definieren.

  • Objektsammlung (Elemente/Objekte, die gefiltert werden sollen): Die Sammlung von Objekten, die gefiltert werden sollen. Diese Objekte sind normalerweise Instanzen mit gemeinsamen Attributen, wie eine Gruppe von Personen, eine Gruppe von Produkten usw.

  • Client: Verwenden Sie konkrete Filterklassen, um Objektsammlungen zu filtern. Der Client kombiniert die Objektsammlung mit Filtern, um Objekte zu erhalten, die die Kriterien erfüllen.

Implementierung

Wir werden einPersonObjekt,Criteria-Schnittstelle und Entitätsklassen, die die Schnittstelle implementieren, erstellen, umPersonListe von Objekten.CriteriaPatternDemoKlassenverwendungCriteria-Objekte, filtern Sie basierend auf verschiedenen Kriterien und deren KombinationenPersonListe von Objekten.

过滤器模式的 UML 图

Schritt 1

Erstelle eine Klasse, auf die die Kriterien angewendet werden.

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

Schritt 2

Erstelle eine Schnittstelle für Criteria.

Criteria.java

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

Schritt 3

Erstelle eine ImplementierungCriteriaEntity-Klasse der Schnittstelle.

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

Schritt 4

Verwenden Sie verschiedene Criteria und ihre Kombinationen, umPersonListe von Objekten zu filtern.

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("Männer: "); printPersons(male.meetCriteria(persons)); System.out.println("\nFrauen: "); printPersons(female.meetCriteria(persons)); System.out.println("\nLedige Männer: "); printPersons(singleMale.meet(persons)); System.out.println("\nLedig oder weiblich: "); printPersons(singleOrFemale.meet(persons)); } public static void print(List<Person> persons){ for (Person person : persons) { System.out.println("Person : [ Name : " + person.getName() +", Geschlecht : " + person.getGender() +", Familienstand : " + person.getMaritalStatus() +" ]"); } } }

Schritt 5

Programm ausführen, Ergebnis ausgeben:

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 ]
Weitere Erweiterungen