我们在开发restful接口的时候，一定会经常遇到异常的情况，包括可预知的异常和不可预知的异常，我们要怎么处理这些异常，才能既优雅的写好代码，又能让程序接口健壮性更好呢？
首先分析下，遇到错误的时候，我们有两种方法，可以把信息返回给客户端：
- 遇到错误，直接返回一个jsonify的json信息给前端
- 抛出一个错误，然后我们在定义错误的handler专门捕捉错误，然后把错误里面的信息，包括错误码，错误信息，都同意填到我们需要返回的json里面。
我们来说说第二种情况，定义各种错误异常，然后抛出，最后在error_hanlder里面捕捉异常统一返回，这样做的目的与几个好处：
- 直接抛出错误，然后在捕捉器统一返回，捕捉器这里可以统一做一下日志记录
- 捕捉器根据不同的异常，做不同的处理
- 捕捉器能获取到异常这个对象，那么异常是我们抛出来的，所以异常的定义可以把很多信息封装进去，比如错误码，错误信息。
看下面error_handler的处理，也就是统一的异常捕捉器
def register_error_handler(app):
@app.errorhandler(errors.BaseError)
def base_error(err):
g.err = err
g.resp_data = err.reason.message
return jsonify(err.to_json()), err.status_code
@app.errorhandler(404)
def page_not_found(err):
g.err = errors.ResourceNotFoundError(
errors.REQ_URL_INVALID_ERROR, 'invalid url')
return jsonify({'message': str(err)}), 404
@app.errorhandler(405)
def method_not_allowed(err):
g.err = errors.BadRequestError(
errors.METHOD_NOT_ALLOWED_ERROR, 'invalid http method')
return jsonify({'message': str(err)}), 405
@app.errorhandler(Exception)
def unknown_error(err):
g.err = errors.InternalServerError(
errors.SERVER_UNEXPECTED_ERROR,
'unknown error: %s' % err,
exc_info=sys.exc_info())
g.resp_data = g.err.reason.message
return jsonify(g.err.to_json()), g.err.status_code
上面的代码，可以看出，第一个捕捉器是专门捕捉BaseError，也就是我们自定义的异常，可以捕捉到不止BaseError，还能BaseError的所有子类。所有继承与它的子异常都可以被捕捉到。
第二和第三个就是捕捉http状态码是404 405的异常，然后返回对应的错误消息。
异常和原因类
既然我们抛出的异常，被捕捉的时候，是可以获取到，并且读到它的属性的，那么我们可以在这个时候，把我们自定义的错误码->错误信息等信息传递过去给异常。捕捉的时候就可以读出来。
那么我们可以顶一个错误原因类，ErrorReason，实例化的时候，把错误码，错误信息，日志的等级也封装进去，成为一个对象，然后把这个对象，传给异常，那么读取异常的时候，就可以Error.reason.msg 这种封装形式来读取了。这样就很OOP了。
# 错误原因类
class ErrorReason(object):
'''
异常原因代码
'''
def __init__(self, code, message, log_level=logging.ERROR):
self.code = code
self.message = message
self.log_level = log_level
# 各种错误理由的实例，生成ErrorReason对象，这时这些属性已经封装到对象里面
REQ_PARAMS_ERROR = ErrorReason(4000, u'用户请求参数错误', log_level=logging.WARNING)
ILLEGAL_CHAR_ERROR = ErrorReason(4000, u'输入包含非法字符，请返回修改', log_level=logging.WARNING)
APP_NOT_EXIST_ERROR = ErrorReason(4000, u'应用不存在', log_level=logging.WARNING)
CATEGORY_NOT_EXIST_ERROR = ErrorReason(4000, u'分类不存在', log_level=logging.WARNING)
DEVELOPER_NOT_EXIST_ERROR = ErrorReason(4000, u'应用开发商不存在', log_level=logging.WARNING)
CHANNEL_NOT_EXIST_ERROR = ErrorReason(4000, u'应用渠道不存在', log_level=logging.WARNING)
PACKAGE_NOT_EXIST_ERROR = ErrorReason(4000, u'应用包不存在', log_level=logging.WARNING)
这样实例化不同的错误原因对象，每个对象都封装了自己的信息。
下面看看错误类，我们自己子类化一个BaseError，它是其他所有的异常的父类。重写了__init__()方法，把reason, message, status_code都封装进去，好让被捕捉的时候，可以知道获取错误原因e.reason, e.reason.code,..错误消息e.message, 和http状态码，e.status_code
# 错误类，继承Exception
class BaseError(Exception):
def __init__(self, reason, message, status_code=500, exc_info=None):
if isinstance(message, unicode):
message = message.encode('utf-8')
self.reason = reason
self.message = message
self.status_code = status_code
self.exc_info = exc_info
def to_json(self):
return {
"status": self.reason.code,
"reason": self.reason.message,
"message": self.message,
}
下面就是继承各种子类
class BadRequestError(BaseError):
def __init__(self, reason, message, exc_info=None):
super(BadRequestError, self).__init__(reason, message, 400, exc_info)
class PermissionError(BaseError):
def __init__(self, reason, message, exc_info=None):
super(PermissionError, self).__init__(reason, message, 403, exc_info)
class ResourceNotFoundError(BaseError):
def __init__(self, reason, message, exc_info=None):
super(ResourceNotFoundError, self).__init__(
reason, message, 404, exc_info)
可以看到，BadRequestError、PermissionError继承的时候，继承了__init__(), 还是调用了父类的__init__()方法，但是就是固定的把403， 400传进去。很多这种继承都是这样，就是把某一个参数固定了，它就变成了一个新的类，但是这样的类一眼就能看出是干嘛的，因为的它的名字很有含义，然后有把代表性的值设成了固定值。
所以我们在调用的时候，遇到有什么不妥的地方，直接抛出错误。
if perm not in consts.PermKey.SCHEMAS:
raise errors.BadRequestError(
errors.BAD_REQ_ERROR, u'Unknown permission')
if not Perm.cancan(perm, g.admin.id) and g.admin.username not in app_config['ADMIN_USER_LIST']:
raise errors.PermissionError(
errors.BAD_REQ_ERROR, u'No permission for %s' % perm)
这样就是可以把异常抛出，同时把定义好的错误理由也封装进去。
我们有了异常捕捉器，基本上整个网站是不会报错500，错误的页面的，而是相对友好的返回一段json。
def handler_api_error():
@api_handler.errorhandler(Exception)
def _handler_app_error(error):
if isinstance(error, errors.BaseError):
reason = error.reason
else:
reason = errors.SERVER_UNEXPECTED_ERROR
return Adaptor.result(
code=reason.code, msg=reason.message,
detail=error.message, log_level=reason.log_level,
exc_info=reason.log_level >= logging.ERROR)
class Adator(object)
@classmethod
def result(cls, code=0, msg=u'操作成功', detail=None,
log_level=logging.DEBUG, exc_info=False, **kargs):
log_data = {u'code': code, u'msg': msg}
if kargs:
log_data.update(cls._mask_resp(kargs))
cls._log_api(log_level, u'json', log_data,
detail=detail, exc_info=exc_info)
return jsonify(code=code, msg=msg, **kargs)
最后看一下这个error_handler,捕捉所有异常Exception， 然后进去后，判断是否我们自己定义的BaseError类型，如果是，则读出它的reason属性，如果不是，则把错误的reason赋值成一个我们的子类化的一个错误原因。 最后通过调用result()返回json化这段错误。result()的主要工作就是log下请求内容，请求的方法，返回的接口内容等信息。
所以，无论使我们自己手动调用Adator.result() , 还是通过抛出异常，然后error_handler捕捉，最后还是调用Adator.result()，这样就形成了一个最终一致性，都是调用Adator.result()，那种情况都可以正常返回json，并且都能记录日志！
