管道或者过滤器模式（Filter Pattern）或是一种设计模式，这种模式允许开发人员使用不同的标准来过滤一组对象，通过逻辑运算以解耦的方式把它们连接起来。

过滤器模式.jpg

应用

最广泛的应用就是Web框架：

image.png

解析 HTTP 消息，包括 HTTP 消息头及消息体。
接着，我们需要对接收的数据做一次安全校验，常见的安全校验包括 XSS 过滤、CSRF Token 校验等。
再接着，我们需要识别当前访问的用户是谁，一般会拆分成会话解析及登录态校验，会话解析只负责解析会话数据，而会话数据一般都是存放在缓存系统，像 redis、kv 等，登录态校验则会从会话数据中取出用户信息，如果用户信息不存在，说明用户未登录，那么，服务端会返回一个重定向响应，浏览器会根据响应 header 头里面的 location 字段，跳转到 location 指定的登录页地址。

引例

• person 对象

class Person {
    friend bool operator< (const Person& lhs, const Person& rhs);
public:
    Person(const string& name, const string& gender, const string& maritalStatus):
            _name(name), _gender(gender), _maritalStatus(maritalStatus) 
    {
    }
    const string& getName() const   {   return _name;   }
    const string& getGender() const     {   return _gender; }
    const string& getMaritalStatus() const  {   return _maritalStatus;  }
private:
    string _name;
    string _gender;
    string _maritalStatus;
};

bool operator< (const Person& lhs, const Person& rhs)
{
    return lhs._name < rhs._name;
}

• Criteria 接口

class Criteria {
public:
    virtual vector<Person> meetCriteria(const vector<Person>& persons) = 0;
};

现在我们有一个 Person 对象、我们希望能按照要求过滤 Person 对象。
将我们的过滤过程分为两部分：筛选器（接受所有项并且只返回某些项的过程）和规范（应用于数据元素的谓词的定义）。

• 规范

  template <typename T> 
  struct Specification
  {
      virtual bool is_satisfied(T* item) = 0;
  };
  

• 过滤标准

  template <typename T> 
  struct Filter
  {
      virtual vector<T*> filter(vector<T*> items, Specification<T>& spec) = 0;
  };
  
  struct BetterFilter : Filter<Person>
  {
      vector<Product*> filter(vector<Product*> items, Specification<Product>& spec) override
      {
          vector<Product*> result;
          for (auto& p : items) 
          {
              if (spec.is_satisfied(p))
                  result.push_back(p);
          }
          return result;
      }
  };
  

// 过滤男性 
class CriteriaMale : public Criteria {
public:
    vector<Person> meetCriteria(const vector<Person>& persons) {
        vector<Person> vec;
        for (const auto& it : persons)
            if (it.getGender() == "Male")
                vec.push_back(it);
        return vec;
    }
};

// 过滤女性 
class CriteriaFemale : public Criteria {
public:
    vector<Person> meetCriteria(const vector<Person>& persons) {
        vector<Person> vec;
        for (const auto& it : persons)
            if (it.getGender() == "Female")
                vec.push_back(it);
        return vec;
    }
};

// 过滤已婚 
class CriteriaMarried : public Criteria {
public:
    vector<Person> meetCriteria(const vector<Person>& persons) {
        vector<Person> vec;
        for (const auto& it : persons)
            if (it.getMaritalStatus() == "Married")
                vec.push_back(it);
        return vec;
    }
};

// 过滤未婚 
class CriteriaSingle : public Criteria {
public:
    vector<Person> meetCriteria(const vector<Person>& persons) {
        vector<Person> vec;
        for (const auto& it : persons)
            if (it.getMaritalStatus() == "Single")
                vec.push_back(it);
        return vec;
    }
};

我们还可以判断 operator &&用于两个 Specification<T> 对象，从而使得过滤过程由两个（或更多！）标准。

template <typename T>
struct Specification
{
    virtual bool is_satisfied(T* item) = 0;
    
    AndSpecification<T> operator &&(Specification&& other)
    {
        return AndSpecification<T>(*this, other);
    }
};
auto green_and_big = ColorSpecification(Color::Green) && SizeSpecification(Size::Large);

• 还可以通过逻辑运算连接多个标准过滤

// 2个标准同时满足
class AndCriteria : public Criteria {
public:
    AndCriteria(Criteria* one, Criteria* two): criteriaPtr(one), otherCriteriaPtr(two)  {

    }

    virtual vector<Person> meetCriteria(const vector<Person>& persons) {
        return otherCriteriaPtr->meetCriteria(criteriaPtr->meetCriteria(persons));
    }
private:
    Criteria* criteriaPtr;
    Criteria* otherCriteriaPtr;
};

// 2个标准满足一个
class OrCriteria : public Criteria {
public:
    OrCriteria(Criteria* one, Criteria* two): criteriaPtr(one), otherCriteriaPtr(two)   {

    }

    virtual vector<Person> meetCriteria(const vector<Person>& persons) {
        vector<Person> vec = criteriaPtr->meetCriteria(persons);
        vector<Person> vec2 = otherCriteriaPtr->meetCriteria(persons);
        set<Person> set(vec.begin(), vec.end());
        for (const auto& person : vec2)
            if (set.find(person) == set.end())
                vec.push_back(person);

        return vec;
    }
private:
    Criteria* criteriaPtr;
    Criteria* otherCriteriaPtr;
};

• 测试

vector<Person> persons;
persons.push_back(Person("lipan", "Male", "Single"));
persons.push_back(Person("wangrong", "Male", "Single"));
persons.push_back(Person("wuyuhang", "Male", "Married"));
persons.push_back(Person("pengxiaowen", "Female", "Single"));

CriteriaMale criteriaMale;
CriteriaSingle criteriaSingle;
// 筛选男性
criteriaMale.meetCriteria(persons)
// 筛选女性未婚
AndCriteria singleMale(&criteriaSingle, &criteriaMale)

参考资料
过滤模式：http://www.runoob.com/design-pattern/filter-pattern.html