过滤器模式

---

---

过滤器模式

1. 介绍

过滤器模式（Filter Pattern）是一种结构型模式。过滤器模式提供了多种过滤接口，你可以将这些过滤接口进行组合来达到你想要的过滤效果。

简单理解：有一个饮水机的滤芯(接口)，它有大小，只有符合大小的过滤器才能装入，现在有木炭过滤器(实现类)、细菌过滤器(实现类)、杂质过滤器(实现类)、异味吸附器(实现类)这几种过滤器，它们都和滤芯的大小一样。所以，你可以随意将这些过滤器进行组合来达到不同的过滤效果。

2. 例子

类图：

Criteria接口
是所以过滤器类都必须实现的接口，其中有一个方法filtered()方法，这个方法中的过滤规则和过滤逻辑由实现了这个接口的类来实现。

package filterPattern;

import java.util.List;

public interface Criteria {
    public List<Person> filtered(List<Person> personList);
}
1
2
3
4
5
6
7

Adult类
一个过滤器类，实现了Criteria接口，将所有的age小于18的Person对象过滤掉。

package filterPattern;

import java.util.ArrayList;
import java.util.List;

public class Adult implements Criteria {

    @Override
    public List<Person> filtered(List<Person> personList) {
        List<Person> temList = new ArrayList<Person>();
        for (Person person : personList) {
            if (person.getAge() >= 18) {
                temList.add(person);
            }
        }
        return temList;
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

FirstNameIsLi类
这个过滤器实现了Criteria接口，将名字的姓氏不为Li的Person对象过滤掉。

package filterPattern;

import java.util.ArrayList;
import java.util.List;

public class FirstNameIsLi implements Criteria {

    @Override
    public List<Person> filtered(List<Person> personList) {
        List<Person> temList = new ArrayList<Person>();
        for (Person person : personList) {
            if(person.getName().split(" ")[0].equals("Li")) {
                temList.add(person);
            }
        }
        return temList;
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

AndFilter类
这个过滤器类可以实现两个过滤器过滤效果的且功能，只要两个过滤器其中的一个可以过滤这个对象，那么这个对象将会被过滤。

package filterPattern;

import java.util.List;

public class AndFilter implements Criteria {
    private Criteria criteria1;
    private Criteria criteria2;

    public AndFilter(Criteria criteria1, Criteria criteria2) {
        this.criteria1 = criteria1;
        this.criteria2 = criteria2;
    }

    @Override
    public List<Person> filtered(List<Person> personList) {
        personList = criteria1.filtered(personList);
        return criteria2.filtered(personList);
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

OrFilter过滤器类
这个过滤器类可以将两个过滤器的过滤功能取或，只要两个过滤器不能都过滤，那么就不过滤。

package filterPattern;

import java.util.ArrayList;
import java.util.List;

public class OrFilter implements Criteria {
    private Criteria criteria1;
    private Criteria criteria2;

    public OrFilter(Criteria criteria1, Criteria criteria2) {
        this.criteria1 = criteria1;
        this.criteria2 = criteria2;
    }

    @Override
    public List<Person> filtered(List<Person> personList) {
        List<Person> temList = new ArrayList<Person>();
        List<Person> personFilteredList = criteria1.filtered(personList);
        for (Person person : personFilteredList) {
            if(!personList.contains(person)) {
                temList.add(person);
            }
        }
        personFilteredList = criteria2.filtered(personList);
        for (Person person : personFilteredList) {
            if(!personList.contains(person)) {
                temList.add(person);
            }
        }
        return temList;
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

Person类
装入ArrayList中的对象

package filterPattern;

public class Person {
    private String name;
    private Integer age;
    private Integer height;
    private Integer weight;

    public Person() {
    }

    public Person(String name, Integer age, Integer height, Integer weight) {
        super();
        this.name = name;
        this.age = age;
        this.height = height;
        this.weight = weight;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Integer getHeight() {
        return height;
    }

    public void setHeight(Integer height) {
        this.height = height;
    }

    public Integer getWeight() {
        return weight;
    }

    public void setWeight(Integer weight) {
        this.weight = weight;
    }

    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + ", height=" + height + ", weight=" + weight + "]";
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }

        if (obj == null || getClass() != obj.getClass()) {
            return false;
        }

        Person person = (Person) obj;
        if (person.getName() == null | getName() == null) {
            return false;
        } else {
            return getName().equalsIgnoreCase(person.getName()) && person.getAge() == age
                    && person.getHeight() == height && person.getWeight() == weight;
        }

    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

测试类
创建一个ArrayList，在其中放入Person对象，再创建几个过滤类来过滤这个ArrayList，看看结果和我们预料的过滤结果是否一样。

package filterPattern;
import java.util.ArrayList;
import java.util.List;

import org.junit.Test;

public class TestJ {
    @Test
    public void test1() {
        //创建一个用来存储Person的ArrayList
        List<Person> personList = new ArrayList<Person>();
        
        //向数组中添加Person对象
        personList.add(new Person("Li hong", 34, 170, 57));
        personList.add(new Person("Sun lie", 23, 176, 60));
        personList.add(new Person("Liu xiao", 13, 167, 65));
        personList.add(new Person("Li ming", 12, 182, 67));
        
        //创建一个成年人过滤器对象
        Criteria adultFiltered = new Adult();
        //打印过滤后的ArrayList
        System.out.println(adultFiltered.filtered(personList).toString());
        
        //创建一个姓氏为Li的过滤器
        Criteria firstNameIsLi = new FirstNameIsLi();
        //打印过滤后的ArrayList
        System.out.println(firstNameIsLi.filtered(personList).toString());
        
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

运行结果：

[Person [name=Li hong, age=34, height=170, weight=57], Person [name=Sun lie, age=23, height=176, weight=60]]
[Person [name=Li hong, age=34, height=170, weight=57], Person [name=Li ming, age=12, height=182, weight=67]]
1
2

3. 总结

过滤器模式就是定义一个过滤接口，所有的过滤类都来实现这个接口，并实现其中的过滤逻辑。然后，将这些过滤类组合起来达到我们想要的过滤效果。