设计模式-过滤器模式

过滤器模式（Filter Pattern）是一种常见的结构型设计模式，可以在不改变原有逻辑或引入复杂流程的情况下，实现对于一些对象的筛选过滤。

适用场景

过滤器模式通常适用于以下情况：

• 当需要在一组对象中，根据特定条件筛选出符合条件的对象时，可以使用过滤器模式。
• 当需要实现多种过滤器对象，而且这些过滤器可以灵活组合，达到不同的筛选效果时，可以使用过滤器模式。
• 当需要对一组对象进行多次筛选操作时，可以使用过滤器模式。

实现过程

过滤器模式的实现涉及以下角色：

• 抽象过滤器（Filter）：声明了一个筛选方法，用于判断给定的对象是否符合筛选条件。
• 具体过滤器（ConcreteFilter）：实现了抽象过滤器中的筛选方法，用于具体的对象筛选。
• 过滤器链（FilterChain）：聚合了多个具体过滤器，并提供了一个筛选方法，用于进行筛选操作。
• 客户端（Client）：使用过滤器链进行对象筛选操作。

UML图

下面是过滤器模式的UML类图：

classDiagram
    class Filter {
        <<interface>>
        +execute(List<T> list): List<T>
    }
    class ConcreteFilterA {
        -condition: string
    }
    class ConcreteFilterB {
        -condition: int
    }
    class FilterChain {
        -filters: List<Filter>
        +addFilter(Filter filter): void
        +execute(List<T> list): List<T>
    }
    class Client {
        +main(): void
    }

    ConcreteFilterA --|> Filter
    ConcreteFilterB --|> Filter
    FilterChain --> Filter
    FilterChain --> List
    Client --> FilterChain

代码实现

下面是一个Java语言的过滤器模式的例子：

抽象过滤器：

public interface Filter<T> {
    List<T> execute(List<T> list);
}

具体过滤器A：

public class ConcreteFilterA<T> implements Filter<T> {
    private final String condition;

    public ConcreteFilterA(String condition) {
        this.condition = condition;
    }

    @Override
    public List<T> execute(List<T> list) {
        return list.stream()
                .filter(item -> item.toString().contains(condition))
                .collect(Collectors.toList());
    }
}

具体过滤器B：

public class ConcreteFilterB<T> implements Filter<T> {
    private final int condition;

    public ConcreteFilterB(int condition) {
        this.condition = condition;
    }

    @Override
    public List<T> execute(List<T> list) {
        return list.stream()
                .filter(item -> item.hashCode() % condition == 0)
                .collect(Collectors.toList());
    }
}

过滤器链：

public class FilterChain<T> {
    private final List<Filter<T>> filters = new ArrayList<>();

    public void addFilter(Filter<T> filter) {
        this.filters.add(filter);
    }

    public List<T> execute(List<T> list) {
        List<T> result = list;
        for (Filter<T> filter : filters) {
            result = filter.execute(result);
        }
        return result;
    }
}

客户端：

public class Client {
    public static void main(String[] args) {
        List<String> data = Arrays.asList("Java", "Filter", "Pattern", "Demo");

        FilterChain<String> filterChain = new FilterChain<>();
        filterChain.addFilter(new ConcreteFilterA<>("Java"));
        filterChain.addFilter(new ConcreteFilterB<>(3));

        List<String> result = filterChain.execute(data);

        System.out.println(result); // Output: [Java]
    }
}

优缺点

优点

• 可以灵活地组合多个过滤器对象，扩展性很好。
• 可以在不改变原有代码的情况下，实现对于一些对象的筛选过滤。

缺点

• 使用过滤器模式会引入额外的对象和类，增加了代码的复杂度。
• 过多的过滤器可能会导致程序效率降低，应该注意过滤器的数量和操作。

总结

过滤器模式是一个常见的结构型设计模式，适用于需要对一组对象进行筛选操作的场景。虽然使用过滤器模式会引入额外的对象和类，增加了代码的复杂度，但可以灵活地组合多个过滤器对象，扩展性很好，可以在不改变原有代码的情况下，实现对于一些对象的筛选过滤。在使用过滤器模式时应该注意过滤器的数量和操作，以避免影响程序效率。