Java 8：Lambda-Streams、メソッドによる例外付きフィルタリング
私は、Java 8のラムダ式を試してみるのに問題があります。通常はうまくいきますが、今はIOExceptionをスローするメソッドがあります。次のコードを見れば最高です。
class Bank{
....
public Set<String> getActiveAccountNumbers() throws IOException {
Stream<Account> s = accounts.values().stream();
s = s.filter(a -> a.isActive());
Stream<String> ss = s.map(a -> a.getNumber());
return ss.collect(Collectors.toSet());
}
....
}
interface Account{
....
boolean isActive() throws IOException;
String getNumber() throws IOException;
....
}
問題はそれがコンパイルされないことです、私はisActiveとgetNumberメソッドの可能な例外をキャッチしなければならないので。しかし、以下のようにtry-catch-Blockを明示的に使用したとしても、Exceptionをキャッチしないため、コンパイルできません。そのため、JDKにバグがあるか、これらの例外を捕捉する方法がわかりません。
class Bank{
....
//Doesn't compile either
public Set<String> getActiveAccountNumbers() throws IOException {
try{
Stream<Account> s = accounts.values().stream();
s = s.filter(a -> a.isActive());
Stream<String> ss = s.map(a -> a.getNumber());
return ss.collect(Collectors.toSet());
}catch(IOException ex){
}
}
....
}
どうやって動かすことができますか？誰かが私に正しい解決策を教えてくれる？
例外をキャッチする必要があります 前 /それはラムダをエスケープします。
s = s.filter(a -> { try { return a.isActive(); }
catch (IOException e) { throw new UncheckedIOException(e); }}});
ラムダは、あなたが書いた場所では評価されず、JDKクラス内の、まったく関係のない場所で評価されるという事実を考えてみてください。それで、それはそのチェックされた例外が投げられる点になるでしょう、そしてその場所でそれは宣言されません。
チェックされた例外をチェックされていない例外に変換するラムダのラッパーを使用することでそれに対処できます。
public static <T> T uncheckCall(Callable<T> callable) {
try { return callable.call(); }
catch (RuntimeException e) { throw e; }
catch (Exception e) { throw new RuntimeException(e); }
}
あなたの例は次のように書かれるでしょう
return s.filter(a -> uncheckCall(a::isActive))
.map(Account::getNumber)
.collect(toSet());
私のプロジェクトでは、この問題をラップせずに扱います。代わりに、コンパイラによる例外のチェックを事実上無効にする方法を使用します。言うまでもありませんが、これは慎重に処理する必要があります。また、プロジェクトのすべての人が、チェックされていない例外が宣言されていない場所に表示される可能性があることに注意する必要があります。これは配管コードです：
public static <T> T uncheckCall(Callable<T> callable) {
try { return callable.call(); }
catch (Exception e) { return sneakyThrow(e); }
}
public static void uncheckRun(RunnableExc r) {
try { r.run(); } catch (Exception e) { sneakyThrow(e); }
}
public interface RunnableExc { void run() throws Exception; }
@SuppressWarnings("unchecked")
private static <T extends Throwable> void sneakyThrow(Throwable t) throws T {
throw (T) t;
}
IOException で宣言していなくても、 collect があなたの顔に投げ込まれることを期待できます。 ほとんどの、しかしすべてではない 実際の状況では、とにかく例外を再スローして一般的な失敗として処理したいと思うでしょう。これらすべての場合において、明快さや正確さにおいて何も失われていません。その場で例外に実際に反応したいと思う他の場合にだけ注意してください。キャッチするIOExceptionがあることを開発者がコンパイラに気付かれることはなく、キャッチしようとするとコンパイラは実際に文句を言います。
静的な痛みをラムダで伝播することもできるので、全体が読みやすくなります。
s.filter(a -> propagate(a::isActive))
ここでpropagateはJava.util.concurrent.Callableをパラメータとして受け取り、呼び出し中に発生した例外をRuntimeExceptionに変換します。 Guavaにも同様の変換方法があります Throwables＃propagate（Throwable） 。
このメソッドはラムダメソッドチェーニングに不可欠であるように思われるので、いつか人気のあるライブラリに追加されるか、この伝播動作がデフォルトになることを願っています。
public class PropagateExceptionsSample {
// a simplified version of Throwables#propagate
public static RuntimeException runtime(Throwable e) {
if (e instanceof RuntimeException) {
return (RuntimeException)e;
}
return new RuntimeException(e);
}
// this is a new one, n/a in public libs
// Callable just suits as a functional interface in JDK throwing Exception
public static <V> V propagate(Callable<V> callable){
try {
return callable.call();
} catch (Exception e) {
throw runtime(e);
}
}
public static void main(String[] args) {
class Account{
String name;
Account(String name) { this.name = name;}
public boolean isActive() throws IOException {
return name.startsWith("a");
}
}
List<Account> accounts = new ArrayList<>(Arrays.asList(new Account("andrey"), new Account("angela"), new Account("pamela")));
Stream<Account> s = accounts.stream();
s
.filter(a -> propagate(a::isActive))
.map(a -> a.name)
.forEach(System.out::println);
}
}
このUtilExceptionヘルパークラスを使用すると、Javaストリームで次のようにチェック済みの例外を使用できます。
Stream.of("Java.lang.Object", "Java.lang.Integer", "Java.lang.String")
.map(rethrowFunction(Class::forName))
.collect(Collectors.toList());
注Class::forNameはClassNotFoundExceptionをスローします。これはチェックされています。ストリーム自体もClassNotFoundExceptionをスローしますが、これはラップされた未チェックの例外ではありません。
public final class UtilException {
@FunctionalInterface
public interface Consumer_WithExceptions<T, E extends Exception> {
void accept(T t) throws E;
}
@FunctionalInterface
public interface BiConsumer_WithExceptions<T, U, E extends Exception> {
void accept(T t, U u) throws E;
}
@FunctionalInterface
public interface Function_WithExceptions<T, R, E extends Exception> {
R apply(T t) throws E;
}
@FunctionalInterface
public interface Supplier_WithExceptions<T, E extends Exception> {
T get() throws E;
}
@FunctionalInterface
public interface Runnable_WithExceptions<E extends Exception> {
void run() throws E;
}
/** .forEach(rethrowConsumer(name -> System.out.println(Class.forName(name)))); or .forEach(rethrowConsumer(ClassNameUtil::println)); */
public static <T, E extends Exception> Consumer<T> rethrowConsumer(Consumer_WithExceptions<T, E> consumer) throws E {
return t -> {
try { consumer.accept(t); }
catch (Exception exception) { throwAsUnchecked(exception); }
};
}
public static <T, U, E extends Exception> BiConsumer<T, U> rethrowBiConsumer(BiConsumer_WithExceptions<T, U, E> biConsumer) throws E {
return (t, u) -> {
try { biConsumer.accept(t, u); }
catch (Exception exception) { throwAsUnchecked(exception); }
};
}
/** .map(rethrowFunction(name -> Class.forName(name))) or .map(rethrowFunction(Class::forName)) */
public static <T, R, E extends Exception> Function<T, R> rethrowFunction(Function_WithExceptions<T, R, E> function) throws E {
return t -> {
try { return function.apply(t); }
catch (Exception exception) { throwAsUnchecked(exception); return null; }
};
}
/** rethrowSupplier(() -> new StringJoiner(new String(new byte[]{77, 97, 114, 107}, "UTF-8"))), */
public static <T, E extends Exception> Supplier<T> rethrowSupplier(Supplier_WithExceptions<T, E> function) throws E {
return () -> {
try { return function.get(); }
catch (Exception exception) { throwAsUnchecked(exception); return null; }
};
}
/** uncheck(() -> Class.forName("xxx")); */
public static void uncheck(Runnable_WithExceptions t)
{
try { t.run(); }
catch (Exception exception) { throwAsUnchecked(exception); }
}
/** uncheck(() -> Class.forName("xxx")); */
public static <R, E extends Exception> R uncheck(Supplier_WithExceptions<R, E> supplier)
{
try { return supplier.get(); }
catch (Exception exception) { throwAsUnchecked(exception); return null; }
}
/** uncheck(Class::forName, "xxx"); */
public static <T, R, E extends Exception> R uncheck(Function_WithExceptions<T, R, E> function, T t) {
try { return function.apply(t); }
catch (Exception exception) { throwAsUnchecked(exception); return null; }
}
@SuppressWarnings ("unchecked")
private static <E extends Throwable> void throwAsUnchecked(Exception exception) throws E { throw (E)exception; }
}
それを使用する方法に関する他の多くの例（静的にUtilExceptionをインポートした後）：
@Test
public void test_Consumer_with_checked_exceptions() throws IllegalAccessException {
Stream.of("Java.lang.Object", "Java.lang.Integer", "Java.lang.String")
.forEach(rethrowConsumer(className -> System.out.println(Class.forName(className))));
Stream.of("Java.lang.Object", "Java.lang.Integer", "Java.lang.String")
.forEach(rethrowConsumer(System.out::println));
}
@Test
public void test_Function_with_checked_exceptions() throws ClassNotFoundException {
List<Class> classes1
= Stream.of("Object", "Integer", "String")
.map(rethrowFunction(className -> Class.forName("Java.lang." + className)))
.collect(Collectors.toList());
List<Class> classes2
= Stream.of("Java.lang.Object", "Java.lang.Integer", "Java.lang.String")
.map(rethrowFunction(Class::forName))
.collect(Collectors.toList());
}
@Test
public void test_Supplier_with_checked_exceptions() throws ClassNotFoundException {
Collector.of(
rethrowSupplier(() -> new StringJoiner(new String(new byte[]{77, 97, 114, 107}, "UTF-8"))),
StringJoiner::add, StringJoiner::merge, StringJoiner::toString);
}
@Test
public void test_uncheck_exception_thrown_by_method() {
Class clazz1 = uncheck(() -> Class.forName("Java.lang.String"));
Class clazz2 = uncheck(Class::forName, "Java.lang.String");
}
@Test (expected = ClassNotFoundException.class)
public void test_if_correct_exception_is_still_thrown_by_method() {
Class clazz3 = uncheck(Class::forName, "INVALID");
}
ただし、次の利点、欠点、制限事項を理解する前に使用しないでください。
•呼び出し元コードがチェック済み例外を処理する場合は、ストリームを含むメソッドのthrows節にそれを追加する必要があります。コンパイラはそれを追加することをもう強制しないので、それを忘れる方が簡単です。
•呼び出し元のコードがすでにチェック済みの例外を処理している場合は、ストリームを含むメソッド宣言にthrows句を追加するようにコンパイラーに指示されます（そうでない場合は、対応するtryステートメントの本体で例外はスローされません）。 ）.
•いずれにせよ、ストリームを含むメソッド内で、チェックされた例外を捕捉するためにストリーム自体を囲むことはできません（試してみると、コンパイラは次のように言うでしょう。対応するtry文の本体に例外が発生しない）。
•文字通り、宣言した例外をスローできないメソッドを呼び出す場合は、throws節を含めないでください。例：new String（byteArr、 "UTF-8"）はUnsupportedEncodingExceptionをスローしますが、UTF-8は常に存在することがJava仕様によって保証されています。ここでは、throw宣言は厄介なものであり、最小限の定型句でそれを黙らせるためのあらゆる解決策は大歓迎です。
•チェック例外を嫌いで、最初からJava言語に追加してはいけないと感じる場合（ますます多くの人がこのように考えています。私はその一人ではありません）。ストリームを含むメソッドのthrows節。チェックされた例外は、その後、UNcheckされた例外のように動作します。
•throws宣言を追加するオプションがなく、例外をスローすることが完全に適切な場合に厳密なインタフェースを実装している場合は、単に例外をスローして例外をスローする特権を取得すると、誤った例外を伴うスタックトレースが発生します。実際に何が問題になったのかについての情報はありません。良い例はRunnable.run（）で、これはチェックされた例外を投げません。この場合は、ストリームを含むメソッドのthrows節にチェック済みの例外を追加しないことにします。
•いずれにせよ、ストリームを含むメソッドのthrows節にチェック例外を追加しない（または追加するのを忘れた）場合は、CHECKED例外をスローすることによる次の2つの結果に注意してください。
1）呼び出しコードは名前でそれを捕らえることができないでしょう（あなたが試みるならば、コンパイラは言うでしょう：例外は対応するtryステートメントの本体で決して投げられません）。それはバブルになり、おそらく "catch Exception"または "catch Throwable"によってメインプログラムループにキャッチされるでしょう。
2）これは、驚くことではないという原則に反します。すべての可能性のある例外を確実に捕捉できるようにするためには、RuntimeExceptionを捕捉するだけでは不十分です。このため、フレームワークコードではなく、あなたが完全に管理しているビジネスコードでのみこれを行うべきです。
結論として、ここでの制限はそれほど深刻ではないと思います。そしてUtilExceptionクラスを恐れることなく使用することができます。しかし、それはあなた次第です！
- 参考文献：
- http://www.philandstuff.com/2012/04/28/sneakily-throwing-checked-exceptions.html
- http://www.mail-archive.com/[email protected]/msg05984.html
- Project Lombokアノテーション：@SneakyThrows
- Brian Goetzの意見は（反対）： Java 8ストリーム内からCHECKED例外をスローする方法は？
- https://softwareengineering.stackexchange.com/questions/225931/workaround-for-Java-checked-exceptions?newreg=ddf0dd15e8174af8ba52e091cf85688e *
ラムダをラップして未チェックの例外をスローし、後でターミナルオペレーションでその未チェックの例外をラップ解除することで、独自のStreamname__バリアントをロールバックすることができます。
@FunctionalInterface
public interface ThrowingPredicate<T, X extends Throwable> {
public boolean test(T t) throws X;
}
@FunctionalInterface
public interface ThrowingFunction<T, R, X extends Throwable> {
public R apply(T t) throws X;
}
@FunctionalInterface
public interface ThrowingSupplier<R, X extends Throwable> {
public R get() throws X;
}
public interface ThrowingStream<T, X extends Throwable> {
public ThrowingStream<T, X> filter(
ThrowingPredicate<? super T, ? extends X> predicate);
public <R> ThrowingStream<T, R> map(
ThrowingFunction<? super T, ? extends R, ? extends X> mapper);
public <A, R> R collect(Collector<? super T, A, R> collector) throws X;
// etc
}
class StreamAdapter<T, X extends Throwable> implements ThrowingStream<T, X> {
private static class AdapterException extends RuntimeException {
public AdapterException(Throwable cause) {
super(cause);
}
}
private final Stream<T> delegate;
private final Class<X> x;
StreamAdapter(Stream<T> delegate, Class<X> x) {
this.delegate = delegate;
this.x = x;
}
private <R> R maskException(ThrowingSupplier<R, X> method) {
try {
return method.get();
} catch (Throwable t) {
if (x.isInstance(t)) {
throw new AdapterException(t);
} else {
throw t;
}
}
}
@Override
public ThrowingStream<T, X> filter(ThrowingPredicate<T, X> predicate) {
return new StreamAdapter<>(
delegate.filter(t -> maskException(() -> predicate.test(t))), x);
}
@Override
public <R> ThrowingStream<R, X> map(ThrowingFunction<T, R, X> mapper) {
return new StreamAdapter<>(
delegate.map(t -> maskException(() -> mapper.apply(t))), x);
}
private <R> R unmaskException(Supplier<R> method) throws X {
try {
return method.get();
} catch (AdapterException e) {
throw x.cast(e.getCause());
}
}
@Override
public <A, R> R collect(Collector<T, A, R> collector) throws X {
return unmaskException(() -> delegate.collect(collector));
}
}
それからStreamname__と全く同じ方法でこれを使うことができます：
Stream<Account> s = accounts.values().stream();
ThrowingStream<Account, IOException> ts = new StreamAdapter<>(s, IOException.class);
return ts.filter(Account::isActive).map(Account::getNumber).collect(toSet());
この解決法はかなりの定型文を必要とするでしょう、それで私はあなたが全体のStreamname__クラスのために私がここで述べたことをまさに行う 私がすでに作ったライブラリ を見ることを勧めます。
#propagate（）メソッドを使用してください。 Sam Beranによる Java 8ブログからの非Guava実装のサンプル ：
public class Throwables {
public interface ExceptionWrapper<E> {
E wrap(Exception e);
}
public static <T> T propagate(Callable<T> callable) throws RuntimeException {
return propagate(callable, RuntimeException::new);
}
public static <T, E extends Throwable> T propagate(Callable<T> callable, ExceptionWrapper<E> wrapper) throws E {
try {
return callable.call();
} catch (RuntimeException e) {
throw e;
} catch (Exception e) {
throw wrapper.wrap(e);
}
}
}
AbacusUtil で Stream および Try を使用した以下の簡単なコードで解決できます。
Stream.of(accounts).filter(a -> Try.call(a::isActive)).map(a -> Try.call(a::getNumber)).toSet();
開示：私はAbacusUtilの開発者です。
（RuntimeExceptionに）IOException処理コードを正しく追加するためのメソッドは次のようになります。
Stream<Account> s = accounts.values().stream();
s = s.filter(a -> { try { return a.isActive(); }
catch (IOException e) { throw new RuntimeException(e); }});
Stream<String> ss = s.map(a -> { try { return a.getNumber() }
catch (IOException e) { throw new RuntimeException(e); }});
return ss.collect(Collectors.toSet());
ここでの問題は、IOExceptionをRuntimeExceptionとしてキャプチャしてIOExceptionに戻す必要があることです。これにより、上記のメソッドにさらに多くのコードが追加されます。
このようにすることができるのになぜStreamを使うのか - そしてメソッドはIOExceptionを投げるので、そのためにも余分なコードは必要ありません。
Set<String> set = new HashSet<>();
for(Account a: accounts.values()){
if(a.isActive()){
set.add(a.getNumber());
}
}
return set;
これは直接質問に答えるのではありません（他にも多くの回答があります）が、まず問題を回避しようとします。
私の経験では、Stream（または他のラムダ式）で例外を処理する必要性は、例外がスローされるべきでないメソッドからスローされることが宣言されているという事実から来ることがよくあります。これは多くの場合、ビジネスロジックとインプットおよびアウトプットを混在させることによって発生します。あなたのAccountインターフェースはその好例です。
interface Account {
boolean isActive() throws IOException;
String getNumber() throws IOException;
}
各ゲッターにIOExceptionをスローする代わりに、次のデザインを検討してください。
interface AccountReader {
Account readAccount(…) throws IOException;
}
interface Account {
boolean isActive();
String getNumber();
}
メソッドAccountReader.readAccount(…)は、データベースまたはファイルなどからアカウントを読み取り、成功しなかった場合は例外をスローすることができます。これは既に使用されているすべての値を含むAccountオブジェクトを構成します。値はreadAccount(…)によって既にロードされているので、ゲッターは例外をスローしません。したがって、例外をラップ、マスキング、または非表示にすることなく、ラムダで自由にそれらを使用できます。
もちろん、私が説明した方法でそれを実行することが常に可能というわけではありませんが、多くの場合それは完全にクリーンなコード（IMHO）につながります。
@marcgソリューションを拡張すると、通常はStreamsでchecked例外をスローしてキャッチできます。つまり、コンパイラーはキャッチ/再スローを要求しますあなたはストリームの外にいたのと同じです。
@FunctionalInterface
public interface Predicate_WithExceptions<T, E extends Exception> {
boolean test(T t) throws E;
}
/**
* .filter(rethrowPredicate(t -> t.isActive()))
*/
public static <T, E extends Exception> Predicate<T> rethrowPredicate(Predicate_WithExceptions<T, E> predicate) throws E {
return t -> {
try {
return predicate.test(t);
} catch (Exception exception) {
return throwActualException(exception);
}
};
}
@SuppressWarnings("unchecked")
private static <T, E extends Exception> T throwActualException(Exception exception) throws E {
throw (E) exception;
}
それでは、あなたの例は次のように書かれるでしょう（より明確に示すためにテストを追加する）：
@Test
public void testPredicate() throws MyTestException {
List<String> nonEmptyStrings = Stream.of("ciao", "")
.filter(rethrowPredicate(s -> notEmpty(s)))
.collect(toList());
assertEquals(1, nonEmptyStrings.size());
assertEquals("ciao", nonEmptyStrings.get(0));
}
private class MyTestException extends Exception { }
private boolean notEmpty(String value) throws MyTestException {
if(value==null) {
throw new MyTestException();
}
return !value.isEmpty();
}
@Test
public void testPredicateRaisingException() throws MyTestException {
try {
Stream.of("ciao", null)
.filter(rethrowPredicate(s -> notEmpty(s)))
.collect(toList());
fail();
} catch (MyTestException e) {
//OK
}
}
あなたの例は次のように書くことができます。
import utils.stream.Unthrow;
class Bank{
....
public Set<String> getActiveAccountNumbers() {
return accounts.values().stream()
.filter(a -> Unthrow.wrap(() -> a.isActive()))
.map(a -> Unthrow.wrap(() -> a.getNumber()))
.collect(Collectors.toSet());
}
....
}
Unthrowクラスをここに取ることができます https://github.com/SeregaLBN/StreamUnthrower
この問題を念頭に置いて、私はチェック例外とラムダを扱うための小さなライブラリを開発しました。カスタムアダプタを使用すると、既存の機能タイプと統合できます。
stream().map(unchecked(URI::new)) //with a static import
私はストリーム（Java -8）でチェック例外を処理する方法を見ていません、私が適用した唯一の方法はストリームでチェック例外をキャッチし、未チェック例外として再スローします。
Arrays.stream(VERSIONS)
.map(version -> TemplateStore.class
.getClassLoader().getResourceAsStream(String.format(TEMPLATE_FILE_MASK, version)))
.map(inputStream -> {
try {
return ((EdiTemplates) JAXBContext.newInstance(EdiTemplates.class).createUnmarshaller()
.unmarshal(inputStream)).getMessageTemplate();
} catch (JAXBException e) {
throw new IllegalArgumentException(ERROR, e);
}})
.flatMap(Collection::stream)
.collect(Collectors.toList());
Javaの機能的なインターフェースは、チェック済みまたはチェックなし例外を宣言しません。メソッドのシグネチャを以下から変更する必要があります。
boolean isActive() throws IOException;
String getNumber() throwsIOException;
に：
boolean isActive();
String getNumber();
またはtry-catchブロックで処理してください。
public Set<String> getActiveAccountNumbers() {
Stream<Account> s = accounts.values().stream();
s = s.filter(a ->
try{
a.isActive();
}catch(IOException e){
throw new RuntimeException(e);
}
);
Stream<String> ss = s.map(a ->
try{
a.getNumber();
}catch(IOException e){
throw new RuntimeException(e);
}
);
return ss.collect(Collectors.toSet());
}
他の選択肢は、カスタムラッパーを書くか、ThrowingFunctionのようなライブラリを使うことです。このライブラリでは、pom.xmlに依存関係を追加するだけです。
<dependency>
<groupId>pl.touk</groupId>
<artifactId>throwing-function</artifactId>
<version>1.3</version>
</dependency>
そして、ThrowingFunction、ThrowingConsumer、ThrowingPredicate、ThrowingRunnable、ThrowingSupplierなどの特定のクラスを使用します。
最後に、コードは次のようになります。
public Set<String> getActiveAccountNumbers() {
return accounts.values().stream()
.filter(ThrowingPredicate.unchecked(Account::isActive))
.map(ThrowingFunction.unchecked(Account::getNumber))
.collect(Collectors.toSet());
}
サードパーティのライブラリを使用しても構わないのであれば、AOLの cyclops-react lib、disclosure ::私は寄稿者ですが、 ExceptionSoftener こちらのクラスで役に立つことができます。
s.filter(softenPredicate(a->a.isActive()));