devbox
IT小白
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

设计模式之过滤器模式_过滤器是什么设计模式

作者：IT小白 | 2024-04-24 23:10:46

赞

踩

过滤器是什么设计模式

  1. 定义

过滤器模式（Filter Pattern）又称为标准模式 （Criteria Pattern）是一种设计模式，这种模式允许开发人员使用不同的标准来过滤一组对象，通过运算逻辑以解耦的方式将它们联系起来。这种类型的设计模式属于结构型模式，说白了，就是按条件筛选一组对象出来。

  1. 组成角色

过滤器模式一般有如下角色：

  • 抽象过滤器角色（AbstractFilter）：负责定义过滤器的实现接口，具体的实现还要具体过滤器角色去参与，客户端可以调用抽象过滤器角色中定义好的方法，将客户端的所有请求委派到具体的实现类去，从而让实现类去处理；

  • ConcreteFilter（具体过滤器角色）：该角色负责具体筛选规则的逻辑实现，最后再返回一个过滤后的数据集合，标准的过滤器只对数据做过滤，当然也可以对集合中的数据做某项处理，再将处理后的集合返回；

  • Subject（被过滤的主体角色）：一个软件系统中可以有一个或多个目标角色，在具体过滤器角色中会对指定感兴趣的目标进行处理，以确保后面的数据确实是我想要的。

  1. 示例一

有一队人，进行条件筛选，第一次筛选女性，第二次筛选成年男性，第三次筛选已知性别的人，不符合条件的不进入选中队列。

  • 创建应用标准的类；

  1. /**
  2.  * 1. 创建一个类，在该类上应用该标准
  3.  * @author 程就人生
  4.  * @Date
  5.  */
  6. public class Person {
  7.   
  8.   public Person(String name, String sex, int age) {
  9.     this.name = name;
  10.     this.sex = sex;
  11.     this.age = age;
  12.   }
  13.  
  14.   private String name;
  15.   
  16.   private String sex;
  17.     
  18.   private int age;
  19.  
  20.   public String getName() {
  21.     return name;
  22.   }
  23.  
  24.   public void setName(String name) {
  25.     this.name = name;
  26.   }
  27.  
  28.   public String getSex() {
  29.     return sex;
  30.   }
  31.  
  32.   public void setSex(String sex) {
  33.     this.sex = sex;
  34.   }
  35.   
  36.   public int getAge() {
  37.     return age;
  38.   }
  39.  
  40.   public void setAge(int age) {
  41.     this.age = age;
  42.   }
  43.  
  44.   @Override
  45.   public String toString() {
  46.     return "Person [name=" + name + ", sex=" + sex + ", age=" + age + "]";
  47.   }
  48. }

  • 为标准创建接口；

  1. import java.util.List;
  2. /**
  3.  * 2.为标准创建一个接口
  4.  * @author 程就人生
  5.  * @Date
  6.  */
  7. public interface ICriteria {
  8.  
  9.   public List<Person> filter(List<Person> personList);
  10. }

  • 多个标准接口实现类；

  1. import java.util.List;
  2. /**
  3.  * 3.标准接口实现类
  4.  * @author 程就人生
  5.  * @Date
  6.  */
  7. public class AddCriteria implements ICriteria {
  8.  
  9.   private ICriteria criteria1;
  10.   
  11.   private ICriteria criteria2;  
  12.   
  13.   public AddCriteria(ICriteria criteria1, ICriteria criteria2) {
  14.     this.criteria1 = criteria1;
  15.     this.criteria2 = criteria2;
  16.   }
  17.  
  18.   @Override
  19.   public List<Person> filter(List<Person> personList) {
  20.     List<Person> criteria = criteria1.filter(personList);
  21.     return criteria2.filter(criteria);
  22.   }
  23. }
  24.  
  25. import java.util.List;
  26. import java.util.stream.Collectors;
  27. /**
  28.  * 3.标准接口实现类
  29.  * @author 程就人生
  30.  * @Date
  31.  */
  32. public class AgeCriteria implements ICriteria{
  33.  
  34.   @Override
  35.   public List<Person> filter(List<Person> personList) {
  36.     return personList.stream().filter(person->person.getAge() >=18 ).collect(Collectors.toList());
  37.   }
  38.  
  39. }
  40.  
  41. import java.util.List;
  42. import java.util.stream.Collectors;
  43.  
  44. /**
  45.  * 3.标准接口实现类
  46.  * @author 程就人生
  47.  * @Date
  48.  */
  49. public class FemaleCriteria implements ICriteria{
  50.  
  51.   @Override
  52.   public List<Person> filter(List<Person> personList) {
  53.       return personList.stream().filter(person->person.getSex().equals("女")).collect(Collectors.toList());
  54.   }
  55.  
  56. }
  57.  
  58. import java.util.List;
  59. import java.util.stream.Collectors;
  60.  
  61. /**
  62.  * 3.标准接口实现类
  63.  * @author 程就人生
  64.  * @Date
  65.  */
  66. public class MaleCriteria implements ICriteria{
  67.  
  68.   @Override
  69.   public List<Person> filter(List<Person> personList) {
  70.       return personList.stream().filter(person->person.getSex().equals("男")).collect(Collectors.toList());
  71.   }
  72.  
  73. }
  74.  
  75. import java.util.List;
  76. /**
  77.  * 3.标准接口实现类
  78.  * @author 程就人生
  79.  * @Date
  80.  */
  81. public class OrCriteria implements ICriteria{
  82.  
  83.     private ICriteria criteria1;
  84.   
  85.   private ICriteria criteria2;  
  86.   
  87.   public OrCriteria(ICriteria criteria1, ICriteria criteria2) {
  88.     this.criteria1 = criteria1;
  89.     this.criteria2 = criteria2;
  90.   }
  91.   
  92.   @Override
  93.   public List<Person> filter(List<Person> personList) {
  94.     List<Person> firstCriteriaItems = criteria1.filter(personList);
  95.         List<Person> otherCriteriaItems = criteria2.filter(personList); 
  96.         for (Person person : otherCriteriaItems) {
  97.           if(!firstCriteriaItems.contains(person)){
  98.             firstCriteriaItems.add(person);
  99.           }
  100.        }  
  101.        return firstCriteriaItems;
  102.   }
  103. }

  • 简单应用；

  1. public static void main(String[] argo){
  2.     List<Person> personList = new ArrayList<Person>();
  3.     personList.add(new Person("张三", "女", 20)); 
  4.     personList.add(new Person("老张", "女", 40)); 
  5.     personList.add(new Person("小明", "男", 15)); 
  6.     personList.add(new Person("李四", "男", 30));
  7.     personList.add(new Person("王五", "男", 35));
  8.     personList.add(new Person("王麻子", "未知", 45));
  9.     
  10.     // 女性
  11.     ICriteria femaleCriteria = new FemaleCriteria();
  12.     List<Person> list = femaleCriteria.filter(personList);
  13.     System.out.println("女性为：" + list);
  14.     
  15.     // 成年男性
  16.     ICriteria maleCriteria = new MaleCriteria();
  17.     ICriteria ageCriteria = new AgeCriteria();
  18.     ICriteria addCriteria = new AddCriteria(maleCriteria, ageCriteria);
  19.     list = addCriteria.filter(personList);
  20.     System.out.println("成年男性：" + list);
  21.     
  22.     // 男性或者女性    
  23.     ICriteria orCriteria = new OrCriteria(maleCriteria, femaleCriteria);
  24.     list = orCriteria.filter(personList);
  25.     System.out.println("男性或者女性为：" + list);
  26.     
  27.   }

  • 运行结果

  1. 女性为：[Person [name=张三, sex=女, age=20], Person [name=老张, sex=女, age=40]]
  2. 成年男性：[Person [name=李四, sex=男, age=30], Person [name=王五, sex=男, age=35]]
  3. 男性或者女性为：[Person [name=小明, sex=男, age=15], Person [name=李四, sex=男, age=30], Person [name=王五, sex=男, age=35], Person [name=张三, sex=女, age=20], Person [name=老张, sex=女, age=40]]

  1. 示例二

以垃圾分类为例进行说明，使用不同的垃圾桶进行垃圾分类过滤，“垃圾” 就是我们的被过滤的角色，垃圾桶可以充当我们的绝体过滤器角色，

  • 首先是 “垃圾” 类，也就是我们的被过滤的主体角色：

  1. public class Rubbish {
  2.  
  3.     private String name; // 垃圾名称
  4.  
  5.     private boolean isHarm; // 是否有害垃圾
  6.     private boolean isRecycled; // 是否可回收
  7.     private boolean isDry; // 是否干垃圾
  8.     private boolean isWet; // 是否湿垃圾
  9.  
  10.     public Rubbish(String name, boolean isHarm, boolean isRecycled, boolean isDry, boolean isWet) {
  11.         this.name = name;
  12.         this.isHarm = isHarm;
  13.         this.isRecycled = isRecycled;
  14.         this.isDry = isDry;
  15.         this.isWet = isWet;
  16.     }
  17.     ... getter、setter省略，或者直接使用lombok
  18. }

  • 然后是我们的过滤标准的接口，即抽象过滤器角色：

  1. import java.util.List;
  2.  
  3. public interface Criteria {
  4.     // 定义过滤的标准
  5.     List<Rubbish> rubbishFilter(List<Rubbish> rubbishes);
  6. }

  • 我们继续创建实现了 Criteria 接口的几个实体类：

  1. // 干垃圾
  2. public class DryRubbishCriteria implements Criteria{
  3.  
  4.     @Override
  5.     public List<Rubbish> rubbishFilter(List<Rubbish> rubbishes) {
  6.         List<Rubbish> rubbishList = new ArrayList<>();
  7.         for (Rubbish rubbish: rubbishes) {
  8.             // 这里只过滤出所有干垃圾
  9.             if (rubbish.isDry()) {
  10.                 rubbishList.add(rubbish);
  11.             }
  12.         }
  13.         return rubbishList;
  14.     }
  15. }
  16. ...
  17. // 有害垃圾
  18. public class HarmfulRubbishCriteria implements Criteria{
  19.  
  20.     @Override
  21.     public List<Rubbish> rubbishFilter(List<Rubbish> rubbishes) {
  22.         List<Rubbish> rubbishList = new ArrayList<>();
  23.         for (Rubbish rubbish: rubbishes) {
  24.             // 这里只过滤出所有有害垃圾
  25.             if (rubbish.isHarm()) {
  26.                 rubbishList.add(rubbish);
  27.             }
  28.         }
  29.         return rubbishList;
  30.     }
  31. }
  32. ...
  33. // 可回收垃圾
  34. public class RecycledRubbishCriteria implements Criteria{
  35.  
  36.     @Override
  37.     public List<Rubbish> rubbishFilter(List<Rubbish> rubbishes) {
  38.         List<Rubbish> rubbishList = new ArrayList<>();
  39.         for (Rubbish rubbish: rubbishes) {
  40.             // 这里只过滤出所有可回收垃圾
  41.             if (rubbish.isRecycled()) {
  42.                 rubbishList.add(rubbish);
  43.             }
  44.         }
  45.         return rubbishList;
  46.     }
  47. }
  48. ...
  49. // 湿垃圾
  50. public class WetRubbishCriteria implements Criteria{
  51.  
  52.     @Override
  53.     public List<Rubbish> rubbishFilter(List<Rubbish> rubbishes) {
  54.         List<Rubbish> rubbishList = new ArrayList<>();
  55.         for (Rubbish rubbish: rubbishes) {
  56.             // 这里只过滤出所有湿垃圾
  57.             if (rubbish.isWet()) {
  58.                 rubbishList.add(rubbish);
  59.             }
  60.         }
  61.         return rubbishList;
  62.     }
  63. }

  • 使用不同的标准（Criteria）来过滤 Rubbish 对象的列表：

  1. import java.util.ArrayList;
  2. import java.util.List;
  3.  
  4. public class Main {
  5.  
  6.     public static void main(String[] args) {
  7.         // 原始数据集合
  8.         List<Rubbish> rubbishList = new ArrayList<>();
  9.         rubbishList.add(new Rubbish("果壳", false, false, true, false));
  10.         rubbishList.add(new Rubbish("陶瓷", false, false, true, false));
  11.         rubbishList.add(new Rubbish("菜根菜叶", false, false, false, true));
  12.         rubbishList.add(new Rubbish("果皮", false, false, false, true));
  13.         rubbishList.add(new Rubbish("水银温度计", true, false, false, false));
  14.         rubbishList.add(new Rubbish("电池", true, false, false, false));
  15.         rubbishList.add(new Rubbish("灯泡", true, false, false, false));
  16.         rubbishList.add(new Rubbish("废纸塑料", false, true, false, false));
  17.         rubbishList.add(new Rubbish("金属和布料", false, true, false, false));
  18.         rubbishList.add(new Rubbish("玻璃", false, true, false, false));
  19.  
  20.         // 四种不同的过滤标准
  21.         Criteria dryRubbishCriteria = new DryRubbishCriteria();
  22.         Criteria wetRubbishCriteria = new WetRubbishCriteria();
  23.         Criteria harmfulRubbishCriteria = new HarmfulRubbishCriteria();
  24.         Criteria recycledRubbishCriteria = new RecycledRubbishCriteria();
  25.  
  26.         System.out.println("干垃圾: ");
  27.         printRubbishes(dryRubbishCriteria.rubbishFilter(rubbishList));
  28.  
  29.         System.out.println("湿垃圾: ");
  30.         printRubbishes(wetRubbishCriteria.rubbishFilter(rubbishList));
  31.  
  32.         System.out.println("有害垃圾: ");
  33.         printRubbishes(harmfulRubbishCriteria.rubbishFilter(rubbishList));
  34.  
  35.         System.out.println("可回收垃圾: ");
  36.         printRubbishes(recycledRubbishCriteria.rubbishFilter(rubbishList));
  37.     }
  38.  
  39.     private static void printRubbishes(List<Rubbish> rubbishes) {
  40.         for (Rubbish rubbish: rubbishes) {
  41.             System.out.println(rubbish);
  42.         }
  43.     }
  44.  
  45. }

  • 结果如下

  1. 干垃圾: 
  2. Rubbish{name='果壳', isHarm=false, isRecycled=false, isDry=true, isWet=false}
  3. Rubbish{name='陶瓷', isHarm=false, isRecycled=false, isDry=true, isWet=false}
  4.  
  5. 湿垃圾: 
  6. Rubbish{name='菜根菜叶', isHarm=false, isRecycled=false, isDry=false, isWet=true}
  7. Rubbish{name='果皮', isHarm=false, isRecycled=false, isDry=false, isWet=true}
  8.  
  9. 有害垃圾: 
  10. Rubbish{name='水银温度计', isHarm=true, isRecycled=false, isDry=false, isWet=false}
  11. Rubbish{name='电池', isHarm=true, isRecycled=false, isDry=false, isWet=false}
  12. Rubbish{name='灯泡', isHarm=true, isRecycled=false, isDry=false, isWet=false}
  13.  
  14. 可回收垃圾: 
  15. Rubbish{name='废纸塑料', isHarm=false, isRecycled=true, isDry=false, isWet=false}
  16. Rubbish{name='金属和布料', isHarm=false, isRecycled=true, isDry=false, isWet=false}
  17. Rubbish{name='玻璃', isHarm=false, isRecycled=true, isDry=false, isWet=false}

  1. 过滤器模式的特点：

  • 可插拔：过滤器的设计概念要求其是支持可插拔设计的；

  • 有序性：过滤器是被设计为一组组的过滤装置，要实现数据过滤，就必须有顺序性要求，比如我们要设计编解码过滤器，用户请求过来的 xml 数据会优先通过 xml2json 过滤器进行数据处理，完了再在响应发出前进行相应的 json2xml 过滤处理，以保证客户端交互以 xml 数据格式为准的同时系统内部数据交互还是维持 json 格式不变；

  • 过滤器的独立性：每种过滤器必须是独立的实体，其状态不受其它过滤器的影响，每个过滤器都有自己独立的数据输入输出接口，只要各个过滤器之间传送的数据遵守共同的规约就可以相连接。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/IT小白/article/detail/482035
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号