Java 8: Як я можу працювати з методами метання винятків у потоках?

Припустимо, у мене є клас і метод

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

Тепер я хотів би зателефонувати foo для кожного екземпляра, який Aпередається потоком, наприклад:

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

Питання: Як я правильно поводжусь із винятком? Код не збирається на моїй машині, оскільки я не обробляю можливі винятки, які можуть бути викинуті foo (). throws ExceptionЗ , barздається, марно тут. Чому так?

Вам потрібно загорнути виклик методу в інший, де ви не кидаєте перевірені винятки . Ви все одно можете кинути все, що є підкласом RuntimeException.

Звичайна ідіома, що обгортає щось таке:

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

(Supertype винятком Exceptionє лише використовується в якості прикладу, не намагатися спіймати його самостійно)

Тоді ви можете назвати його: as.forEach(this::safeFoo).

Якщо все, що вам потрібно, - це посилатися foo, і ви віддаєте перевагу розповсюдженню виключення як є (без обгортання), ви можете також просто forзамість цього використовувати цикл Java (після перетворення потоку в Iterable з деякою хитрістю ):

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

Це, принаймні, те, що я роблю в своїх тестах JUnit, де я не хочу переживати проблеми, пов'язані з перевіркою своїх перевірених винятків (і насправді віддаю перевагу моїм тестам викидати незагорнуті оригінали)

Це запитання може бути трохи старим, але тому, що я думаю, що "правильна" відповідь тут лише один із способів, який може призвести до прихованих проблем пізніше у вашому коді. Навіть якщо є суперечка , перевірені винятки існують не просто так.

На мою думку, найелегантніший спосіб, який ви можете знайти, був наданий Мішею. Тут викладені винятки у виконанні потоків Java 8 , просто виконуючи дії у "ф'ючерсах". Таким чином, ви можете запускати всі робочі частини та збирати непрацюючі винятки як єдину. В іншому випадку ви можете зібрати їх у списку та обробити їх пізніше.

Аналогічний підхід походить від Бенджі Вебера . Він пропонує створити власний тип для збору робочих, а не працюючих деталей.

Залежно від того, що ви дійсно хочете домогтися простого відображення між вхідними значеннями та вихідними значеннями, що сталися, Винятки також можуть працювати для вас.

Якщо вам не подобається жоден із цих способів, рекомендуйте використовувати (залежно від оригінального винятку) принаймні власне виключення.

Я пропоную скористатися класом Throwables Google Guava

Propagate ( Throwable Throwable)

Поширення, що передається як-є, якщо це екземпляр RuntimeException або Помилка, або в крайньому випадку, загортає його в RuntimeException і потім поширює. **

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

ОНОВЛЕННЯ:

Тепер, коли це застаріле використання:

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

Ви можете перегорнути та вилучити винятки таким чином.

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);
    }
}

Ви можете зробити одну з наступних дій:

• поширювати перевірений виняток,
• заверніть його та поширюйте неперевірений виняток, або
• зловити виняток і припинити розповсюдження.

Кілька бібліотек дозволяють зробити це легко. Приклад нижче написаний за допомогою моєї бібліотеки NoException .

// 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)));

Більш зрозумілий спосіб:

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

Просто прихойте це, RuntimeExceptionщоб пройти йогоforEach()

  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();
      }
  }

Хоча в цей момент я не затримаюсь проти когось, якщо вони скажуть пропустити потоки та йти циклом for, якщо тільки:

• ви не створюєте свій потік за допомогою Collection.stream(), тобто не прямого перекладу до циклу for.
• ви намагаєтеся використовувати parallelstream()