Java 8: Bagaimana cara saya bekerja dengan pengecualian melempar metode dalam aliran?

Misalkan saya memiliki kelas dan metode

class A {
  void foo() throws Exception() {
    ...
  }
}

Sekarang saya ingin memanggil foo untuk setiap contoh yang Adikirimkan oleh aliran seperti:

void bar() throws Exception {
  Stream<A> as = ...
  as.forEach(a -> a.foo());
}

Pertanyaan: Bagaimana cara saya menangani pengecualian dengan benar? Kode tidak dikompilasi di mesin saya karena saya tidak menangani kemungkinan pengecualian yang dapat dilempar oleh foo (). The throws Exceptionof bartampaknya tidak berguna di sini. Mengapa demikian?

Anda harus memasukkan panggilan metode Anda ke panggilan lain, di mana Anda tidak membuang pengecualian yang dicentang . Anda masih dapat membuang apa pun yang merupakan subkelas dari RuntimeException.

Idiom pembungkus yang normal adalah sesuatu seperti:

private void safeFoo(final A a) {
    try {
        a.foo();
    } catch (Exception ex) {
        throw new RuntimeException(ex);
    }
}

(Supertype pengecualian Exceptionyang hanya digunakan sebagai contoh, tidak pernah mencoba untuk menangkapnya sendiri)

Kemudian Anda bisa menyebutnya dengan: as.forEach(this::safeFoo).

Jika semua yang Anda inginkan adalah memanggil foo, dan Anda lebih memilih untuk menyebarkan pengecualian seperti apa adanya (tanpa membungkus), Anda juga dapat menggunakan forloop Java saja (setelah mengubah Stream menjadi Iterable dengan beberapa tipu daya ):

for (A a : (Iterable<A>) as::iterator) {
   a.foo();
}

Ini, setidaknya, apa yang saya lakukan dalam tes JUnit saya, di mana saya tidak ingin melalui masalah membungkus pengecualian diperiksa (dan sebenarnya lebih suka tes saya untuk membuang yang asli yang terbuka)

Pertanyaan ini mungkin agak lama, tetapi karena saya pikir jawaban "benar" di sini hanya satu cara yang dapat menyebabkan beberapa masalah tersembunyi di kode Anda nanti. Bahkan jika ada sedikit Kontroversi , Pengecualian Diperiksa ada karena suatu alasan.

Cara paling elegan menurut saya dapat Anda temukan diberikan oleh Misha di sini Pengecualian runtime agregat di Java 8 stream dengan hanya melakukan tindakan dalam "masa depan". Jadi, Anda dapat menjalankan semua bagian yang bekerja dan mengumpulkan Pengecualian yang tidak berfungsi sebagai satu bagian. Kalau tidak, Anda bisa mengumpulkan semuanya dalam Daftar dan memprosesnya nanti.

Pendekatan serupa datang dari Benji Weber . Dia menyarankan untuk membuat tipe sendiri untuk mengumpulkan bagian yang bekerja dan tidak.

Bergantung pada apa yang Anda benar-benar ingin capai, pemetaan sederhana antara nilai input dan Nilai Output yang terjadi Pengecualian juga berlaku untuk Anda.

Jika Anda tidak menyukai cara-cara ini, pertimbangkan untuk menggunakan (tergantung pada Pengecualian Asli), setidaknya pengecualian sendiri.

Saya sarankan untuk menggunakan kelas Google Guava Throwables

merambat ( Throwable throwable)

Propagate yang dapat dilempar apa adanya adalah jika itu adalah turunan dari RuntimeException atau Error, atau sebagai upaya terakhir, membungkusnya dalam RuntimeException dan kemudian menyebar. **

void bar() {
    Stream<A> as = ...
    as.forEach(a -> {
        try {
            a.foo()
        } catch(Exception e) {
            throw Throwables.propagate(e);
        }
    });
}

MEMPERBARUI:

Sekarang sudah tidak digunakan lagi:

void bar() {
    Stream<A> as = ...
    as.forEach(a -> {
        try {
            a.foo()
        } catch(Exception e) {
            Throwables.throwIfUnchecked(e);
            throw new RuntimeException(e);
        }
    });
}

Anda dapat membungkus dan membuka bukaan pengecualian dengan cara ini.

class A {
    void foo() throws Exception {
        throw new Exception();
    }
};

interface Task {
    void run() throws Exception;
}

static class TaskException extends RuntimeException {
    private static final long serialVersionUID = 1L;
    public TaskException(Exception e) {
        super(e);
    }
}

void bar() throws Exception {
      Stream<A> as = Stream.generate(()->new A());
      try {
        as.forEach(a -> wrapException(() -> a.foo())); // or a::foo instead of () -> a.foo()
    } catch (TaskException e) {
        throw (Exception)e.getCause();
    }
}

static void wrapException(Task task) {
    try {
        task.run();
    } catch (Exception e) {
        throw new TaskException(e);
    }
}

Anda mungkin ingin melakukan salah satu dari yang berikut:

• memperbanyak pengecualian yang diperiksa,
• bungkus dan sebarkan pengecualian yang tidak dicentang, atau
• tangkap pengecualian dan hentikan propagasi.

Beberapa perpustakaan memungkinkan Anda melakukannya dengan mudah. Contoh di bawah ini ditulis menggunakan pustaka NoException saya .

// Propagate checked exception
as.forEach(Exceptions.sneak().consumer(A::foo));

// Wrap and propagate unchecked exception
as.forEach(Exceptions.wrap().consumer(A::foo));
as.forEach(Exceptions.wrap(MyUncheckedException::new).consumer(A::foo));

// Catch the exception and stop propagation (using logging handler for example)
as.forEach(Exceptions.log().consumer(Exceptions.sneak().consumer(A::foo)));

Cara yang lebih mudah dibaca:

class A {
  void foo() throws MyException() {
    ...
  }
}

Cukup sembunyikan di RuntimeExceptionuntuk melewatinyaforEach()

  void bar() throws MyException {
      Stream<A> as = ...
      try {
          as.forEach(a -> {
              try {
                  a.foo();
              } catch(MyException e) {
                  throw new RuntimeException(e);
              }
          });
      } catch(RuntimeException e) {
          throw (MyException) e.getCause();
      }
  }

Meskipun pada titik ini saya tidak akan menahan seseorang jika mereka mengatakan melewatkan aliran dan pergi dengan for for loop, kecuali:

• Anda tidak membuat aliran menggunakan Collection.stream(), yaitu terjemahan tidak langsung ke for for loop.
• Anda mencoba menggunakannya parallelstream()