如何映射 Java 流中的 RuntimeExceptions 以从无效流元素中“恢复”

Question

想象一下，我正在构建一个库，它将接收一个整数流，而库代码需要做的就是返回一个字符串流，其中包含数字的字符串表示形式。

public Stream<String> convertToString(Stream<Integer> input) {
  return input.map(n -> String.valueOf(n));
}

但是，假设有人决定使用以下代码调用我的函数：

Stream<Integer> input = Stream.of(1,2,3)
  .map(n -> {
    if (n %3 ) { throw new RuntimeException("3s are not welcome here!"); }
    else { return n; }
  }

Stream<String> output = convertToString(input);

由于我希望我的 API 合同能够处理这种情况并仍然返回字符串流，我想知道如何更改我的代码，以便它检测到流中存在异常并从异常中“恢复”通过将其映射到特殊的"NaN"值。

最后，我希望我的输出 Stream 为"1","2","NaN"

笔记：

• 我不希望我的 API 必须为输入定义一个特殊的包装器。
• 由于依赖关系的影响，我不想依赖 3rd 方库。
• 我不知道流有多大或以什么速率生成，所以我不能对所有值使用任何类型的缓存/预加载。

Java 8 Streams 可以做到这一点吗？

使用迭代器，我想我可以做到：

public class SafeIntegerToStringIterator implements Iterator<String> {
  Iterator<Integer> innerIterator;
  ...
  public String next() throws NoSuchElementException {
    try { return String.valueOf(this.innerIterator.next()); }
    catch (RuntimeException e) { return "NaN"; }
  }

}
...
public Iterator<String> convertToString(Iterator<Integer> input) {
  return new SafeIntegerToStringIterator(input);
}

谢谢

Answer 1

注意：请参阅本文末尾的编辑，修复了原始答案中的错误。 无论如何，我正在离开我的原始答案，因为它在许多情况下仍然有用，我认为它有助于解决OP的问题，至少有一些限制。

---

您使用Iterator方法是正确的方向。 可以按如下方式起草解决方案：将流转换为迭代器，按照已经完成的方式包装迭代器，然后从包装器迭代器创建流，除了您应该使用Spliterator 。 这是代码：

private static <T> Stream<T> asNonThrowingStream(
        Stream<T> stream,
        Supplier<? extends T> valueOnException) {

    // Get spliterator from original stream
    Spliterator<T> spliterator = stream.spliterator();

    // Return new stream from wrapper spliterator
    return StreamSupport.stream(

        // Extending AbstractSpliterator is enough for our purpose
        new Spliterators.AbstractSpliterator<T>(
                spliterator.estimateSize(),
                spliterator.characteristics()) {

            // We only need to implement tryAdvance
            @Override
            public boolean tryAdvance(Consumer<? super T> action) {
                try {
                    return spliterator.tryAdvance(action);
                } catch (RuntimeException e) {
                    action.accept(valueOnException.get());
                    return true;
                }
            }
        }, stream.isParallel());
}

我们正在扩展AbstractSpliterator来包装原始流返回的spliterator。 我们只需要实现tryAdvance方法，该方法可以委托给原始的spliterator的tryAdvance方法，也可以捕获RuntimeException并使用提供的valueOnException值调用该操作。

Spliterator的契约指定如果操作被占用，则tryAdvance的返回值必须为true ，因此如果捕获了RuntimeException ，则意味着原始的spliterator已经从其自己的tryAdvance方法中抛出它。 因此，在这种情况下我们返回true ，这意味着该元素无论如何都被消耗了。

通过将这些值作为参数传递给AbstractSpliterator的构造函数来保留原始spliterator的估计大小和特征。

最后，我们通过StreamSupport.stream方法从新的spliterator创建一个新流。 如果原始流也是并行的，则新流是并行的。

以下是如何使用上述方法：

public Stream<String> convertToString(Stream<Integer> input) {
    return asNonThrowingStream(input.map(String::valueOf), () -> "NaN");
}

---

编辑

根据Holger在下面的评论 ， 用户holi-java提供了一个解决方案，避免了Holger指出的陷阱。

这是代码：

<T> Stream<T> exceptionally(Stream<T> source, BiConsumer<Exception, Consumer<? super T>> handler) {
    class ExceptionallySpliterator extends AbstractSpliterator<T>
            implements Consumer<T> {

        private Spliterator<T> source;
        private T value;
        private long fence;

        ExceptionallySpliterator(Spliterator<T> source) {
            super(source.estimateSize(), source.characteristics());
            this.fence = source.getExactSizeIfKnown();
            this.source = source;
        }

        @Override
        public Spliterator<T> trySplit() {
            Spliterator<T> it = source.trySplit();
            return it == null ? null : new ExceptionallySpliterator(it);
        }

        @Override
        public boolean tryAdvance(Consumer<? super T> action) {
            return fence != 0 && consuming(action);
        }

        private boolean consuming(Consumer<? super T> action) {
            Boolean state = tryConsuming(action);
            if (state == null) {
                return true;
            }
            if (state) {
                action.accept(value);
                value = null;
                return true;
            }
            return false;
        }


        private Boolean tryConsuming(Consumer<? super T> action) {
            fence--;
            try {
                return source.tryAdvance(this);
            } catch (Exception ex) {
                handler.accept(ex, action);
                return null;
            }
        }

        @Override
        public void accept(T value) {
            this.value = value;
        }
    }

    return stream(new ExceptionallySpliterator(source.spliterator()), source.isParallel()).onClose(source::close);
}

如果您想进一步了解此解决方案，请参阅测试 。

Answer 2

流中间操作中发生错误，像您解决问题一样聪明的方法是使用代理设计模式 。 对于使用流api，您只需要通过StreamSupport＃stream ＆ Spliterators＃spliterator（Iterator，long，int）将Iterator从源Stream 代理到另一个Stream ，例如：

Stream<String> result = convertToString(Stream.of("1", "bad", "2")
                       .map(Integer::parseInt));



public Stream<String> convertToString(Stream<Integer> input) {
    return exceptionally(input, (e, action) -> action.accept(null))
            .map(it -> String.format("%s", it == null ? "NaN" : it));
}

---

当前版本Stream基于Iterator修复了Stream.of(T)错误，有关详细信息，请参阅我的问题 。

<T> Stream<T> exceptionally(Stream<T> source,
                            BiConsumer<Exception, Consumer<? super T>> handler) {
    Spliterator<T> s = source.spliterator();
    return StreamSupport.stream(
            spliterator(
                    exceptionally(s, handler),
                    s.estimateSize(),
                    s.characteristics()
            ),
            source.isParallel()
    ).onClose(source::close);
}


//Don't worried the thread-safe & robust since it is invisible for anyone
private <T> Iterator<T> exceptionally(Spliterator<T> spliterator,
                            BiConsumer<Exception, Consumer<? super T>> handler) {
    class ExceptionallyIterator implements Iterator<T>, Consumer<T> {
        private Iterator<T> source = Spliterators.iterator(spliterator);
        private T value;
        private boolean valueInReady = false;
        private boolean stop = false;

        @Override
        public boolean hasNext() {

            while (true) {
                if (valueInReady) return true;
                if (stop) return false;
                try {
                    return source.hasNext();
                } catch (Exception ex) {
                    stop = shouldStopTraversing(ex);
                    handler.accept(ex, this);
                }
            }
        }

        @Override
        public T next() {
            return valueInReady ? dump() : source.next();
        }

        private T dump() {
            T result = value;
            valueInReady = false;
            value = null;
            return result;
        }

        @Override
        public void accept(T value) {
            this.value = value;
            this.valueInReady = true;
        }
    }
    return new ExceptionallyIterator();
}

---

static final String BUG_CLASS = "java.util.stream.Streams$StreamBuilderImpl";

public static boolean shouldStopTraversing(Exception ex) {
    for (StackTraceElement element : ex.getStackTrace()) {
        if (BUG_CLASS.equals(element.getClassName())) {
            return true;
        }
    }
    return false;
}

Answer 3

import java.util.NoSuchElementException;
import java.util.Objects;
import java.util.function.Function;

public class RecoverableOptional<T> {
/**
 * Common instance for {@code empty()}.
 */
private static final RecoverableOptional<?> EMPTY = new     RecoverableOptional<>();

/**
 * If non-null, the value; if null, indicates no value is present
 */
private final T value;

/**
 * If non-null, the value; if null, indicates recover value is present
 */
private final T defaultValue;

/**
 * Constructs an empty instance.
 *
 * should exist per VM.
 */
private RecoverableOptional() {
    this.value = null;
    this.defaultValue = null;
}

/**
 * Returns an empty {@code Optional} instance.  No value is present for this
 * Optional.
 *
 * @param <T> Type of the non-existent value
 * @return an empty {@code Optional}
 * @apiNote Though it may be tempting to do so, avoid testing if an object
 * is empty by comparing with {@code ==} against instances returned by
 * {@code Option.empty()}. There is no guarantee that it is a singleton.
 */
public static <T> T empty() {
    @SuppressWarnings("unchecked")
    RecoverableOptional<T> t = (RecoverableOptional<T>) EMPTY;
    return t.get();
}

/**
 * Constructs an instance with the value present.
 *
 * @param value the non-null value to be present
 * @throws NullPointerException if value is null
 */
private RecoverableOptional(T value, T value2) {
    this.value = Objects.requireNonNull(value);
    this.defaultValue = value2;
}


/**
 * Returns an {@code Optional} with the specified present non-null value.
 *
 * @param <T>   the class of the value
 * @param value the value to be present, which must be non-null
 * @return an {@code Optional} with the value present
 * @throws NullPointerException if value is null
 */
private static <T> RecoverableOptional<T> of(T value, T value2) {
    return new RecoverableOptional<>(value, value2);
}

/**
 * Returns an {@code Optional} with the specified present non-null value.
 *
 * @param <T>   the class of the value
 * @param value2 the value to be present on recovery
 * @return an {@code Optional} with the value present
 * @throws NullPointerException if value is null
 */
public <T> RecoverableOptional<T> recoverWith(T value2) {
    return new RecoverableOptional<T>((T) value, value2);
}

/**
 * Returns an {@code Optional} describing the specified value, if non-null,
 * otherwise returns an empty {@code Optional}.
 *
 * @param <T>   the class of the value
 * @param value the possibly-null value to describe
 * @return an {@code Optional} with a present value if the specified value
 * is non-null, otherwise an empty {@code Optional}
 */
public static <T> RecoverableOptional<T> ofNullable(T value, T value2) {
    return value == null ? empty() : of(value, value2);
}

/**
 * Returns an {@code Optional} describing the specified value, if non-null,
 * otherwise returns an empty {@code Optional}.
 *
 * @param <T>   the class of the value
 * @param value the possibly-null value to describe
 * @return an {@code Optional} with a present value if the specified value
 * is non-null, otherwise an empty {@code Optional}
 */
public static <T> RecoverableOptional<T> ofNullable(T value) {
    return value == null ? empty() : of(value, null);
}

public T get() {
    if (value == null) {
        throw new NoSuchElementException("No value present");
    }
    return value;
}

public <U> U map(Function<? super T, ? extends U> mapper) {
    Objects.requireNonNull(mapper);
    if (!isPresent())
        return empty();
    else {
        try {
            return value == null ? null : mapper.apply(value);
        } catch (Exception e) {
            if (defaultValue == null) {
                return null;
            }
            return mapper.apply(defaultValue);
        }
    }
}

/**
 * Return {@code true} if there is a value present, otherwise {@code false}.
 *
 * @return {@code true} if there is a value present, otherwise {@code false}
 */
public boolean isPresent() {
    return value != null;
}

}

---

现在测试

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.junit4.SpringRunner;

import java.io.File;

import static org.junit.Assert.*;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;


@RunWith(SpringRunner.class)
public class RecoverOptionalTest {

@Test
public void recoverSilentlyForExceptionWithRecoverValue() {
    File file = mock(File.class);

    when(file.getName()).thenThrow(new RuntimeException(""));

    String value = RecoverableOptional
            .ofNullable(file)
            .recoverWith(new File("eliko"))
            .map(f -> f.getName());

    assertEquals(value, "eliko");
}

@Test
public void recoverSilentlyForExceptionWithNullForNoRecoveryValue() {
    File file = mock(File.class);

    when(file.getName()).thenThrow(new RuntimeException(""));

    String value = RecoverableOptional
            .ofNullable(file)
            .map(f -> f.getName());

    assertNull(value);
}

@Test
public void noRecover() {
    File file = new File("check");

    String value = RecoverableOptional
            .ofNullable(file)
            .recoverWith(new File("eliko"))
            .map(f -> f.getName());

    assertEquals(value, "check");
}

}