So behandeln Sie Ausnahmen mit Java 8 Stream oder Optional kühl

Problem: Es ist umständlich, Ausnahmen mit Lambda-Ausdrücken zu behandeln

Verwenden Sie die Streams-API von Java8? Es ist sehr praktisch. Die Streams-API oder der Lambda-Ausdruck ist sehr leistungsfähig.

Die Lambda-Formel ist sehr mächtig, aber das Beispiel ist schlecht.java

Function<String, String> slice = x -> x.substring(3, 6);
System.out.println(slice.apply("abcdefghij")); // -> "def"

Wie viele darauf hingewiesen haben, ist [^ 1] nicht mit der Ausnahmebehandlung kompatibel, und es ist nicht möglich, Ausnahmen außerhalb von Lambda abzufangen. (Nein, ich denke, es ist natürlich, weil es ein Klumpen der Verarbeitung mit Lambda ist.)

Wenn im obigen Beispiel die Zeichenfolge aus 3 Zeichen oder weniger besteht, tritt ein Fehler auf. Fügen Sie daher die Ausnahmeverarbeitung ein, damit sie so zurückgegeben wird, wie sie ist, wenn ein Fehler auftritt.

Try Catch ist nicht cool und das Nesting ist tief und ich möchte, dass du aufhörst.java

Function<String, String> sliceAndCatch = x -> {
	try {
		return x.substring(3, 6);
	} catch (Exception e) {
		return x;
	}
};

System.out.println(sliceAndCatch.apply("abcdefghij")); // -> "def"
System.out.println(sliceAndCatch.apply("xy")); // -> "xy"

Wow, das Nest ist tief.

Außerdem müssen Sie bei einer Methode, die eine aktivierte Ausnahme auslöst, versuchen, im Lambda zu fangen, damit Sie hoge :: fuga nicht aufrufen können, das mit stream.map (hoge :: fuga) eine Ausnahme auslöst, wodurch Sie sich frustriert fühlen. .. Wenn es sich um eine nicht aktivierte Ausnahme handelt, kann sie zum Zeitpunkt des Aufrufs abgerufen werden (versuchen Sie es mit {stream.map (hoge :: fuga)} catch {～}), aber sie ist nicht sauber. Es gibt auch eine Bibliothek, die Stream und Optional umschließt, aber es ist ziemlich unpraktisch.

Lösung: Ich hoffe, Sie können in einer Zeile schreiben → Sie können auf diese Weise schreiben

Ich möchte das obige Beispiel mit einem Liner schreiben. Wenn Sie zwei Lambdas übergeben und die normale Verarbeitung für das erste Lambda und die Ausnahmeverarbeitung für das zweite Lambda schreiben, sieht es intelligent aus. Bereiten Sie also zunächst eine funktionale Schnittstelle vor, die Ausnahmen auslöst

Funktion, bei der eine Ausnahme ausgelöst wird.java

interface ThrowableFunction<T, R> {
	R apply(T t) throws Exception;
}

Und definieren Sie Versuchen Sie so

Das ganze Bild kommt in Sicht.java

public <T, R> Function<T, R> Try(ThrowableFunction<T, R> onTry, BiFunction<Exception, T, R> onCatch) {
	return x -> {
		try {
			return onTry.apply(x);
		} catch (Exception e) {
			return onCatch.apply(e, x);
		}
	};
}

Das allein ermöglicht eine coole Codierung!

Cool.java

Function<String, String> coolSlice = Try(x -> x.substring(3, 6), (error, x) -> x);

System.out.println(coolSlice.apply("abcdefghij")); // -> "def"
System.out.println(coolSlice.apply("xy")); // -> "xy"

Wenn der Verbraucher dasselbe tut,

Für Verbraucher.java

interface ThrowableConsumer<T> {
	void accept(T t) throws Exception;
}

public <T> Consumer<T> Try(ThrowableConsumer<T> onTry, BiConsumer<Exception, T> onCatch) {
	return x -> {
		try {
			onTry.accept(x);
		} catch (Exception t) {
			onCatch.accept(t, x);
		}
	};
}

Das ist auch cool!

Ich habs gemacht.java

Consumer<String> coolCatch = Try(x -> {System.out.println(Integer.valueOf(x));}, (error, x) -> error.printStackTrace());

coolCatch.accept("33"); //-> 33
coolCatch.accept("Hoge"); //-> java.lang.NumberFormatException: For input string: "Hoge"・ ・ ・

Verdienst und Fehler

Das Gute an dieser Methode

• Kurz
• Sie können Ausnahmen ordnungsgemäß verwenden (im Vergleich zum Umschließen aktivierter Ausnahmen und zum Auslösen nicht aktivierter Ausnahmen, um sie abzufangen).
• Vielseitiger als verpackter Stream oder optional. Es ist nur eine Funktion, die zurückkommt

Schlechter Platz

• Lange Vorbereitung → Es ist leichter als andere Trompeten, also schreiben wir es und führen einen statischen Import durch
• Versuchen Sie, für alle funktionalen Schnittstellen vorbereitet zu sein
• Es ist nicht typsicher und ich nehme auch RuntimeExceptions auf, die ich nicht abholen möchte → Gibt es einen besseren Weg?

Anwendung: Der Mechanismus ist einfach, aber nützlich

Natürlich können Sie es auch als Methodenreferenz übergeben, sodass Sie es so aufrufen können

Gewöhnliches Beispiel.java

stream.flatMap(Try(this::calc, (x,y)->Stream.empty()));

Wenn es die Funktion <T, R> akzeptiert, auch wenn es kein Stream ist, kann es optional sein.

Optional.java

Optional<String> name = getName();
name.flatMap(Try( dao::getFindByName ,(x,y)->Optional.empty()));

Auch beim Übergeben von Lambda an die Schnittstelle

Homebrew-Schnittstelle.java

interface JisakuInterface{
	String Method(String Argument);
}

JisakuInterface m = str->"hoge";
JisakuInterface f = Try(str -> str+str,(x,y)->"b")::apply;

Wenn Sie sich auf die Methode beziehen, können Sie sie problemlos mit Lambda übergeben. groß.

Danach, als ich Oleoremonado gemacht habe

Monamodoki.java

// LogicalDeletable.of(null)So generieren Sie ein logisches Löschen mit.
LogicalDeletable<LegacyData> record = getRecord(); 
//Diejenigen, die bei der Konvertierung einen Fehler gemacht haben, werden als logische Löschung behandelt
record.map(Try(Legacy::legacyTransform)) , (error,record) -> null));

Sie können also Ausnahmen machen.

Ich kann mir kein Beispiel vorstellen (viertes Mal), aber da der ausgelöste Inhalt als Argument an onCatch übergeben wird, sollten alle Funktionen möglich sein, die mit normalem TryCatch ausgeführt werden können (außer try-with-resource).

Deshalb sollte jeder die Ausnahme kühl abfangen.

[^ 1]: Qiita allein http://qiita.com/daylife/items/b977f4f29b1f8ced3a02, http://qiita.com/KIchiro/items/4fafd74c46d08275eb56, http://qiita.com/yoshi389111/items/c6b7f7