在 lambda 内抛出异常不起作用

Question

我在 lambda 中抛出异常时遇到了一些问题，请考虑以下代码：

public interface StoreTransactionalExecutable {
    void execute(@NotNull final StoreTransaction txn);
}

还有一个经理 class：

public final class DatabaseManager {
  // ...
  @Override
  public void transactPersistentEntityStore(String dir, StoreTransactionalExecutable txn) {
    final PersistentEntityStore entityStore =
        getPersistentEntityStore(dir, isReadOnly);
    entityStore.executeInTransaction(txn);
  }
  // ...
}

当像下面这样访问管理器 class 方法transactPersistentEntityStore时，它可以工作：

public class Service {
    databaseManager.transactPersistentEntityStore("/dbPath", txn -> {
         txn.find(); // do stuff (throws and works)
    });
}

但是，如果这样，它会引发编译时错误

public class Service {
    databaseManager.transactPersistentEntityStore("/dbPath", rethrow(
        transaction -> {
            StoreTransaction txn = (StoreTransaction) transaction; 
            txn.find(); // do stuff 
        }
     ));
}

这是扔的东西

[ERROR]     method com.myproject.store.DatabaseManager.transactPersistentEntityStore(java.lang.String,jetbrains.exodus.entitystore.StoreTransactionalExecutable) is not applicable
[ERROR]       (argument mismatch; no instance(s) of type variable(s) T exist so that java.util.function.Consumer<T> conforms to jetbrains.exodus.entitystore.StoreTransactionalExecutable)
[ERROR]     method com.myproject.store.DatabaseManager.<T,B>transactPersistentEntityStore(java.lang.String,java.util.Map<java.lang.Class<T>,B>,jetbrains.exodus.entitystore.StoreTransactionalExecutable) is not applicable
[ERROR]       (cannot infer type-variable(s) T,B
[ERROR]         (actual and formal argument lists differ in length))

rethrow和ThrowingConsumer的代码是这样的：

public final class Throwing {

  private Throwing() {}

  @Nonnull
  public static <T> Consumer<T> rethrow(@Nonnull final ThrowingConsumer<T> consumer) {
    return consumer;
  }

  @SuppressWarnings("unchecked")
  @Nonnull
  public static <E extends Throwable> void sneakyThrow(@Nonnull Throwable ex) throws E {
    throw (E) ex;
  }

}

和

@FunctionalInterface
public interface ThrowingConsumer<T> extends Consumer<T>{
  @Override
  default void accept(final T e) {
    try {
      accept0(e);
    } catch (Throwable ex) {
      Throwing.sneakyThrow(ex);
    }
  }
  void accept0(T t) throws Throwable;
}

我真的很想知道这里有什么问题？ 任何提示将不胜感激。

Answer 1

关于第一个编译器错误：
如果您仔细阅读错误“参数不匹配；不存在类型变量 T 的实例，因此 java.util.function.Consumer 符合 jetbrains.exodus.entitystore.Sto reTransactionalExecutable”
你会注意到一些事情：

1. StoreTransactionalExecutable 与 Consumer 不同。
2. StoreTransactionalExecutable 不是泛型类型。 而消费者是。
3. StoreTransactionalExecutable 不扩展消费者并且具有execute方法 not accept 。 所以在entityStore.executeInTransaction(txn);里面的代码调用execute方法而不accept
   

因此，当您将 Consumer object 传递给transactPersistentEntityStore方法时，编译器会抱怨。
如果我错了，请纠正我。

Answer 2

一种“偷偷摸摸”的方式来抛出这个（但有一个try-catch）是做一个：

public class UncheckedException extends RuntimeException {
  public UncheckedException(Throwable cause) {
    super(cause);
  }
}

然后像这样使用：

class Scratch {
    public static void main(String[] args) {
        databaseManager.transactPersistentEntityStore("/dbPath", txn -> {
            try {
                somethingThatThrows();
            } catch (Exception e) {
                throw new UnchecekdServiceException(e);
            }
        });
    }
}