精华内容
下载资源
问答
  • 本文首发至java技术博客【码上】:码上​jdkcb.com设计模式开源笔记项目github链接(欢迎star):hanshuaikang/design-pattern-java​github.com过滤器模式定义:过滤器模式(Filter Pattern)或标准模式(Criteria Pattern)...

    本文首发至java技术博客【码上】:码上​jdkcb.com

    设计模式开源笔记项目github链接(欢迎star):hanshuaikang/design-pattern-java​github.comd408db5a7517b738c8d774453a4ea38e.png

    过滤器模式定义:

    过滤器模式(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)是一种设计模式,这种模式允许开发人员使用不同的标准来过滤一组对象,通过逻辑运算以解耦的方式把它们连接起来。这种类型的设计模式...

    在这里插入图片描述

    过滤器模式定义:

    过滤器模式(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框架都使用了拦截过滤器模式用于拦截某些请求,而其他的就更数不胜数了。毕竟在讲一个设计模式的过程中代码使用了这种设计模式的实现这种情况还是很少见的。

    欢迎关注~我们下一篇文章见!

    展开全文
  • Java过滤器模式

    2019-01-09 15:38:39
    过滤器模式用于对一组对象实现过滤。 首先定义一个过滤器接口。 然后为过滤器接口提供不同的实现。 再通过装饰器模式,允许不同的过滤器实现各种组合,如逻辑与逻辑或等。 示例代码: import java.lang....

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

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

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

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

    示例代码:

    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());
    		}
    
    	}
    
    }

    本例演示了过滤器模式

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

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

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

    展开全文
  • 拦截过滤器模式(Intercepting Filter Pattern)用于对应用程序的请求或响应做一些预处理/后处理。定义过滤器,并在把请求传给实际目标应用程序之前应用在请求上。过滤器可以做认证/授权/记录日志,或者跟踪请求,...

    目录

    拦截过滤模式

    拦截过滤器模式(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

    代码地址

    拦截过滤模式

    系列导航

    系列导航

    展开全文
  • 过滤器模式或条件模式是一种设计模式,使开发人员可以使用不同的条件过滤一组对象,并通过逻辑操作以解耦方式将其链接。 这种类型的设计模式属于结构模式,因为该模式组合多个标准以获得单个标准。实现实现我们将...
  • 过滤器模式是一种设计模式,使开发人员可以使用不同的条件过滤一组对象,并通过逻辑操作以解耦方式将其链接。 这种类型的设计模式属于结构模式,因为该模式组合多个标准以获得单个标准。 实现 主要有3个角色 请求...
  • 过滤器模式(Filter Pattern)或标准模式(Criteria Pattern)是一种设计模式,这种模式允许开发人员使用不同的标准来过滤一组对象,通过逻辑运算以解耦的方式把它们连接起来。这种类型的设计模式属于结构型模式,它...
  • Java过滤器模式(条件模式) 过滤器模式或条件模式是一种设计模式,使开发人员可以使用不同的条件过滤一组对象,并通过逻辑操作以解耦方式将其链接。 这种类型的设计模式属于结构模式,因为该模式组合多个标准以...
  • 过滤器模式 实际案例 定义 测试 实现方式 UML &amp; Code UML Code 系列导航 过滤器模式 过滤器模式(Filter Pattern)或标准模式(Criteria Pattern)是一种设计模式,这种模式允许开发人员使用不同...
  • Tomcat容器以及一些Web框架都使用了责任链设计模式来对请求和响应进行逐步的处理或者过滤,本文使用Java语言来模拟过滤器实现。其序列图如下: 如果简单的使用责任链模式,用一个List来实现层层过滤,则会...
  • 管道-过滤器结构模式简介代码实现1、定义一个管道接口2、定义一个管道上下文流转抽象3、定义一个抽象阀门4、实现管道接口5、定义阀门按照业务逻辑组装管道-阀门 简介 在管道和过滤器软件体系结构中,每个模块都有一个...
  • Java过滤器设计模式,是针对一组数据按指定规则进行过滤,比如我们的实体类中有很多的属性,若存在某些属性就或不存在某些属性,我们进行移除或者保留 在网上找的一个例子 public class Person { private String ...
  • 过滤器模式或条件模式是一种设计模式,使开发人员可以使用不同的条件过滤一组对象,并通过逻辑操作以解耦方式将其连接,这种类型的设计模式属于结构模式,因为该模式组合多个标准以获得单个标准。 我们将创建一个...
  • 过滤器模式可以帮助开发者根据一些条件来选择对象,也可以是这些条件的组合。本例创建一个Person类,和Criteria接口,以及具体的实现。 public class Person { private String name; private String gender; ...
  • 这种模式允许开发人员使用不同的标准来过滤一组对象,通过逻辑运算以解耦的方式把他们连接在一起。 2 person对象,Criteria接口和实现该接口的实体类,来过滤Persond对象的列表。 样例: //对person类进行过滤 ...
  • 过滤器模式 过滤器模式(Filter Pattern)或标准模式(Criteria Pattern)是一种设计模式,这种模式允许开发人员使用不同的标准来过滤一组对象,通过逻辑运算以解耦的方式把它们连接起来。这种类型的设计模式属于...
  • 过滤器模式:通过给定对象过滤属性过滤对象,相对比较简单(简单实现如下):提供一个具体的实体对象类:提供一个基于接口的过滤实现类:注:省略接口...
  • java设计模式—过滤器模式 一.概述 过滤模式又叫责任链模式,可以通过不同的过滤规则过滤一组对象。 二.模式示例: 我们以过滤学生成绩60以下的为例,说明过滤器模式具体实现过程: 1.创建学生类 public...
  • 过滤器模式 定义 过滤器模式(Filter Pattern)或标准模式(CriteriaPattern)是一种设计模式,这种模式允许开发人员使用不同的标准来过滤一组对象,通过逻辑运算以解耦的方式把它们连接起来。这种类型的设计模式...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 455
精华内容 182
热门标签
关键字:

java实现过滤器模式

java 订阅