経緯
トップダウンエラーハンドリングという記事を読んでいて、
確かに非同期処理中にthrowするようなエラーが発生すると
コールバックの中で同じような処理を何度も書いて面倒だなと思うことが
多々あるなと感じました。
こんな感じでしょうか？
※Coordinatorは画面遷移を制御するクラスのようなものです。
特にthrowするようなエラーは特定の機能に関係するものよりは
APIの403や500などのHTTPステータスエラー、継続不能なアプリ内のエラー)など
一般的なエラーが多く上の階層でまとめて処理したいという気持ちが強くあります。
そこでエラー処理をうまく一箇所にまとめられないか
エラーハンドリングについていくつか検討してみました。
トップダウンエラーハンドリングとは？
通常エラーが発生した箇所から上の階層へ順々にエラー処理の判定をしていくが、
これを２段階に分けてトップダウンでエラー処理をしていくという方式です。
1段階目 エラーをルートまで伝達をする。
2段階目 ルートから順にエラーハンドリングできる階層まで下っていく
Errors.swift
enum ApiError: LocalizedError {
case firstError
case firstNextError
case secondError
var errorDescription: String? {
switch self {
case .firstError:
return "First Error"
case .firstNextError:
return "First Next Error"
case .secondError:
return "Second Error"
}
}
}
enum UnexpectedError: LocalizedError {
case only
var errorDescription: String? {
return "Unexpected Error"
}
}
ErrorHandler.swift
public typealias HandleAction<T> = (T) throws -> ()
public typealias ErrorMatcher = (Error) -> Bool
public protocol ErrorHandleable: class {
func `throw`(_: Error, finally: @escaping (Bool) -> Void)
func `catch`(action: @escaping HandleAction<Error>) -> ErrorHandleable
}
public class ErrorHandler: ErrorHandleable {
private var parent: ErrorHandler?
private let action: HandleAction<Error>
public convenience init(action: @escaping HandleAction<Error> = { throw $0 }) {
self.init(action: action, parent: nil)
}
private init(action: @escaping HandleAction<Error>, parent: ErrorHandler? = nil) {
self.action = action
self.parent = parent
}
public func `throw`(_ error: Error, finally: @escaping (Bool) -> Void) {
`throw`(error, previous: [], finally: finally)
}
private func `throw`(_ error: Error, previous: [ErrorHandler], finally: ((Bool) -> Void)? = nil) {
// 1段階目
if let parent = parent {
parent.`throw`(error, previous: previous + [self], finally: finally)
return
}
// 2段階目
serve(error, next: AnyCollection(previous.reversed()), finally: finally)
}
private func serve(_ error: Error, next: AnyCollection<ErrorHandler>, finally: ((Bool) -> Void)? = nil) {
do {
try action(error)
finally?(true)
} catch {
if let nextHandler = next.first {
nextHandler.serve(error, next: next.dropFirst(), finally: finally)
} else {
finally?(false)
}
}
}
public func `catch`(action: @escaping HandleAction<Error>) -> ErrorHandleable {
return ErrorHandler(action: action, parent: self)
}
}
public extension ErrorHandleable {
func `do`<A>(_ section: () throws -> A) {
do {
_ = try section()
} catch {
`throw`(error)
}
}
}
public extension ErrorHandleable {
func `throw`(_ error: Error) {
`throw`(error, finally: { _ in })
}
}
public extension ErrorHandleable {
func `catch`<K: Error>(_ type: K.Type, action: @escaping HandleAction<K>) -> ErrorHandleable {
return `catch`(action: { (e) in
if let k = e as? K {
try action(k)
} else {
throw e
}
})
}
func `catch`<K: Error>(_ value: K, action: @escaping HandleAction<K>) -> ErrorHandleable where K: Equatable {
return `catch`(action: { (e) in
if let k = e as? K, k == value {
try action(k)
} else {
throw e
}
})
}
}
...
(以下略)
RootViewController.swift
final class RootViewController: UIViewController, AlertShowable {
//
private let excludeErrors: [ErrorMatcher] = [
{ error in (error is ApiError) }
]
private lazy var errorHandler = {
ErrorHandler()
.catch(UnexpectedError.self) { [unowned self] error in
self.showAlert(title: "Root Error", message: error.localizedDescription)
}
// 最終的に特定のエラーに当てはまらなかった場合
.catch { [unowned self] error in
// 下の階層に渡す必要があるエラーの場合はハンドリングしない
if self.excludeErrors.contains(where: { $0(error) }) {
throw error
}
self.showAlert(title: "Root Error", message: "Somethig wrong!!!")
}
}()
func showFirst() {
// ErrorHandlerは下の階層に渡していく
let first = FirstFlowController(errorHandler)
...
}
}
FirstFlowController.swift
final class FirstFlowController: UIViewController, AlertShowable {
private let parentErrorHandler: ErrorHandleable
// 上の階層のエラーにさらにハンドリング処理を追加する
private var errorHandler: ErrorHandleable {
return parentErrorHandler.catch(ApiError.firstError) { [weak self] error in
self?.showAlert(title: "Error", message: error.localizedDescription)
}.catch(ApiError.firstNextError) { [weak self] error in
self?.showAlert(title: "Error", message: error.localizedDescription)
}
}
init(_ parentErrorHandler: ErrorHandleable) {
self.parentErrorHandler = parentErrorHandler
...
}
}
extension FirstFlowController: FirstViewDelegate {
func goToNext(user: User) {
let viewController = FirstNextViewController.fromStoryboard()
let viewModel = FirstNextViewModel(errorHandler: errorHandler, user: user)
viewController.viewModel = viewModel
navigation.pushViewController(viewController, animated: true)
}
}
FirstNextViewModel.swift
struct FirstNextViewModel {
private let errorHandler: ErrorHandleable
let user: User
init(errorHandler: ErrorHandleable, user: User) {
self.errorHandler = errorHandler
self.user = user
}
func throwError() throws {
asyncAction {
throw ApiError.firstError
}
}
func throwFirstNextError() throws {
asyncAction {
throw ApiError.firstNextError
}
}
func throwUnexpectedError() throws {
asyncAction {
throw UnexpectedError.only
}
}
func throwNSError() throws {
asyncAction {
throw NSError(domain: "example.stzn.nseeror", code: 999, userInfo: ["message": "This is NSError!!"])
}
}
func asyncAction(callback: @escaping () throws -> Void) {
ApiClient.doAsync {
// 何かしらのエラーを発生させる
do {
try callback()
} catch let error {
self.errorHandler.throw(error)
}
}
}
}
良いと思うところ
・逐一処理を書かないで済むようになる
・必要な場合は下の階層にエラーを伝播して処理させることができる
悩みどころ
・最終的にハンドリングできなかった場合のエラー処理をするために下の階層に渡す必要があるエラーを除外しなければいけない
・ErrorHandlerを引数で渡していかなければならない
・記事にもあるように、networkエラーなどエラーのスタックが欲しい場合には対応できない
※以下を参考にしてログは残しておくなどの対処が良いのかもしれません。
https://tech.just-eat.com/2018/01/26/effective-ios-error-management/
他の方法も探してみる
他にも何かないかと探してみたところ、
以下の動画も参考にしてみました。
https://academy.realm.io/posts/try-swift-nyc-2017-eleni-papanikolopoulou-kostas-kremizas-error-handling/
ErrorHandler(一部省略).swift
extension Notification.Name {
public static let errorOccured = Notification.Name("errorOccured")
}
public enum HandleStrategy {
case next
case stop
}
public typealias ErrorAction = (Error) -> HandleStrategy
public typealias Tag = String
public final class ErrorHandler {
// ErrorMatcherは(Error)->Boolをクラスにしたようなもの
private var errorActions: [(ErrorMatcher, ErrorAction)] = []
private var onNoMatch:[ErrorAction] = []
private var alwaysActions: [ErrorAction] = []
private var errorStack: [Error] = []
public init() {}
public func on(matches: @escaping ((Error)-> Bool), do action: @escaping ErrorAction) -> ErrorHandler {
let matcher = ClosureErrorMatcher(matches: matches)
return on(matcher, do: action)
}
public func on(_ matcher: ErrorMatcher, do action: @escaping ErrorAction) -> ErrorHandler {
errorActions.append((matcher, action))
return self
}
public func onNoMatch(do action: @escaping ErrorAction) -> ErrorHandler {
onNoMatch.append(action)
return self
}
public func always(do action: @escaping ErrorAction) -> ErrorHandler {
alwaysActions.append(action)
return self
}
public func handle(_ error: Error) {
// 最後に必ず実行するアクション
defer {
for alwaysAction in alwaysActions.reversed() {
let alwaysHandleStrategy = alwaysAction(error)
if case .stop = alwaysHandleStrategy {
break
}
}
}
// 条件にあったエラーに対してアクションをする
var found = false
for (matcher, action) in errorActions.reversed() {
if matcher.matches(error) {
found = true
let strategy = action(error)
// stopがあっても引き続きアクションは実行していく
if case .stop = strategy {
return
}
}
}
// アクション済みの場合は終了
if found { return }
// 条件に合うエラーではなかったエラーに対してアクションをする
for otherwise in onNoMatch.reversed() {
let strategy = otherwise(error)
if case .stop = strategy {
break
}
}
}
// ErrorのTypeにまとめて同じアクションを設定する
public func onError<T: Error>(ofType type: T.Type, do action: @escaping ErrorAction) -> ErrorHandler {
return on(ErrorTypeMatcher<T>(), do: action)
}
public func on<E:Error & Equatable>(_ error: E, do action: @escaping ErrorAction) -> ErrorHandler {
return self.on(matches: { (handleError) -> Bool in
guard let handleError = handleError as? E else { return false }
return handleError == error
}, do: action)
}
public func onNSError(domain: String, code: Int? = nil, do action: @escaping ErrorAction) -> ErrorHandler {
return self.on(NSErrorMatcher(domain: domain, code: code), do: action)
}
public func postError(_ error: Error) {
NotificationCenter.default.post(name: .errorOccured, object: nil, userInfo: ["error": error])
}
}
DefaultErrorHandler.swift
extension ErrorHandler {
static var `default`: ErrorHandler {
return ErrorHandler()
.onError(ofType: ApiError.self,
do: { error -> HandleStrategy in
print(error.localizedDescription)
AlertManager.shared.showErrorAlert(message: error.localizedDescription)
return .next
})
.onError(ofType: UnexpectedError.self,
do: { error -> HandleStrategy in
print(error.localizedDescription)
AlertManager.shared.confirm(title: "Error", message: "Exit?")
return .next
})
.onNSError(domain: "stzn.sample.nserror",
do: { error -> HandleStrategy in
let nserror = error as NSError
let message = "NSError \n domain:\(nserror.domain) \n code:\(nserror.code) \n userInfo:\(nserror.userInfo)"
print(message)
AlertManager.shared.showErrorAlert(message: message)
return .next
})
.onNoMatch(do: {_ in
AlertManager.shared.showErrorAlert(message: "Something wrong!!")
print("Something wrong!!")
return .stop
})
.always(do: { _ in
print("Finish error handle!!")
return .stop
})
}
}
RootViewController.swift
final class RootViewController: UIViewController {
private var errorHandler = ErrorHandler.default
private var token: NSObjectProtocol?
override init(nibName nibNameOrNil: String?, bundle nibBundleOrNil: Bundle?) {
super.init(nibName: nil, bundle: nil)
token = NotificationCenter.default.addObserver(forName: .errorOccured, object: nil, queue: nil) { [weak self] note in
guard let strongSelf = self,
let info = note.userInfo,
let error = info["error"] as? Error else {
return
}
strongSelf.errorHandler.handle(error)
}
}
deinit {
token = nil
}
}
FirstFlowController.swift(一部省略)
final class FirstFlowController: UIViewController {
// こっちはErrorHandlerを渡していっているだけ
private let errorHandler: ErrorHandler
init(_ errorHandler: ErrorHandler) {
self.errorHandler = errorHandler
...
}
}
FirstNextViewModel.swift
struct FirstNextViewModel {
private let errorHandler: ErrorHandler
init(errorHandler: ErrorHandler) {
self.errorHandler = errorHandler
}
func throwError() throws {
asyncAction {
self.errorHandler.postError(ApiError.firstError)
}
}
func asyncAction(callback: @escaping () -> Void) {
// 何かしらの非同期処理
ApiClient.doAsync {
callback()
}
}
}
良かったと思う点
・エラーハンドリングを一箇所で管理できるようになった
・エラーをthrowするときにNotificationを使用しているが、RootViewControllerで管理しているため通知解除の処理がわずらわしくない
・必要に応じでdefaultのエラーハンドリングを変更することができる
悩みどころ
・アラートを表示する以外などのエラー処理が必要な場合に、ErrorHandlerから再度処理の移譲をしなければならない(例えばRootViewControllerのメソッドを呼び出すなど)
・さらに特定の画面に対して処理が必要な場合は、ルートから辿っていく必要がある。またはDelegateや通知で知らせる方法もあるが、それはそれで管理する対象が増えてしまう。
まとめ
エラー処理をまとめて管理できることは
今後の修正や拡張という点で楽になりそうな気がしました。
一方で、エラーによって特定の画面の一部を変更するなど
仕様に左右される部分が出てきた際に苦労することもありそうだとも感じました。
一概に使えるというものは存在しないと思いますので、
都度都度、どうしたらもっとシンプルにコードが書くことができるようになるのか
ということは追い求めていきたいです。