6

我正在尝试使用 Kotlin 的 Arrow 库Either对象来处理项目中的异常。

到目前为止，我的经验还不错，但我正在努力寻找一种方法来处理事务Either——尤其是回滚。在 Spring 中，抛出 aRuntimeException是导致事务回滚的可靠方法。但是，通过使用Either不会引发异常，因此不会触发回滚。

您可以将其视为一个多方面的问题：

  1. Either适合真正的Exception处理吗？不是替代控制流，我的意思是程序流需要停止的真正错误情况。
  2. 如果是这样，您如何使用它们实现回滚？
  3. 如果问题 2. 的答案是以transactionManager编程方式使用 - 你能避免这种情况吗？
  4. 我把这个挤进去，你怎么避免嵌套Eithers？
4

2 回答 2

5

您的一些问题没有直接的答案，但我会尽力而为：D

  1. 是否适用于真正的异常处理。不是替代控制流，我的意思是程序流需要停止的真正错误情况。

Spring 使用异常来对触发器回滚进行建模，因此在这种情况下，您需要遵守 Spring 的机制。

如果你更喜欢使用EitherAPI，你可以用一个Either<RuntimeException, A>或Either<E, A>一个来包装 Spring 的基于异常的 API。

所以回答你的问题，Either适合异常处理。但是，通常您只会捕获您感兴趣的异常并使用您自己的错误域对其进行建模。意外的异常或您无法解决的异常通常被允许冒泡。

  1. 如果是这样，您如何使用它们实现回滚？

transaction: () -> A用transactionEither: () -> Either<E, A>. _

class EitherTransactionException(val result: Either<Any?, Any?>): RuntimeException(..)

fun transactionEither(f: () -> Either<E, A>): Either<E, A> =
  try {
     val result = transaction { f() }
     when(val result) {
       is Either.Right -> result
       is Either.Left -> throw EitherTransactionException(result)
     }
  } catch(e: EitherTransactionException) {
     return e.result as Either<E, A>
  }

现在您应该能够Either<E, A>在保持 Spring 的基于异常的模型完整的同时使用。

如果问题 2. 的答案是以编程方式使用 transactionManager - 你能避免这种情况吗？

我回答了问题 2，同时已经回避了它。或者，通过以transactionManager编程方式使用，您可以避免抛出该异常并恢复该值。

我把这个挤进去，你如何避免嵌套 Eithers

  • 使用Either#flatMaporeither { }链接相关值(Either<E, A>)+(A) -> Either<E, B>
  • 用于Either#zip组合独立值。Either<E, A>+ Either<E, B>+ (A, B) -> C。
于 2021-04-28T11:41:11.073 回答
3

1.是否适合真正的异常处理？

一个有点自以为是的答案：通过异常进行的常规错误处理具有与使用可怕的 GOTO 语句类似的缺点：执行跳转到代码中的另一个特定点 - catch 语句。它比 GOTO 更好，因为它不会在完全任意点恢复执行，但必须向上调用函数调用堆栈。

使用 Either<Error, Value> 错误处理模型，您不会中断程序流程，这使代码更易于推理、更易于调试、更易于测试。

因此，我不仅会说它是合适的，而且会更好。

2. 如果是这样，您如何使用它们实现回滚？

我建议使用 Springs 事务模板： 示例：

fun <A, B> runInTransaction(block: () -> Either<A, B>): Either<A, B> {
  return transactionTemplate.execute {
    val result = block()
    return@execute when (result) {
      is Either.Left -> {
        it.setRollbackOnly()
        result
      }
      is Either.Right -> result
   }
}!! // execute() is a java method which may return nulls

fun usage(): Either<String, String> {
  return runInTransaction {
    // do stuff
    return@runInTransaction "Some error".left()
  }
}

现在这很简单，因为它将任何左值视为需要回滚，您可能希望根据您的目的对其进行调整，并使用密封类来封装您希望为左案例处理的可能错误结果。

您还需要为包含此方法的类提供一个 transactionTemplate。

3. 如果问题 2. 的答案是以编程方式使用 transactionManager - 你能避免这种情况吗？

我不明白如何，因为 Springs 声明式事务管理是建立在异常错误处理模型上的，并且它对控制流的中断。

4.我把这个挤进去，你怎么避免嵌套Eithers？

您可以使用Either.fx { }来避免任何一种嵌套。注意！用于将 Either 值绑定到 .fx 范围的语法。可以这么说，这“解包”了它们：

fun example(): Either<Error, Unit> {
  return Either.fx {
            val accessToken: String = !getAccessToken()
            return@fx !callHttp(accessToken)
        }
}

fun getAccessToken(): Either<Error, String> {
  return "accessToken".right()
}

fun callHttp(token: String): Either<Error, Unit> {  
  return Unit.right()
}

为此，Left 值必须都是相同的类型。如果绑定了一个左值，它将被返回。这使您可以避免嵌套 when 语句或与 map/flatmap/fold 等的功能链接。

于 2021-04-30T10:58:19.470 回答