设计模式学习之过滤器模式

什么是过滤器模式？

        这种模式允许开发人员使用不同的标准来过滤一组对象，通过逻辑运算以解耦的方式把它们连接起来。

过滤器模式的关键是什么？

        过滤器模式比较容易，通过过滤器实现过滤，关键就是我们的filter的逻辑，我们举一个简单的例子，如下图所示：

        我们的computer包括有cpu，memory、disk等，然后我们通过AMDCpuFilter过滤出所有使用AMD牌子CPU的computer。代码如下所示：

Computer类：

public class Computer {

    private String cup;

    private String disk;

    private String memory;

    public Computer(String cup, String disk, String memory) {
        this.cup = cup;
        this.disk = disk;
        this.memory = memory;
    }

    public String getCup() {
        return cup;
    }

    public void setCup(String cup) {
        this.cup = cup;
    }

    public String getDisk() {
        return disk;
    }

    public void setDisk(String disk) {
        this.disk = disk;
    }

    public String getMemory() {
        return memory;
    }

    public void setMemory(String memory) {
        this.memory = memory;
    }

    public void show() {
        System.out.println("computer cpu = " + cup + ", disk = " + disk + ", memory = " + memory);
    }
}

Filter类：

public interface Filter {
    public List<Computer> execute(List<Computer> computerList);
}

AMDCpuFilter

public class AMDCpuFilter implements Filter {

    @Override
    public List<Computer> execute(List<Computer> computerList) {
        List<Computer> interList = Lists.newArrayList();
        for (Computer computer:computerList) {
            if ("AMD".equals(computer.getCup())) {
                interList.add(computer);
            }
        }
        return interList;
    }
}

InterCpuFilter类：

public class InterCpuFilter implements Filter {

    @Override
    public List<Computer> execute(List<Computer> computerList) {
        List<Computer> interList = Lists.newArrayList();
        for (Computer computer:computerList) {
            if ("INTER".equals(computer.getCup())) {
                interList.add(computer);
            }
        }
        return interList;
    }
}

SeagateDiskFilter类：

public class SeagateDiskFilter implements Filter {

    @Override
    public List<Computer> execute(List<Computer> computerList) {
        List<Computer> interList = Lists.newArrayList();
        for (Computer computer:computerList) {
            if ("SEAGATE".equals(computer.getDisk())) {
                interList.add(computer);
            }
        }
        return interList;
    }
}

client代码：

public class FilterDemo {

    public static void main(String[] args) {
        List<Computer> computerList = Lists.newArrayList();
        computerList.add(new Computer("INTER", "WG", "GEIL"));
        computerList.add(new Computer("INTER", "SEAGATE", "KINGSTON"));
        computerList.add(new Computer("AMD", "SEAGATE", "KINGSTON"));
        computerList.add(new Computer("AMD", "TOSHIBA", "HP"));

        AMDCpuFilter amdFilter = new AMDCpuFilter();
        InterCpuFilter interFilter = new InterCpuFilter();
        SeagateDiskFilter seagateFilter = new SeagateDiskFilter();

        List<Computer> amdList = amdFilter.execute(computerList);
        List<Computer> interList = interFilter.execute(computerList);
        List<Computer> seagateList = seagateFilter.execute(computerList);

        System.out.println("AMD:");
        print(amdList);

        System.out.println("INTER");
        print(interList);

        System.out.println("SEAGATE:");
        print(seagateList);
    }

    public static void print(List<Computer> computerList) {
        for (Computer computer:computerList) {
            computer.show();
        }
    }

}

最终输出为：

AMD:
computer cpu = AMD, disk = SEAGATE, memory = KINGSTON
computer cpu = AMD, disk = TOSHIBA, memory = HP
INTER
computer cpu = INTER, disk = WG, memory = GEIL
computer cpu = INTER, disk = SEAGATE, memory = KINGSTON
SEAGATE:
computer cpu = INTER, disk = SEAGATE, memory = KINGSTON
computer cpu = AMD, disk = SEAGATE, memory = KINGSTON

最终我们可以有一个过滤器聚合类进行多聚合器的管理，有FilterChain类：

public class FilterChain {

    private List<Filter> filterList = Lists.newArrayList();

    public void add(Filter filter) {
        filterList.add(filter);
    }

    public List<Computer> execute(List<Computer> computerList) {
        List<Computer> resultList = computerList;
        for (Filter filter:filterList) {
            resultList = filter.execute(resultList);
        }
        return resultList;
    }

}

client类中代码为：

        System.out.println("CHAIN:");
        FilterChain chain = new FilterChain();
        chain.add(new AMDCpuFilter());
        chain.add(new SeagateDiskFilter());
        List<Computer> chainList = chain.execute(computerList);
        print(chainList);

最终结果为：

CHAIN:  
computer cpu = AMD, disk = SEAGATE, memory = KINGSTON