过滤器模式是一种设计模式，使开发人员可以使用不同的条件过滤一组对象，并通过逻辑操作以解耦方式将其链接。 这种类型的设计模式属于结构模式，因为该模式组合多个标准以获得单个标准。
 
实现
 
主要有3个角色
 
请求实体类
 
/**
 * 请求类，模拟一次请求
 * 有名字和信息两个属性，根据实际情况自定义
 * @author tiancaixiaoniuniu
 * @date 2019/4/12  15:13
 */
public class Request {
    private String name;
    private String info="";

    public Request(String name, int num) {
        this.name = name;
        this.num = num;
    }

    //一个条件数值，用来过滤条件判断
    private int num;

    //get set方法略
   }
 
过滤器：自定义方法对请求进行判断拦截数据加工等操作
 
/**
 * 过滤器接口
 * @author tiancaixiaoniuniu
 * @date 2019/4/12  15:11
 */
public interface Filter {
    /**
     *对请求进行一次过滤或者处理
     * 如果继续执行后面的过滤器，返回true，否则返回false
     * @param request    请求类
     */
    public boolean execute(Request request);
}
 
/**
 * @author tiancaixiaoniuniu
 * @date 2019/4/12  15:48
 */
public class Filter_A implements Filter{
    @Override
    public boolean execute( Request request) {
        System.out.println("请求"+request.getName()+"正在执行Filter_A过滤器-----------------------");
        //对请求进行判断
        if (request!=null&&request.getNum()>10){
            System.out.println(request.getInfo()+"通过了Filter_A过滤器,继续执行下一个");
            request.setInfo(request.getInfo()+"通过了Filter_A过滤器 ");
            return true;
        }else if (request!=null){
            request.setInfo(request.getInfo()+"未通过了Filter_A过滤器,停止执行\n");
        }
        return false;
    }
}
 
/**
 * @author tiancaixiaoniuniu
 * @date 2019/4/12  15:48
 */
public class Filter_B implements Filter{
    @Override
    public boolean execute( Request request) {
        System.out.println("请求"+request.getName()+"正在执行Filter_B过滤器-----------------------");
        //对请求进行判断
        if (request!=null&&request.getNum()>20){
            System.out.println(request.getInfo()+"通过了Filter_B过滤器,继续执行下一个");
            request.setInfo(request.getInfo()+"通过了Filter_B过滤器 ");
            return true;
        }else if (request!=null){
            request.setInfo(request.getInfo()+"未通过了Filter_B过滤器,停止执行\n");
        }
        return false;
    }
}
 
/**
 * @author tiancaixiaoniuniu
 * @date 2019/4/12  15:48
 */
public class Filter_C implements Filter{
    @Override
    public boolean execute( Request request) {
        System.out.println("请求"+request.getName()+"正在执行Filter_C过滤器-----------------------");
        //对请求进行判断
        if (request!=null&&request.getNum()>30){
            System.out.println(request.getInfo()+"通过了Filter_C过滤器,继续执行下一个");
            request.setInfo(request.getInfo()+"通过了Filter_C过滤器 ");
            return true;
        }else if (request!=null){
            request.setInfo(request.getInfo()+"未通过了Filter_C过滤器,停止执行\n");
        }
        return false;
    }
}
 
 
 
过滤器容器：存储多个过滤器，可以自定义执行顺序和数量，并使请求执行过滤器列表
 
/**
 * 过滤器容器类   用来管理过滤器
 * @author tiancaixiaoniuniu
 * @date 2019/4/12  15:16
 */
public class FilterContainer {
    private List<Filter> list=new ArrayList<>();
    //设置要执行的过滤器列表
    public void setFilterList(List<Filter> list){
        this.list=list;
    }
    //执行过滤器
    public void doFilter(Request request){
        for (Filter filter:list) {
            //如果返回false,结束执行
            if (!filter.execute( request)){
                break;
            }
        }
        System.out.println("执行完成！");
    }
}
 
客户端执行
 
/**
 * @author tiancaixiaoniuniu
 * @date 2019/4/12  16:25
 */
public class Client {
    public static void main(String[] args) {
        //配置过滤器执行列表
        List<Filter> list=new ArrayList<>();
        list.add(new Filter_A());
        list.add(new Filter_B());
        list.add(new Filter_C());
        //加载过滤器容器
        FilterContainer filterContainer=new FilterContainer();
        filterContainer.setFilterList(list);
        //请求
        Request request1=new Request("请求1",25);
        Request request2=new Request("请求2",35);
        filterContainer.doFilter(request1);
        System.out.println(request1.getInfo());
        filterContainer.doFilter(request2);
        System.out.println(request2.getInfo());
    }
}
 
执行结果：
 
 
 
 
*原创作品，转载请表明出处。有建议或者问题欢迎联系我，QQ1595787997
 
 
 
 
 
 
 
 
 
 
 

过滤器模式用于对一组对象实现过滤。
 
首先定义一个过滤器接口。
 
然后为过滤器接口提供不同的实现。
 
再通过装饰器模式，允许不同的过滤器实现各种组合，如逻辑与逻辑或等。
 
示例代码：
 
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());
		}

	}

}
 
本例演示了过滤器模式
 
为了提高代码的可重用性及扩展性，用到了装饰器模式
 
同样，为了提高代码的可重用性，用到了泛型及反射机制。
 
当然如果处理的数据量比较大，还应该考虑多线程实现。

 
管道-过滤器结构模式
 
简介
代码实现
1、定义一个管道接口
2、定义一个管道上下文流转抽象
3、定义一个抽象阀门
4、实现管道接口
5、定义阀门
按照业务逻辑组装管道-阀门
 

 
简介
 
在管道和过滤器软件体系结构中,每个模块都有一个输入和一个输出。它采用流水线的方式对数据进行作业。类似我们生活中的管道，过滤器相当于管道上的阀门。我们在每个阀门上进行一定的数据计算，并将得到的结果传递给下个阀门。这种有序的数据处理就是我们所说的管道-过滤器模式。
 它的优点在于可以将整个计算提示分解为多个计算行为的叠加组合，通过管道过滤器结构我们可以将复杂的计算分解，达到化烦为简的目的。同时任意两个过滤只要他们遵守同样的要约，那么他们就可以进行组合，这一点可以提高代码的复用。同时过滤器的顺序可以自由调节，程序设计灵活多变。学习管道过滤器模式我们需要了解两个属于
 Pipeline：管道，相当于车间的生产线，是一套明确的逻辑处理总线。
 Valve： 阀门，相当于生产线上的工人，负责完成各自职责内的工作。
 那么我们如何实现管道过滤器模式呢？
 
代码实现
 
1、定义一个管道接口
 
/**
 * @author FeianLing
 * @date 2019/7/12
 */
public interface Pipeline {
  /**
   * @author FeianLing
   * @date 2019/7/12
   * @desc 设计基础阀门，一个管道必须基本有一个基本阀门
   * @param [bases]
   * @return void
   */
  boolean setBases(AbstractValve valve);
  /**
   * @author FeianLing
   * @date 2019/7/12
   * @desc 添加阀门信息
   * @param [valve]
   * @return void
   */
  boolean addValve(AbstractValve valve);
  /**
   * @author FeianLing
   * @date 2019/7/12
   * @desc 移除管道中的阀门
   * @param [valve]
   * @return void
   */
  boolean removeValve(AbstractValve valve);
  /**
   * @author FeianLing
   * @date 2019/7/12
   * @desc 调用管道处理数据
   * @param []
   * @return void
   */
  void invoke();
}
 
2、定义一个管道上下文流转抽象
 
public interface PipelineContext {
  /**
   * @author FeianLing
   * @date 2019/7/12
   * @desc 调用下一个阀门
   * @param []
   * @return void
   */
  void invokeNext();
}
 
3、定义一个抽象阀门
 
public abstract class AbstractValve {
  /**
   * @author FeianLing
   * @date 2019/7/12
   * @desc 当前阀门需要的处理逻辑
   * @param [context] d.
   * @return void
   */
  abstract void execute(PipelineContext context);

  /**
   * @author FeianLing
   * @date 2019/7/12
   * @desc 调用阀门
   * @param [context]
   * @return void
   */
  void invoke(PipelineContext context) {
    execute(context);
    context.invokeNext();
  }
}

 
4、实现管道接口
 
public class StandardPipeline implements Pipeline {
  /** 阀门集合 */
  private List<AbstractValve> valves;
  /** 基础阀门 */
  private AbstractValve bases;
  /** 管道流转的上下文，可根据业务需要在上下文中加入流转的数据 */
  private PipelineContext context;

  public StandardPipeline() {
    valves = new ArrayList<>();
    context = new StandardPipelineContext();
  }

  @Override
  public boolean setBases(AbstractValve valve) {
    bases = valve;
    return true;
  }

  @Override
  public boolean addValve(AbstractValve valve) {
    return valves.add(valve);
  }

  @Override
  public boolean removeValve(AbstractValve valve) {
    if (valves.contains(valve)) {
      return valves.remove(valve);
    }
    return true;
  }

  @Override
  public void invoke() {
    context.invokeNext();
  }

  /** 定义一个管道上下文内部类 实现管道上下文接口 */
  private class StandardPipelineContext implements PipelineContext {
    int index = 0;

    @Override
    public void invokeNext() {
      if (!valves.isEmpty() && index < valves.size()) {
        valves.get(index++).invoke(context);
      } else {
        bases.execute(context);
      }
    }
  }
}

 
5、定义阀门
 
//首先定义一个基础的阀门
@Slf4j
public class BaseValve extends AbstractValve {
  @Override
  void execute(PipelineContext context) {
    log.info("BaseValve > invoke > {}", context);
  }
}
//下面我们在定义几个阀门来测试
@Slf4j
public class Valve1 extends AbstractValve {
  @Override
  void execute(PipelineContext context) {
    log.info("Valve1 > invoke >{}", context);
  }
}


@Slf4j
public class Valve2 extends AbstractValve {
  @Override
  void execute(PipelineContext context) {
    log.info("Valve2 > invoke > {}", context);
  }
}
@Slf4j
public class Valve3 extends AbstractValve {
  @Override
  void execute(PipelineContext context) {
    log.info("Valve3 > invoke > {}", context);
  }
}
 
按照业务逻辑组装管道-阀门
 
管道组装代码如下所示，我们预期的数据处理流转是 阀门1 -> 阀门3 ->阀门2 -> 基础阀门。
 
public class PipelineTest {
  public static void main(String[] args) {
    StandardPipeline pipeline = new StandardPipeline();
    BaseValve baseValve = new BaseValve();
    Valve1 valve1 = new Valve1();
    Valve2 valve2 = new Valve2();
    Valve3 valve3 = new Valve3();
    pipeline.setBases(baseValve);
    pipeline.addValve(valve1);
    pipeline.addValve(valve3);
    pipeline.addValve(valve2);
    pipeline.invoke();
  }
}

 
通过执行main方法，打印结果如下。
 
 如果你觉得本文还不错，还请不吝打赏。
 

1 Filter Pattern 过滤器模式
 
目的：使用不同的标准来过滤一组对象，通过逻辑运算以解耦的方式把它们连接起来；
 实现：制定不同的规则来对一组对象进行过滤，然后对过滤结果进行分组。
 
 
 
1.结合多个标准来获得单一标准。
 
 
2 实现
 
代码场景：中国移动有很多营销活动，而这些营销活动的对象是有要求的，有的需要判断在网时长，有的需要有最低套餐要求等；
 1.中国移动客户是目标角色；
 2.它不同营销活动的要求是过滤器角色；
 
2.1 代码实现
 
抽象过滤器角色：Filter
 
public interface Filter {
	public List<Consumer> filtrate(List<Consumer> consumers);
}
 
具体过滤器角色：赠送移动宽带过滤器
 
public class BroadbandFilter implements Filter {
	@Override
	public List<Consumer> filtrate(List<Consumer> consumers) {
		List<Consumer> cs = new ArrayList<Consumer>();
		// 手机套餐为138以上 赠送移动宽带100M一年
		for (Consumer c : consumers) {
			if (c.getCombos() >= 138) {
				cs.add(c);
			}
		}
		return cs;
	}
}
 
具体过滤器角色：赠送流量过滤器
 
public class FreeFlowFilter implements Filter {

	@Override
	public List<Consumer> filtrate(List<Consumer> consumers) {
		List<Consumer> cs = new ArrayList<Consumer>();
		// 在网年份大于5年 赠送10G移动流量
		for (Consumer c : consumers) {
			if (c.getExistsYears() >= 5) {
				cs.add(c);
			}
		}
		return cs;
	}
}

 
具体过滤器角色：生日提醒过滤器
 
public class BirthdayRemindFilter implements Filter {

	@Override
	public List<Consumer> filtrate(List<Consumer> consumers) {
		List<Consumer> cs = new ArrayList<Consumer>();
		// 星级为5星级以上 赠送生日提醒
		for (Consumer c : consumers) {
			if (c.getCombos() >= 138) {
				cs.add(c);
			}
		}
		return cs;
	}
}

 
2.2 涉及角色
 
过滤器模式包含如下两个角色：
 
(1) AbstractFilter（抽象过滤器角色）：在客户端可以调用它的方法，在抽象过滤器角色中可以知道相关的（一个或者多个）子系统的功能和责任；在正常情况下，它将所有从客户端发来的请求委派到相应的实现类去，传递给相应的实现类对象处理。
 (2) ConcreteFilter（具体滤器角色）：在客户端可以调用它的方法，在具体滤器角色会对目标对象集合进行逻辑过滤，最后再返回一个过滤后的集合。
 (3) Subject（被过滤角色）：在软件系统中可以有一个或者多个目标角色，在具体过滤器中会对目标角色进行逻辑处理以查看是否是我想要的。
 
2.3 调用
 
调用者：
 
public class Client {

	public static void main(String[] args) {
		Consumer zhangft = new Consumer("张奉天", 1, 5, 138);
		Consumer ruiBo = new Consumer("芮博", 5, 2, 238);
		Consumer zhongJj = new Consumer("仲军军", 10, 4, 1);

		List<Consumer> cs = new ArrayList<Consumer>();
		cs.add(zhangft);
		cs.add(ruiBo);
		cs.add(zhongJj);

		Filter broadbandFilter = new BroadbandFilter();
		Filter freeFlowFilter = new FreeFlowFilter();
		Filter birthdayRemindFilter = new BirthdayRemindFilter();

		System.out.println("移动宽带免费一年用户:");
		List<Consumer> broadband = broadbandFilter.filtrate(cs);
		printList(broadband, "移动宽带");
		System.out.println("免费赠送移动流量用户:");
		List<Consumer> freeFlow = freeFlowFilter.filtrate(cs);
		printList(freeFlow, "流量10G");
		System.out.println("赠送生日提醒用户:");
		List<Consumer> birthdayRemind = birthdayRemindFilter.filtrate(cs);
		printList(birthdayRemind, "生日提醒功能");

	}
	private static void printList(List<Consumer> cs, String bussiness) {
		for (Consumer c : cs) {
			System.out.println("[" + c.getStar() + "]星级用户[" + c.getName()
					+ "],在网[" + c.getExistsYears() + "],当前套餐为[" + c.getCombos()
					+ "],免费赠送[" + bussiness + "]");
		}
	}

}
 
结果:
 
移动宽带免费一年用户:
[5]星级用户[张奉天],在网[1],当前套餐为[138],免费赠送[移动宽带]
[2]星级用户[芮博],在网[5],当前套餐为[238],免费赠送[移动宽带]
免费赠送移动流量用户:
[2]星级用户[芮博],在网[5],当前套餐为[238],免费赠送[流量10G]
[4]星级用户[仲军军],在网[10],当前套餐为[1],免费赠送[流量10G]
赠送生日提醒用户:
[5]星级用户[张奉天],在网[1],当前套餐为[138],免费赠送[生日提醒功能]
[2]星级用户[芮博],在网[5],当前套餐为[238],免费赠送[生日提醒功能]
 
Java设计模式汇总：点击跳转
 代码地址：点击跳转
 
 
 
参考文献：
 [ 1 ] 图解设计模式/(日)结城浩著;杨文轩译。–北京:人民邮电出版社，2017.1.
 [ 2 ] 维基百科 设计模式
 [ 3 ] 极客学院WIKI–设计模式.
 [ 4 ] 菜鸟教程–设计模式.