Java's kontrollerede undtagelser var en massiv forbedring i forhold til C's fejlhåndteringsmekanisme. Efterhånden som tiden gik og erfaringen akkumulerede, konkluderede vi kollektivt, at vi ikke var der endnu. Java 8 bragte lambdas efter "kontrollerede undtagelser er gode" tendens. Ingen af de funktionelle grænseflademetoder accepterer en kontrolleret undtagelse. Problemet er i koden. Tænk på en simpel undtagelsesmetode. public class Foo {
    public String throwing(String input) throws IOException {
        return input;                          //1
    }
}
 
 
 Kroppen er der til kompileringsformål; dens nøjagtige indhold er irrelevant. Metoden accepterer en Tilbage til A Den har formen af en Vi kan bruge den som sådan: String String Function<I, O> var foo = new Foo();
List.of("One", "Two").stream()
    .map(string -> foo.throwing(string))
    .toList();
 Ovenstående kode fejler med en kompileringsfejl: unreported exception IOException; must be caught or declared to be thrown
            .map(string -> foo.throwing(string)).toList();
                                       ^
1 error
 For at løse fejlen skal vi pakke kastekoden i et try-catch-blok: List.of("One", "Two").stream()
    .map(string -> {
        try {
            return foo.throwing(string);
        } catch (IOException e) {
            return "";
        }
    }).toList();
 På dette tidspunkt samler koden, men besejrer det vigtigste formål med lambdas: at være kortfattet og læsbar. En bedre tilgang. Vi kan helt sikkert forbedre designet ved at modelere en Med et kast . Function apply() interface ThrowingFunction<I, O, E extends Exception> {
    O apply(I i) throws E;
}
 Vi kan derefter give en indpakning til at omdanne en sådan kaste Ind i et regelmæssigt . Function Function class LambdaUtils {
    public static <I, O, E extends Exception> Function<I, O> safeApply(ThrowingFunction<I, O, E> f) {
        return input -> {
            try {
                return f.apply(input);
            } catch (Exception e) {
                return "";
            }
        };
    }
}
 Med ovenstående kan opkaldskoden forbedres på denne måde: var foo = new Foo();
List.of("One", "Two").stream()
    .map(string -> LambdaUtils.safeApply(foo::throwing))     //1
    .toList();
 
 
 Korrekt kode igen Biblioteker til redning. Den nemmeste måde at ringe til undtagelses-throwing-kode i en lambda involverer at bruge et bibliotek. 
 
 
 Download af Apache Commons Lang 3 Vavr Her er, hvordan vi kan omskrive ovenstående kode ved hjælp af Commons Lang 3-kode: var foo = new Foo();
FailableFunction<String, String, IOException> throwingFunction = foo::throwing; //1
List.of("One", "Two").stream()
    .map(throwingFunction)
    .recover(e -> "")                                                           //2
    .toList();
 
 
 
 Commons Lang 3 modeller en kastefunktion recover() efterligner den værdi, der er angivet i den foregående catch-blok Bibliotekerne forbedrer på mit kontroversielle design ovenfor, men ideen forbliver den samme. Beslutningen om at udnytte dit eget eller bruge et bibliotek afhænger af en række faktorer, der går ud over dette indlæg. For at hjælpe dig. Nogle kriterier Fjernelse af kontrollerede undtagelser Kontrollerede undtagelser er en compile-time bekymring. Java Language Specification siger: 
 
 
 En kompilator til Java-programmeringsspråket kontrollerer på compilationstidspunktet, at et program indeholder håndtere for kontrollerede undtagelser, ved at analysere, hvilke kontrollerede undtagelser der kan være resultatet af udførelsen af en metode eller konstruktør. For hver kontrolleret undtagelse, der er et muligt resultat, skal kast klausulen for metoden (§8.4.6) eller konstruktøren (§8.8.5) nævne klassen for den pågældende undtagelse eller en af superklassen i klassen for den pågældende undtagelse. 11.2 Compile-Time Kontrol af undtagelser En compiler til Java-programmeringssproget kontrollerer på compileringstidspunktet, at et program indeholder handlere til , ved at analysere, hvilke kontrollerede undtagelser der kan være resultatet af udførelsen af en metode eller konstruktør. I en klausul for metoden (§8.4.6) eller konstruktoren (§8.8.5) skal der nævnes klassen i den pågældende undtagelse eller en af superklassen i klassen i den pågældende undtagelse. Undtagelser kontrolleret throws 11.2 Compile-Time Kontrol af undtagelser Vi kunne potentielt hænge ind i compileren for at forhindre denne kontrol via et compiler-plugin. eller finde et bibliotek, der gør. 
 
 
 
 
 Manifold er en Java compiler plugin. Brug det til at supplere dine Java-projekter med meget produktive funktioner. Kraftfulde sprogforbedringer forbedrer udviklerens produktivitet. 
 
 
 
 
 
 
 
 
 
 
 Udvidelsesmetoder True delegation Ejendomme Valgfrie parametre (New!) Dobbelt udtryk Operatør overlader Unit expressions En Java Template Engine En præprocessor ...og mere Hvad er Manifold Manifold er en Java compiler plugin. Brug det til at supplere dine Java-projekter med meget produktive funktioner. Kraftfulde sprogforbedringer forbedrer udviklerens produktivitet. 
 
 
 
 
 
 
 
 
 
 
 Udvidelsesmetoder En ægte delegation Ejendomme Valgfrie parametre (New!) Dobbelt udtryk Operatør overlader Enhedsudtryk En Java Template Engine En præprocessor ...og mere - - - Hvad er Manifold Ansvarsfraskrivelse: Jeg er ikke tilhænger af at bruge Manifold. Det gør det sprog, du arbejder med, anderledes end Java. På dette tidspunkt ville du være bedre af at bruge Kotlin direkte. Brug af Manifold til at undertrykke kontrollerede undtagelser er en to-trins proces. Først tilføjer vi Manifold runtime til projektet: <dependency>
    <groupId>systems.manifold</groupId>
    <artifactId>manifold-rt</artifactId>
    <version>${manifold.version}</version>
    <scope>provided</scope>
</dependency>
 Derefter konfigurerer vi compiler-pluginet: <build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.8.0</version>
            <configuration>
                <source>11</source>
                <target>11</target>
                <encoding>UTF-8</encoding>
                <compilerArgs>
                    <arg>-Xplugin:Manifold</arg>
                </compilerArgs>
                <annotationProcessorPaths>
                    <path>
                        <groupId>systems.manifold</groupId>
                        <artifactId>manifold-exceptions</artifactId>
                        <version>${manifold.version}</version>
                    </path>
                </annotationProcessorPaths>
            </configuration>
        </plugin>
    </plugins>
</build>
 På dette tidspunkt kan vi behandle kontrollerede undtagelser som ukontrollerede. var foo = new Foo();
List.of("One", "Two").stream()
        .map(string -> foo.throwing(string))       //1
        .toList();
 
 
 Kompilér uden problem Konklusionen I dette indlæg behandlede jeg spørgsmålet om at integrere kontrollerede undtagelser med lambdas i Java. Jeg listede flere muligheder: try-catch-blokken, kastefunktionen, biblioteket og Manifold. To go further: 
 
 
 
 
 
 
 Download af Apache Commons Lang 3 Vavr Undtagelser i Java Lambda-udtryk Undtagelser i Lambda-udtryk ved hjælp af Vavr Sig farvel til kontrollerede undtagelser Revision af løsningen af Java's kontrollerede undtagelser Oprindeligt udgivet på A Java Geek den 18. januar 2026 En Java Geek

Read all my posts!

Read My Stories

Follow @nicolas_frankel on Twitter

Denne lyd er produceret på historiens originalsprog!

Sådan Gør Din Legacy Undtagelse-Throwing Code Kompatibel Med Lambdas

About Author

KOMMENTARER

HÆNG TAGS

DENNE ARTIKEL BLEV PRÆsenterET I

Related Stories

Meet Brave: HackerNoon Company of the Week

Meet Tailscale: HackerNoon Company of the Week

Meet Bybit: HackerNoon Company of the Week

Meet HubSpot: HackerNoon Company of the Week

Meet Brave: HackerNoon Company of the Week

Meet Tailscale: HackerNoon Company of the Week

Meet Bybit: HackerNoon Company of the Week

Meet HubSpot: HackerNoon Company of the Week

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps