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

拦截过滤器模式

« 前端控制器模式

服务定位器模式 »

拦截过滤器模式（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: HOMErequest log: HOME
Executing 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.过滤器集合