Java 8: Obligatorisch geprüfte Ausnahmebehandlung in Lambda-Ausdrücken. Warum obligatorisch, nicht optional?

Ich spiele mit den neuen Lambda-Funktionen in Java 8 und habe festgestellt, dass die von Java 8 angebotenen Methoden wirklich nützlich sind. Ich frage mich jedoch, ob es eine gute Möglichkeit gibt, das folgende Szenario zu umgehen. Angenommen, Sie haben einen Objektpool-Wrapper, für den eine Art Factory erforderlich ist, um den Objektpool zu füllen, z. B. (mit java.lang.functions.Factory):

public class JdbcConnectionPool extends ObjectPool<Connection> {

    public ConnectionPool(int maxConnections, String url) {
        super(new Factory<Connection>() {
            @Override
            public Connection make() {
                try {
                    return DriverManager.getConnection(url);
                } catch ( SQLException ex ) {
                    throw new RuntimeException(ex);
                }
            }
        }, maxConnections);
    }

}

Nach der Umwandlung der Funktionsschnittstelle in einen Lambda-Ausdruck sieht der obige Code folgendermaßen aus:

public class JdbcConnectionPool extends ObjectPool<Connection> {

    public ConnectionPool(int maxConnections, String url) {
        super(() -> {
            try {
                return DriverManager.getConnection(url);
            } catch ( SQLException ex ) {
                throw new RuntimeException(ex);
            }
        }, maxConnections);
    }

}

Nicht so schlimm, aber die aktivierte Ausnahme java.sql.SQLExceptionerfordert einen try/ catchBlock innerhalb des Lambda. In meiner Firma verwenden wir lange Zeit zwei Schnittstellen:

• IOut<T>das ist ein Äquivalent zu java.lang.functions.Factory;
• und eine spezielle Schnittstelle für die Fälle, in denen normalerweise die Weitergabe geprüfter Ausnahmen erforderlich ist : interface IUnsafeOut<T, E extends Throwable> { T out() throws E; }.

Beide IOut<T>und IUnsafeOut<T>sollen während der Migration auf Java 8 entfernt werden, es gibt jedoch keine genaue Übereinstimmung für IUnsafeOut<T, E>. Wenn die Lambda-Ausdrücke mit geprüften Ausnahmen umgehen könnten, als wären sie nicht markiert, könnte es möglich sein, im obigen Konstruktor einfach Folgendes zu verwenden:

super(() -> DriverManager.getConnection(url), maxConnections);

Das sieht viel sauberer aus. Ich sehe, dass ich die Superklasse umschreiben kann ObjectPool, um unsere zu akzeptieren IUnsafeOut<T>, aber soweit ich weiß, ist Java 8 noch nicht fertig, daher könnte es einige Änderungen geben wie:

• etwas ähnliches implementieren wie IUnsafeOut<T, E>? (Um ehrlich zu sein, halte ich das für schmutzig - das Thema muss wählen, was akzeptiert werden soll: entweder Factoryoder "unsichere Fabrik", die keine kompatiblen Methodensignaturen haben kann)
• einfach geprüfte Ausnahmen in Lambdas ignorieren, also keine Notwendigkeit in IUnsafeOut<T, E>Ersatz? (Warum nicht? zB eine weitere wichtige Änderung: OpenJDK, das ich verwende, javacerfordert jetzt nicht, dass Variablen und Parameter deklariert werden final, um in einer anonymen Klasse [Funktionsschnittstelle] oder einem Lambda-Ausdruck erfasst zu werden.)

Die Frage ist also im Allgemeinen: Gibt es eine Möglichkeit, geprüfte Ausnahmen in Lambdas zu umgehen, oder ist dies in Zukunft geplant, bis Java 8 endgültig veröffentlicht wird?

Update 1

Hm-mm, soweit ich weiß, was wir derzeit haben, scheint es im Moment keinen Weg zu geben, obwohl der Artikel, auf den verwiesen wird, aus dem Jahr 2010 stammt: Brian Goetz erklärt die Ausnahmetransparenz in Java . Wenn sich in Java 8 nicht viel geändert hat, kann dies als Antwort angesehen werden. Auch Brian sagt, dass interface ExceptionalCallable<V, E extends Exception>(was ich IUnsafeOut<T, E extends Throwable>aus unserem Code-Erbe erwähnt habe) so ziemlich nutzlos ist, und ich stimme ihm zu.

Vermisse ich noch etwas anderes?

Sie sind sich nicht sicher, ob ich Ihre Frage wirklich beantworte, aber können Sie so etwas nicht einfach verwenden?

public final class SupplierUtils {
    private SupplierUtils() {
    }

    public static <T> Supplier<T> wrap(Callable<T> callable) {
        return () -> {
            try {
                return callable.call();
            }
            catch (RuntimeException e) {
                throw e;
            }
            catch (Exception e) {
                throw new RuntimeException(e);
            }
        };
    }
}

public class JdbcConnectionPool extends ObjectPool<Connection> {

    public JdbcConnectionPool(int maxConnections, String url) {
        super(SupplierUtils.wrap(() -> DriverManager.getConnection(url)), maxConnections);
    }
}

In der Lambda-Mailingliste wurde dies ausführlich besprochen . Wie Sie sehen können, schlug Brian Goetz dort vor, dass die Alternative darin besteht, einen eigenen Kombinator zu schreiben:

Oder Sie könnten Ihren eigenen trivialen Kombinator schreiben:

static<T> Supplier<T> exceptionWrappingSupplier(Supplier<T> b) {
     return e -> {
         try { b.accept(e); }
         catch (Exception e) { throw new RuntimeException(e); }
     };
}

Sie können es einmal schreiben, in weniger als der Zeit, die zum Schreiben Ihrer ursprünglichen E-Mail benötigt wurde. Und ähnlich einmal für jede Art von SAM, die Sie verwenden.

Ich würde es vorziehen, wenn wir dies als "Glas 99% voll" betrachten und nicht als Alternative. Nicht alle Probleme erfordern neue Sprachfunktionen als Lösungen. (Ganz zu schweigen davon, dass neue Sprachfunktionen immer neue Probleme verursachen.)

In jenen Tagen hieß die Consumer-Schnittstelle Block.

Ich denke, das entspricht der Antwort von JB Nizet .

Später erklärt Brian , warum dies so gestaltet wurde (der Grund des Problems)

Ja, Sie müssten Ihre eigenen außergewöhnlichen SAMs bereitstellen. Aber dann würde die Lambda-Konvertierung mit ihnen gut funktionieren.

Die EG erörterte zusätzliche Sprach- und Bibliotheksunterstützung für dieses Problem und war am Ende der Ansicht, dass dies ein schlechter Kosten-Nutzen-Kompromiss war.

Bibliotheksbasierte Lösungen verursachen eine zweifache Explosion bei SAM-Typen (außergewöhnlich gegen nicht), die für die primitive Spezialisierung schlecht mit vorhandenen kombinatorischen Explosionen interagieren.

Die verfügbaren sprachbasierten Lösungen waren Verlierer eines Kompromisses zwischen Komplexität und Wert. Obwohl es einige alternative Lösungen gibt, werden wir weiter nachforschen - allerdings eindeutig nicht für 8 und wahrscheinlich auch nicht für 9.

In der Zwischenzeit haben Sie die Werkzeuge, um zu tun, was Sie wollen. Ich verstehe, dass Sie es vorziehen, dass wir Ihnen die letzte Meile zur Verfügung stellen (und zweitens ist Ihre Anfrage wirklich eine kaum verhüllte Anfrage nach "Warum geben Sie nicht einfach bereits geprüfte Ausnahmen auf"), aber ich denke, der aktuelle Status lässt dies zu Sie erledigen Ihre Arbeit.

September 2015:

Sie können hierfür ET verwenden . ET ist eine kleine Java 8-Bibliothek für die Konvertierung / Übersetzung von Ausnahmen.

Mit ET können Sie schreiben:

super(() -> et.withReturningTranslation(() -> DriverManager.getConnection(url)), maxConnections);

Mehrzeilige Version:

super(() -> {
  return et.withReturningTranslation(() -> DriverManager.getConnection(url));
}, maxConnections);

Sie müssen lediglich eine neue ExceptionTranslatorInstanz erstellen :

ExceptionTranslator et = ET.newConfiguration().done();

Diese Instanz ist threadsicher und kann von mehreren Komponenten gemeinsam genutzt werden. Sie können spezifischere Ausnahmekonvertierungsregeln (z. B. FooCheckedException -> BarRuntimeException) konfigurieren, wenn Sie möchten. Wenn keine anderen Regeln verfügbar sind, werden aktivierte Ausnahmen automatisch in konvertiert RuntimeException.

(Haftungsausschluss: Ich bin der Autor von ET)

Haben Sie darüber nachgedacht, eine (nicht aktivierte) RuntimeException-Wrapper-Klasse zu verwenden, um die ursprüngliche Ausnahme aus dem Lambda-Ausdruck zu schmuggeln und die umschlossene Ausnahme dann wieder in die ursprünglich aktivierte Ausnahme umzuwandeln ?

class WrappedSqlException extends RuntimeException {
    static final long serialVersionUID = 20130808044800000L;
    public WrappedSqlException(SQLException cause) { super(cause); }
    public SQLException getSqlException() { return (SQLException) getCause(); }
}

public ConnectionPool(int maxConnections, String url) throws SQLException {
    try {
        super(() -> {
            try {
                return DriverManager.getConnection(url);
            } catch ( SQLException ex ) {
                throw new WrappedSqlException(ex);
            }
        }, maxConnections);
    } catch (WrappedSqlException wse) {
        throw wse.getSqlException();
    }
}

Das Erstellen einer eigenen eindeutigen Klasse sollte verhindern, dass eine andere ungeprüfte Ausnahme mit der in Ihrem Lambda verpackten Ausnahme verwechselt wird, selbst wenn die Ausnahme irgendwo in der Pipeline serialisiert wird, bevor Sie sie abfangen und erneut auslösen.

Hmm ... Das einzige, was ich hier sehe, ist, dass Sie dies in einem Konstruktor mit einem Aufruf von super () tun, was laut Gesetz die erste Aussage in Ihrem Konstruktor sein muss. Zählt tryals vorherige Aussage? Ich habe dies (ohne den Konstruktor) in meinem eigenen Code.

Wir haben in meinem Unternehmen ein internes Projekt entwickelt, das uns dabei geholfen hat. Wir haben uns vor zwei Monaten entschlossen, an die Börse zu gehen.

Folgendes haben wir uns ausgedacht:

@FunctionalInterface
public interface ThrowingFunction<T,R,E extends Throwable> {
R apply(T arg) throws E;

/**
 * @param <T> type
 * @param <E> checked exception
 * @return a function that accepts one argument and returns it as a value.
 */
static <T, E extends Exception> ThrowingFunction<T, T, E> identity() {
    return t -> t;
}

/**
 * @return a Function that returns the result of the given function as an Optional instance.
 * In case of a failure, empty Optional is returned
 */
static <T, R, E extends Exception> Function<T, Optional<R>> lifted(ThrowingFunction<T, R, E> f) {
    Objects.requireNonNull(f);

    return f.lift();
}

static <T, R, E extends Exception> Function<T, R> unchecked(ThrowingFunction<T, R, E> f) {
    Objects.requireNonNull(f);

    return f.uncheck();
}

default <V> ThrowingFunction<V, R, E> compose(final ThrowingFunction<? super V, ? extends T, E> before) {
    Objects.requireNonNull(before);

    return (V v) -> apply(before.apply(v));
}

default <V> ThrowingFunction<T, V, E> andThen(final ThrowingFunction<? super R, ? extends V, E> after) {
    Objects.requireNonNull(after);

    return (T t) -> after.apply(apply(t));
}

/**
 * @return a Function that returns the result as an Optional instance. In case of a failure, empty Optional is
 * returned
 */
default Function<T, Optional<R>> lift() {
    return t -> {
        try {
            return Optional.of(apply(t));
        } catch (Throwable e) {
            return Optional.empty();
        }
    };
}

/**
 * @return a new Function instance which wraps thrown checked exception instance into a RuntimeException
 */
default Function<T, R> uncheck() {
    return t -> {
        try {
            return apply(t);
        } catch (final Throwable e) {
            throw new WrappedException(e);
        }
    };
}

}}

https://github.com/TouK/ThrowingFunction/

Das Umschließen der Ausnahme auf die beschriebene Weise funktioniert nicht. Ich habe es versucht und erhalte immer noch Compilerfehler, was tatsächlich der Spezifikation entspricht: Der Lambda-Ausdruck löst die Ausnahme aus, die mit dem Zieltyp des Methodenarguments nicht kompatibel ist: Callable; call () wirft es nicht, so dass ich den Lambda-Ausdruck nicht als Callable übergeben kann.

Im Grunde gibt es also keine Lösung: Wir sind beim Schreiben von Boilerplate festgefahren. Das einzige, was wir tun können, ist unsere Meinung zu äußern, dass dies behoben werden muss. Ich denke, die Spezifikation sollte einen Zieltyp, der auf inkompatiblen ausgelösten Ausnahmen basiert, nicht einfach blind verwerfen, sondern anschließend prüfen, ob die ausgelöste inkompatible Ausnahme im aufrufenden Bereich abgefangen oder als Auslöser deklariert wird. Und für Lambda-Ausdrücke, die nicht inline sind, schlage ich vor, dass wir sie als stillschweigend ausgelöste geprüfte Ausnahme markieren können (still in dem Sinne, dass der Compiler nicht prüfen sollte, aber die Laufzeit immer noch abfangen sollte). Markieren wir diese mit => im Gegensatz zu -> Ich weiß, dass dies keine Diskussionsseite ist, aber da dies die einzige Lösung für die Frage ist, lassen Sie sich hören und ändern Sie diese Spezifikation!

Paguro bietet funktionale Schnittstellen, die geprüfte Ausnahmen umschließen . Ich habe ein paar Monate, nachdem Sie Ihre Frage gestellt haben, angefangen, daran zu arbeiten, also waren Sie wahrscheinlich Teil der Inspiration dafür!

Sie werden feststellen, dass es in Paguro nur 4 funktionale Schnittstellen gibt, im Vergleich zu den 43 in Java 8 enthaltenen Schnittstellen. Dies liegt daran, dass Paguro Generika gegenüber Grundelementen bevorzugt.

Paguro hat Single-Pass-Transformationen in seine unveränderlichen Sammlungen eingebaut (kopiert von Clojure). Diese Transformationen entsprechen in etwa Clojure-Wandlern oder Java 8-Streams, akzeptieren jedoch funktionale Schnittstellen, die geprüfte Ausnahmen umschließen. Siehe: die Unterschiede zwischen Paguro und Java 8 Streams .

Sie können von Ihren Lambdas werfen, sie müssen nur "auf Ihre eigene Weise" deklariert werden (was sie leider nicht in Standard-JDK-Code wiederverwendbar macht, aber hey, wir tun, was wir können).

@FunctionalInterface
public interface SupplierIOException {
   MyClass get() throws IOException;
}

Oder die allgemeinere Version:

public interface ThrowingSupplier<T, E extends Exception> {
  T get() throws E;
}

Ref hier . Es wird auch erwähnt, dass "sneakyThrow" verwendet wird, um die aktivierten Ausnahmen nicht zu deklarieren, sondern sie dennoch zu werfen. Es tut mir ein bisschen weh, vielleicht eine Option.