Java23种设计模式之过滤器模式

深藏阁楼爱情的钟 2021-09-21 23:34 360阅读 0赞

### 1，背景 ###

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

### 二，实现 ###

被过滤的对象

/**
     * 被过滤的对象
     */
    public class Person {
    
        /**
         * 姓名
         */
        private String name;
    
        /**
         * 性别 MALE FEMALE
         */
        private String gender;
    
        /**
         * 婚姻状况: SINGLE MARRIED
         */
        private String marital;
    
        public Person(String name, String gender, String marital) {
            this.name = name;
            this.gender = gender;
            this.marital = marital;
        }
    
        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;
        }
    
        public String getMarital() {
            return marital;
        }
    
        public void setMarital(String marital) {
            this.marital = marital;
        }
    }

过滤器接口

import java.util.List;
    
    /**
     * 过滤器接口
     */
    public interface IFilter {
    
        List<Person> filter(List<Person> persons);
    }

过滤器

/**
     * 男生过滤器
     */
    public class MaleFilter implements IFilter {
    
        @Override
        public List<Person> filter(List<Person> persons) {
            return persons.stream().filter(person -> person.getGender().equals("MALE")).collect(Collectors.toList());
        }
    
    }
    
    /**
     * 女生过滤器
     */
    public class MarriedFilter implements IFilter {
    
        @Override
        public List<Person> filter(List<Person> persons) {
            return persons.stream().filter(person -> person.getGender().equals("MARRIED")).collect(Collectors.toList());
        }
    
    }
    
    /**
     * 已婚过滤器
     *
     * @author xiaowen
     */
    public class MarryFilter implements IFilter {
    
        @Override
        public List<Person> filter(List<Person> persons) {
            return persons.stream().filter(person -> person.getMarital().equals("MARRIED")).collect(Collectors.toList());
        }
    
    }
    
    /**
     * 未婚过滤器
     *
     * @author xiaowen
     */
    public class SingleFilter implements IFilter {
    
        @Override
        public List<Person> filter(List<Person> persons) {
            return persons.stream().filter(person -> person.getMarital().equals("SINGLE")).collect(Collectors.toList());
        }
    }

处理并且逻辑的组合条件过滤器

import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.List;
    
    /**
     * 处理并且逻辑的组合条件过滤器
     */
    public class FilterAnd implements IFilter {
    
        private List<IFilter> filters;
    
        public FilterAnd(IFilter... filter) {
            filters = Arrays.asList(filter);
        }
    
        @Override
        public List<Person> filter(List<Person> persons) {
            List<Person> filter = new ArrayList<>(persons);
            for (IFilter x : filters) {
                filter = x.filter(filter);
            }
            return filter;
        }
    
    }

测试

public class TestMain {
    
        public static void main(String[] args) {
    
            // 初始化数据
            List<Person> persons = new ArrayList<>();
            persons.add(new Person("霍一", "FEMALE", "MARRIED"));
            persons.add(new Person("邓二", "MALE", "MARRIED"));
            persons.add(new Person("张三", "MALE", "SINGLE"));
            persons.add(new Person("李四", "FEMALE", "MARRIED"));
            persons.add(new Person("王五", "MALE", "SINGLE"));
            persons.add(new Person("赵六", "FEMALE", "SINGLE"));
            persons.add(new Person("孙七", "MALE", "SINGLE"));
            persons.add(new Person("罗八", "MALE", "MARRIED"));
            persons.add(new Person("刘九", "FEMALE", "SINGLE"));
            persons.add(new Person("史十", "FEMALE", "SINGLE"));
    
            System.out.println("---------------获取所有的男性信息------------------");
            List<Person> maleList = new MaleFilter().filter(persons);
            maleList.forEach(male -> {
                System.out.println(male.getName() + "-" + male.getGender() + "-" + male.getMarital());
            });
            System.out.println("---------------获取所有单身------------------");
            List<Person> singleList = new SingleFilter().filter(persons);
            singleList.forEach(single -> {
                System.out.println(single.getName() + "-" + single.getGender() + "-" + single.getMarital());
            });
            System.out.println("--------------------所有单身的男性-------------------");
            List<Person> singleAndMale = new FilterAnd(new MaleFilter(), new SingleFilter()).filter(persons);
            singleAndMale.forEach(result -> {
                System.out.println(result.getName() + "-" + result.getGender() + "-" + result.getMarital());
            });
            System.out.println("--------------------所有已婚的男性-------------------");
            List<Person> marryList = new FilterAnd(new MaleFilter(), new MarryFilter()).filter(persons);
            marryList.forEach(marrayAndMale -> {
                System.out.println(marrayAndMale.getName() + "-" + marrayAndMale.getGender() + "-" + marrayAndMale.getMarital());
            });
        }
    }

> \---------------获取所有的男性信息------------------  
> 邓二-MALE-MARRIED  
> 张三-MALE-SINGLE  
> 王五-MALE-SINGLE  
> 孙七-MALE-SINGLE  
> 罗八-MALE-MARRIED  
> \---------------获取所有单身------------------  
> 张三-MALE-SINGLE  
> 王五-MALE-SINGLE  
> 赵六-FEMALE-SINGLE  
> 孙七-MALE-SINGLE  
> 刘九-FEMALE-SINGLE  
> 史十-FEMALE-SINGLE  
> \--------------------所有单身的男性-------------------  
> 张三-MALE-SINGLE  
> 王五-MALE-SINGLE  
> 孙七-MALE-SINGLE  
> \--------------------所有已婚的男性-------------------  
> 邓二-MALE-MARRIED  
> 罗八-MALE-MARRIED