Guava 的可选使用（有例外）的快捷方式？

Question

我一直在编写特定的异常抛出程序，以防可选值不存在。

例如：

Optional<?> optional = ...;
if (!optional.isPresent()) {
  throw new MyException();
}
Object result = optional.get();

我发现这段代码不太流畅，尤其是 bang (!) 的使用。我宁愿写这样的东西：

Optional<?> optional = ...;
Object result = optional.orThrow(MyException.class);

Guava 中是否有我还没有找到的快捷方式？

Answer 1

作为一名 Guava 开发人员，让我尝试解开这里的逻辑。回答原始问题以及直接针对该问题的评论线程：

绝对是这样，我们试图强迫 Guava 用户尊重我们良好编程习惯的标准。 （我们的标准强烈受到Effective Java等的影响。）

也就是说，我同意您在这个特定问题中提到的行为有非常好的用例：“如果不存在，抛出一个例外。”也许您正在实现一个可以通过两种方式访问​​的类 - 一种方法具有可选返回值，另一种方法假设该值始终存在，否则抛出异常。例如，Deque 接口提供了 peek、poll 和 Offer 的特殊值和异常抛出版本。

综上所述，据我所知，真正的 Guava 方法是......

if (value.isPresent()) {
  return value.get();
} else {
  throw new MyException();
}

您提出的“orThrow”方法需要反射（!!），不允许您使用有用的消息自定义异常等“正常方式”是完全可读且更高效的。

有时 Guava 不会提供明确的支持，因为对于这些用例，我们认为最好以“正常方式”完成。我想这里就是这种情况。

Answer 2

毫无价值的是，Java 8 的 Optional 有一个允许请求的行为的 orElseThrow(Supplier) 方法。

它的使用方式如下：

Optional<Object> reference = Optional.empty()
reference.orElseThrow(MyOwnException::new); // Throws a new MyOwnException

此外，Java 10 中添加了一个方法 orElseThrow()，如果不存在任何值，该方法会抛出 NoSuchElementException。

Optional<Object> reference = Optional.empty();
reference.orElseThrow(); // Throws a new NoSuchElementException

Answer 3

这是另一种无需添加 Guava 的方法：

Object result = optional.or(new Supplier() {
    public Object get() {
        throw new MyException();
    }
});

必须取消选中 MyException，但这确实允许您将参数传递给其构造函数。当然，如果您经常这样做，您可以将供应商存储在某个地方，并在您需要的每个地方使用它。

Object result = optional.or(SomethingIsMissing.INSTANCE);

Answer 4

我认为这不属于图书馆。我发现很少有一个库能够接收异常实例，以防万一事情没有按预期进行，特别是因为在许多情况下，异常必须有一条消息来指示出了什么问题。

话虽这么说，您可以创建自己的可选类来完成您的需要。或者您可以创建自己的OptionalHelper类，其中您有一个可以执行您想要的操作的方法：

public class OptionalHelper {
   public <T> T valueOrThrow(final Optional<T> optional) throws MyException {
      if (optional.isPresent()) {
          return optional.get();
      } else {
          throw new MyException();
      }
   }
}

编辑：

假设您有一个自定义类接收您需要检查的参数/字段名称，您可以有一个更好的方法，类似于先决条件做：

public class OptionalHelper {
   public <T> T valueOrFail(final Optional<T> optional, final String fieldName) throws OptionalNotPresentError {
      if (optional.isPresent()) {
          return optional.get();
      } else {
          throw new OptionalNotPresentError(fieldName);
      }
   }
}

Answer 5

这对我有用（没有反射，只是类型推断）：

public class ExceptionSupplier<T, E extends RuntimeException> implements Supplier<T> {

    private final E exception;

    private ExceptionSupplier(E exception) {
        this.exception = exception;
    }

    public static <T, E extends RuntimeException> ExceptionSupplier<T, E> throwA(E exception) {
        return new ExceptionSupplier<T, E>(exception);
    }    

    public static <T, E extends RuntimeException> ExceptionSupplier<T, E> throwA(@SuppressWarnings("UnusedParameters") Class<T> class_, E exception) {
        return new ExceptionSupplier<T, E>(exception);
    }

    @Override
    public T get() {
        throw exception;
    }
}

用法：

Something something = optionalSomething.or(throwA(Something.class, new SomeException()));

这可能可以进一步扩展，但对于我的用例来说，它已经足够并且易于理解。

Answer 6

请参阅此处的官方问题

决定：否 - 太昂贵，不是常见模式，可以只使用 !isPresent()，抛出

由于 optional.orThrow(new Exception()) 对性能不利，我更喜欢 static import，这与@timk的回答类似。

Result result = optional.or(throwException());

等于

Result result = optional.or(SomeSupplier.throwException());

静态方法

public static Supplier<Result> throwException() {
    return new Supplier<Result>() {
        @Override
        public Result get() {
            throw new RuntimeException();
        }

    };
}

===========

堆栈跟踪看起来像

Exception ... RuntimeException
at SomeSupplier$1.get(SomeSupplier.java:line where throw RuntimeException)
at SomeSupplier$1.get(SomeSupplier.java:1)
at com.google.common.base.Absent.or(Absent.java:60)
at line where call optional.or(throwException());

Answer 7

虽然有点晚了，但在 Guava 中这样做是一种优雅的方法：

Optional<?> optional = ...;
Object result = optional.or(supplyError(MyException::new));

使用以下辅助方法：

public static Supplier supplyError(Supplier<Error> errorSupplier) {
    return () -> { throw errorSupplier.get(); };
}