python开发接口故障码_Python接口开发的异常处理

最新推荐文章于 2023-02-09 10:49:39 发布

weixin_39541767

最新推荐文章于 2023-02-09 10:49:39 发布

阅读量568

点赞数

文章标签： python开发接口故障码

我们在开发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，并且都能记录日志！