As excepcións verificadas de Java foron unha mellora masiva sobre o mecanismo de xestión de erros de C. Co paso do tempo e a experiencia acumulada, concluímos colectivamente que aínda non estabamos alí. Java 8 trouxo lambdas despois da tendencia "excepcións verificadas son grandes". Ningún dos métodos de interface funcional acepta unha excepción verificada. O problema está no código. Considere un simple método de lanzamento de excepcións. public class Foo {
    public String throwing(String input) throws IOException {
        return input;                          //1
    }
}
 
 
 O corpo está aí para fins de compilación; o seu contido exacto é irrelevante. O método acepta a e devolve a Ten a forma dunha Podemos usalo como tal: String String Function<I, O> var foo = new Foo();
List.of("One", "Two").stream()
    .map(string -> foo.throwing(string))
    .toList();
 O código anterior falla cun erro de compilación: unreported exception IOException; must be caught or declared to be thrown
            .map(string -> foo.throwing(string)).toList();
                                       ^
1 error
 Para corrixir o erro, necesitamos envolver o código de lanzamento nun bloque de try-catch: List.of("One", "Two").stream()
    .map(string -> {
        try {
            return foo.throwing(string);
        } catch (IOException e) {
            return "";
        }
    }).toList();
 Neste punto, o código compila, pero derrota o obxectivo principal de lambdas: ser conciso e lexible. Unha mellor aproximación. Pódese mellorar o deseño mediante a con unha lanza . Function apply() interface ThrowingFunction<I, O, E extends Exception> {
    O apply(I i) throws E;
}
 Entón podemos proporcionar un envoltorio para transformar tal lanzamento para unha regularidade . 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 "";
            }
        };
    }
}
 Co anterior, o código de chamada pode ser mellorado deste xeito: var foo = new Foo();
List.of("One", "Two").stream()
    .map(string -> LambdaUtils.safeApply(foo::throwing))     //1
    .toList();
 
 
 Unha vez máis o código Bibliotecas para o rescate. A forma máis sinxela de chamar o código de lanzamento de excepcións nunha lambda implica o uso dunha biblioteca. 
 
 
 Apache Commons Lang 3 Páxina Vaqueiro Aquí está como podemos reescribir o código anterior usando o código Commons Lang 3: 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 modelos unha función de lanzamento recover() imita o valor establecido no bloque de captura anterior As bibliotecas melloran sobre o meu deseño discutible anteriormente, pero a idea permanece a mesma. A decisión de desenvolver a súa propia ou usar unha biblioteca depende dunha variedade de factores que van máis aló desta publicación. para axudarche. Algúns criterios Supresión de excepcións verificadas As excepcións verificadas son unha preocupación do tempo de compilación.A especificación da linguaxe Java di: 
 
 
 Un compilador para a linguaxe de programación Java comproba, no momento da compilación, que un programa contén manipuladores para excepcións verificadas, analizando que excepcións verificadas poden resultar da execución dun método ou constructor. Para cada excepción verificada que é un resultado posible, a cláusula de lanzamento para o método (§8.4.6) ou constructor (§8.8.5) debe mencionar a clase desa excepción ou unha das superclases da clase desa excepción. 11.2 Compilación-Tempo de comprobación de excepcións Un compilador para a linguaxe de programación Java comproba, no momento da compilación, que un programa contén manuais para , analizando que excepcións verificadas poden resultar da execución dun método ou constructor. A cláusula para o método (§8.4.6) ou constructor (§8.8.5) debe mencionar a clase desa excepción ou unha das superclases da clase desa excepción. Excepcións comprobadas throws — — — 11.2 Compilación-Tempo de comprobación de excepcións Poderiamos potencialmente conectarse ao compilador para evitar esta comprobación a través dun complemento de compilador. ou atopar unha biblioteca que o faga. 
 
 
 
 
 Manifold é un complemento de compilador de Java. Use-o para complementar os seus proxectos de Java con características altamente produtivas. As poderosas melloras de linguaxe melloran a produtividade do desenvolvedor. 
 
 
 
 
 
 
 
 
 
 
 Métodos de extensión Unha auténtica delegación Propiedades Parámetros opcionais (Novo!) Expresións dobres Operador de sobrecarga Unit expressions Desenvolvemento de Java Template Engine O preprocesador ...e máis O que é Manifesto Manifold é un complemento de compilador de Java. Use-o para complementar os seus proxectos de Java con características altamente produtivas. As poderosas melloras de linguaxe melloran a produtividade do desenvolvedor. 
 
 
 
 
 
 
 
 
 
 
 Métodos de extensión Unha auténtica delegación Propiedades Parámetros opcionais (Novo!) Expresións dobres Operador de sobrecarga Expresións unitarias Desenvolvemento de Java Template Engine O preprocesador ...e máis O que é Manifesto Disclaimer: Non defendo o uso de Manifold. fai que o idioma co que traballas sexa diferente de Java. Neste punto, sería mellor usar Kotlin directamente. Usar Manifold para suprimir as excepcións verificadas é un proceso de dous pasos. Primeiro, engadimos o tempo de execución de Manifold ao proxecto: <dependency>
    <groupId>systems.manifold</groupId>
    <artifactId>manifold-rt</artifactId>
    <version>${manifold.version}</version>
    <scope>provided</scope>
</dependency>
 Despois, configuramos o plugin do compilador: <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>
 Neste punto, podemos tratar as excepcións verificadas como non verificadas. var foo = new Foo();
List.of("One", "Two").stream()
        .map(string -> foo.throwing(string))       //1
        .toList();
 
 
 Compilación sen problema Conclusión Neste post, abordei o problema de integrar excepcións comprobadas con lambdas en Java. enumerei varias opcións: o bloque try-catch, a función de lanzamento, a biblioteca e Manifold. To go further: 
 
 
 
 
 
 
 Apache Commons Lang 3 Páxina Vaqueiro Excepcións en Java Lambda Expressions Excepcións na expresión Lambda usando Vavr Diga adeus ás excepcións verificadas Resolver o flagelo das excepcións verificadas de Java Publicado orixinalmente en A Java Geek o 18 de xaneiro de 2026 Xogos de Java Geek

Read all my posts!

Read My Stories

Follow @nicolas_frankel on Twitter

Este audio está producido na lingua orixinal da historia!

Como facer que o seu código de exención de legado sexa compatible con Lambdas

About Author

COMENTARIOS

Etiquetas colgantes

ESTE ARTIGO FOI PRESENTADO EN

Related Stories

HackerNoon Decoded 2024: Celebrating Our Science Community!

HackerNoon Decoded 2024: Celebrating Our Product Management Community!

HackerNoon Decoded 2024: Celebrating Our Life Hacking Community!

HackerNoon Decoded 2024: Celebrating Our Web3 Community!

HackerNoon Decoded 2024: Celebrating Our Science Community!

HackerNoon Decoded 2024: Celebrating Our Product Management Community!

HackerNoon Decoded 2024: Celebrating Our Life Hacking Community!

HackerNoon Decoded 2024: Celebrating Our Web3 Community!

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps