Scala Language
오류 처리

시험

map , getOrElse 및 flatMap 사용하여 Try :

import scala.util.Try

val i = Try("123".toInt)     // Success(123)
i.map(_ + 1).getOrElse(321)  // 124

val j = Try("abc".toInt)     // Failure(java.lang.NumberFormatException)
j.map(_ + 1).getOrElse(321)  // 321

Try("123".toInt) flatMap { i =>
  Try("234".toInt)
    .map(_ + i)
}                            // Success(357)

패턴 일치로 Try 하기 :

Try(parsePerson("John Doe")) match {
    case Success(person) => println(person.surname)
    case Failure(ex) => // Handle error ...
}

어느 한 쪽

오류 / 성공에 대한 다른 데이터 유형

def getPersonFromWebService(url: String): Either[String, Person] = {
    
    val response = webServiceClient.get(url)

    response.webService.status match {
        case 200 => {
            val person = parsePerson(response)
            if(!isValid(person)) Left("Validation failed")
            else Right(person)
        }

        case _ => Left(s"Request failed with error code $response.status")
    }
}

양쪽 값에서의 패턴 매칭

getPersonFromWebService("http://some-webservice.com/person") match {
    case Left(errorMessage) => println(errorMessage)
    case Right(person) => println(person.surname)
}

어느 값이든 옵션으로 변환

val maybePerson: Option[Person] = getPersonFromWebService("http://some-webservice.com/person").right.toOption

선택권

의 사용은 null 값을 강하게 기대하고 기존의 자바 코드와 상호 작용하지 않는 한 권장되지 null . 대신, 함수의 결과가 무언가 ( Some ) 또는 무효 ( None ) 일 때 Option 사용해야합니다.

try-catch 블록은 오류 처리에 더 적합하지만 함수가 합법적으로 아무 것도 반환하지 않으면 Option 이 사용하기 쉽고 간단합니다.

Option[T] 는 Some(value) ( T 타입의 값을 포함)이거나 None :

def findPerson(name: String): Option[Person]

사람을 찾을 수 없으면 None 을 반환 할 수 있습니다. 그렇지 않으면, Person 오브젝트를 포함하는 Some 유형의 오브젝트가 리턴됩니다. 다음은 Option 유형의 객체를 처리하는 방법입니다.

패턴 매칭

findPerson(personName) match {
    case Some(person) => println(person.surname)
    case None => println(s"No person found with name $personName")
}

map 및 getOrElse 사용

val name = findPerson(personName).map(_.firstName).getOrElse("Unknown")
println(name) // Prints either the name of the found person or "Unknown"

폴드 사용

val name = findPerson(personName).fold("Unknown")(_.firstName)
// equivalent to the map getOrElse example above.

Java로 변환

상호 운용성을 위해 Option 유형을 null 가능 Java 유형으로 변환해야하는 경우 :

val s: Option[String] = Option("hello")
s.orNull           // "hello": String
s.getOrElse(null)  // "hello": String

val n: Option[Int] = Option(42)
n.orNull           // compilation failure (Cannot prove that Null <:< Int.)
n.getOrElse(null)  // 42

선물에서 발생하는 오류 처리

Future 내에서 exception 가 발생하면이를 사용하여 recover 를 수행 recover 수 있습니다.

예를 들어,

def runFuture: Future = Future { throw new FairlyStupidException }

val itWillBeAwesome: Future = runFuture

... Future 에서 Exception 를 던질 것입니다. 그러나 우리는 FairlyStupidException 유형의 Exception 이 높은 확률로 예측할 수 FairlyStupidException 케이스를 우아한 방식으로 구체적으로 처리 할 수 ​​있습니다.

val itWillBeAwesomeOrIllRecover = runFuture recover { 
    case stupid: FairlyStupidException => 
         BadRequest("Another stupid exception!") 
}

당신에게 주어진 방법 볼 수 있듯이 recover A는 PartialFunction 모두의 도메인에 Throwable 당신은 단지 특정 몇 가지 유형을 처리하고 나머지는 더 높은 수준에서 예외 처리의 에테르로 이동하게 할 수 있도록, Future 스택입니다.

이는 비 Future 컨텍스트에서 다음 코드를 실행하는 것과 유사합니다.

def runNotFuture: Unit = throw new FairlyStupidException

try {
    runNotFuture
} catch {
    case e: FairlyStupidException => BadRequest("Another stupid exception!")
}

훨씬 더 교활하기 때문에 Future 내에서 생성 된 예외를 처리하는 것은 정말로 중요합니다. 그들은 다른 실행 컨텍스트와 스레드에서 실행되기 때문에 일반적으로 얼굴 전체에 나타나지 않습니다. 따라서 로그 나 이벤트에서 아무 것도 눈치 채지 못하면 문제를 해결할 것을 요구하지 않습니다. 신청.

try-catch 절 사용

등의 기능 구조에 더하여 Try , Option 과 Either 오류 처리를위한 스칼라도 (결국뿐만 아니라 차단 잠재적으로) 시도 - 캐치 절을 사용하여, 자바와 유사한 구문을 지원합니다. catch 절은 패턴 일치입니다.

try { 
  // ... might throw exception
} catch {
  case ioe: IOException => ... // more specific cases first
  case e: Exception => ...
  // uncaught types will be thrown
} finally {
  // ...
}

예외를 Either 또는 Option 유형으로 변환

예외를 Either 또는 Option 유형으로 변환하려면 scala.util.control.Exception 에서 제공하는 메소드를 사용할 수 있습니다.

import scala.util.control.Exception._

val plain = "71a"
val optionInt: Option[Int] = catching(classOf[java.lang.NumberFormatException]) opt { plain.toInt }
val eitherInt = Either[Throwable, Int] = catching(classOf[java.lang.NumberFormatException]) either { plain.toInt }