Python接口开发的异常处理

我们在开发restful接口的时候，一定会经常遇到异常的情况，包括可预知的异常和不可预知的异常，我们要怎么处理这些异常，才能既优雅的写好代码，又能让程序接口健壮性更好呢？

首先分析下，遇到错误的时候，我们有两种方法，可以把信息返回给客户端：

1. 遇到错误，直接返回一个jsonify的json信息给前端
2. 抛出一个错误，然后我们在定义错误的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，并且都能记录日志！