Qu'est-ce qu'un modèle de filtre

Le modèle de filtre est un modèle de conception structurel qui vous permet de traiter des chaînes d'objets à l'aide de différents critères (filtres) pour connecter les demandes aux processus. Le mode Filtre est utile lorsque vous devez filtrer des objets selon différentes conditions de filtre.

Pourquoi utiliser le modèle de filtre

L'utilisation du mode filtre peut nous rendre plus flexible et plus pratique lorsque nous opérons sur des collections d'objets. Il peut filtrer dynamiquement des objets en fonction de différentes conditions de filtrage et renvoyer la collection d'objets filtrés. De plus, le mode filtre peut également nous aider à réduire le couplage du code, rendant le code plus concis et facile à entretenir.

Où l'utilisez-vous au travail

Dans Android, le mode filtre est généralement utilisé pour gérer le filtrage des données dans les contrôles de liste tels que ListView et RecyclerView. Par exemple, nous pouvons filtrer les données de la liste à travers les mots-clés entrés par l'utilisateur, ou filtrer les données en fonction de certains attributs des données. De plus, il existe certaines bibliothèques sous Android telles que RxJava qui fournissent également l'implémentation du mode filtre.

Idées de conception

Dans le modèle de filtre, nous définissons une interface Filter, qui contient une méthode filter(), qui reçoit une requête et renvoie une requête filtrée.

Nous devons également définir une classe FilterChain qui maintient une liste de filtres et fournit une méthode addFilter() pour ajouter des filtres. Lorsqu'une requête est transmise à FilterChain, elle sera traitée tour à tour par la méthode filter() de chaque filtre.

Enfin, nous devons définir une classe Request qui contient certaines propriétés que nous devons filtrer. Lorsqu'il est utilisé côté client, nous pouvons créer un objet Request et le transmettre à FilterChain pour traitement.

Implémentation du code du modèle de filtre

Voici un exemple d'implémentation d'un modèle de filtre simple :
Tout d'abord, nous définissons l'interface de filtre :

public interface Filter {
    
    
    void filter(Request request, FilterChain filterChain);
}

Ensuite, nous définissons la classe FilterChain :

public class FilterChain {
    
    
    private List<Filter> filters = new ArrayList<>();
    private int index = 0;

    public FilterChain addFilter(Filter filter) {
    
    
        filters.add(filter);
        return this;
    }

    public void doFilter(Request request) {
    
    
        if (index >= filters.size()) {
    
    
            return;
        }
        Filter filter = filters.get(index);
        index++;
        filter.filter(request, this);
    }
}

Ensuite, nous définissons la classe Request :

public class Request {
    
    
    private String keyword;
    private int price;

    public Request(String keyword, int price) {
    
    
        this.keyword = keyword;
        this.price = price;
    }

    public String getKeyword() {
    
    
        return keyword;
    }

    public int getPrice() {
    
    
        return price;
    }
}

Enfin, nous définissons deux filtres :

public class KeywordFilter implements Filter {
    
    
    private String keyword;

    public KeywordFilter(String keyword) {
    
    
        this.keyword = keyword;
    }

    @Override
    public void filter(Request request, FilterChain filterChain) {
    
    
        if (request.getKeyword().contains(keyword)) {
    
    
            filterChain.doFilter(request);
        }
    }
}

public class PriceFilter implements Filter {
    
    
    private int maxPrice;

    public PriceFilter(int maxPrice) {
    
    
        this.maxPrice = maxPrice;
    }

    @Override
    public void filter(Request request, FilterChain filterChain) {
    
    
        if (request.getPrice() <= maxPrice) {
    
    
            filterChain.doFilter(request);
        }
    }
}

Le client utilise le modèle de filtre comme suit :

public static void main(String[] args) {
    
    
    Request request = new Request("phone", 1000);
    FilterChain filterChain = new FilterChain();
    filterChain.addFilter(new KeywordFilter("phone"))
            .addFilter(new PriceFilter(900));
    filterChain.doFilter(request);
}

Dans le code ci-dessus, nous avons d'abord créé un objet Request et défini deux filtres : KeywordFilter et PriceFilter. Ensuite, ajoutez ces deux filtres à la FilterChain et appelez la méthode doFilter() pour filtrer la requête.

Résumer

Le modèle de filtre est un modèle de conception simple et pratique qui peut nous aider à filtrer dynamiquement les collections d'objets et à réduire le couplage de code. Dans le développement Android, le mode filtre est généralement utilisé pour traiter le filtrage des données de la liste, ce qui est très pratique.

Modèle de conception "Motif de filtre"

------ "Mode filtre"