Las excepciones verificadas de Java fueron una mejora masiva sobre el mecanismo de gestión de errores de C. A medida que pasaba el tiempo y la experiencia se acumulaba, concluimos colectivamente que todavía no estábamos allí. Java 8 trajo lambdas después de la "excepciones verificadas son grandes" tendencia. Ninguno de los métodos de interfaz funcional acepta una excepción verificada. En este post, voy a demostrar tres enfoques diferentes para hacer que su código de lanzamiento de excepciones heredadas sea compatible con lambdas. El problema, en el código. Considere un simple método de lanzamiento excepcional. public class Foo {
    public String throwing(String input) throws IOException {
        return input;                          //1
    }
}
 
 
 El cuerpo está ahí para fines de compilación; su contenido exacto es irrelevante. El método acepta a y devuelve a Tiene la forma de un Por lo tanto, podemos usarlo como tal: String String Function<I, O> var foo = new Foo();
List.of("One", "Two").stream()
    .map(string -> foo.throwing(string))
    .toList();
 El código anterior falla con un error de compilación: unreported exception IOException; must be caught or declared to be thrown
            .map(string -> foo.throwing(string)).toList();
                                       ^
1 error
 Para corregir el error, necesitamos envolver el código de lanzamiento en un bloque de captura: List.of("One", "Two").stream()
    .map(string -> {
        try {
            return foo.throwing(string);
        } catch (IOException e) {
            return "";
        }
    }).toList();
 En este punto, el código compila, pero derrota el propósito principal de lambdas: ser conciso y legible. un mejor enfoque. Podemos mejorar el diseño mediante el diseño de un Con un lanzamiento . Function apply() interface ThrowingFunction<I, O, E extends Exception> {
    O apply(I i) throws E;
}
 Entonces podemos proporcionar un envoltorio para transformar tal lanzamiento En una regularidad . 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 "";
            }
        };
    }
}
 Con lo anterior, el código de llamada se puede mejorar de esta manera: var foo = new Foo();
List.of("One", "Two").stream()
    .map(string -> LambdaUtils.safeApply(foo::throwing))     //1
    .toList();
 
 
 Una vez más el código Librerías para el rescate. La forma más sencilla de llamar el código de lanzamiento excepcional en un lambda consiste en usar una biblioteca. 
 
 
 Apache Commons Lang 3 VAVR Aquí está cómo podemos reescribir el código anterior usando el código de 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 una función de lanzamiento Recover() imita el valor establecido en el bloque de captura anterior Las bibliotecas mejoran en mi discutible diseño anterior, pero la idea permanece la misma. La decisión de desarrollar su propia o usar una biblioteca depende de una variedad de factores que van más allá de este post. para ayudarte. Algunos criterios Supresión de las excepciones verificadas Las excepciones verificadas son una preocupación de tiempo de compilación.La especificación del lenguaje Java dice: 
 
 
 Un compilador para el lenguaje de programación Java verifica, en el momento de la compilación, que un programa contiene manipuladores para excepciones verificadas, analizando qué excepciones verificadas pueden resultar de la ejecución de un método o constructor. Para cada excepción verificada que es un resultado posible, la cláusula de lanzamiento para el método (§8.4.6) o constructor (§8.8.5) debe mencionar la clase de esa excepción o una de las superclases de la clase de esa excepción. 11.2 Compilación del tiempo de comprobación de excepciones Un compilador para el lenguaje de programación Java verifica, en el momento de la compilación, que un programa contiene , analizando qué excepciones verificadas pueden resultar de la ejecución de un método o constructor. La cláusula para el método (§8.4.6) o constructor (§8.8.5) debe mencionar la clase de esa excepción o una de las superclases de la clase de esa excepción. Excepciones verificadas throws - - - 11.2 Compile-Time Control de excepciones Podríamos potencialmente conectarnos al compilador para evitar esta verificación a través de un complemento de compilador.O encontrar una biblioteca que lo haga. 
 
 
 
 
 Manifold es un complemento de compilador de Java. Utilízalo para complementar sus proyectos Java con características altamente productivas. Las potentes mejoras de lenguaje mejoran la productividad del desarrollador. 
 
 
 
 
 
 
 
 
 
 
 Métodos de extensión La verdadera delegación Propiedades Optional parameters (New!) Expresión doble Operator overloading Expresión Unidad Diseño de Java Template Engine El Preprocesador ... y más Qué es el Manifesto Manifold es un complemento de compilador de Java. Utilízalo para complementar sus proyectos Java con características altamente productivas. Las potentes mejoras de lenguaje mejoran la productividad del desarrollador. 
 
 
 
 
 
 
 
 
 
 
 Métodos de extensión La verdadera delegación Propiedades Parámetros opcionales (Nuevo!) Expresión doble Operador sobrecargado Expresión Unidad Diseño de Java Template Engine El Preprocesador ... y más Qué es el Manifesto Disclaimer: No defendo el uso de Manifold. hace que el idioma con el que trabajas sea diferente de Java. En este punto, sería mejor usar Kotlin directamente. El uso de Manifold para suprimir las excepciones verificadas es un proceso de dos pasos. Primero, añadimos el tiempo de ejecución de Manifold al proyecto: <dependency>
    <groupId>systems.manifold</groupId>
    <artifactId>manifold-rt</artifactId>
    <version>${manifold.version}</version>
    <scope>provided</scope>
</dependency>
 A continuación, configuramos el plugin de 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>
 En este punto, podemos tratar las excepciones verificadas como no verificadas. var foo = new Foo();
List.of("One", "Two").stream()
        .map(string -> foo.throwing(string))       //1
        .toList();
 
 
 Compilación sin problemas Conclusión En este post, he abordado el problema de integrar excepciones verificadas con lambdas en Java. He listado varias opciones: el bloque try-catch, la función de lanzamiento, la biblioteca y Manifold. To go further: 
 
 
 
 
 
 
 Apache Commons Lang 3 VAVR Excepciones en Java Lambda Expressions Excepciones en la expresión Lambda utilizando Vavr Dile adiós a las excepciones verificadas Revisión de la resolución del flagelo de las excepciones verificadas de Java Publicado originalmente en A Java Geek el 18 de enero de 2026 El nuevo Java Geek

Read all my posts!

Read My Stories

Follow @nicolas_frankel on Twitter

Este audio es producido en el idioma original de la historia!

Cómo hacer que su código de expulsión de legado sea compatible con Lambdas

About Author

COMENTARIOS

ETIQUETAS

ESTE ARTÍCULO FUE PRESENTADO EN

Related Stories

Una guía del arquitecto para crear una arquitectura de referencia para un lago de datos de IA/ML

De los foros a los feeds: cómo los algoritmos de las redes sociales influyen en la interacción digital

Una breve introducción a la teoría del cerebro de Boltzmann

Nómadas digitales escuchen: lo que necesitan saber sobre la nueva visa DTV de Tailandia

Una guía del arquitecto para crear una arquitectura de referencia para un lago de datos de IA/ML

De los foros a los feeds: cómo los algoritmos de las redes sociales influyen en la interacción digital

Una breve introducción a la teoría del cerebro de Boltzmann

Nómadas digitales escuchen: lo que necesitan saber sobre la nueva visa DTV de Tailandia

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps