设计模式详解-过滤器模式(标准模式)

导言

在软件开发中，我们常常需要对大量的数据进行筛选或过滤。例如，在一个电子商务网站中，我们可能需要根据用户的喜好、价格区间、商品类型等条件来筛选出符合用户需求的商品列表。为了实现这样的功能，过滤器模式就派上了用场。

什么是过滤器模式？

过滤器模式是一种结构型设计模式，它允许我们使用不同的条件从数据集合中筛选出满足特定条件的数据子集。它将筛选条件和数据集合分离，使得二者可以独立变化而互不影响。

过滤器模式的组成部分

过滤器接口（Filter）：定义了过滤器的基本方法，在实际应用中可以扩展该接口以适应不同的过滤条件。
具体过滤器（ConcreteFilter）：实现过滤器接口，根据具体的条件对数据进行过滤。
过滤器链（FilterChain）：将多个过滤器按照一定的顺序组合起来，形成一个过滤器链，依次对数据进行过滤。

过滤器模式的应用场景

过滤器模式在很多实际场景中都有应用，例如：

• 数据查询：在数据库查询中，我们可以使用过滤器模式根据不同的条件对查询结果进行过滤，提高查询效率。
• 日志过滤：在日志系统中，我们可以使用过滤器模式根据级别、关键词等条件对日志进行过滤，方便问题排查与分析。
• 图像处理：在图像处理中，我们可以使用过滤器模式根据不同的条件对图像进行滤波、增强等操作。

过滤器模式的实现

步骤 1
        创建一个类，在该类上应用标准。

        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;
    }
}
步骤 2
        为标准（Criteria）创建一个接口。

        Criteria.java
        import java.util.List;

public interface Criteria {
    public List<Person> meetCriteria(List<Person> persons);
}
步骤 3
        创建实现了 Criteria 接口的实体类。

        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;
    }
}
步骤4
        使用不同的标准（Criteria）和它们的结合来过滤 Person 对象的列表。

        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("Males: ");
        printPersons(male.meetCriteria(persons));

        System.out.println("\nFemales: ");
        printPersons(female.meetCriteria(persons));

        System.out.println("\nSingle Males: ");
        printPersons(singleMale.meetCriteria(persons));

        System.out.println("\nSingle Or Females: ");
        printPersons(singleOrFemale.meetCriteria(persons));
    }

    public static void printPersons(List<Person> persons){
        for (Person person : persons) {
            System.out.println("Person : [ Name : " + person.getName()
                    +", Gender : " + person.getGender()
                    +", Marital Status : " + person.getMaritalStatus()
                    +" ]");
        }
    }
}
步骤 5
        执行程序，输出结果：

        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 ]
        
这段代码展示了一个使用标准模式（Criteria Pattern）的例子。标准模式用于按照特定的标准筛选对象。

步骤1中定义了一个名为Person的类，该类具有name、gender和maritalStatus属性，并提供了相应的构造函数和访问方法。

步骤2中定义了一个名为Criteria的接口，该接口包含一个meetCriteria方法，用于根据特定的标准筛选Person对象。

步骤3中定义了几个实现了Criteria接口的类，分别用于筛选男性、女性和单身人士的Person对象。还定义了AndCriteria和OrCriteria类，用于组合不同的标准进行筛选。

步骤4中使用不同的标准和它们的组合来过滤Person对象的列表。在示例中，创建了一个包含多个Person对象的列表，然后使用不同的标准对该列表进行筛选，并打印出符合相应标准的Person对象。

步骤5中执行程序，根据不同的标准筛选并输出结果。可以看到，根据不同的标准筛选后，输出的Person对象列表符合对应的要求。

标准模式可以很好地实现对象的筛选和过滤，提供了灵活性和可扩展性，使得筛选逻辑与具体对象的实现解耦。这对于需要根据不同的标准进行筛选的应用场景非常有用。

结语

过滤器模式是一种简单而强大的软件设计模式，它可以帮助我们灵活地筛选数据，并将过滤条件与数据集合解耦。通过本篇博客的学习，读者可以了解到过滤器模式的基本概念、应用场景和实现方式，并通过实例演示掌握其具体使用方法。希望本文对您深入理解过滤器模式有所帮助，并能在实际开发中灵活运用。