Poikkeusten käsittely Stream API:ssa vaatii erityistä lähestymistapaa. Toisin kuin perinteisissä silmukoissa, joissa try-catch-lohko voidaan sijoittaa silmukan sisälle, streamit toimivat deklaratiivisesti, mikä tekee poikkeusten käsittelystä niissä monimutkaisempaa.

Jos poikkeusta ei käsitellä, se keskeyttää koko stream-käsittelyn. Tässä osiossa tutustut oikeaan tapaan käsitellä ja ottaa kiinni poikkeuksia Stream API:ssa.

Poikkeuksen käsittelyn ongelma

Oletetaan, että verkkokaupassamme on getTotal()-metodi, joka voi heittää poikkeuksen, jos tilausdata on vioittunut tai puuttuu. Esimerkiksi tilaus voidaan ladata tietokannasta, jossa kokonaissumma on tallennettu arvolla null.

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;
    }
}

Nyt, jos jokin order sisältää total-arvon, joka on alle 0, koko Stream API -prosessi keskeytyy poikkeukseen.

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

Mutta tässä on ongelma—tämä koodi ei edes käynnisty, koska et käsittele mahdollisia poikkeuksia, joita voi esiintyä getTotal()-metodissa. Tarkastellaan siis, miten poikkeusten käsittely onnistuu Stream API:ssa.

Poikkeusten käsittely Stream API:ssa

Koska try-catch-rakennetta ei voi käyttää suoraan lambdoissa, on olemassa useita strategioita poikkeusten käsittelyyn Stream API:ssa.

Yksi tapa on käsitellä poikkeus suoraan map()-metodissa ja korvata se käsitellyllä tuloksella:

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();

mapToDouble()-metodin sisällä poikkeus otetaan kiinni ja heitetään RuntimeException, jossa määritellään, mikä käyttäjä aiheutti ongelman. Tämä lähestymistapa on hyödyllinen, kun suoritus halutaan keskeyttää välittömästi ja ongelma tunnistaa nopeasti.

Virheellisten alkioiden ohittaminen

Joskus koko prosessia ei haluta keskeyttää virheen sattuessa—riittää, että ongelmalliset alkiot ohitetaan. Tämän voi toteuttaa käyttämällä filter()-metodia yhdessä poikkeusten käsittelyn kanssa:

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();

Jos virhe tapahtuu kohdassa mapToDouble(Order::getTotal), koko tilausten virran käsittely keskeytyisi normaalisti. try-catch-lohko filter()-metodin sisällä kuitenkin estää tämän, jolloin vain ongelmallinen käyttäjä jätetään pois lopullisesta listasta.

Poikkeusten käsittely kääreellä

Koodin luotettavuuden parantamiseksi voidaan luoda kääre-metodi, joka mahdollistaa poikkeusten käsittelyn lambda-lausekkeissa ja sieppaa ne automaattisesti.

Java ei salli, että Function<T, R> heittää tarkistettuja poikkeuksia. Jos poikkeus tapahtuu apply()-menetelmän sisällä, se täytyy joko käsitellä metodissa tai kääriä RuntimeException-poikkeukseen, mikä monimutkaistaa koodia. Tämän yksinkertaistamiseksi määritellään oma funktionaalinen rajapinta:

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

Tämä rajapinta toimii samalla tavalla kuin Function<T, R>, mutta sallii apply()-menetelmän heittää poikkeuksen.

Seuraavaksi luodaan ExceptionWrapper-luokka, jossa on wrap()-metodi. Tämä metodi muuntaa ThrowingFunction<T, R>-funktion tavalliseksi Function<T, R>-funktioksi ja ottaa toisena parametrina varmistusarvon poikkeustilanteita varten:

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;
            }
        };
    }
}

wrap() metodi ottaa vastaan ThrowingFunction<T, R>-funktion ja muuntaa sen tavalliseksi Function<T, R>-funktioksi samalla kun se käsittelee poikkeukset. Jos ilmenee virhe, se kirjaa viestin ja palauttaa määritetyn oletusarvon.

Käyttö Stream API:ssa

Oletetaan, että käytössä on lista käyttäjistä verkkokaupassa, ja tavoitteena on löytää aktiiviset käyttäjät, joilla on vähintään kolme tilausta, joiden arvo on yli 10 000. Jos kuitenkin tilauksella on negatiivinen summa, virran käsittelyä ei haluta keskeyttää—palautetaan yksinkertaisesti 0 merkiksi siitä, että hinta oli virheellinen.

Nyt, jos tilaus sisältää negatiivisen summan, ohjelma ei pysähdy vaan kirjaa virheen ja korvaa summan arvolla 0.0. Tämä tekee datan käsittelystä kestävämpää ja käytännöllisempää todellisissa käyttötapauksissa.