Date: 2021/02/07 Flask version: 1.1.2
对于前后端分离的项目，希望只通过JSON与前端交互，包括异常信息也要包装JSON格式发送给前端。要想在Flask项目中处理好异常，建立一套自己的异常处理机制，首先必须先知道Flask自己是如何处理异常的。进入到flask源码的app.py文件中，可以看到所有的异常都是从werkzeug中引入的：
...
from werkzeug.exceptions import BadRequest
from werkzeug.exceptions import BadRequestKeyError
from werkzeug.exceptions import default_exceptions
from werkzeug.exceptions import HTTPException
from werkzeug.exceptions import InternalServerError
from werkzeug.exceptions import MethodNotAllowed
...
werkzeug是Flask两大依赖之一（另一个是Jinja2），用来规定Web服务器如何与Python Web程序进行沟通。通过源码可以发现，werkzeug中定义的异常类都继承自HTTPException，下面就简单研究一下这个异常基类。通过查看源码，发现HTTPException继承自Python的Exception对象，它的构造函数接收两个参数：description 和 response. description就是HTTPException显示在错误页面中的异常信息，而response则是一个响应对象。这两个参数后面会用到。现在先看看它的"_call_"方法：
def __call__(self, environ, start_response):
"""Call the exception as WSGI application.
:param environ: the WSGI environment.
:param start_response: the response callable provided by the WSGI
server.
"""
response = self.get_response(environ)
return response(environ, start_response)
很明显，当在代码中raise一个HTTPException时，它会使用get_response()方法来生成一个response响应对象，然后将这个response对象交给前端，继续看get_response()的内部实现：
def get_response(self, environ=None):
"""Get a response object. If one was passed to the exception
it's returned directly.
:param environ: the optional environ for the request. This
can be used to modify the response depending
on how the request looked like.
:return: a :class:`Response` object or a subclass thereof.
"""
from .wrappers.response import Response
if self.response is not None:
return self.response
if environ is not None:
environ = _get_environ(environ)
headers = self.get_headers(environ)
return Response(self.get_body(environ), self.code, headers)
可以看到，get_response()方法考虑了两种情况：
- 如果self.response对象不为空，它就直接返回这个response对象作为异常响应；
- 如果self.response对象为空，它会调用get_headers()方法和get_body()方法来生成一个response对象
关于get_headers()和get_body()方法，看一下它的源码就很容易理解了：
def get_body(self, environ=None):
"""Get the HTML body."""
return text_type(
(
u'<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">\n'
u"<title>%(code)s %(name)s</title>\n"
u"<h1>%(name)s</h1>\n"
u"%(description)s\n"
)
% {
"code": self.code,
"name": escape(self.name),
"description": self.get_description(environ),
}
)
def get_headers(self, environ=None):
"""Get a list of headers."""
return [("Content-Type", "text/html; charset=utf-8")]
HTTPException通过get_headers()生成头部信息，通过get_body()生成具体内容，我们在构造函数中传入的description参数就是在这里传入get_body()中，两者配合定义了一个HTML页面。这里的关键点是get_heades()方法将响应对象的“Content-Type”参数设为了“text/html”格式，这就是为什么它会返还给前端一个HTML页面的原因。显然，这里只要将get_headers()中的“Content-Type”改写为“application/json”，然后再改写get_body()中的内容，就能让它返回JSON格式的数据了。
当然，以上只是第一种方法。再回到之前的get_response()方法中，它里面的self.response对象就是开头在构造函数中传入的那个response参数，就是说，只要我们定义一个JSON格式的response对象传给HTTPException的构造函数就能达到我们想要的效果了。
综上所述，我们有两种方法来实现我们的目的：
- 重写get_headers()和get_body()方法；
- 传入一个JSON格式的response对象；
这两种方法都可以通过定义一个继承自HTTPException的子类来实现，以下我将分别实现这两种方法。
自定义异常处理类
方法一：重写get_headers()和get_body()方法
新定义一个APIException，使其继承自HTTPException，代码如下：
class APIException(HTTPException):
code = 500 # http status code
error_code = 10999 # 项目内部使用的接口状态码
message = 'Server Internal Error'
def __init__(self, code=None, message=None, error_code=None):
if code is not None:
self.code = code
if message is not None:
self.message = message
if error_code is not None:
self.error_code = error_code
super(APIException, self).__init__(self.message, None)
def get_body(self, environ=None):
body = dict(
code=self.error_code,
message=self.message,
data=None,
request=request.method + ' ' + self.get_url_without_param())
return json.dumps(body)
def get_headers(self, environ=None):
return [('Content-Type', 'application/json')]
@staticmethod
def get_url_without_param():
full_url = str(request.full_path)
return full_url.split('?')[0]
方法二：传入一个JSON格式的response对象
直接上代码，如下：
class APIException(HTTPException):
code = 500
error_code = 10999
message = 'Server Internal Error'
def __init__(self, code=None, message=None, error_code=None):
if code is not None:
self.code = code
if message is not None:
self.message = message
if error_code is not None:
self.error_code = error_code
super(APIException, self).__init__(response=self.__make_response())
def __make_response(self):
r = {
'code': self.error_code,
'message': self.message,
'data': None
}
responese = Response(json.dumps(r), mimetype='application/json')
return responese
定义场景错误类
有了上面我们改写好的APIException类，我们就可以自由的定义各种状态码的错误以及对应的错误信息，然后在合适的位置抛出即可，如下：
...
class ParameterError(APIException):
code = 400
error_code = APIStatusCode.PARAMETER_ERROR.code # APIStatusCode是我项目中定义的接口状态码枚举类
message = APIStatusCode.PARAMETER_ERROR.message
class InvalidToken(APIException):
code = 401
error_code = APIStatusCode.Invalid_Token.code
message = APIStatusCode.Invalid_Token.message
...
接下来做一个简单的测试，在视图函数中raise ParameterError, 然后使用curl命令请求接口：
@api.route('/invoke', methods=['GET', 'POST'])
def invoke():
raise ParameterError()
curl http://127.0.0.1:5008/api/v1/mock/invoke
{"code": 400, "message": "Parameter Error", "data": null, "request": "GET /api/v1/mock/invoke"}
可以看到结果是完全符合预期的。这个例子充分体现了Flask的灵活性，这也是我喜爱Flask最重要的原因。同时，也说明HTTPException在设计时就已经考虑好了开发者对它的重构，使我们能方便实现自己的异常处理方式。
注册全局错误处理函数
尽管可以在认为可能出错的所有地方，定义自己的错误类然后抛出，但是也不是所有的异常都是可以提前预知的。比如我们接收前端传来的参数，参数类型或取值范围不正确，这些我们可以预知并处理好，但是如果是逻辑处理中出现了问题，这些不是我们程序可以控制并处理的。所以光有自定义错误类还不够，我们还需要在全局捕获异常来判断，利用AOP思想。
def register_errors(app):
@app.errorhandler(Exception)
def framework_error(e):
if isinstance(e, APIException): # 手动触发的异常
return e
elif isinstance(e, HTTPException): # 代码异常
return APIException(e.code, e.description, None)
else:
if current_app.config['DEBUG']:
raise e
else:
return ServerError()
然后再在工厂函数中进行注册：
def create_app(config_name=None):
"""Flask Application Factory Function"""
app = Flask(__name__)
....
register_errors(app)
....
关于flask的异常处理，以上就是我目前学习到的一些经验技巧，如有错误欢迎指出,，后续会不断更新。