本文首发至java技术博客【码上】:码上​jdkcb.com
设计模式开源笔记项目github链接(欢迎star):hanshuaikang/design-pattern-java​github.com
过滤器模式定义:
过滤器模式(Filter Pattern)或标准模式(Criteria Pattern)是一种设计模式，这种模式允许开发人员使用不同的标准来过滤一组对象，通过逻辑运算以解耦的方式把它们连接起来。这种类型的设计模式属于结构型模式，它结合多个标准来获得单一标准。
优/缺点:
优点:简单，解耦，使用方便。
缺点:查了资料发现这货竟然没什么缺点？算了，日后补充吧
这绝对是我见过的最没存在感的设计模式了。
应用场景:当需要对某一组对象进行筛选的时候(比如女澡堂只让女生进，男澡堂只让男生进)
应用案例:Spring MVC 中的过滤器，用来过滤掉某些请求。
微剧场:
阿呆上学的时候，有一次需要分组，男生一组，女生一组，没了。
这就没了？你，，你这次也太短了吧
靠，你才短，这个设计模式真的想不出来什么情节帮助你们加深理解啊，因为太容易理解了，直接看代码就能看懂，我是编不出来了。
我太难了
代码实战：
首先新建一个Person，代表班级里每个人物，同时，设置姓名和性别两个属性。
public class Person {
private String name;//姓名    private String gender;//性别
public Person(String name, String gender) {
this.name = name;
this.gender = gender;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
@Override
public String toString() {
return "Person [name=" + name + ", gender=" + gender + "]";
}
}
第二步，老规矩，面向接口编程，新建一个Ifilter对象，规范我们后续过滤器的行为：
public interface IFilter {
public List filter(List persons);
}
新建两个实现，根据性别过滤相关的对象。
public class GirlFilter implements IFilter {
@Override
public List filter(List persons) {
return persons.stream().filter(person ->
person.getGender().equals("男")
).collect(Collectors.toList());
}
}
public class BoyFilter implements IFilter {
@Override
public List filter(List persons) {
return persons.stream().filter(person ->
person.getGender().equals("男")
).collect(Collectors.toList());
}
}
你写的是啥过滤器模式，你咋不写个人家那种的，菜就是菜
不要在意这些细节
细节决定成败
我.
测试:
public class Test {
public static void main(String[] args) {
List persons = new LinkedList<>();
for (int i = 0; i < 10 ; i++) {
if (i<5) {
persons.add(new Person(String.valueOf(i), "男"));
}else {
persons.add(new Person(String.valueOf(i), "女"));
}
}
IFilter boyFilter = new BoyFilter();
//筛选出男同胞们         persons = boyFilter.filter(persons);
persons.forEach(person->System.out.println(person.toString()));
}
}
输出：
Person [name=0, gender=男]
Person [name=1, gender=男]
Person [name=2, gender=男]
Person [name=3, gender=男]
Person [name=4, gender=男]
总结:
本篇笔记较为简单的说明了过滤器模式的应用场景及其实现，麻雀虽小五脏俱全，过滤器模式虽然简单，但是因为实际开发中需要过滤的场景还是比较多的，所以经常能看到它的身影，比如最常见的SpringMVC Struts2等web框架都使用了拦截过滤器模式用于拦截某些请求，而其他的就更数不胜数了。毕竟在讲一个设计模式的过程中代码使用了这种设计模式的实现这种情况还是很少见的。
大家好，我是韩数，欢迎大家关注我，我们下篇文章再见。

过滤器模式定义:
过滤器模式（Filter Pattern）或标准模式（Criteria Pattern）是一种设计模式，这种模式允许开发人员使用不同的标准来过滤一组对象，通过逻辑运算以解耦的方式把它们连接起来。这种类型的设计模式属于结构型模式，它结合多个标准来获得单一标准。
优/缺点:
优点：

简单，解耦，使用方便。

缺点：

查了资料发现这货竟然没什么缺点？

算了，日后补充吧 这绝对是我见过的最没存在感的设计模式了。
应用场景:

当需要对某一组对象进行筛选的时候（比如女澡堂只让女生进，男澡堂只让男生进）

应用案例:

Spring MVC 中的过滤器，用来过滤掉某些请求。

微剧场:
阿呆上学的时候，有一次需要分组，男生一组，女生一组，没了。
这就没了？你，，你这次也太短了吧
靠，你才短，这个设计模式真的想不出来什么情节帮助你们加深理解啊，因为太容易理解了，直接看代码就能看懂，我是编不出来了。
我太难了
代码实战：
首先新建一个Person，代表班级里每个人物，同时，设置姓名和性别两个属性。
public class Person {
​
​
 private String name;//姓名
 private String gender;//性别
 
 
 public Person(String name, String gender) {
 this.name = name;
 this.gender = gender;
 }
 
 
 public String getName() {
 return name;
 }
 public void setName(String name) {
 this.name = name;
 }
 public String getGender() {
 return gender;
 }
 public void setGender(String gender) {
 this.gender = gender;
 }
​
​
 @Override
 public String toString() {
 return "Person [name=" + name + ", gender=" + gender + "]";
 }
​
​
}
​
​

第二步，老规矩，面向接口编程，新建一个Ifilter对象，规范我们后续过滤器的行为：
public interface IFilter {
 
 public List<Person> filter(List<Person> persons);
 
}

新建两个实现，根据性别过滤相关的对象。
public class GirlFilter implements IFilter {
​
 @Override
 public List<Person> filter(List<Person> persons) {
 return persons.stream().filter(person ->
 person.getGender().equals("男")
 ).collect(Collectors.toList());
 }
​
}
​
​
public class BoyFilter implements IFilter {
​
 @Override
 public List<Person> filter(List<Person> persons) {
 return persons.stream().filter(person ->
 person.getGender().equals("男")
 ).collect(Collectors.toList());
 }
 
}
​

你写的是啥过滤器模式，你咋不写个人家那种的，菜就是菜
不要在意这些细节
细节决定成败 我？
测试:
public class Test {
 
 public static void main(String[] args) {
 List<Person> persons = new LinkedList<>();
 
 
 for (int i = 0; i < 10 ; i++) {
 if (i<5) {
 persons.add(new Person(String.valueOf(i), "男"));
 }else {
 persons.add(new Person(String.valueOf(i), "女"));
 }
 }
 
 
 IFilter boyFilter = new BoyFilter();
 //筛选出男同胞们
 persons = boyFilter.filter(persons);
 persons.forEach(person->System.out.println(person.toString()));
 
 
 }
 
​
}
​

输出：
Person [name=0, gender=男]
Person [name=1, gender=男]
Person [name=2, gender=男]
Person [name=3, gender=男]
Person [name=4, gender=男]

总结:
本篇笔记较为简单的说明了过滤器模式的应用场景及其实现，麻雀虽小五脏俱全，过滤器模式虽然简单，但是因为实际开发中需要过滤的场景还是比较多的，所以经常能看到它的身影，比如最常见的SpringMVC Struts2等web框架都使用了拦截过滤器模式用于拦截某些请求，而其他的就更数不胜数了。毕竟在讲一个设计模式的过程中代码使用了这种设计模式的实现这种情况还是很少见的。
欢迎关注~我们下一篇文章见！

过滤器模式用于对一组对象实现过滤。

首先定义一个过滤器接口。

然后为过滤器接口提供不同的实现。

再通过装饰器模式，允许不同的过滤器实现各种组合，如逻辑与逻辑或等。

示例代码：

import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

// 集合元素
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;
	}
}

// 标准过滤器抽象类,采用泛型，对Collection的具体类型没有限制，对Collection中的元素类型也没有限制
abstract class MyFilter<T> {
	public abstract Collection<T> filter(Collection<T> mySet);

	@SuppressWarnings("unchecked")
	protected Collection<T> getCache(Collection<T> mySet) {
		Collection<T> result = null;
		try {
			// 反射
			result = mySet.getClass().getDeclaredConstructor().newInstance();
		} catch (InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException
				| NoSuchMethodException | SecurityException e) {
			e.printStackTrace();
		}
		return result;
	}
}

// 实现过滤器接口
class MyFilterMale extends MyFilter<Person> {
	public Collection<Person> filter(Collection<Person> mySet) {
		Collection<Person> result = getCache(mySet);
		if (result != null) {
			for (Person person : mySet) {
				if (person.getGender().equalsIgnoreCase("MALE")) {
					result.add(person);
				}
			}
		}
		return result;
	}
}

// 实现过滤器接口
class MyFilterSingle extends MyFilter<Person> {
	public Collection<Person> filter(Collection<Person> mySet) {
		Collection<Person> result = getCache(mySet);
		if (result != null) {
			for (Person person : mySet) {
				if (person.getMaritalStatus().equalsIgnoreCase("SINGLE")) {
					result.add(person);
				}
			}
		}
		return result;
	}
}

// 实现逻辑与过滤，采用泛型实现，可以重用，同时是装饰模式
class MyFilterLogicAnd<T> extends MyFilter<T> {
	private MyFilter<T> con1;
	private MyFilter<T> con2;

	public MyFilterLogicAnd(MyFilter<T> con1, MyFilter<T> con2) {
		this.con1 = con1;
		this.con2 = con2;
	}

	public Collection<T> filter(Collection<T> mySet) {
		return con2.filter(con1.filter(mySet));
	}
}

//实现逻辑或过滤，采用泛型实现，可以重用，同时是装饰模式
class MyFilterLogicOr<T> extends MyFilter<T> {
	private MyFilter<T> con1;
	private MyFilter<T> con2;

	public MyFilterLogicOr(MyFilter<T> con1, MyFilter<T> con2) {
		this.con1 = con1;
		this.con2 = con2;
	}

	public Collection<T> filter(Collection<T> mySet) {
		Collection<T> temp1 = getCache(mySet);
		Collection<T> temp2 = getCache(mySet);
		Collection<T> result = getCache(mySet);
		if (temp1 != null) {
			temp1 = con1.filter(mySet);
			temp2 = con2.filter(mySet);
			for (T item : temp1) {
				if (!(result.contains(item))) {
					result.add(item);
				}
			}
			for (T item : temp2) {
				if (!(result.contains(item))) {
					result.add(item);
				}
			}
		}
		return result;
	}
}

public class Filter {

	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"));

		List<Person> malePersons = (List<Person>) new MyFilterMale().filter(persons);
		System.out.println("==========All Male==========");
		for (Person p : malePersons) {
			System.out.println(p.getName());
		}

		List<Person> maleAndSinglePersons = (List<Person>) new MyFilterLogicAnd<Person>(new MyFilterMale(),
				new MyFilterSingle()).filter(persons);
		System.out.println("==========All Male And Single==========");
		for (Person p : maleAndSinglePersons) {
			System.out.println(p.getName());
		}

		List<Person> maleOrSinglePersons = (List<Person>) new MyFilterLogicOr<Person>(new MyFilterMale(),
				new MyFilterSingle()).filter(persons);
		System.out.println("==========All Male Or Single==========");
		for (Person p : maleOrSinglePersons) {
			System.out.println(p.getName());
		}

	}

}

本例演示了过滤器模式

为了提高代码的可重用性及扩展性，用到了装饰器模式

同样，为了提高代码的可重用性，用到了泛型及反射机制。

当然如果处理的数据量比较大，还应该考虑多线程实现。

目录



目录
拦截过滤模式
实际案例

定义
测试


实现方式
UML & Code

UML
Code


系列导航






拦截过滤模式

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


过滤器（Filter）


过滤器在请求处理程序执行请求之前或之后，执行某些任务。


过滤器链（Filter Chain） 


过滤器链带有多个过滤器，并在 Target 上按照定义的顺序执行这些过滤器。



实际案例

类信息概览：




  
类名
  
说明



  
Main.java
  
方法的总入口


  
FilterChain.java
  
过滤器链


  
ValidFilter.java
  
校验过滤


  
AuthFilter.java
  
验证过滤


  
Filter.java
  
过滤接口






定义


FilterChain.java




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 * Copyright (c) 2012-2018. houbinbini Inc.
 * design-pattern All rights reserved.
 */

package com.ryo.design.pattern.note.interceptingFilter;

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

/**
 * <p> </p>
 *
 * <pre> Created: 2018/5/29 下午5:24  </pre>
 * <pre> Project: design-pattern  </pre>
 *
 * @author houbinbin
 * @version 1.0
 * @since JDK 1.7
 */
public class FilterChain implements Filter {

    private List<Filter> filterList = new ArrayList<>();

    public FilterChain addFilter(Filter filter) {
        filterList.add(filter);
        return this;
    }


    @Override
    public Filter filter(String info) {
        for(Filter filter : this.filterList) {
            filter.filter(info);
        }
        return this;
    }

}



ValidFilter.java




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 * Copyright (c) 2012-2018. houbinbini Inc.
 * design-pattern All rights reserved.
 */

package com.ryo.design.pattern.note.interceptingFilter;

/**
 * <p> </p>
 *
 * <pre> Created: 2018/5/29 下午5:22  </pre>
 * <pre> Project: design-pattern  </pre>
 *
 * @author houbinbin
 * @version 1.0
 * @since JDK 1.7
 */
public class ValidFilter implements Filter {

    @Override
    public Filter filter(String info) {
        System.out.println("[Valid]: "+info);
        return this;
    }

}



AuthFilter.java




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 * Copyright (c) 2012-2018. houbinbini Inc.
 * design-pattern All rights reserved.
 */

package com.ryo.design.pattern.note.interceptingFilter;

/**
 * <p> 权限过滤器 </p>
 *
 * <pre> Created: 2018/5/29 下午5:22  </pre>
 * <pre> Project: design-pattern  </pre>
 *
 * @author houbinbin
 * @version 1.0
 * @since JDK 1.7
 */
public class AuthFilter implements Filter {

    @Override
    public Filter filter(String info) {
        System.out.println("[Auth]: "+info);
        return this;
    }

}



Filter.java




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 * Copyright (c) 2012-2018. houbinbini Inc.
 * design-pattern All rights reserved.
 */

package com.ryo.design.pattern.note.interceptingFilter;

/**
 * <p> </p>
 *
 * <pre> Created: 2018/5/29 下午5:22  </pre>
 * <pre> Project: design-pattern  </pre>
 *
 * @author houbinbin
 * @version 1.0
 * @since JDK 1.7
 */
public interface Filter {

    /**
     * 执行过滤信息
     * @param info 原始信息
     * @return 过滤器本身
     */
    Filter filter(final String info);

}




测试


Main.java




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 * Copyright (c) 2012-2018. houbinbini Inc.
 * design-pattern All rights reserved.
 */

package com.ryo.design.pattern.note.interceptingFilter;

/**
 * <p> </p>
 *
 * <pre> Created: 2018/5/29 下午5:20  </pre>
 * <pre> Project: design-pattern  </pre>
 *
 * @author houbinbin
 * @version 1.0
 * @since JDK 1.7
 */
public class Main {

    public static void main(String[] args) {
        FilterChain filterChain = new FilterChain();
        filterChain.addFilter(new AuthFilter())
                .addFilter(new ValidFilter());
        filterChain.filter("filtered info");
    }

}



测试结果




[Auth]: filtered info
[Valid]: filtered info



实现方式



UML & Code



UML

UML 图示如下



Code

代码地址


  
拦截过滤模式




系列导航


  
系列导航