拦截过滤器模式
拦截过滤器模式（Intercepting Filter Pattern）用于对应用程序的请求或响应做一些预处理/后处理。定义过滤器，并在把请求传给实际目标应用程序之前应用在请求上。过滤器可以做认证/授权/记录日志，或者跟踪请求，然后把请求传给相应的处理程序。以下是这种设计模式的实体。
- 过滤器（Filter） - 过滤器在请求处理程序执行请求之前或之后，执行某些任务。
- 过滤器链（Filter Chain） - 过滤器链带有多个过滤器，并在 Target 上按照定义的顺序执行这些过滤器。
- Target - Target 对象是请求处理程序。
- 过滤管理器（Filter Manager） - 过滤管理器管理过滤器和过滤器链。
- 客户端（Client） - Client 是向 Target 对象发送请求的对象。
实现
我们将创建 FilterChain、FilterManager、Target、Client 作为表示实体的各种对象。AuthenticationFilter 和 DebugFilter 表示实体过滤器。
InterceptingFilterDemo，我们的演示类使用 Client 来演示拦截过滤器设计模式。
步骤 1
创建过滤器接口 Filter。
Filter.java
|
1
2
3
|
public
interface
Filter {
public
void
execute(String request);
}
|
步骤 2
创建实体过滤器。
AuthenticationFilter.java
|
1
2
3
4
5
|
public
class
AuthenticationFilter
implements
Filter {
public
void
execute(String request){
System.out.println(
"Authenticating request: "
+ request);
}
}
|
DebugFilter.java
|
1
2
3
4
5
|
public
class
DebugFilter
implements
Filter {
public
void
execute(String request){
System.out.println(
"request log: "
+ request);
}
}
|
步骤 3
创建 Target。
Target.java
|
1
2
3
4
5
|
public
class
Target {
public
void
execute(String request){
System.out.println(
"Executing request: "
+ request);
}
}
|
步骤 4
创建过滤器链。
FilterChain.java
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
import
java.util.ArrayList;
import
java.util.List;
public
class
FilterChain {
private
List<Filter> filters =
new
ArrayList<Filter>();
private
Target target;
public
void
addFilter(Filter filter){
filters.add(filter);
}
public
void
execute(String request){
for
(Filter filter : filters) {
filter.execute(request);
}
target.execute(request);
}
public
void
setTarget(Target target){
this
.target = target;
}
}
|
步骤 5
创建过滤管理器。
FilterManager.java
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
public
class
FilterManager {
FilterChain filterChain;
public
FilterManager(Target target){
filterChain =
new
FilterChain();
filterChain.setTarget(target);
}
public
void
setFilter(Filter filter){
filterChain.addFilter(filter);
}
public
void
filterRequest(String request){
filterChain.execute(request);
}
}
|
步骤 6
创建客户端 Client。
Client.java
|
1
2
3
4
5
6
7
8
9
10
11
|
public
class
Client {
FilterManager filterManager;
public
void
setFilterManager(FilterManager filterManager){
this
.filterManager = filterManager;
}
public
void
sendRequest(String request){
filterManager.filterRequest(request);
}
}
|
步骤 7
使用 Client 来演示拦截过滤器设计模式。
FrontControllerPatternDemo.java
|
1
2
3
4
5
6
7
8
9
10
11
|
public
class
InterceptingFilterDemo {
public
static
void
main(String[] args) {
FilterManager filterManager =
new
FilterManager(
new
Target());
filterManager.setFilter(
new
AuthenticationFilter());
filterManager.setFilter(
new
DebugFilter());
Client client =
new
Client();
client.setFilterManager(filterManager);
client.sendRequest(
"HOME"
);
}
}
|
步骤 8
验证输出。
Authenticating request: HOME request log: HOMEExecuting request: HOME
==================================
过滤器模式（Filter Pattern）或标准模式（Criteria Pattern）是一种设计模式，这种模式允许开发人员使用不同的标准来过滤一组对象，通过逻辑运算以解耦的方式把它们连接起来。这种类型的设计模式属于结构型模式，它结合多个标准来获得单一标准。
实现
我们将创建一个 Person 对象、Criteria 接口和实现了该接口的实体类，来过滤 Person 对象的列表。CriteriaPatternDemo，我们的演示类使用 Criteria 对象，基于各种标准和它们的结合来过滤 Person 对象的列表。
步骤 1
创建一个类，在该类上应用标准。
Person.java
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
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
|
1
2
3
4
5
|
import
java.util.List;
public
interface
Criteria {
public
List<Person> meetCriteria(List<Person> persons);
}
|
步骤 3
创建实现了 Criteria 接口的实体类。
CriteriaMale.java
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
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
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
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
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
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
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
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
|
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
|
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
|
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
|
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 ]http://www.ziqiangxuetang.com/design-pattern/filter-pattern.html
管道过滤器模式的软件体系结构及其设计
http://wenku.baidu.com/link?url=QF1pG6DGMtl2uV1yt998xCduKsiEO7Bwn4CW79g0nx6EUw4iNgcBUz_jAA1W0FigotA66GKCLyve0Q0X61fI1uaVY8vXmOqNbjS9IKhyt2a
责任链设计模式（过滤器、拦截器）
http://blog.csdn.net/z69183787/article/details/43451413
数据规则：拦截过滤器模式（true和false）,过滤器变少的对象，责任链找个人来处理。层级关系类似，返回来请求不同，终节点不同。 政策集合，航班集合，过滤器集合，三个集合计算。1.航班集合；2.政策集合，3.过滤器集合
4565
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
