面向对象知识补充

1、getattr(self)

• 用于反射属性和方法

  ​x
  class Foo(object):
      def __init__(self, name, age):
          self.name = name
          self.age = age
  
      def show(self):
          return "这是 show 方法的返回值"
  
  
  obj = Foo("小明", 21)
  
  v1 = getattr(obj, 'name')
  print(v1)
  
  v2 = getattr(obj, 'show')()
  print(v2)
  

  结果：

  xxxxxxxxxx
  小明
  这是 show 方法的返回值
  

2、__getattr__(self, item)

• 在面向对象当你获取不存在的属性时执行

  xxxxxxxxxx
  class Foo(object):
      def __init__(self, name, age):
          self.name = name
          self.age = age
  
      def __getattr__(self, item):
          print("不存在的属性----->",item)
          return "这是 getattr 的返回值"
  
  
  obj = Foo("小明", 21)
  
  print(obj.xxxxx)
  

  结果：

  xxxxxxxxxx
  不存在的属性-----> xxxxx
  这是 getattr 的返回值
  

  如果没有getattr方法的话打印不存在的属性时会报错

3、__getattribute__(self, item)

• 在面向对象中访问属性时执行无论是否存在都会执行

  xxxxxxxxxx
  class Foo(object):
      def __init__(self, name, age):
          self.name = name
          self.age = age
  
      def __getattribute__(self, item):
          print("无论是否存在的属性----->",item)
          return "这是 getattribute 的返回值"
  
  
  obj = Foo("小明", 21)
  
  print(obj.name)
  print(obj.age)
  print(obj.xxxxx)
  

  结果：

  xxxxxxxxxx
  无论是否存在的属性-----> name
  这是 getattribute 的返回值
  无论是否存在的属性-----> age
  这是 getattribute 的返回值
  无论是否存在的属性-----> xxxxx
  这是 getattribute 的返回值
  

4、@property

xxxxxxxxxx
@property
def user(self):
    return 123

• 此时可以直接使用属性的调用方式调用

  xxxxxxxxxx
  obj.user
  

   

drf（纯净版项目）

settings.py基本配置，可参考

xxxxxxxxxx
from pathlib import Path

BASE_DIR = Path(__file__).resolve().parent.parent

SECRET_KEY = 'django-insecure-6t452+ox7@$=!#-jgywyo*7$fy3&2*x^0xaqtg25k74k51j8bf'

DEBUG = True

ALLOWED_HOSTS = []

INSTALLED_APPS = [
    # 'django.contrib.admin',
    # 'django.contrib.auth',
    # 'django.contrib.contenttypes',
    # 'django.contrib.sessions',
    # 'django.contrib.messages',
    'django.contrib.staticfiles',
    'rest_framework',
    'api.apps.ApiConfig'
]

MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    # 'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    # 'django.middleware.csrf.CsrfViewMiddleware',
    # 'django.contrib.auth.middleware.AuthenticationMiddleware',
    # 'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
]

ROOT_URLCONF = 'blog.urls'

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [],
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.debug',
                'django.template.context_processors.request',
                # 'django.contrib.auth.context_processors.auth',
                # 'django.contrib.messages.context_processors.messages',
            ],
        },
    },
]

WSGI_APPLICATION = 'blog.wsgi.application'

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': BASE_DIR / 'db.sqlite3',
    }
}

AUTH_PASSWORD_VALIDATORS = [
    {
        'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
    },
    {
        'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator',
    },
    {
        'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator',
    },
    {
        'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator',
    },
]


LANGUAGE_CODE = 'en-us'

TIME_ZONE = 'UTC'

USE_I18N = True

USE_TZ = True

STATIC_URL = 'static/'

DEFAULT_AUTO_FIELD = 'django.db.models.BigAutoField'

REST_FRAMEWORK = {
    "UNAUTHENTICATED_USER": None
}

drf（认证）

对匿名用户添加配置防止报错

• 源码入口

  

  在settings.py中添加

  xxxxxxxxxx
  REST_FRAMEWORK = {
      "UNAUTHENTICATED_USER": None,
  }
  

  

  这样的话就从源码从分析，会走下面的这个，如果走上面那个会调用drf的默认值，使页面报错

如何进行用户的认证

• 基础实现

  xxxxxxxxxx
  from rest_framework.response import Response
  from rest_framework.views import APIView
  from rest_framework.authentication import BaseAuthentication
  from rest_framework.exceptions import AuthenticationFailed
  
  class MyAuthentication(BaseAuthentication):
      def authenticate(self, request):
          token = request.query_params.get("token")
          if token:
              return "JELEE", token
          # raise AuthenticationFailed("认证失败") 
          raise AuthenticationFailed({"code": 2000, "message": "认证失败"})
  
  
  class loginView(APIView):
      def get(self, request):
          print(request.user,request.auth) # None None
          return Response("loginView")
  
  class userView(APIView):
      authentication_classes = [MyAuthentication, ] # 添加验证的类，可以填写多个
      def get(self, request):
          print(request.user,request.auth) # JELEE xxxx 这里打印的是上面返回的两个值
          return Response("userView")
  
  class orderView(APIView):
      authentication_classes = [MyAuthentication, ]
      def get(self, request):
          return Response("orderView")
  

  • 解释代码

    raise AuthenticationFailed()

    如果里面填写的是字符串，那他会自动添加detail拼接成字典

    如果里面直接填写的字典，那他就会返回字典在页面上显示

    return "JELEE", token

    这里面的两个分别会赋值给

    request.user和request.auth

    就可以在方法里面获取这两个的值

添加全局验证配置

• 添加配置

  xxxxxxxxxx
  REST_FRAMEWORK = {
      "UNAUTHENTICATED_USER": None,
      "DEFAULT_AUTHENTICATION_CLASSES": ["位置", ]
  }
  

  "DEFAULT_AUTHENTICATION_CLASSES": ["位置", ]

  的意思是添加全局验证配置，列表中填写验证的规则位置

  如果两个地方都写了配置，会执行视图的配置

  注意：

  理解方式：优先执行全局的配置后执行视图的配置后会覆盖全局的配置

  真实实现原理（面向对象的继承）：

  xxxxxxxxxx
  class APIView(object):
   authentication_classes = 读取配置文件中的列表
   def dispatch(self):
       self.authentication_classes
  
  class UserView(APIView):
   authentication_classes = []
  
  
  obj = UserView()
  obj.dispatch()
  

  源码解析：

  

  此图较大，看不清的话就下载下来看

• 验证的位置

  如果是全局的验证，不能编写在视图中

  如果是在视图中编写全局的应用类，会出现循环引用的问题

  

  如果有多个认证组件，认证组件中如果没有抛出异常的话，那视图函数依然会执行

  如果抛出了异常，那视图函数就不会执行

  最佳实践：

  将所有的验证类都编写在一个统一的文件中

解决状态码一致问题

• 在AuthenticationFailed抛出异常以后此处状态码应该是401的

  

• 但是实际上的状态码

  

这个现象需要在源码中解释

拓展：子类约束

需要让自己的子类里面必须有某个方法的时候

使用raise NotImplementedError

xxxxxxxxxx
class Foo(object):
    def f1(self):
        raise NotImplementedError("")

class New(Foo):
    pass

此时的New里面必须有f1方法，否则就会报错

在drf中的体现：

案例：用户登录注册

• request.data可以获取用户发过来的请求体中的数据

  xxxxxxxxxx
  def post(self, request):
      print(request.data)
      print(request.query_params)
      return Response("loginView")
  # 通过这两个可以把请求体中的数据和用户在url中携带的数据都拿到
  

  

  

• 案例代码

  auth.py

  xxxxxxxxxx
  from rest_framework.authentication import BaseAuthentication
  from rest_framework.exceptions import AuthenticationFailed
  from app01 import models
  
  
  class QueryParamsAuthentication(BaseAuthentication):
      def authenticate(self, request):
          token = request.query_params.get("token")
          if not token:
              return
          user_object = models.UserInfo.objects.filter(token=token).first()
          if user_object:
              return user_object, token
  
      def authenticate_header(self, request):
          return "token API"
  
  
  class MetaAuthentication(BaseAuthentication):
      def authenticate(self, request):
          token = request.META.get("HTTP_AUTHORIZATION")  # 获取请求头中的 Authorization
          if not token:
              return
          user_object = models.UserInfo.objects.filter(token=token).first()
          if user_object:
              return user_object, token
  
      def authenticate_header(self, request):
          return "token API"
  
  
  class NoAuthentication(BaseAuthentication):
      def authenticate(self, request):
          raise AuthenticationFailed({"code": 10001, "msg": "认证失败"})
  
      def authenticate_header(self, request):
          return "token API"
  

  views.py

  xxxxxxxxxx
  from rest_framework.response import Response
  from rest_framework.views import APIView
  from app01 import models
  import uuid
  class loginView(APIView):
      authentication_classes = []
      def post(self, request):
          user = request.data.get("username")
          pwd = request.data.get("password")
          user_object = models.UserInfo.objects.get(username=user, password=pwd)
          if user_object:
              token = str(uuid.uuid4())
              user_object.token = token
              user_object.save()
              return Response({"code": 0, "token": token})
          return Response({"code": 1001, "msg": "用户名或密码错误"})
  
  class userView(APIView):
      def get(self, request):
          return Response("userView")
  
  class orderView(APIView):
      def get(self, request):
          return Response("orderView")
  

   

drf（权限）

• 概述：

  

• 代码：

  编写一个权限类

  xxxxxxxxxx
  from rest_framework.permissions import BasePermission
  from random import randint
  class MyPermissions(BasePermission):
      def has_permission(self, request, view):
          v = randint(1,3)
          if v == 2:
              return False
          return True
  

  全局应用

  xxxxxxxxxx
  REST_FRAMEWORK = {
      "UNAUTHENTICATED_USER": None,
      # -------------------------------------
      "DEFAULT_PERMISSION_CLASSES": [
          "ext.per.MyPermissions"
      ]
  }
  
  

  局部应用

  xxxxxxxxxx
  class loginView(APIView):
      authentication_classes = []
      permission_classes = [] 
  

  应用的场景和生效的场景和认证组件一样

自定义错误信息

• 默认情况下的错误信息

  

• 在定义权限类的时候添加message类变量

  xxxxxxxxxx
  from rest_framework.permissions import BasePermission
  from random import randint
  class MyPermissions(BasePermission):
      message = {"status": False, "msg": "无权访问"}
      def has_permission(self, request, view):
          v = randint(1,3)
          if v == 2:
              return False
          return True
  

• 此时的错误信息

  

权限组件的源码流程

从源码也可以看出，当进行权限认证时

遇到一个报错了后面的就不会再执行了

当有一个返回了False就会执行permission_denied报错拦截

我们可以通过更改这个逻辑来实现不一样的效果：

权限组件的拓展（更改逻辑）

在执行的过程中会优先在自己的方法里面寻找check_permissoins

如果自己的方法里面没有的话才会去父类中找

所以可以在自己的类里面定义一个check_permissoins方法

达到重写逻辑的目的

xxxxxxxxxx
class orderView(APIView):
    authentication_classes = []
    permission_classes = [MyPermissions, MyPermissions1, MyPermissions2]

    def check_permissions(self, request):
        for permission in self.get_permissions():
            if permission.has_permission(request, self):
                return
        else:
            self.permission_denied(
                request,
                message=getattr(permission, 'message', None),
                code=getattr(permission, 'code', None)
            )

在类里面添加方法修改

改为只要有一个返回为True就通过验证

都返回False才会报错

• 错误信息也可以自定义

  xxxxxxxxxx
  def check_permissions(self, request):
      no_permissions_list = []
      for permission in self.get_permissions():
          if permission.has_permission(request, self):
              return
          else:
              no_permissions_list.append(permission)
      else:
          self.permission_denied(
              request,
              message=getattr(no_permissions_list[0], 'message', None),
              code=getattr(no_permissions_list[0], 'code', None)
          )
  

• 甚至可以自己写

  xxxxxxxxxx
  message = {"code": 1000, "message": "这是自己写的错误信息"}
  

  

• 如果想对多个视图函数使用的话可以编写一个类，让其他的类继承他，这样就可以实现多个类共用

  xxxxxxxxxx
  class NbAPIView(APIView):
      def check_permissions(self, request):
          no_permissions_list = []
          for permission in self.get_permissions():
              if permission.has_permission(request, self):
                  return
              else:
                  no_permissions_list.append(permission)
          else:
              self.permission_denied(
                  request,
                  message=getattr(no_permissions_list[0], 'message', None),
                  code=getattr(no_permissions_list[0], 'code', None)
              )
  

  让其他的类继承NbAPIView

案例：权限处理

• 认证处理

  xxxxxxxxxx
  from rest_framework.authentication import BaseAuthentication
  from rest_framework.exceptions import AuthenticationFailed
  from app01 import models
  
  
  class QueryParamsAuthentication(BaseAuthentication):
      def authenticate(self, request):
          token = request.query_params.get("token")
          if not token:
              return
          user_object = models.UserInfo.objects.filter(token=token).first()
          if user_object:
              return user_object, token
  
      def authenticate_header(self, request):
          return "token API"
  
  
  class MetaAuthentication(BaseAuthentication):
      def authenticate(self, request):
          token = request.META.get("HTTP_AUTHORIZATION")  # 获取请求头中的 Authorization
          if not token:
              return
          user_object = models.UserInfo.objects.filter(token=token).first()
          if user_object:
              return user_object, token
  
      def authenticate_header(self, request):
          return "token API"
  
  
  class NoAuthentication(BaseAuthentication):
      def authenticate(self, request):
  
          raise AuthenticationFailed({"code": 10001, "msg": "认证失败"})
      def authenticate_header(self, request):
          return "token API"
  
  

• 权限处理

  xxxxxxxxxx
  from rest_framework.permissions import BasePermission
  from random import randint
  
  
  class UserPermissions(BasePermission):
      message = {"status": False, "msg": "无权访问"}
  
      def has_permission(self, request, view):
          if request.user.role == 3:
              return True
          return False
  
  
  class ManagePermissions1(BasePermission):
      message = {"status": False, "msg": "无权访问"}
  
      def has_permission(self, request, view):
          if request.user.role == 2:
              return True
          return False
  
  class BossPermissions2(BasePermission):
      message = {"status": False, "msg": "无权访问"}
  
      def has_permission(self, request, view):
          if request.user.role == 1:
              return True
          return False
  
  

• 视图

  xxxxxxxxxx
  from ext.view import NbAPIView # 上文中提到过
  
  class userView(NbAPIView):
      permission_classes = [ManagePermissions1, BossPermissions2]
      def get(self, request):
          print("访问成功,只有管理员或老板可以访问")
          return Response("userView")
  
  
  class orderView(NbAPIView):
      permission_classes = [UserPermissions, ManagePermissions1, BossPermissions2]
      def get(self, request):
          print("访问成功，都可以访问")
          return Response("orderView")
  

这样就可以实现识别用户的权限，并且根据权限拦截访问

• 多个权限组件与多个认证组件的区分

  组件类型	进行下一个判断的条件	退出判断的条件	逻辑
  认证组件	返回None	返回user和auth或者raise AuthenticationFailed	接收到值或者报错就退出校验
  权限组件（默认逻辑）	返回True	返回False	默认全部为True才通过，返回一个False即结束
  权限组件（修改为或逻辑）	返回False	返回True	返回False即说明不符合这个权限，进行下一个权限验证，返回True说明权限校验成功，退出验证

  • 或逻辑权限校验

    xxxxxxxxxx
    from rest_framework.views import APIView
    
    class NbAPIView(APIView):
        def check_permissions(self, request):
            no_permissions_list = []
            for permission in self.get_permissions():
                if permission.has_permission(request, self):
                    return
                else:
                    no_permissions_list.append(permission)
            else:
                self.permission_denied(
                    request,
                    message=getattr(no_permissions_list[0], 'message', None),
                    code=getattr(no_permissions_list[0], 'code', None)
                )
    

补充

django中的中间件执行时机在认证组件，权限组件之前

drf（限流）

快速上手

• 限制访问的次数频率（一分钟多少次？）

• 使用示例：

  先安装模块

  xxxxxxxxxx
  pip install django-redis
  

  xxxxxxxxxx
  from rest_framework.throttling import SimpleRateThrottle
  from django.core.cache import cache as default_cache 
  
  class MyThrottle(SimpleRateThrottle):
      scope = "XXX"                           # 配置节流器的名称
      THROTTLE_RATES = {"XXX": "5/m"}         # 键是节流器名称 值是限制的频率
      cache = default_cache                   # 配置redis作为cache将访问记录缓存起来
      def get_cache_key(self, request, view):
          if request.user:                    # 如果是已经认证的用户
              ident = request.user.pk         # 就把id设置为主键
          else:
              ident = self.get_ident(request) # 没有认证用户就使用ip地址
          return self.cache_format % {'scope': self.scope, 'ident': ident}
  
  

  from django.core.cache import cache as default_cache

  这里引入的cache默认读取的是settings文件中CACHES中的 default ，如果没没有配置default，这个cache默认是用不了的

  xxxxxxxxxx
  # 导入组件
  class loginView(APIView):
      throttle_classes = [MyThrottle, ] # 编写 throttle_classes 应用类
  
  

  • 配置redis作为默认缓存（settings.py）

    xxxxxxxxxx
    CACHES = {
        # 默认缓存
        "default": {
            "BACKEND": "django_redis.cache.RedisCache",
            # 项目上线时,需要调整这里的路径
            # "LOCATION": "redis://:密码@IP地址:端口/库编号",
            "LOCATION": "redis://:@192.168.207.100:6379/0",
            "OPTIONS": {
                "CLIENT_CLASS": "django_redis.client.DefaultClient",
                "CONNECTION_POOL_KWARGS": {"max_connections": 10}
            }
        }
    }
    

    配置了以后在redis中会记录访问的频率

    前五次正常访问

    

    超过频率后

    

    提示超过频率限制

源码和具体实现

• 获取时间间隔、访问次数

  

  此时得到

  self.num_requests和self.duration

• 源码执行流程

  

案例

xxxxxxxxxx
from rest_framework.throttling import SimpleRateThrottle
from django.core.cache import cache as default_cache
from rest_framework.exceptions import Throttled

class IPThrottle(SimpleRateThrottle):
    scope = "ip"
    cache = default_cache
    def get_cache_key(self, request, view):
        ident = self.get_ident(request)
        return self.cache_format % {'scope': self.scope, 'ident': ident}


class UserThrottle(SimpleRateThrottle):
    scope = "user"
    cache = default_cache
    def get_cache_key(self, request, view):
        ident = request.user.pk
        return self.cache_format % {'scope': self.scope, 'ident': ident}

    def wait(self):
        """
        重写wait方法，返回自定义信息
        """
        if self.history:
            remaining_duration = self.duration - (self.now - self.history[-1])
        else:
            remaining_duration = self.duration
        raise Throttled(
            detail={
                "message": "请求过于频繁，请稍后再试",
                "retry_after": int(remaining_duration),
                "code": 429
            }
        )

拓展（自定义限流类抛出的异常信息）

在分析源码执行流程时可以看出请求被限制时会进入wait方法

如果想要自定义异常信息的话只需要重写wait方法即可

xxxxxxxxxx
class UserThrottle(SimpleRateThrottle):
    scope = "user"
    cache = default_cache
    def get_cache_key(self, request, view):
        ident = request.user.pk
        return self.cache_format % {'scope': self.scope, 'ident': ident}
    # --------------------- 在throttle类里面重写wait方法
    def wait(self):
        """
        重写wait方法，返回自定义信息
        """
        if self.history:
            remaining_duration = self.duration - (self.now - self.history[-1])
        else:
            remaining_duration = self.duration
        raise Throttled(
            detail={
                "message": "请求过于频繁，请稍后再试",
                "retry_after": int(remaining_duration),
                "code": 429
            }
        )

关注源码的流程，只有当请求收到限制的时候，也就是超过了限流类允许的最大次数时，wait方法才会被调用，所以当需要自定义抛出的异常信息时，只需要在wait方法里面抛出自定义的错误信息就可以了

drf（版本）

参数传递

方式一（基于GET参数）

xxxxxxxxxx
from rest_framework.versioning import QueryParameterVersioning

class homeView(APIView):
    versioning_class = QueryParameterVersioning
    def get(self, request):
        # http://127.0.0.1:8000/home/?version=v2
        print(request.version) # v2
        return Response({"code": 0, "message": "成功"})

此时会自动的读取query请求头中携带的版本信息

比如此时?name=vhsj&age=20&version=v2

此时会自动读取请求头中的version信息

并赋值给request.version

从源码中可以看出，获取的请求头中的名字取决于配置文件中的VERSION_PARAM

可以通过配置这个信息来自定义获取的参数名

xxxxxxxxxx
REST_FRAMEWORK = {
    "UNAUTHENTICATED_USER": None,
    "VERSION_PARAM": "v",
    # ----------- 如果获取不到的话就会获取DEFAULT_VERSION
    "DEFAULT_VERSION": "v",
    # ----------- 填写已有的版本号信息 如果用户发送了不存在的版本号则报错
    "ALLOWED_VERSIONS": ['v1']
}

此时就可以使用v来传递版本参数

最佳实践：

使用默认的version来传递参数名称

####

反向生成url

首先分析源码流程

了解源码流程以后就可以执行以下操作反向生成url

xxxxxxxxxx
from django.urls import path
from api import views
urlpatterns = [
    path("home/", views.homeView.as_view(), name="hh")
]

xxxxxxxxxx
class homeView(APIView):
    versioning_class = QueryParameterVersioning
    def get(self, request):
        # http://127.0.0.1:8000/home/?version=v1
        print(request.version) # v1
        url = request.versioning_scheme.reverse("hh", request=request)
        print("反向生成的url：", url)
        return Response({"code": 0, "message": "成功"})

注意此时反向生成的url是只会携带你的版本号参数，如果有其他参数他不会自动携带

方式二（基于路由URL）

xxxxxxxxxx
from django.urls import path
from api import views
urlpatterns = [
    path("api/<str:version>/home/", views.homeView.as_view(), name="hh")
]

xxxxxxxxxx
from rest_framework.versioning import QueryParameterVersioning, URLPathVersioning

class homeView(APIView):
    versioning_class = URLPathVersioning
    def get(self, request, *args, **kwargs):
        print(request.version)
        return Response({"code": 0, "message": "成功"})
"""
class homeView(APIView):
    versioning_class = URLPathVersioning
    def get(self, request, version):
        print(version) 直接获取
        return Response({"code": 0, "message": "成功"})
"""

方式三（Accept请求头）

xxxxxxxxxx
from django.urls import path
from api import views
urlpatterns = [
    path("api/home/", views.homeView.as_view(), name="hh")
]

xxxxxxxxxx
from rest_framework.response import Response
from rest_framework.views import APIView
from rest_framework.versioning import AcceptHeaderVersioning


class homeView(APIView):
    versioning_class = AcceptHeaderVersioning
    def get(self, request, *args, **kwargs):
        print(request.version)
        print(request.versioning_scheme.reverse("hh", request=request))
        return Response({"code": 0, "message": "成功"})

这样也可以获取到版本信息，且同样可以反向生成URL

最佳实践

以上三种传递参数的方式

最常用的是方式二

其次是方式一

方式三几乎不使用

补充

为了方便可以这样写

xxxxxxxxxx
REST_FRAMEWORK = {
    "UNAUTHENTICATED_USER": None,
    "DEFAULT_VERSIONING_CLASS": "rest_framework.versioning.URLPathVersioning"
}

在定义类的时候就不用每次都写一遍版本信息的相关配置了

drf（解析器）

解析器：解析请求者发送过来的数据，根据请求头的类型匹配类，然后在类里面对不同的数据进行解析之后赋值给request.data

基本用法和流程

xxxxxxxxxx
from rest_framework.parsers import JSONParser, FormParser
from rest_framework.negotiation import DefaultContentNegotiation

class homeView(APIView):
    # 所有的解析器
    parser_classes = [JSONParser, FormParser]

    # 根据请求 匹配对应的解析器
    content_negotiation_class = DefaultContentNegotiation
    def get(self, request, *args, **kwargs):
        print(request.version)
        print(request.versioning_scheme.reverse("hh", request=request))
        return Response({"code": 0, "message": "成功"})

    def post(self, request, *args, **kwargs):
        return Response("OK")

此时可以通过request.data打印获取到的数据

最佳实践：

使用JSONParser

因为JSON对于多层嵌套的格式易于处理

源码流程

在执行request.data时才会去触发解析器的动作

如果调用多次

xxxxxxxxxx
request.data
request.data

那只会解析一次

文件上传

• FileUploadParser

  此方法为手动写入文件且写入的路径是项目的根路径

  xxxxxxxxxx
  from rest_framework.parsers import FileUploadParser
  
  class homeView(APIView):
      parser_classes = [FileUploadParser]
  
      content_negotiation_class = DefaultContentNegotiation
      def post(self, request, *args, **kwargs):
          print(request.content_type)
          print(request.data)
          file_object = request.data.get('file')
          with open(file_object.name, mode='wb') as target_file_object:
              for chunk in file_object:
                  target_file_object.write(chunk)
              file_object.close()
          return Response("OK")
  

  FileUploadParser最佳实践

  default_storage.save会将文件保存到media目录下

  default_storage.url会返回文件的相对路径（相对根目录）

  缺点：

  此方法只能传输文件，不能同时传输其他类型的数据，导致了在传输时必须携带Header

  

  （前端一般默认会携带）

  在某些场景下会显得不方便

  xxxxxxxxxx
  from rest_framework.parsers import FileUploadParser
  from django.core.files.storage import default_storage
  class homeView(APIView):
      parser_classes = [FileUploadParser]
  
      content_negotiation_class = DefaultContentNegotiation
      def post(self, request, *args, **kwargs):
          file_object = request.data.get('file')
          file_name = default_storage.save(file_object.name, file_object)
          file_url = default_storage.url(file_name)
          print(file_url)
          return Response("OK")
  

• MultiPartParser最佳实践

  这种解析可以允许多种数据的携带

  可以在上传文件的同时上传其他的东西

  

  xxxxxxxxxx
  from rest_framework.parsers import MultiPartParser
  from django.core.files.storage import default_storage
  class homeView(APIView):
      parser_classes = [MultiPartParser]
      content_negotiation_class = DefaultContentNegotiation
      
      def post(self, request, *args, **kwargs):
          print(request.data)
          file_object = request.data.get('file')
          default_storage.save(file_object.name, file_object)
          return Response("OK")
  

拓展（自定义解析器配置）

许多开发者一般都不写解析器的配置，drf内部有默认值

在学习阶段建议手动编写配置

xxxxxxxxxx
class homeView(APIView):
    # 所有的解析器
    content_negotiation_class = DefaultContentNegotiation
    def post(self, request, *args, **kwargs):
        print(self.parser_classes)
        return Response("OK")

输出结果

xxxxxxxxxx
[<class 'rest_framework.parsers.JSONParser'>, <class 'rest_framework.parsers.FormParser'>, <class 'rest_framework.parsers.MultiPartParser'>]

可以通过在settings.py中通过配置来修改这一项

xxxxxxxxxx
REST_FRAMEWORK = {
    "DEFAULT_PARSER_CLASSES": ['rest_framework.parsers.JSONParser']
}

输出结果

xxxxxxxxxx
[<class 'rest_framework.parsers.JSONParser'>]

drf（序列化）

前置知识（元类）

以下两部分的创建类的效果完全一样

都是使用的type创建类，只是表现的形式不一样

xxxxxxxxxx
# class Foo(object):
#     v1 = 123
#     def func(self):
#         return 999


Foo = type("Foo", (object,), {"v1": 123, "func": lambda self: 999})


obj = Foo()
print(obj.v1)
print(obj.func())

type("Foo", (object,), {"v1": 123, "func": lambda self: 999})

会去执行这个类里面的__init__方法

所有的类在执行__init__方法之前会先执行一个__new__方法

__new__方法会先创建一个空值，然后再让__init__方法去这个空值里面去初始化数据

所以创建类本质上是在__new__方法中执行的

演示：

xxxxxxxxxx
class MyType(type):
    def __new__(cls, *args, **kwargs):
        xx = super().__new__(cls, *args, **kwargs)
        print(xx)
        return xx


Foo = MyType("Foo", (object,), {"v1": 123, "func": lambda self: 999})
print(Foo)

print("--------------- 下面是测试类产生的")
obj = Foo()
print(obj.v1)
print(obj.func())

• new方法的应用

  xxxxxxxxxx
  class MyType(type):
   def __new__(cls, name, bases, attrs):
       del attrs['v1']
       xx = super().__new__(cls, name, bases, attrs)
       print(name, bases, attrs)
       return xx
  
  
  class Foo(object, metaclass=MyType):
   v1 = 123
   def __init__(self):
       self.age = 20
   def func(self):
       pass
  
  
  print(Foo.v1)
  

  可以在创建之前就把属性删除

  注意此时删除的不能是init方法里面创建的属性

  要在参数传递到super里面之前删除否则传递到super里面以后删除也没用了

  可以删除属性东西同样也可以往里面添加东西

• 继承的子类也由父类的决定

  xxxxxxxxxx
  class MyType(type):
   def __new__(cls, name, bases, attrs):
       xx = super().__new__(cls, name, bases, attrs)
       return xx
  
  
  class Base(object, metaclass=MyType):
   pass
  
  class Foo(Base):
   pass
  

  此时Foo也由MyType创建

  类或父类中如果指定了metaclass则当前类和子类也由指定的metaclass创建

• 在类加载的时候可以通过元类对类进行一些操作

  xxxxxxxxxx
  # 利用attrs获取里面的数据
  def __new__(cls, name, bases, attrs):
    for k, v in list(attrs.items()):
   if isinstance(v, int):
     del attrs[k]
  

  像这样的操作

基本使用（快速功能演示）

序列化的本质是把数据库中获取到的数据转换成JSON格式

并返回给用户， 已有的json.dumps()方法由于使用类型受限，只能转换原生的python中的数据类型

所以需要用到drf的序列化

这是用于测试的数据库表

xxxxxxxxxx
class DepartSerializers(serializers.Serializer):
    title = serializers.CharField()
    count = serializers.IntegerField()


class DepartView(APIView):
    def get(self, request):
        depart_obj = models.Depart.objects.all().first()
        ser = DepartSerializers(instance=depart_obj)
        print(ser.data)
        return Response("这是成功的消息")

想要使用序列化首先要定义一个类

这个类里面的字段使用serializers.字段类型（定义时的数据类型）

这里面有哪些字段，后面的对象就可以获取到哪些字段

上面的演示代码会输出

xxxxxxxxxx
{'title': '开发部', 'count': 10}

基本使用（支持QuerySet）

在上一节点中使用的depart_obj是一个字典类型的对象

在实际开发中我们遇到的不一定是这样简简单单的对象，可能是queryset类型的

xxxxxxxxxx
class DepartSerializers(serializers.Serializer):
    title = serializers.CharField()
    count = serializers.IntegerField()


class DepartView(APIView):
    def get(self, request):
        queryset = models.Depart.objects.all()
        ser = DepartSerializers(instance=queryset, many=True)
        print(ser.data)
        return Response(ser.data)

通过指定many=True就可以让他支持queryset类型的数据

注意此处的名称类型需要对应

此时输出的内容：

xxxxxxxxxx
[{'title': '开发部', 'count': 10}, {'title': '运营部', 'count': 20}]

基本使用（Model）

每次使用Serializer都需要把需要的字段都重新写一遍显得有点麻烦

我们可以使用ModelSerializer来简化写法

就像这样：

xxxxxxxxxx
from rest_framework.views import APIView
from rest_framework.response import Response
from api.auth import MyAuthentication
from api import models
from rest_framework import serializers


class DepartSerializers(serializers.ModelSerializer):
    class Meta:
        model = models.Depart
        fields = "__all__"


class DepartView(APIView):
    def get(self, request):
        queryset = models.Depart.objects.all()
        ser = DepartSerializers(instance=queryset, many=True)
        print(ser.data)
        return Response(ser.data)

输出示例：

xxxxxxxxxx
[{'id': 1, 'title': '开发部', 'order': 1, 'count': 10}, {'id': 2, 'title': '运营部', 'order': 2, 'count': 20}]

基本使用（source和时间）

首先创建一个模型

xxxxxxxxxx
class UserInfo(models.Model):
 name = models.CharField(verbose_name="姓名", max_length=32)
 age = models.IntegerField(verbose_name="年龄")
 gender = models.SmallIntegerField(verbose_name="性别", choices=((1, '男'), (2, '女')))
 depart = models.ForeignKey(verbose_name="部门", to="Depart", on_delete=models.CASCADE)
 ctime = models.DateTimeField(verbose_name="时间", auto_now_add=True)

插入两条数据

现在

xxxxxxxxxx
class UserSerializers(serializers.ModelSerializer):
 class Meta:
     model = models.UserInfo
     fields = "__all__"

class UserView(APIView):
 def get(self, request):
     models.UserInfo.objects.all().update(ctime=datetime.datetime.now())

     queryset = models.UserInfo.objects.all()
     ser = UserSerializers(instance=queryset, many=True)
     return Response(ser.data)

发送请求后得到的返回的数据是这样的：

xxxxxxxxxx
[
 {
     "id": 1,
     "name": "a",
     "age": 21,
     "gender": 1,
     "ctime": "2026-03-07T07:08:12.571546Z",
     "depart": 1
 },
 {
     "id": 2,
     "name": "b",
     "age": 21,
     "gender": 2,
     "ctime": "2026-03-07T07:08:12.571546Z",
     "depart": 2
 }
]

gender字段如何显示名称

利用source指定，利用Django中的知识

xxxxxxxxxx
class UserSerializers(serializers.ModelSerializer):
    gender = serializers.CharField(source="get_gender_display")
    class Meta:
        model = models.UserInfo
        fields = ["name", "age", "gender"]

指定source="get_gender_display"

注意此时获取到的“男”/“女”是CharField，所以需要改成CharField

如果说同字段类型重名，则会报错，比如如果我model中定义的是CharField，我这里再自定义一个CharFIeld，那就会报错，不同类型重名则会覆盖

xxxxxxxxxx
[
    {
        "name": "a",
        "age": 21,
        "gender": "男"
    },
    {
        "name": "b",
        "age": 21,
        "gender": "女"
    }
]

depart外键怎么显示名称

xxxxxxxxxx
class UserSerializers(serializers.ModelSerializer):
    gender = serializers.CharField(source="get_gender_display")
    depart = serializers.CharField(source="depart.title")
    class Meta:
        model = models.UserInfo
        fields = ["name", "age", "gender", "depart"]

指定source="depart.title"

本质上：

xxxxxxxxxx
obj.get_gender_display()
obj.depart.title

ctime时间字段怎么格式化

xxxxxxxxxx
class UserSerializers(serializers.ModelSerializer):
    gender = serializers.CharField(source="get_gender_display")
    depart = serializers.CharField(source="depart.title")
    ctime = serializers.DateTimeField(format="%Y年%m月%d日")
    class Meta:
        model = models.UserInfo
        fields = ["name", "age", "gender", "depart", "ctime"]

利用format=""

将时间格式格式化

输出：

xxxxxxxxxx
[
 {
     "name": "a",
     "age": 21,
     "gender": "男",
     "depart": "开发部",
     "ctime": "2026年03月07日"
 },
 {
     "name": "b",
     "age": 21,
     "gender": "女",
     "depart": "运营部",
     "ctime": "2026年03月07日"
 }
]

自定义字段内容

xxxxxxxxxx
class UserSerializers(serializers.ModelSerializer):
    gender = serializers.CharField(source="get_gender_display")
    depart = serializers.CharField(source="depart.title")
    ctime = serializers.DateTimeField(format="%Y年%m月%d日")
    xxx = serializers.SerializerMethodField()
    class Meta:
        model = models.UserInfo
        fields = ["name", "age", "gender", "depart", "ctime", "xxx"]

    def get_xxx(self, obj):
        return f'{obj.name}-{obj.age}-{obj.gender}'

自定义字段名称是xxx的话方法就是get_xxx

方法里面的obj就是当前的字段对象

示例返回：

xxxxxxxxxx
[
 {
     "name": "a",
     "age": 21,
     "gender": "男",
     "depart": "开发部",
     "ctime": "2026年03月07日",
     "xxx": "a-21-1"
 },
 {
     "name": "b",
     "age": 21,
     "gender": "女",
     "depart": "运营部",
     "ctime": "2026年03月07日",
     "xxx": "b-21-2"
 }
]

基本使用（如何处理ManyToManyField类型）

方法一

示例model：

xxxxxxxxxx
class Depart(models.Model):
    title = models.CharField(verbose_name="部门", max_length=64)
    order = models.IntegerField(verbose_name="顺序")
    count = models.IntegerField(verbose_name="人数")


class UserInfo(models.Model):
    name = models.CharField(verbose_name="姓名", max_length=32)
    age = models.IntegerField(verbose_name="年龄")
    gender = models.SmallIntegerField(verbose_name="性别", choices=((1, '男'), (2, '女')))
    depart = models.ForeignKey(verbose_name="部门", to="Depart", on_delete=models.CASCADE)
    ctime = models.DateTimeField(verbose_name="时间", auto_now_add=True)
    tags = models.ManyToManyField(verbose_name="标签", to="Tag")


class Tag(models.Model):
    caption = models.CharField(verbose_name="标签", max_length=32)

此时由于UserInfo中返回的tags字段是一个queryset类型的数据，无法利用source解决

可以使用自定义方法处理

处理实例：

xxxxxxxxxx
class UserSerializers(serializers.ModelSerializer):
    gender = serializers.CharField(source="get_gender_display")
    depart = serializers.CharField(source="depart.title")
    ctime = serializers.DateTimeField(format="%Y年%m月%d日")
    tags = serializers.SerializerMethodField()
    class Meta:
        model = models.UserInfo
        fields = ["name", "age", "gender", "depart", "ctime", "tags"]

    def get_tags(self, obj):
        result = [{"id": item.id, "tag": item.caption} for item in obj.tags.all()]
        return result

方法二（最佳实践）

xxxxxxxxxx
class D1(serializers.ModelSerializer):
    class Meta:
        model = models.Depart()
        fields = "__all__"


class D2(serializers.ModelSerializer):
    class Meta:
        model = models.Tag()
        fields = "__all__"


class UserSerializers(serializers.ModelSerializer):
    gender = serializers.CharField(source="get_gender_display")
    depart = D1()
    ctime = serializers.DateTimeField(format="%Y年%m月%d日")
    tags = D2(many=True)
    class Meta:
        model = models.UserInfo
        fields = ["name", "age", "gender", "depart", "ctime", "tags"]

利用类的嵌套

在新创建的类里面对于这种类型的数据添加many=True实现获取到所有对应的数据

返回示例：

xxxxxxxxxx
[
 {
     "name": "a",
     "age": 21,
     "gender": "男",
     "depart": {
         "id": 1,
         "title": "开发部",
         "order": 1,
         "count": 10
     },
     "ctime": "2026年03月08日",
     "tags": [
         {
             "id": 1,
             "caption": "暖男"
         },
         {
             "id": 2,
             "caption": "渣男"
         }
     ]
 },
 ...
]

注意上述的D1和D2类里面的字段也可以自定义，和普通的类里面自定义的方法一致

小技巧

对于两个类里面都需要使用同一个字段的情况，可以使用继承

示例：

xxxxxxxxxx
class Base(serializers.ModelSerializer):
  xx = ...
  
class D(serializers.ModelSerializer, Base):
  ...

这样在D类里面就自带了xx这个字段，就不用再自己重新写了

源码解析

创建字段对象

创建类

上一步中创建了字段了，按照执行的流程，这一步到了创建类

序列化过程

数据校验

基本校验

写法一（最佳实践）

xxxxxxxxxx
class DepartSerializers(serializers.Serializer):
    username = serializers.CharField(required=True)
    password = serializers.CharField(required=True)


class DepartView(APIView):
    def post(self, request, *args, **kwargs):
        # 1. 获取原始数据
        # print(request.data)
        # 2. 校验
        ser = DepartSerializers(data=request.data)
        if ser.is_valid(): 
            print(ser.validated_data)
        else:
            print(ser.errors)       
        return Response("...")

写法二

xxxxxxxxxx
class DepartSerializers(serializers.Serializer):
    username = serializers.CharField(required=True)
    password = serializers.CharField(required=True)


class DepartView(APIView):
    def post(self, request, *args, **kwargs):
        ser = DepartSerializers(data=request.data)
        ser.is_valid(raise_exception=True) 
        return Response("成功")

第二种写法关键在于传递了raise_exception=True

这样的话如果校验成功他就会继续往下执行

如果校验失败就会抛出异常，并且让异常信息返回，drf会自动捕获这个异常，不会中断程序

演示：

校验成功：

xxxxxxxxxx
"成功"

校验失败：

xxxxxxxxxx
{
 "password": [
     "该字段是必填项。"
 ]
}

这种写法的坏处在于抛出的异常信息不方便控制

内置校验和正则校验

内置校验

xxxxxxxxxx
class DepartSerializers(serializers.Serializer):
    title = serializers.CharField(required=True, max_length=20, min_length=6)
    order = serializers.IntegerField(required=False, max_value=100, min_value=10)
    level = serializers.ChoiceField(choices=[("1", "高级"), (2, "中级")])

class DepartView(APIView):
    def post(self, request, *args, **kwargs):
        # 1. 获取原始数据
        # print(request.data)
        # 2. 校验

        ser = DepartSerializers(data=request.data)
        if ser.is_valid():
            print(ser.validated_data)
        else:
            print(ser.errors)

        return Response("...")

在创建类的时候添加校验规则

上面的level里面定义的choices中数字的类型程序会自动帮我们处理，实际开发中建议保持规则

比如在上述实例中：

输入

xxxxxxxxxx
{"title": "afsdfsd", "order": "11", "level": 1}

程序打印

xxxxxxxxxx
{'title': 'afsdfsd', 'order': 11, 'level': '1'}

会自动处理类型

正则校验

上述中有一种特殊的

xxxxxxxxxx
class DepartSerializers(serializers.Serializer):
    email = serializers.EmailField()

这种写法几乎等价于：

xxxxxxxxxx
from django.core.validators import EmailValidator
class DepartSerializers(serializers.Serializer):
    email = serializers.CharField(validators=[EmailValidator(message="邮箱格式错误")])

邮箱可以用内置的校验规则，也可以自己编写校验规则

xxxxxxxxxx
from django.core.validators import RegexValidator
class DepartSerializers(serializers.Serializer):
    email = serializers.CharField(validators=[RegexValidator(r'\d+', message="格式错误")])