zdppy_api如何实现带参数的中间件

参考代码

import time

from api.middleware import Middleware
from api.middleware.base import BaseHTTPMiddleware
from api.exceptions import AuthException
import jwt

has_logger = False
try:
    from log import logger

    has_logger = True
except:
    pass


def roleapi(has_auth_func, jwtkey=None):
    """
    判断用户角色是否有某个接口的权限
    :param has_auth_func 考虑到可能使用异步的MySQL库，此函数必须是一个异步函数
    接受Token中解析出来的role和request中的method和path作为参数，用于判断用户对该路径是否有访问权限
    """
    return Middleware(RoleAPIAuthMiddleware, has_auth_func=has_auth_func, jwtkey=jwtkey)


class RoleAPIAuthMiddleware(BaseHTTPMiddleware):
    def __init__(self, has_auth_func, jwtkey, app):
        super().__init__(app)
        self.has_auth_func = has_auth_func
        self.jwtkey = jwtkey

    async def dispatch(self, request, call_next):
        # 判断是否需要跳过校验
        if "/login" in str(request.url) or "/register" in str(request.url):
            if has_logger:
                logger.debug("识别到正在访问不需要校验的路径", method=request.method, url=request.url)
            return await call_next(request)

        if has_logger:
            msg = f"开始进行基于角色和接口的高级别权限校验：method={request.method} url={request.url}"
            logger.debug(msg)

        # 获取token
        token = request.headers.get("Authorization")
        if token is None:
            if has_logger:
                logger.error("权限不足：没有携带Token", token=token)
            raise AuthException("权限不足：没有携带Token")

        # 解析token
        data = None
        try:
            if isinstance(self.jwtkey, str):
                data = jwt.parse_token(token, key=self.jwtkey)
            else:
                data = jwt.parse_token(token)
        except Exception as e:
            if has_logger:
                logger.error("获取用户Token失败", headers=request.headers, token=token, error=e)
            raise AuthException("无效的Token")

        # token的结果必须是字典类型
        if not isinstance(data, dict):
            if has_logger:
                logger.error("Token的解析结果不是字典类型", data=data)
            raise AuthException("无效的Token")

        # 必须要有过期时间
        expired = data.get("expired")
        if expired is None:
            if has_logger:
                logger.error("该Token没有设置过期时间", data=data, expired=expired)
            raise AuthException("无效的Token")

        # 校验过期时间的类型
        if not (isinstance(expired, int) or isinstance(expired, float)):
            if has_logger:
                logger.error("该Token的过期时间不是数字类型", expired=expired)
            raise AuthException("无效的Token")

        # 校验是否过期
        now = time.time()
        if now > expired:
            if has_logger:
                logger.warning("Token已过期", expired=expired)
            raise AuthException("Token已过期")

        # 必须要有用户名和用户ID
        userid = data.get("id")
        username = data.get("username")
        userrole = data.get("role")
        if not (userid or username or userrole):
            if has_logger:
                logger.error(
                    "Token中应该包含用户ID，用户名和用户角色",
                    userid=userid,
                    username=username,
                    userrole=userrole,
                    token=token,
                    data=data,
                )
            raise AuthException("无效的Token")

        # 获取请求方法和请求路径
        base_url = request.base_url
        url = request.url
        method = request.method
        path = str(url).replace(str(base_url), "")
        if has_logger:
            logger.debug(
                "开始查询用户是否具备接口级别的权限",
                method=method,
                path=path,
                userid=userid,
                username=username,
                userrole=userrole,
            )
        has_auth = False
        try:
            has_auth = await self.has_auth_func(userrole, method, path)
        except Exception as e:
            if has_logger:
                logger.error(
                    "查询用户接口级别权限失败",
                    method=method,
                    path=path,
                    userid=userid,
                    username=username,
                    userrole=userrole,
                    error=e,
                )
            raise AuthException("无效的Token")
        if has_logger:
            logger.debug(
                "成功查询用户是否具备接口级别的权限",
                has_auth=has_auth,
                method=method,
                path=path,
                userid=userid,
                username=username,
                userrole=userrole,
            )
        if not has_auth:
            if has_logger:
                logger.warning(
                    "权限不足",
                    has_auth=has_auth,
                    method=method,
                    path=path,
                    userid=userid,
                    username=username,
                    userrole=userrole,
                )
            raise AuthException("权限不足")

        # 权限充足，发送请求，获取响应
        response = await call_next(request)
        return response

调用栈分析

使用中间件

app1 = api.Api(
    routes=[
        api.resp.get("/", index),
        api.resp.get("/1", index),
        api.resp.post("/login", login),
    ],
    middleware=[
        # 默认是：zhangdapeng zhangdapng520
        # 可以传入账号和密码进行覆盖
        apimidauth.roleapi(has_auth_func)
    ]
)

apimidauth.roleapi(has_auth_func) 实例化了一个中间件对象。

has_auth_func 是一个函数

这个函数，会在中间件里面，被调用到，完整代码如下。

async def has_auth_func(role, method, path):
    """校验角色对method和path是否有访问权限"""
    print(role, method, path)
    if not str(path).startswith("/"):
        path = f"/{path}"

    # GET:/1
    auth = str(method).upper() + ":" + path

    # 判断是否有权限
    role_auth_dict = auth_dict.get(role)
    if not isinstance(role_auth_dict, dict):
        return False
    if not role_auth_dict.get(auth):
        return False

    return True

roleapi 方法

完整代码如下：

def roleapi(has_auth_func, jwtkey=None):
    """
    判断用户角色是否有某个接口的权限
    :param has_auth_func 考虑到可能使用异步的MySQL库，此函数必须是一个异步函数
    接受Token中解析出来的role和request中的method和path作为参数，用于判断用户对该路径是否有访问权限
    """
    return Middleware(RoleAPIAuthMiddleware, has_auth_func=has_auth_func, jwtkey=jwtkey)

这个其实就是一个普通的函数。

不过比较特殊的地方在于，这个函数的返回值是一个Middleware类的实例。这个类接收如下参数：

• RoleAPIAuthMiddleware：自定义的中间件
• has_auth_func：实际上是自定义中间件需要的一个参数
• jwtkey：实际上也是自定义中间件需要的一个参数

注意：has_auth_func 和 jwtkey 这两个参数，不是 Middleware 类必须的，而是我们自定义的 RoleAPIAuthMiddleware 需要的。

RoleAPIAuthMiddleware 的代码分析

完整代码：

class RoleAPIAuthMiddleware(BaseHTTPMiddleware):
    def __init__(self, has_auth_func, jwtkey, app):
        super().__init__(app)
        self.has_auth_func = has_auth_func
        self.jwtkey = jwtkey

    async def dispatch(self, request, call_next):
        # 判断是否需要跳过校验
        if "/login" in str(request.url) or "/register" in str(request.url):
            if has_logger:
                logger.debug("识别到正在访问不需要校验的路径", method=request.method, url=request.url)
            return await call_next(request)

        if has_logger:
            msg = f"开始进行基于角色和接口的高级别权限校验：method={request.method} url={request.url}"
            logger.debug(msg)

        # 获取token
        token = request.headers.get("Authorization")
        if token is None:
            if has_logger:
                logger.error("权限不足：没有携带Token", token=token)
            raise AuthException("权限不足：没有携带Token")

        # 解析token
        data = None
        try:
            if isinstance(self.jwtkey, str):
                data = jwt.parse_token(token, key=self.jwtkey)
            else:
                data = jwt.parse_token(token)
        except Exception as e:
            if has_logger:
                logger.error("获取用户Token失败", headers=request.headers, token=token, error=e)
            raise AuthException("无效的Token")

        # token的结果必须是字典类型
        if not isinstance(data, dict):
            if has_logger:
                logger.error("Token的解析结果不是字典类型", data=data)
            raise AuthException("无效的Token")

        # 必须要有过期时间
        expired = data.get("expired")
        if expired is None:
            if has_logger:
                logger.error("该Token没有设置过期时间", data=data, expired=expired)
            raise AuthException("无效的Token")

        # 校验过期时间的类型
        if not (isinstance(expired, int) or isinstance(expired, float)):
            if has_logger:
                logger.error("该Token的过期时间不是数字类型", expired=expired)
            raise AuthException("无效的Token")

        # 校验是否过期
        now = time.time()
        if now > expired:
            if has_logger:
                logger.warning("Token已过期", expired=expired)
            raise AuthException("Token已过期")

        # 必须要有用户名和用户ID
        userid = data.get("id")
        username = data.get("username")
        userrole = data.get("role")
        if not (userid or username or userrole):
            if has_logger:
                logger.error(
                    "Token中应该包含用户ID，用户名和用户角色",
                    userid=userid,
                    username=username,
                    userrole=userrole,
                    token=token,
                    data=data,
                )
            raise AuthException("无效的Token")

        # 获取请求方法和请求路径
        base_url = request.base_url
        url = request.url
        method = request.method
        path = str(url).replace(str(base_url), "")
        if has_logger:
            logger.debug(
                "开始查询用户是否具备接口级别的权限",
                method=method,
                path=path,
                userid=userid,
                username=username,
                userrole=userrole,
            )
        has_auth = False
        try:
            has_auth = await self.has_auth_func(userrole, method, path)
        except Exception as e:
            if has_logger:
                logger.error(
                    "查询用户接口级别权限失败",
                    method=method,
                    path=path,
                    userid=userid,
                    username=username,
                    userrole=userrole,
                    error=e,
                )
            raise AuthException("无效的Token")
        if has_logger:
            logger.debug(
                "成功查询用户是否具备接口级别的权限",
                has_auth=has_auth,
                method=method,
                path=path,
                userid=userid,
                username=username,
                userrole=userrole,
            )
        if not has_auth:
            if has_logger:
                logger.warning(
                    "权限不足",
                    has_auth=has_auth,
                    method=method,
                    path=path,
                    userid=userid,
                    username=username,
                    userrole=userrole,
                )
            raise AuthException("权限不足")

        # 权限充足，发送请求，获取响应
        response = await call_next(request)
        return response

基本结构分析

class RoleAPIAuthMiddleware(BaseHTTPMiddleware):
    def __init__(self, has_auth_func, jwtkey, app):
        super().__init__(app)
        self.has_auth_func = has_auth_func
        self.jwtkey = jwtkey

自定义的中间件类，需要继承：BaseHTTPMiddleware，这个类来自于 from api.middleware.base import BaseHTTPMiddleware 。

初始化方法：

def __init__(self, has_auth_func, jwtkey, app):
    super().__init__(app)
    self.has_auth_func = has_auth_func
    self.jwtkey = jwtkey

在这个初始化方法中，我们定义了此中间件需要的参数。

我们在这里定义的是类的参数，但是实际上最后传递参数的方式是：

return Middleware(RoleAPIAuthMiddleware, has_auth_func=has_auth_func, jwtkey=jwtkey)

这里的 app 是没有传参的。

核心是 dispatch 方法

async def dispatch(self, request, call_next):
  # 判断是否需要跳过校验
  if "/login" in str(request.url) or "/register" in str(request.url):
      if has_logger:
          logger.debug("识别到正在访问不需要校验的路径", method=request.method, url=request.url)
      return await call_next(request)

  if has_logger:
      msg = f"开始进行基于角色和接口的高级别权限校验：method={request.method} url={request.url}"
      logger.debug(msg)

  # 获取token
  token = request.headers.get("Authorization")
  if token is None:
      if has_logger:
          logger.error("权限不足：没有携带Token", token=token)
      raise AuthException("权限不足：没有携带Token")

  # 解析token
  data = None
  try:
      if isinstance(self.jwtkey, str):
          data = jwt.parse_token(token, key=self.jwtkey)
      else:
          data = jwt.parse_token(token)
  except Exception as e:
      if has_logger:
          logger.error("获取用户Token失败", headers=request.headers, token=token, error=e)
      raise AuthException("无效的Token")

  # token的结果必须是字典类型
  if not isinstance(data, dict):
      if has_logger:
          logger.error("Token的解析结果不是字典类型", data=data)
      raise AuthException("无效的Token")

  # 必须要有过期时间
  expired = data.get("expired")
  if expired is None:
      if has_logger:
          logger.error("该Token没有设置过期时间", data=data, expired=expired)
      raise AuthException("无效的Token")

  # 校验过期时间的类型
  if not (isinstance(expired, int) or isinstance(expired, float)):
      if has_logger:
          logger.error("该Token的过期时间不是数字类型", expired=expired)
      raise AuthException("无效的Token")

  # 校验是否过期
  now = time.time()
  if now > expired:
      if has_logger:
          logger.warning("Token已过期", expired=expired)
      raise AuthException("Token已过期")

  # 必须要有用户名和用户ID
  userid = data.get("id")
  username = data.get("username")
  userrole = data.get("role")
  if not (userid or username or userrole):
      if has_logger:
          logger.error(
              "Token中应该包含用户ID，用户名和用户角色",
              userid=userid,
              username=username,
              userrole=userrole,
              token=token,
              data=data,
          )
      raise AuthException("无效的Token")

  # 获取请求方法和请求路径
  base_url = request.base_url
  url = request.url
  method = request.method
  path = str(url).replace(str(base_url), "")
  if has_logger:
      logger.debug(
          "开始查询用户是否具备接口级别的权限",
          method=method,
          path=path,
          userid=userid,
          username=username,
          userrole=userrole,
      )
  has_auth = False
  try:
      has_auth = await self.has_auth_func(userrole, method, path)
  except Exception as e:
      if has_logger:
          logger.error(
              "查询用户接口级别权限失败",
              method=method,
              path=path,
              userid=userid,
              username=username,
              userrole=userrole,
              error=e,
          )
      raise AuthException("无效的Token")
  if has_logger:
      logger.debug(
          "成功查询用户是否具备接口级别的权限",
          has_auth=has_auth,
          method=method,
          path=path,
          userid=userid,
          username=username,
          userrole=userrole,
      )
  if not has_auth:
      if has_logger:
          logger.warning(
              "权限不足",
              has_auth=has_auth,
              method=method,
              path=path,
              userid=userid,
              username=username,
              userrole=userrole,
          )
      raise AuthException("权限不足")

  # 权限充足，发送请求，获取响应
  response = await call_next(request)
  return response

中间件核心方法分析

参数是什么

async def dispatch(self, request, call_next):

首先，这个方法是一个异步方法。

第一个参数是请求对象，存储了客户端的所有请求信息。

第二个参数是调用下一个中间件的对象，如果成功了，则调用此方法得到一个response对象，返回response对象即可。

如果成功了返回什么？

如果成功了，则调用此 call_next 方法得到一个response对象，返回response对象即可。

response = await call_next(request)
return response

如果失败了，该返回什么？

示例代码如下：

if has_logger:
    logger.error("Token的解析结果不是字典类型", data=data)
raise AuthException("无效的Token")

首先，我们是记录错误日志。

然后，抛出一个异常。

因为 zdppy_api 已经内部封装了全局异常处理，所以这个异常，最终会被全局异常错误处理器自动捕获，并返回给客户端一个比较通用且友好的错误信息。

支持哪些异常类

首先是 AuthException，这个来源于：

from api.exceptions import AuthException

通过查看源码，我们可以知道， zdppy_api 框架，目前内置了如下异常处理器：

default_exception_handlers = {
    404: not_found,
    500: server_error,
    HTTPException: handle_http_exception,
    AuthException: handle_auth_exception,
    Exception: handle_exception,
}

最终总结

如果，我们要实现 db 请求上下文中间件：

• 请求开始时，自动建立连接
• 请求结束是，自动断开连接

那么，我们的实现思路如下：

• 1、实现一个 OrmRequestMiddleware 中间件类。这个类继承 api.middleware.base.BaseHTTPMiddleware，接收一个 db 作为参数。
• 2、实现一个 apimidorm.request(db) 方法，这个方法的返回值是 Middleware(OrmRequestMiddleware, db=db)
• 3、在 OrmRequestMiddleware 自定义中间件类中，重写 async def dispatch(self, request, call_next) 方法
• 4、方法体中实现具体的逻辑。请求开始之前，调用 db.connect()，调用 response = call_next()，之后调用 db.colse()，最后返回 response。

以上是一个具体的实现思路，仅供参考。