sanic研究之HTTPMethodView类

2020-12-19 09:17:04 编辑 1 阅读量:1842

sanic是一个基于协程的异步框架，有着很优秀的性能，使用方式与flask类似。这里来讨论一下使用sanic开发RESTful api。

在sanic.views中，有个HTTPMethodView，基于这个可以很方便的实现同一个URI的不同的方法，比如：

```
from sanic import Sanic
from sanic.views import HTTPMethodView
from sanic.response import text

app = Sanic(__name__)

class ResourceView(HTTPMethodView):

def get(self, request):
	    return text("I am get method")

def post(self, request):
	    return text("I am post method")

app.add_route(ResourceView.as_vies(), "/")

app.run(host='0.0.0.0', port=8090, debug=True)
```

运行起来后，用get和post访问能得到不同的结果。如果需要添加权限认证等装饰器，可以如下：

```
from sanic import Sanic
from sanic.views import HTTPMethodView
from sanic.response import text
from sanic.exceptions import abort

app = Sanic(__name__)

def login_required(func):
    async def decorated(request, *args, **kwargs):
	    abort(403)  # 这里都认证失败
    return decorated

class ResourceView(HTTPMethodView):
    decorators = [login_required]

def get(self, request):
	    return text("I am get method")

def post(self, request):
	    return text("I am post method")

app.add_route(ResourceView.as_vies(), "/")

app.run(host='0.0.0.0', port=8090, debug=True)
```

这是，get和post访问都会得出权限不足的结果。这里装饰器可以累加，但是decorators有个不足就是，ResourceView内的所有方法都会被要求需要权限，无法单独使某个方法不需要权限，比如如下场景：

```
登录实际是对应的资源是 session，因此
GET /session # 获取会话信息 
POST /session # 创建新的会话（登录） 
PUT /session # 更新会话信息 
DELETE /session # 销毁当前会话（注销） 
而注册对应的资源是user，api如下： 
GET /user/:id # 获取id用户的信息 
POST /user # 创建新的用户（注册） 
PUT /user/:id # 更新id用户的信息 
DELETE /user/:id # 删除id用户（注销）
```
注册不需要权限，而获取id用户信息需要权限。如果使用decorators的话，所有就需要权限。来了解一下sanic的实现。

```
# sanic.views中
class HTTPMethodView:
    """Simple class based implementation of view for the sanic.
    You should implement methods (get, post, put, patch, delete) for the class
    to every HTTP method you want to support.

For example:

.. code-block:: python

class DummyView(HTTPMethodView):
            def get(self, request, *args, **kwargs):
                return text('I am get method')
            def put(self, request, *args, **kwargs):
                return text('I am put method')

etc.

If someone tries to use a non-implemented method, there will be a
    405 response.

If you need any url params just mention them in method definition:

.. code-block:: python

class DummyView(HTTPMethodView):
            def get(self, request, my_param_here, *args, **kwargs):
                return text('I am get method with %s' % my_param_here)

To add the view into the routing you could use
        1) app.add_route(DummyView.as_view(), '/')
        2) app.route('/')(DummyView.as_view())

To add any decorator you could set it into decorators variable
    """

decorators = []

def dispatch_request(self, request, *args, **kwargs):
        import pdb; pdb.set_trace()
        handler = getattr(self, request.method.lower(), None)
        return handler(request, *args, **kwargs)

@classmethod
    def as_view(cls, *class_args, **class_kwargs):
        """Return view function for use with the routing system, that
        dispatches request to appropriate handler method.
        """
        # import pdb; pdb.set_trace()
        def view(*args, **kwargs):
            # import pdb; pdb.set_trace()
            self = view.view_class(*class_args, **class_kwargs)
            return self.dispatch_request(*args, **kwargs)

if cls.decorators:
            view.__module__ = cls.__module__
            for decorator in cls.decorators:
                view = decorator(view)

view.view_class = cls
        view.__doc__ = cls.__doc__
        view.__module__ = cls.__module__
        view.__name__ = cls.__name__
        return view
```
在调用as_view的时候，sanic定义了一个view的函数，并且把view用装饰器都装饰了一遍，然后把HTTPMethodView的子类赋给view函数，然后把view函数添加到路由中（在app.add_route实现）。而sanic处理一个http请求的步骤都在sanic.app.handle_request中
```
async def handle_request(self, request, write_callback, stream_callback):
        """Take a request from the HTTP Server and return a response object
        to be sent back The HTTP Server only expects a response object, so
        exception handling must be done here

:param request: HTTP Request object
        :param write_callback: Synchronous response function to be
            called with the response as the only argument
        :param stream_callback: Coroutine that handles streaming a
            StreamingHTTPResponse if produced by the handler.

:return: Nothing
        """
        try:
            # -------------------------------------------- #
            # Request Middleware
            # -------------------------------------------- #

request.app = self
            response = await self._run_request_middleware(request)
            # No middleware results
            if not response:
                # -------------------------------------------- #
                # Execute Handler
                # -------------------------------------------- #

# Fetch handler from router
                import pdb; pdb.set_trace()
                handler, args, kwargs, uri = self.router.get(request) # 这里的handler就是上面说的view函数
                request.uri_template = uri
                if handler is None:
                    raise ServerError(
                        ("'None' was returned while requesting a "
                         "handler from the router"))

# Run response handler
                response = handler(request, *args, **kwargs)  # 执行view函数
                if isawaitable(response):
                    response = await response
        except Exception as e:
            # -------------------------------------------- #
            # Response Generation Failed
            # -------------------------------------------- #

try:
                response = self.error_handler.response(request, e)
                if isawaitable(response):
                    response = await response
            except Exception as e:
                if self.debug:
                    response = HTTPResponse(
                        "Error while handling error: {}\nStack: {}".format(
                            e, format_exc()))
                else:
                    response = HTTPResponse(
                        "An error occurred while handling an error")
        finally:
            # -------------------------------------------- #
            # Response Middleware
            # -------------------------------------------- #
            try:
                response = await self._run_response_middleware(request,
                                                               response)
            except BaseException:
                error_logger.exception(
                    'Exception occurred in one of response middleware handlers'
                )

# pass the response to the correct callback
        if isinstance(response, StreamingHTTPResponse):
            await stream_callback(response)
        else:
            write_callback(response)
```

在执行view函数的时候，已经先经过了decorators的步骤（因为view已经被decorators装饰了），所以`ResourceView`里面的所有方法都经过了权限认证的要求。接下来，再看下view的定义
```
def view(*args, **kwargs):
   self = view.view_class(*class_args, **class_kwargs)  # 把ResourceView初始化并赋值给self，这里是resourceview
   return self.dispatch_request(*args, **kwargs)  # 所以这里调用的是ResourceView中的dispatch_request的方法
```

所以，我们可以利用as_view和dispatch_request做很多事情。

sanic研究之HTTPMethodView类

附件: