Aller au contenu
S'identifier S’abonner
Back — Java — developpeur — Programmation Fonctionnelle

Programmation Fonctionnelle en Java : Partie 3 - interfaces fonctionnelles

Depuis Java 8, les interfaces fonctionnelles et les expressions lambda ont révolutionné la manière de coder en Java. Découvrez comment ces outils puissants permettent de simplifier votre code, d'améliorer sa lisibilité et de tirer parti des API modernes comme Stream, Optional et CompletableFuture.

,   and  Guillaume Fourny
6 lecture min
Interfaces fonctionnelles

Introduction : La vraie raison de la révolution

Lorsque Java 8 a été introduit en 2014, beaucoup ont salué l'arrivée des API Stream, Optional et CompletableFuture comme les grandes innovations de cette version. Mais la véritable révolution réside ailleurs : dans les interfaces fonctionnelles et leur implémentation via les expressions lambda.

Ces interfaces ont permis à Java d'adopter un paradigme plus fonctionnel, rendant possible l'émergence d'API modernes et performantes. Sans elles, des fonctionnalités comme les pipelines de traitement de données avec Stream ou les combinaisons de tâches asynchrones avec CompletableFuture n’auraient jamais vu le jour.

Les interfaces fonctionnelles sont la base de beaucoup d'API dans l'OpenJDK, c'est grâce à elles que le langage évolue et que les API continuent de s'enrichir. Si en Java nous avons une nouvelle API pour l'API Stream, l'API Gatherer, c'est encore grâce aux interfaces fonctionnelles.

Ainsi, après avoir vu les fondamentaux de la programmation fonctionnelle et découvert en profondeur l'API Stream et l'API Collector, devenons maître des interfaces fonctionnelle !

Si vous êtes un.e développeur.se Java, maîtriser ces concepts est indispensable pour rester pertinent.e dans un écosystème en constante évolution.

Les interfaces fonctionnelles - votre boîte à outils

Les interfaces fonctionnelles : plus que des Lambdas

Une interface fonctionnelle est une interface qui ne contient qu'une seule méthode abstraite. Cette caractéristique unique permet de les implémenter à l'aide d'expressions lambda, rendant le code plus concis et lisible. En Java, le package java.util.function fournit plus de 40 interfaces fonctionnelles prêtes à l'emploi.

Voici les interfaces fonctionnelles les plus couramment utilisées et leurs cas d'usage :

1. Function<T, R> - La transformation

L'interface Function<T, R> représente une fonction qui prend un argument de type T et retourne un résultat de type R. Elle est idéale pour des transformations métier.

Transformations courantes :

private final Function<Order, OrderDTO> orderToDto = order -> 
    new OrderDTO(order.getId(), order.getCustomer().getName(), order.getAmount());

private final Function<String, Customer> findCustomerByEmail = email ->
    customerRepository.findByEmail(email)
        .orElseThrow(() -> new CustomerNotFoundException(email));

Function

Composition de fonctions :

private final Function<BigDecimal, BigDecimal> applyVAT = amount ->
    amount.multiply(new BigDecimal("1.20"));

public Function<Order, BigDecimal> calculateFinalPrice() {
    return Order::getAmount
        .andThen(this::applyDiscount)
        .andThen(applyVAT)
        .andThen(this::roundToNearestCent);
}

private BigDecimal applyDiscount(BigDecimal amount) {
    return amount.multiply(new BigDecimal("0.9")); // -10%
}

private BigDecimal roundToNearestCent(BigDecimal amount) {
    return amount.setScale(2, RoundingMode.HALF_UP);
}

Composition de fonctions

Pattern : fabrique de fonctions

public static Function<BigDecimal, BigDecimal> createDiscountCalculator(BigDecimal discountRate) {
    return amount -> amount.multiply(BigDecimal.ONE.subtract(discountRate));
}

Function factory

2. Predicate<T> - Les conditions métier simplifiées

L'interface Predicate<T> représente une fonction qui prend un argument de type T et retourne un booléen (true ou false). Elle est parfaite pour exprimer des conditions métier.

Exemples d'utilisation

Prédicats simples :

public static final Predicate<Order> IS_HIGH_VALUE = 
    order -> order.getAmount().compareTo(new BigDecimal("1000")) > 0;

public static final Predicate<Order> IS_RECENT = 
    order -> order.getCreatedAt().isAfter(LocalDateTime.now().minusDays(7));

public static final Predicate<Order> IS_COMPLETED = 
    order -> order.getStatus() == OrderStatus.COMPLETED;

public static final Predicate<Order> IS_URGENT = 
    order -> order.getPriority() == Priority.URGENT;

public static final Predicate<Customer> IS_VIP = 
    customer -> customer.getTotalSpent().compareTo(new BigDecimal("5000")) > 0;

Predicate

Combinaisons de prédicats :

// Combinaison avec and() - toutes les conditions doivent être vraies
public static final Predicate<Order> HIGH_VALUE_AND_RECENT = 
    IS_HIGH_VALUE.and(IS_RECENT);

public static final Predicate<Order> VIP_COMPLETED_ORDER = 
    IS_COMPLETED.and(order -> IS_VIP.test(order.getCustomer()));

// Combinaison avec or() - au moins une condition doit être vraie
public static final Predicate<Order> HIGH_VALUE_OR_URGENT = 
    IS_HIGH_VALUE.or(IS_URGENT);

public static final Predicate<Order> PRIORITY_ORDER = 
    IS_URGENT.or(IS_HIGH_VALUE).or(order -> IS_VIP.test(order.getCustomer()));

// Négation avec negate() - inverse la condition
public static final Predicate<Order> NOT_HIGH_VALUE = 
    IS_HIGH_VALUE.negate();

public static final Predicate<Order> OLD_OR_LOW_VALUE = 
    IS_RECENT.negate().or(IS_HIGH_VALUE.negate());

// Utilisation de not() - méthode statique pour plus de lisibilité
public static final Predicate<Order> NOT_COMPLETED = 
    Predicate.not(IS_COMPLETED);

// Combinaisons complexes
public static final Predicate<Order> PROBLEMATIC_ORDER = 
    IS_RECENT.negate()                    // Ancienne commande
        .and(Predicate.not(IS_COMPLETED)) // ET non complétée
        .and(IS_HIGH_VALUE);              // ET de grande valeur

public static final Predicate<Order> REVIEW_REQUIRED = 
    IS_HIGH_VALUE.and(IS_URGENT)         // (Haute valeur ET urgente)
        .or(                              // OU
            IS_RECENT.negate()            // (Ancienne
                .and(Predicate.not(IS_COMPLETED)) // ET non complétée)
        );

// Exemple d'utilisation pratique
public List<Order> findOrdersRequiringAttention(List<Order> orders) {
    return orders.stream()
        .filter(OrderFilters.PROBLEMATIC_ORDER)
        .sorted(Comparator.comparing(Order::getCreatedAt))
        .toList();
}

Composition de prédicat

Validation complexe avec prédicats composés :

public ValidationResult validateOrderForProcessing(Order order) {
    // Conditions requises : (Complétée OU Confirmée) ET (Récente OU Haute valeur) ET PAS Annulée
    Predicate<Order> canProcess = 
        (IS_COMPLETED.or(order1 -> order1.getStatus() == OrderStatus.CONFIRMED))
            .and(IS_RECENT.or(IS_HIGH_VALUE))
            .and(((Predicate<Order>) order1 -> order1.getStatus() == OrderStatus.CANCELLED).negate());
    
    if (canProcess.test(order)) {
        return ValidationResult.valid();
    } else {
        return ValidationResult.invalid("La commande ne peut pas être traitée selon les critères définis");
    }
}

Power of Predicate and composition

3. Consumer<T> et Supplier<T> - Actions et Création

Consumer<T> : Pour les Effets de Bord

L'interface Consumer<T> représente une opération qui accepte un argument de type T et ne retourne rien. Elle est souvent utilisée pour des actions comme la journalisation ou l'envoi de notifications.

// Consumers pour les effets de bord contrôlés
private final Consumer<Order> logOrderCreation = order ->
    logger.info("Nouvelle commande créée: {} pour {}", 
        order.getId(), order.getCustomer().getName());

private final Consumer<Order> sendOrderConfirmation = order ->
    emailService.sendOrderConfirmation(order.getCustomer().getEmail(), order);

private final Consumer<Order> updateInventory = order ->
    order.getItems().forEach(item -> 
        inventoryService.decreaseStock(item.getProductId(), item.getQuantity()));

// Composition de consumers
public Consumer<Order> createOrderProcessor() {
    return logOrderCreation
        .andThen(sendOrderConfirmation)
        .andThen(updateInventory);
}

Consumer

Supplier<T> : pour la création de données

L'interface Supplier<T> représente une fonction qui ne prend aucun argument et retourne une valeur de type T. Elle est idéale pour générer des données ou des messages.

// Pattern réutilisable pour messages d'exception
public static Supplier<String> insufficientStockMessage(String productId, int requested, int available) {
    return () -> String.format(
        "Stock insuffisant [Produit: %s, Demandé: %d, Disponible: %d, Vérification: %s]",
        productId,
        requested,
        available,
        LocalDateTime.now()
    );

// Utilisation dans les services
if (product.getStock() < quantity) {
  throw new InsufficientStockException(
    insufficientStockMessage(productId, quantity,product.getStock()).get());
}

Supplier

Créer ses propres interfaces fonctionnelles

Java permet également de définir vos propres interfaces fonctionnelles pour répondre à des besoins métier spécifiques. Voici un exemple avec un validateur de commandes :

Création de l'interface :

@FunctionalInterface
public interface OrderValidator {
    ValidationResult validate(Order order);
    
    // Méthode par défaut pour la composition
    default OrderValidator and(OrderValidator other) {
        return order -> {
            ValidationResult first = this.validate(order);
            if (!first.isValid()) {
                return first;
            }
            return other.validate(order);
        };
    }
    
    default OrderValidator or(OrderValidator other) {
        return order -> {
            ValidationResult first = this.validate(order);
            if (first.isValid()) {
                return first;
            }
            return other.validate(order);
        };
    }
}

Custom Functional Interface

Implémentation :

public class OrderValidators {
    
    public static final OrderValidator AMOUNT_VALIDATOR = order -> {
        if (order.getAmount().compareTo(BigDecimal.ZERO) <= 0) {
            return ValidationResult.invalid("Le montant doit être positif");
        }
        return ValidationResult.valid();
    };
    
    public static final OrderValidator CUSTOMER_VALIDATOR = order -> {
        if (order.getCustomer() == null) {
            return ValidationResult.invalid("Le client est obligatoire");
        }
        return ValidationResult.valid();
    };
    
    public static final OrderValidator ITEMS_VALIDATOR = order -> {
        if (order.getItems().isEmpty()) {
            return ValidationResult.invalid("La commande doit contenir au moins un article");
        }
        return ValidationResult.valid();
    };
    
    // Validateur composite
    public static final OrderValidator COMPLETE_VALIDATOR = 
        AMOUNT_VALIDATOR
            .and(CUSTOMER_VALIDATOR)
            .and(ITEMS_VALIDATOR);
}

Build your own Functional Interface

Conclusion : devenez Maître des interfaces fonctionnelles

Les interfaces fonctionnelles ne sont pas qu'une simple addition à Java 8 – elles représentent un changement fondamental dans la façon dont nous concevons et structurons nos applications.

En maîtrisant Function<T, R>, Predicate<T>, Consumer<T>, et Supplier<T>, vous disposez désormais d'un arsenal puissant pour créer du code plus expressif, maintenable et performant.

Les bénéfices concrets

Expressivité du Code : Vos intentions métier deviennent explicites. Un prédicat IS_HIGH_VALUE_ORDER est infiniment plus parlant qu'une série de conditions imbriquées.

Réutilisabilité : Les fonctions composables permettent de créer des briques logiques réutilisables à travers toute votre application.

Testabilité : Chaque interface fonctionnelle peut être testée unitairement de manière isolée, simplifiant grandement vos tests.

Performance : La composition de fonctions évite la création d'objets intermédiaires inutiles et optimise les traitements.

Vers l'avenir

Les interfaces fonctionnelles sont la fondation sur laquelle reposent les innovations futures de Java. L'API Gatherer de Java 24, les améliorations continues de l'API Stream, et les futures évolutions du langage s'appuient toutes sur ces concepts fondamentaux.

En intégrant ces patterns dans votre code quotidien, vous ne faites pas que suivre les bonnes pratiques – vous préparez vos applications aux évolutions futures de l'écosystème Java.

Prochaines étapes

Maintenant que vous maîtrisez les interfaces fonctionnelles, il est temps de les mettre en pratique dans vos projets. Commencez par identifier les endroits où des conditions complexes ou des transformations répétitives peuvent être refactorisées avec ces outils.

Dans le prochain article de cette série, nous explorerons comment ces concepts s'articulent avec les patterns avancés de la programmation fonctionnelle en Java, notamment la gestion des erreurs avec Try, Option et Either, et les techniques de composition avancées.

La programmation fonctionnelle en Java n'est plus un luxe – c'est une nécessité pour tout développeur qui souhaite créer des applications robustes et évolutives.

Lié

Dernier