【过滤器设计模式详解】C/Java/JS/Go/Python/TS不同语言实现

简介

过滤器模式（Filter Pattern）或标准模式（Criteria Pattern），是一种结构型模式。这种模式允许使用不同的标准条件来过滤一组对象，并通过逻辑运算的方式把各条件连接起来，它结合多个标准来获得单一标准。
例子将创建一个 Person 对象、Criteria 接口和实现了该接口的实体类，来过滤 Person 对象的列表。Test 类使用 Criteria 对象，基于各种标准和它们的结合来过滤 Person 对象的列表。
 
作用

• 可以通过层层筛选，过滤出自己想要的结果。
  
• 面向接口编程，将对象过滤，接口不依赖对象；对象无入侵，每次只需要增加规则就行了，不用修改过滤对象类。
  

 
实现步骤

• 创建Criteria基础接口，定义过滤方法。
  
• 创建多个条件类，实现过滤逻辑。
  
• 客户端调用时，通条件类过滤数据。
  

 
UML

 
 
Java代码

 
标准接口类

1. // Criteria.java 定义抽象标准接口，聚合实体对象
2. public interface Criteria {
3.    public List<Person> filter(List<Person> persons);
4. }

复制代码

 
 
具体标准实现类

 

1. // AndCriteria.java 定义And过滤标准
2. public class AndCriteria implements Criteria {
4.    private Criteria criteria;
5.    private Criteria otherCriteria;
7.    public AndCriteria(Criteria criteria, Criteria otherCriteria) {
8.       this.criteria = criteria;
9.       this.otherCriteria = otherCriteria;
10.    }
12.    @Override
13.    public List<Person> filter(List<Person> persons) {
14.       List<Person> firstCriteriaPersons = criteria.filter(persons);
15.       return otherCriteria.filter(firstCriteriaPersons);
16.    }
17. }
20. // OrCriteria.java 定义Or过滤标准
21. public class OrCriteria implements Criteria {
23.    private Criteria criteria;
24.    private Criteria otherCriteria;
26.    public OrCriteria(Criteria criteria, Criteria otherCriteria) {
27.       this.criteria = criteria;
28.       this.otherCriteria = otherCriteria;
29.    }
31.    @Override
32.    public List<Person> filter(List<Person> persons) {
33.       List<Person> firstCriteriaItems = criteria.filter(persons);
34.       List<Person> otherCriteriaItems = otherCriteria.filter(persons);
36.       for (Person person : otherCriteriaItems) {
37.          if (!firstCriteriaItems.contains(person)) {
38.             firstCriteriaItems.add(person);
39.          }
40.       }
41.       return firstCriteriaItems;
42.    }
43. }
46. // CriteriaFemale.java 根据标准接口实现的过滤
47. public class CriteriaFemale implements Criteria {
49.   @Override
50.   public List<Person> filter(List<Person> persons) {
51.     List<Person> femalePersons = new ArrayList<Person>();
52.     for (Person person : persons) {
53.       if (person.getGender().equalsIgnoreCase("FEMALE")) {
54.         femalePersons.add(person);
55.       }
56.     }
57.     return femalePersons;
58.   }
59. }
62. // CriteriaMale.java 根据标准接口实现的过滤
63. public class CriteriaMale implements Criteria {
65.    @Override
66.    public List<Person> filter(List<Person> persons) {
67.       List<Person> malePersons = new ArrayList<Person>();
68.       for (Person person : persons) {
69.          if (person.getGender().equalsIgnoreCase("MALE")) {
70.             malePersons.add(person);
71.          }
72.       }
73.       return malePersons;
74.    }
75. }
78. // CriteriaSingle.java 根据标准接口实现按属性的过滤
79. public class CriteriaSingle implements Criteria {
81.    @Override
82.    public List<Person> filter(List<Person> persons) {
83.       List<Person> singlePersons = new ArrayList<Person>();
84.       for (Person person : persons) {
85.          if (person.getStatus().equalsIgnoreCase("SINGLE")) {
86.             singlePersons.add(person);
87.          }
88.       }
89.       return singlePersons;
90.    }
91. }

复制代码

 
业务实体类

 

1. // Person.java 定义一个实体类，用来过滤的对象
2. public class Person {
4.    private String name;
5.    private String gender;
6.    private String status;
8.    public Person(String name, String gender, String status) {
9.       this.name = name;
10.       this.gender = gender;
11.       this.status = status;
12.    }
14.    public String getName() {
15.       return name;
16.    }
18.    public String getGender() {
19.       return gender;
20.    }
22.    public String getStatus() {
23.       return status;
24.    }
26.    public String toString() {
27.       return "Person : [ Name : " + getName() + ", Gender : "
28.             + getGender() + ", Marital Status : " + getStatus() + " ]";
29.    }
30. }

复制代码

 
测试调用

 

1.     /**
2.      * 过滤器模式就是不断组合过滤条件，然后层层过滤的模式
3.      * 这里是简单演示，用List筛选来模拟过滤，实际例子有各种数据结构
4.      */
5.     List<Person> persons = new ArrayList<Person>();
7.     persons.add(new Person("王男单", "Male", "Single"));
8.     persons.add(new Person("李男婚", "Male", "Married"));
9.     persons.add(new Person("张女婚", "Female", "Married"));
10.     persons.add(new Person("赵女单", "Female", "Single"));
11.     persons.add(new Person("刘男单", "Male", "Single"));
12.     persons.add(new Person("杨男单", "Male", "Single"));
14.     Criteria male = new CriteriaMale();
15.     Criteria female = new CriteriaFemale();
16.     Criteria single = new CriteriaSingle();
17.     Criteria singleMale = new AndCriteria(single, male);
18.     Criteria singleOrFemale = new OrCriteria(single, female);
20.     // 查询男性
21.     System.out.println("Males: ");
22.     printPersons(male.filter(persons));
24.     // 查询女性
25.     System.out.println("\nFemales: ");
26.     printPersons(female.filter(persons));
28.     // 嵌套查询女性且单身
29.     System.out.println("\nFemales and Single: ");
30.     printPersons(single.filter(female.filter(persons)));
32.     // 查询男性男性单身
33.     System.out.println("\nSingle Males: ");
34.     printPersons(singleMale.filter(persons));
36.     // 查询女性或单身
37.     System.out.println("\nSingle Or Females: ");
38.     printPersons(singleOrFemale.filter(persons));

复制代码

 
C代码

 
head文件

 

1. // func.h文件
2. #include <stdio.h>
3. #include <ctype.h>
4. #include <stdlib.h>
5. #include <stdbool.h>
6. #include <string.h>
8. char *str_toupper(char str[]);
9. char *str_tolower(char str[]);
11. // 定义用于过滤的Person数组查询对象
12. // 因C语言无法定义动态数组，将数组长度存在此处
13. typedef struct FilterPersons
14. {
15.     int length;
16.     struct Person **persons;
17. } FilterPersons;
19. // 定义一个实体类，用来过滤的对象
20. typedef struct Person
21. {
22.     char name[50];
23.     char gender[20];
24.     char status[20];
25.     char *(*get_name)(struct Person *);
26.     char *(*to_string)(struct Person *);
27.     bool (*is_contained)(struct Person *, struct FilterPersons *);
28. } Person;
29. Person *person_constructor(char *name, char *gender, char *status);
31. // 定义抽象标准接口，聚合要过滤的对象集合
32. typedef struct Criteria
33. {
34.     struct Criteria *first_criteria;
35.     struct Criteria *other_criteria;
36.     FilterPersons *(*filter)(FilterPersons *, struct Criteria *);
37. } Criteria;
39. // 根据标准接口实现的过滤
40. typedef struct CriteriaFemale
41. {
42.     FilterPersons *(*filter)(FilterPersons *, struct Criteria *);
43. } CriteriaFemale;
44. CriteriaFemale *criteria_female_constructor();
46. // 根据标准接口实现的过滤
47. typedef struct CriteriaMale
48. {
49.     FilterPersons *(*filter)(FilterPersons *, struct Criteria *);
50. } CriteriaMale;
51. CriteriaMale *criteria_male_constructor();
53. // 根据标准接口实现的过滤
54. typedef struct CriteriaSingle
55. {
56.     FilterPersons *(*filter)(FilterPersons *, struct Criteria *);
57. } CriteriaSingle;
58. CriteriaSingle *criteria_single_constructor();
60. // 定义And过滤标准
61. typedef struct AndCriteria
62. {
63.     struct Criteria *first_criteria;
64.     struct Criteria *other_criteria;
65.     FilterPersons *(*filter)(FilterPersons *, struct Criteria *);
66. } AndCriteria;
67. AndCriteria *and_criteria_constructor(Criteria *, Criteria *);
69. // 定义Or过滤标准
70. typedef struct OrCriteria
71. {
72.     struct Criteria *first_criteria;
73.     struct Criteria *other_criteria;
74.     FilterPersons *(*filter)(FilterPersons *, struct Criteria *);
75. } OrCriteria;
76. OrCriteria *or_criteria_constructor(Criteria *, Criteria *);

复制代码

 
条件接口类

 

1. // criteria.c 定义抽象标准接口，聚合实体对象
2. #include "func.h"
3. // c语言没有抽象类或接口，Criterial作为基础struct定义在head， 这里放一些公共函数
4. char *str_toupper(char str[])
5. {
6.     int size = strlen(str);
7.     char *result = (char *)malloc(size * sizeof(char));
8.     int i = 0;
9.     while (str[i])
10.     {
11.         result[i] = toupper(str[i]);
12.         i++;
13.     }
15.     return result;
16. }
18. char *str_tolower(char str[])
19. {
20.     int size = strlen(str);
21.     char *result = (char *)malloc(size * sizeof(char));
22.     int i = 0;
23.     while (str[i])
24.     {
25.         result[i] = tolower(str[i]);
26.         i++;
27.     }
29.     return result;
30. }

复制代码

 
 
具体标准实现类

 

1. // and_criteria.c 定义And过滤标准
2. #include "func.h"
3. // 先过滤条件1，再把结果按照条件2进行过滤
4. FilterPersons *and_criteria_filter(FilterPersons *filter, Criteria *criteria)
5. {
6.   FilterPersons *first_filter = criteria->first_criteria->filter(filter, criteria);
7.   return criteria->other_criteria->filter(first_filter, criteria);
8. }
10. AndCriteria *and_criteria_constructor(Criteria *first_criteria, Criteria *other_criteria)
11. {
12.   Criteria *criteria = (Criteria *)malloc(sizeof(Criteria));
13.   criteria->filter = &and_criteria_filter;
14.   AndCriteria *and_criteria = (AndCriteria *)criteria;
15.   and_criteria->first_criteria = first_criteria;
16.   and_criteria->other_criteria = other_criteria;
17.   and_criteria->filter = &and_criteria_filter;
18.   return and_criteria;
19. }
22. // or_criteria.c 定义Or过滤标准
23. #include "func.h"
24. // 先过滤条件1，再把结果按照条件2进行过滤
25. FilterPersons *or_criteria_filter(FilterPersons *filter, Criteria *criteria)
26. {
27.   FilterPersons *first_filter = criteria->first_criteria->filter(filter, criteria);
28.   FilterPersons *other_filter = criteria->other_criteria->filter(filter, criteria);
30.   int first_size = first_filter->length;
31.   int other_size = other_filter->length;
33.   for (int i = 0; i < other_size; i++)
34.   {
35.     Person *person = other_filter->persons[i];
36.     // 符合项如果不存在条件1里，则追加到条件1里去
37.     if (!person->is_contained(person, first_filter))
38.     {
39.       // 这里数组长度直接增加
40.       first_filter->persons[first_size++] = person;
41.     }
42.   }
44.   first_filter->length = first_size;
46.   return first_filter;
47. }
49. OrCriteria *or_criteria_constructor(Criteria *first_criteria, Criteria *other_criteria)
50. {
51.   Criteria *criteria = (Criteria *)malloc(sizeof(Criteria));
52.   criteria->filter = &or_criteria_filter;
53.   OrCriteria *or_criteria = (OrCriteria *)criteria;
54.   or_criteria->first_criteria = first_criteria;
55.   or_criteria->other_criteria = other_criteria;
56.   or_criteria->filter = &or_criteria_filter;
57.   return or_criteria;
58. }
62. // ccriteria_female.c 根据标准接口实现的过滤
63. #include "func.h"
64. // 根据是否女性进行过滤
65. FilterPersons *criteria_female_filter(FilterPersons *filter, Criteria *criteria)
66. {
67.   int person_size = filter->length;
68.   int *female_index_list = (int *)malloc(person_size * sizeof(int));
69.   int count = 0;
70.   char *gender;
71.   for (int i = 0; i < person_size; i++)
72.   {
73.     if (filter->persons[i] == NULL)
74.     {
75.       break;
76.     }
77.     gender = str_toupper(filter->persons[i]->gender);
78.     if (strcmp(gender, "FEMALE") == 0)
79.     {
80.       // 记录下所有符合条件的person下标
81.       female_index_list[count] = i;
82.       count += 1;
83.     }
84.   }
85.   free(gender);
86.   free(female_index_list);
88.   // 将符合条件的person追加到新数组
89.   Person **female_persons = (Person **)calloc(count, sizeof(Person));
90.   for (int i = 0; i < count; i++)
91.   {
92.     female_persons[i] = filter->persons[female_index_list[i]];
93.   }
94.   FilterPersons *female_filter = (FilterPersons *)calloc(1, sizeof(FilterPersons));
95.   female_filter->length = count;
96.   female_filter->persons = female_persons;
97.   return female_filter;
98. }
100. CriteriaFemale *criteria_female_constructor()
101. {
102.   Criteria *criteria = (Criteria *)malloc(sizeof(Criteria));
103.   criteria->filter = &criteria_female_filter;
104.   CriteriaFemale *criteria_female = (CriteriaFemale *)criteria;
105.   criteria_female->filter = &criteria_female_filter;
106.   return criteria_female;
107. }
111. // criteria_male.c 根据标准接口实现的过滤
112. #include "func.h"
114. // 根据是否男性进行过滤
115. FilterPersons *criteria_male_filter(FilterPersons *filter, Criteria *criteria)
116. {
117.   int person_size = filter->length;
118.   int *male_index_list = (int *)malloc(person_size * sizeof(int));
119.   int count = 0;
120.   char *gender;
121.   for (int i = 0; i < person_size; i++)
122.   {
123.     if (filter->persons[i] == NULL)
124.     {
125.       break;
126.     }
127.     gender = str_tolower(filter->persons[i]->gender);
128.     if (strcmp(gender, "male") == 0)
129.     {
130.       // 记录下所有符合条件的person下标
131.       male_index_list[count] = i;
132.       count += 1;
133.     }
134.   }
135.   free(gender);
136.   free(male_index_list);
138.   // 将符合条件的person追加到新数组
139.   Person **male_persons = (Person **)calloc(count, sizeof(Person));
140.   for (int i = 0; i < count; i++)
141.   {
142.     male_persons[i] = filter->persons[male_index_list[i]];
143.   }
144.   FilterPersons *male_filter = (FilterPersons *)calloc(1, sizeof(FilterPersons));
145.   male_filter->length = count;
146.   male_filter->persons = male_persons;
147.   return male_filter;
148. }
150. CriteriaMale *criteria_male_constructor()
151. {
152.   Criteria *criteria = (Criteria *)malloc(sizeof(Criteria));
153.   criteria->filter = &criteria_male_filter;
154.   CriteriaMale *criteria_male = (CriteriaMale *)criteria;
155.   criteria_male->filter = &criteria_male_filter;
156.   return criteria_male;
157. }
160. // criteria_single.c 根据标准接口实现按属性的过滤
161. #include "func.h"
163. // 根据是否单身进行过滤
164. FilterPersons *criteria_single_filter(FilterPersons *filter, Criteria *criteria)
165. {
166.   int person_size = filter->length;
167.   int *single_index_list = (int *)malloc(person_size * sizeof(int));
168.   int count = 0;
169.   char *status;
170.   for (int i = 0; i < person_size; i++)
171.   {
172.     if (filter->persons[i] == NULL)
173.     {
174.       break;
175.     }
176.     status = str_tolower(filter->persons[i]->status);
177.     if (strcmp(status, "single") == 0)
178.     {
179.       // 记录下所有符合条件的person下标
180.       single_index_list[count] = i;
181.       count += 1;
182.     }
183.   }
184.   free(status);
185.   free(single_index_list);
187.   // 将符合条件的person追加到新数组
188.   Person **single_persons = (Person **)calloc(count, sizeof(Person));
189.   for (int i = 0; i < count; i++)
190.   {
191.     single_persons[i] = filter->persons[single_index_list[i]];
192.   }
194.   FilterPersons *single_filter = (FilterPersons *)calloc(1, sizeof(FilterPersons));
195.   single_filter->length = count;
196.   single_filter->persons = single_persons;
197.   return single_filter;
198. }
200. CriteriaSingle *criteria_single_constructor()
201. {
202.   Criteria *criteria = (Criteria *)malloc(sizeof(Criteria));
203.   criteria->filter = &criteria_single_filter;
204.   CriteriaSingle *criteria_single = (CriteriaSingle *)criteria;
205.   criteria_single->filter = &criteria_single_filter;
206.   return criteria_single;
207. }

复制代码

 
 
业务实体类

 

1. // person.c 定义一个实体类，用来过滤的对象
2. #include "func.h"
3. // 是否被包含在对象数组中
4. bool person_is_contained(Person *person, FilterPersons *filter)
5. {
6.   int persons_size = filter->length;
7.   for (int i = 0; i < persons_size; i++)
8.   {
9.     if (filter->persons[i] == person)
10.     {
11.       return true;
12.     }
13.   }
14.   return false;
15. }
17. char *person_get_name(Person *person)
18. {
19.   return person->name;
20. }
22. // 返回字符串
23. char *person_to_string(Person *person)
24. {
25.   char *result = (char *)malloc(500 * sizeof(char));
26.   strcat(result, "Person :[ name :");
27.   strcat(result, person->name);
28.   strcat(result, ", gender : ");
29.   strcat(result, person->gender);
30.   strcat(result, ", status : ");
31.   strcat(result, person->status);
32.   strcat(result, "]");
33.   return result;
34. }
36. Person *person_constructor(char *name, char *gender, char *status)
37. {
38.   Person *person = (Person *)malloc(sizeof(Person));
39.   strncpy(person->name, name, 50);
40.   strncpy(person->gender, gender, 20);
41.   strncpy(person->status, status, 20);
42.   person->get_name = &person_get_name;
43.   person->to_string = &person_to_string;
44.   person->is_contained = &person_is_contained;
45.   return person;
46. }

复制代码

 
测试调用

3.     /**
4.      * 过滤器模式就是不断组合过滤条件，然后层层过滤的模式
5.      * 这里是简单演示，用List筛选来模拟过滤，实际例子有各种数据结构。
6.      */
8.     int data_size = 6;
9.     // 定义一些数据
10.     char data[6][3][100] = {
11.         {"王男单", "Male", "Single"},
12.         {"李男婚", "Male", "Married"},
13.         {"张女婚", "Female", "Married"},
14.         {"赵女单", "Female", "Single"},
15.         {"刘男单", "Male", "Single"},
16.         {"杨男单", "Male", "Single"}};
18.     // 定义persons数组
19.     Person *persons[data_size];
20.     for (int i = 0; i < data_size; i++)
21.     {
22.         char *name = data[i][0];
23.         char *gender = data[i][1];
24.         char *status = data[i][2];
25.         Person *person = person_constructor(name, gender, status);
26.         persons[i] = person;
27.     }
29.     // 构建查询对象
30.     FilterPersons *filter_persons = (FilterPersons *)malloc(sizeof(FilterPersons *));
31.     filter_persons->length = data_size;
32.     filter_persons->persons = persons;
34.     // 声明属性过滤条件，可用Criteria或具体条件声明
35.     Criteria *criteria_male = (Criteria *)criteria_male_constructor();
36.     CriteriaFemale *criteria_female = criteria_female_constructor();
37.     Criteria *criteria_single = (Criteria *)criteria_single_constructor();
39.     // 声明逻辑条件，传入属性过滤条件
40.     Criteria *single_male = (Criteria *)and_criteria_constructor(criteria_single, criteria_male);
41.     OrCriteria *single_or_female = or_criteria_constructor(criteria_single, (Criteria *)criteria_female);
43.     // 查询男性
44.     printf("\n Males: ");
45.     print_persons(((CriteriaMale *)criteria_male)->filter(filter_persons, criteria_male));
47.     // 查询女性
48.     printf("\nFemales: ");
49.     print_persons(criteria_female->filter(filter_persons, (Criteria *)criteria_female));
51.     // 嵌套查询女性且单身
52.     printf("\nFemales and Single: ");
53.     FilterPersons *females = criteria_female->filter(filter_persons, (Criteria *)criteria_female);
54.     print_persons(((CriteriaSingle *)criteria_single)->filter(females, criteria_single));
56.     // 查询男性男性单身
57.     printf("\nSingle Males: ");
58.     // 逐个条件过滤，与下面AndCriteria效果相同
59.     FilterPersons *single_males = ((CriteriaMale *)criteria_male)->filter(filter_persons, criteria_male);
60.     print_persons(((CriteriaSingle *)criteria_single)->filter(single_males, criteria_single));
61.     printf("\nSingle Males: ");
62.     // 通过AndCriteria来过滤
63.     FilterPersons *single_males2 = ((AndCriteria *)single_male)->filter(filter_persons, single_male);
64.     print_persons(single_males2);
66.     // 查询女性或单身
67.     printf("\nSingle Or Females: ");
68.     print_persons(single_or_female->filter(filter_persons, (Criteria *)single_or_female));
70.     free(filter_persons);
71.     free(criteria_male);
72.     free(criteria_female);
73.     free(criteria_single);
74.     free(single_male);
75.     free(single_or_female);
77.     return 0;

复制代码

 
 
更多语言版本

不同语言实现设计模式：https://github.com/microwind/design-pattern

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！