scala中的自定義異常

Question

如何在Scala中創建自定義異常並將其延伸到Exception類中，並在發生異常時將其拋出並捕獲它們。

例如在Java中：

class CustomeException extends Exception { 

    public final static String _FAIL_TO_INSERT = "FAIL_TO_INSERT"; 

} 

Answer 1

final case class CustomException(private val message: String = "", 
          private val cause: Throwable = None.orNull) 
         extends Exception(message, cause) 

剛剛嘗試捕獲：

try { 
    throw new CustomException("optional") 
} catch { 
    case c: CustomException => 
      c.printStackTrace 
} 

Answer 2

你這樣定義

case class CustomException(s: String) extends Exception(s) 

您的自定義異常，你可以把你的例外，像這個：

try{ 
... 
} catch{ 
case x:Exception => throw new CustomException("whatever") 
} 

Answer 3

您可能希望創建一個密封的特點：

sealed trait MyException { 
    self: Throwable => //This is called self annotations and you can use "self" or "dog" or whatever you want, it requires from those who extend this trait, to also extend a Throwable or a subclass of it. 
    val: message: String 
    val: details: JsValue 
} 

然後你可以有很多case class ES，因爲你需要延長不僅Exception但你的新特點。

case class CustomeException(message: String) extends Exception(message) with MyException { 
    override val details: JsValue = Json.obj("message" -> message, "etc" -> "Anything else") 
} 

現在，使用Scala是朝着一個功能更強大的編程風格走的整點，它會使你的應用程序更多的併發，所以如果你需要使用新的自定義異常，你可能想嘗試像這樣的：

def myExampleMethod(s: Option[String]): Future[Boolean] = { 
    Try(
     s match { 
      case Some(text) => 
       text.lenght compareTo 5 match { 
        case 1 => true 
        case _ => false 
       } 
      case _ => throw CustomeException("Was expecting some txt") 
     } 
    ) 
    match { 
     case Success(bool) => Future.success(bool) 
     case Failure(e) => Future.failed(e) 
    } 

Answer 4

爲了反映所有從Exception我會實現與下面的模式自定義異常的原始構造函數：

class CustomException(msg: String) extends Exception(msg) { 
    def this(msg: String, cause: Throwable) = { 
    this(msg) 
    initCause(cause) 
    } 

    def this(cause: Throwable) = { 
    this(Option(cause).map(_.toString).orNull) 
    initCause(cause) 
    } 

    def this() = { 
    this(null: String) 
    } 
} 

這可以也可以在前面的答案中提到的特質來實現。在這種情況下，我只是不創建單獨的類：

trait SomeException { self: Throwable => 
    def someDetail: SomeDetail 
} 

然後，投擲時：

throw new Exception(...) with SomeException { 
    override val someDetail = ... 
} 

和匹配時：

try { 
    ... 
} catch { 
    case ex: Throwable with SomeException => 
    ex.getCause 
    ex.getMessage 
    ex.someDetail 
} 

這裏的好處是，你是不是堅持父異常的任何特定構造函數。

或多或少的東西。

Answer 5

class MyException(message: String) extends Exception(message) { 

    def this(message: String, cause: Throwable) { 
    this(message) 
    initCause(cause) 
    } 

    def this(cause: Throwable) { 
    this(Option(cause).map(_.toString).orNull, cause) 
    } 

    def this() { 
    this(null: String) 
    } 
} 

這與@Jacek L.的答案几乎相同。我只是想爲這個答案背後的動機增加更多的意見。

爲什麼這麼多構造函數？

Throwable寫的是一種有趣的方式。它有4個構造函數 - 忽略與boolean切換的構造函數 - 它們每個與null的行爲有點不同，並且這些差異只能由多個構造函數維護。

它會被清潔了一下，如果斯卡拉將允許通過super調用父類的構造函數，但它不會:(

爲什麼不案例類？

• 完美維護建設者對null的行爲是不可能的;具體而言，def this()和def this(message: String)將不得不將cause設置爲null，而最初它被設置爲this。
• toString不會被覆蓋。
• 該消息和原因已通過getMessage和getCause公開可用。對這些添加另一個參考是多餘的。
• equals將被覆蓋，將表現不同。
  含義，new Exception("m") == new Exception("m") // false
  而new CaseException("m") == new CaseException("m") // true

如果一個期望訪問該消息並通過模式匹配的原因，可以簡單地實現unapply方法：

object MyException { 
    def unapply(e: MyException): Option[(String,Throwable)] = Some((e.getMessage, e.getCause)) 
}