Foutafhandeling in Stream API

Het afhandelen van exceptions in de Stream API vereist een specifieke benadering. In tegenstelling tot traditionele lussen, waarbij een try-catch-blok binnen het luslichaam kan worden geplaatst, werken streams declaratief, waardoor exception handling binnen streams complexer wordt.

Als een exception niet wordt afgehandeld, onderbreekt dit de volledige streamverwerking. In deze sectie wordt de juiste manier besproken om exceptions in de Stream API op te vangen en af te handelen.

Het probleem van exception handling

Stel dat onze webwinkel een getTotal()-methode heeft die een exception kan opwerpen als ordergegevens beschadigd of ontbrekend zijn. Bijvoorbeeld, een order kan worden geladen uit een database waarbij het totaalbedrag als null is opgeslagen.

class Order {
    private final double total;

    public Order(double total) {
        this.total = total;
    }

    public double getTotal() throws Exception {
        if (total < 0) {
            throw new IllegalArgumentException("Invalid order total");
        }
        return total;
    }
}

Nu, als een order een totaal minder dan 0 heeft, zal het volledige Stream API-proces worden beëindigd met een exceptie.

 List<User> premiumUsers = users.stream()
                .filter(User::isActive)
                .filter(user -> user.getOrders().stream()
                        .filter(order -> order.getTotal() >= 10000)
                        .count() >= 3)
                .toList();

Maar er is een probleem—deze code zal niet eens uitvoeren omdat de excepties die kunnen optreden in de getTotal() methode niet worden afgehandeld. Laten we daarom bekijken hoe excepties kunnen worden afgehandeld in de Stream API.

Afhandelen van uitzonderingen in Stream API

Aangezien try-catch niet direct kan worden gebruikt binnen lambdas, zijn er verschillende strategieën voor het afhandelen van uitzonderingen in de Stream API.

Een benadering is om de uitzondering direct binnen map() op te vangen en te vervangen door een verwerkt resultaat:

List<User> premiumUsers = users.stream()
        .filter(User::isActive)
        .filter(user -> user.getOrders().stream()
                .mapToDouble(order -> {
                    try {
                        return order.getTotal();
                    } catch (IllegalArgumentException e) {
                        throw new RuntimeException("Error in user's order: " + user, e);
                    }
                })
                .filter(total -> total >= 10000)
                .count() >= 3)
        .toList();

Binnen mapToDouble() wordt de uitzondering opgevangen en wordt een RuntimeException gegooid, waarbij wordt aangegeven welke gebruiker het probleem veroorzaakte. Deze aanpak is nuttig wanneer het noodzakelijk is om de uitvoering onmiddellijk te stoppen en snel het probleem te identificeren.

Elementen met fouten overslaan

Soms is het niet wenselijk om het volledige proces te stoppen wanneer zich een fout voordoet—het is voldoende om alleen de problematische elementen over te slaan. Dit kan worden bereikt door filter() te gebruiken met foutafhandeling:

List<User> premiumUsers = users.stream()
        .filter(User::isActive)
        .filter(user -> {
            try {
                return user.getOrders().stream()
                        .mapToDouble(Order::getTotal)
                        .filter(total -> total >= 10000)
                        .count() >= 3;
            } catch (Exception e) {
                return false; // Skip users with problematic orders
            }
        })
        .toList();

Als er een fout optreedt in mapToDouble(Order::getTotal), zou normaal gesproken de volledige orderstreamverwerking stoppen. Door de try-catch-blok binnen filter() wordt dit voorkomen, zodat alleen de problematische gebruiker wordt uitgesloten van de eindlijst.

Foutafhandeling met een Wrapper

Om onze code robuuster te maken, kun je een wrappermethode creëren waarmee fouten binnen lambdas kunnen worden afgehandeld en automatisch worden opgevangen.

Java staat niet toe dat een Function<T, R> gecontroleerde uitzonderingen gooit. Als er een uitzondering optreedt binnen apply(), moet je deze binnen de methode afhandelen of omzetten naar een RuntimeException, wat de code complexer maakt. Om dit te vereenvoudigen, definiëren we een aangepaste functionele interface:

@FunctionalInterface
interface ThrowingFunction<T, R> {
    R apply(T t) throws Exception;
}

Deze interface werkt vergelijkbaar met Function<T, R>, maar staat toe dat apply() een uitzondering gooit.

Nu maken we een ExceptionWrapper klasse met een wrap() methode die een ThrowingFunction<T, R> omzet naar een standaard Function<T, R> en een tweede parameter accepteert die de fallbackwaarde specificeert voor het geval er een uitzondering optreedt:

class ExceptionWrapper {
    // Wrapper for `Function` to handle exceptions
    public static <T, R> Function<T, R> wrap(ThrowingFunction<T, R> function, R defaultValue) {
        return t -> {
            try {
                return function.apply(t);
            } catch (Exception e) {
                System.out.println(e.getMessage());
                return defaultValue;
            }
        };
    }
}

De methode wrap() neemt een ThrowingFunction<T, R> en zet deze om naar een standaard Function<T, R> waarbij uitzonderingen worden afgehandeld. Als er een fout optreedt, wordt het bericht gelogd en wordt de opgegeven standaardwaarde geretourneerd.

Gebruik in Stream API

Stel, er is een lijst van gebruikers in een online winkel en het is nodig om actieve gebruikers te vinden die minimaal drie bestellingen hebben met een waarde van meer dan 10.000. Als een bestelling echter een negatief bedrag heeft, moet de stream niet worden gestopt—er wordt gewoon 0 geretourneerd als indicatie dat de prijs ongeldig was.

Nu, als een order een negatief bedrag bevat, stopt het programma niet maar registreert eenvoudig een foutmelding en vervangt het door 0,0. Dit maakt de gegevensverwerking robuuster en praktischer voor toepassing in de echte wereld.