拦截过滤器模式和数据规则

拦截过滤器模式

拦截过滤器模式（Intercepting Filter Pattern）用于对应用程序的请求或响应做一些预处理/后处理。定义过滤器，并在把请求传给实际目标应用程序之前应用在请求上。过滤器可以做认证/授权/记录日志，或者跟踪请求，然后把请求传给相应的处理程序。以下是这种设计模式的实体。

  • 过滤器（Filter） - 过滤器在请求处理程序执行请求之前或之后，执行某些任务。
  • 过滤器链（Filter Chain） - 过滤器链带有多个过滤器，并在 Target 上按照定义的顺序执行这些过滤器。
  • Target - Target 对象是请求处理程序。
  • 过滤管理器（Filter Manager） - 过滤管理器管理过滤器和过滤器链。
  • 客户端（Client） - Client 是向 Target 对象发送请求的对象。

实现

我们将创建 FilterChain、FilterManager、Target、Client 作为表示实体的各种对象。AuthenticationFilter 和 DebugFilter 表示实体过滤器。

InterceptingFilterDemo，我们的演示类使用 Client 来演示拦截过滤器设计模式。

拦截过滤器模式的 UML 图

步骤 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: HOME

Executing request: HOME


==================================
过滤器模式（Filter Pattern）或标准模式（Criteria Pattern）是一种设计模式，这种模式允许开发人员使用不同的标准来过滤一组对象，通过逻辑运算以解耦的方式把它们连接起来。这种类型的设计模式属于结构型模式，它结合多个标准来获得单一标准。
实现
我们将创建一个 Person 对象、Criteria 接口和实现了该接口的实体类，来过滤 Person 对象的列表。CriteriaPatternDemo，我们的演示类使用 Criteria 对象，基于各种标准和它们的结合来过滤 Person 对象的列表。
过滤器模式（Filter/Criteria Pattern）的 UML 图
步骤 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.过滤器集合