Handling Exceptions in Java Streams using a Functional Interface

I was reviewing some code recently and ran into something like this:

subject.getIdentities().forEach(i -> {
  try {
    caseService.updateDocument(i.getCase());
  } catch (Exception e) {
    log.error(e); 
  }
});

If you have read my other articles about functional programming concepts in Java (here and here), you can probably guess that I am a big fan of lambda expressions. However, one of the primary advantages of using lambda expressions is terseness. The above code looks not-so-terse and a bit messy to me. How can we clean this up? Functional interfaces to the rescue.

What do we need? We know that a forEach expects a Consumer as an input. If we could wrap our logic that handles an exception in a Consumer, we could use the logic in the forEach.

The main logic inside the forEach is the following line:

//try catch removed
// i is an Identity and updateDocument returns a UpdateResponse
i -> caseService.updateDocument(i.getCase());

We know the input and the return type, and we can create a functional interface whose method throws an Exception.

@FunctionalInterface
public interface ThrowingFunction<Identity, UpdateResponse> {
  UpdateResponse apply(Identity i) throws Exception;
}

We can make this more usable with generics.

@FunctionalInterface
public interface ThrowingFunction<T, R> {
  R apply(T t) throws Exception;
}

With the interface created, the original logic can be target typed as such:

ThrowingFunction<Identity, UpdateResponse> tf = i -> caseService.updateDocument(i.getCase());

Now that we have a functional interface for our logic, we can pass it as a parameter to a method that handles the exception and returns a Consumer we can use in the forEach.

private static <T, R> Consumer<T> wrap(ThrowingFunction<T, R> f) {
  return t -> {
    try  {
      f.apply(t);
    } catch (Exception e) {
      throw new RuntimeException(e);
    }
  };
}

It's a little weird looking, but essentially the wrap method takes a ThrowingFunction as input and handles executing the function or catching and throwing the Exception in a Consumer.

Now we can wrap any logic used inside a forEach that may throw an exception. It looks something like this:

// target type the original logic
ThrowingFunction<Identity, UpdateResponse> tf = i -> caseService.updateDocument(i.getCase()):

// pass logic to the wrapmethod
// which will execute the function or throw a RunTimeException. 
Consumer<Identity> p = wrap(tf);

// use Consumer in foreach
subject.getIdentities().forEach(p); 

Or if you prefer one line:

subject.getIdentities().forEach(wrap(i -> caseService.updateDocument(i.getCase())));

Much better! You could implement something similar to handle different types of functional interfaces. For instance, a map operation only takes a Function as an input. Instead of a wrap method that returns a Consumer you could have a method that returns a Function.
This is just one pattern for handling exceptions in streams. I should mention there are libraries that do this kind of thing for you if you don't want to roll with your own implementation. Or you could use a monad to handle success/failures, but that is beyond the scope of this post. Let me know if you have implemented any other ways of handling exceptions in streams!