Django Rest framework之认证的实现代码

django rest framework 官网

在学习django rest framework(下面简称drf)之前需要知道

  • 对RESTful API设计有一定了解
  • 对django框架有一定认识,本身drf就是基于django做的
  • 对python面向对象编程有了解(drf会对一些原生的django类做封装)

一、前言

在学习drf之前的时候,先简单说一下需要的预备知识。在django中,路由匹配之后,会进行路由分发,这个时候会有两种选择模式的选择。也就是FBVCBV

1、FBV

fbv就是在url中一个路径对应一个函数

urlpatterns = [
  url(r'^admin/', admin.site.urls),
  url(r'^index/', views.index)
]

在视图函数中

def index(request):
  return render(request, 'index.html')

2、CBV

cbv就是在url中一个路径对应一个类,drf主要使用CBV

urlpatterns = [
  url(r'^admin/', admin.site.urls),
  url(r'^index/', views.IndexView.as_view())   # 执行类后面的as_view()方法,是父类里面的方法
]

在视图函数中

from django.views import View

class IndexView(View):

  # 以get形式访问会执行get函数,一般情况下获取数据
  def get(self, *args, **kwargs):
    return HttpResponse('666')

  # 以post形式访问的话会执行post函数,一般情况下发送数据
  def post(self, *args, **kwargs):
    return HttpResponse('999')

我们在路由匹配的时候看到url(r'^index/', views.IndexView.as_view()),那这个as_view()是什么,既然我们在视图类中没有定义这个as_view()方法,就应该到父类(也就是IndexView的父类View)中看一下View。以下是django源码,路径是\django\views\generic\base.py,

class View:

  http_method_names = ['get', 'post', 'put', 'patch', 'delete', 'head', 'options', 'trace'] # 支持的各种http方法

  def __init__(self, **kwargs):
     pass

  @classonlymethod
  def as_view(cls, **initkwargs): # url路由匹配进入as_view方法
    def view(request, *args, **kwargs):
      return self.dispatch(request, *args, **kwargs) # 返回dispath方法
    return view

  def dispatch(self, request, *args, **kwargs): # dispath方法是drf的关键,dispath方法会通过反射,通过请求的方法,分发到各个视图类的方法中
    pass

3、django的请求周期

因此根据CBV和FBVdjango的生命周期可以又两类

FBV:请求通过uwsgi网关,中间件,然后进入路由匹配,进入视图函数,连接数据库ORM操作,模板渲染,返回经过中间件,最终交给浏览器response字符串。

CBV:请求通过uwsgi网关,中间件,然后进入路由匹配,这里就与FBV有区别了,因为不再是试图函数而是视图类,说的详细一点,先经过父类View的dispath方法,进行请求方法的判断,在分发到视图类的方法,连接数据库ORM操作,模板渲染,返回经过中间件,最终交给浏览器response字符串。

而再drf中主要使用CBV,生命周期就变成了如下

请求通过uwsgi网关,中间件,然后进入路由匹配,这里就有区别了,先经过drf中APIView类中的dispath方法(这里假定视图类没有重写APIView中的dispath方法),在dispath中对request请求进行封装,反射回到视图类,连接数据库ORM操作,模板渲染,返回经过中间件,最终交给浏览器响应字符串。

4、面向对象

说到面向对象就是三个特性,封装,多态,继承。

<1>、子类重写父类方法

我们在继承父类的时候往往会重写父类中的方法,例如

class A:
  def get_name(self):
    return self.name
  def return_name(self):
    if hasattr(self, 'name'):
      return 'name: ' + getattr(self, 'name', None)  

class B(A):
  name = "b"
  def get_name(self):
    return self.name

b = B()
b.get_name() # 输出B
b.return_name() # 输出name: B,这里由于B类中没有实现return_name方法,实例化B得到b之后,会调用父类A中的return_name方法,hasattr方法会查找类中是否有name属性,这里虽然在类A中没有,会向下查找B类中是否有name属性,然后返回'name: ' + getattr(self, 'name', None) ,也就是name:b

这是简单的子类方法重写父类中的方法,我们再使用drf的认证,权限等组件是会经常对父类中的方法重写,从而细粒度的实现自己的功能。

请注意:事情往往不是绝对的,如果像重写python内置的基本数据类型,如字典,列表中的特殊方法,就会的到意想不到的结果,就是实例化的对象不再调用你重写的方法,而是调用本来的方法。这是因为python的一些基本类型的方法是由c语言编写的,python为了满足速度,抄近道不会再调用你重写的特殊方法。

<2>、mixin模式

class X(object):
  def f(self):
    print( 'x')

class A(X):
  def f(self):
    print('a')

  def extral(self):
    print('extral a')

class B(X):
  def f(self):
    print('b')

  def extral(self):
    print( 'extral b')

class C(A, B, X):
  def f(self):
    super(C, self).f()
    print('c')

print(C.mro())

c = C()
c.f()
c.extral()

这样做也可以输出结果

[<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class '__main__.X'>, <class 'object'>] # 继承的顺序是 A-->B-->X-->object 这了的object在python3中是一切类的基类,包括object类本身。
a
c
extral a # 虽然类C中没有实现接口extral(),却调用了父类A中的extral()方法

这样的继承虽然可以实现功能,但是有一个很明显的问题,那就是在面向对象中,一定要指明一个类到底是什么。也就是说,如果我想构造一个类,假如是Somthing,那么我想让这个类实现会飞,会游泳,会跑,三种行为,我可以这样做,同时继承,鸟,鱼,马三个类,像这样

class Bird:
  def fly(self):
    print('fly')

class Fish:
  def swim(self):
    print('swim')

class Horse:
  def run(self):
    print('run')

class Something(Bird, Fish, Horse):
  pass

s = Something()
s.fly()
s.swim()
s.run()

输出

fly
swim
run

可是实现会跑,会飞,会游泳的三种行为,但是这个类到底是什么,是鱼,是马,还是鸟,也就是说不知道Something到底是个什么类。为了解决这个问题,我们可以引用mixin模式。改写如下

class BirdMixin:
  def fly(self):
    print('fly')

class FishMixin:
  def swim(self):
    print('swim')

class Horse:
  def run(self):
    print('run')

class Something(BirdMixin, FishMixin, Horse):
  pass

这样就解决了上面的问题,也许你会发现,这其实没有什么变化,只是在类的命名加上了以Mixin结尾,其实这是一种默认的声明,告诉你,Something类其实是一种马,父类是HorseHorse,继承其他两个类,只是为了调用他们的方法而已,这种叫做mixin模式,在drf的源码种会用到。

例如drf中的generics 路径为rest_framework/generics.py

class CreateAPIView(mixins.CreateModelMixin,
          GenericAPIView):
  pass

class ListAPIView(mixins.ListModelMixin,
         GenericAPIView):
  pass

class RetrieveAPIView(mixins.RetrieveModelMixin,
           GenericAPIView):
  pass

相当于每多一次继承,子类可调用的方法就更多了。

二、生成项目

1、生成项目

这里可以使用pycharm作为集成开发工具,创建django项目查看Python和第三方库源码很方便,使用pycharm创建一个django项目,然后将django rest framework作为第三方包放入django项目中

2、数据库设计

先来看一下如果不使用drf怎么进行用户认证,通常是用字段验证的方式,来生成相应的数据库,在用户登录时候,对数据库查询,简单的数据库设计如下

from django.db import models

class UserInfo(models.Model):
  USER_TYPE = (
    (1,'普通用户'),
    (2,'VIP'),
    (3,'SVIP')
  )

  user_type = models.IntegerField(choices=USER_TYPE, default=1)
  username = models.CharField(max_length=32)
  password = models.CharField(max_length=64)

class UserToken(models.Model):
  user = models.OneToOneField(UserInfo,on_delete=models.CASCADE)
  token = models.CharField(max_length=64)

简单的用户信息,每个用户关联一个一对一的usertoken做为验证

然后在项目目录下执行生成数据库命令

python manage.py makemigrations
python manage.py migrate

3、路由系统

from django.contrib import admin
from django.urls import path
from django.conf.urls import url

from api.views import AuthView

urlpatterns = [
  path('admin/', admin.site.urls),
  url(r'^api/v1/auth/$', AuthView.as_view())
]

api/v1/auth/中的api分别代表接口和版本号,后面会说到

4、视图函数

md5函数根据用户名和用户的访问时间进行加密

当用户第一次访问时,数据库创建用户,并将token字符串,存储到数据库

当用户下次访问的时候,需要带着这个字符串与数据库比对,并返回相应的提示信息

这里的token暂时没有放回浏览器端,真正项目中可以写入到浏览器cookie中

from django.shortcuts import render, HttpResponse
from django.http import JsonResponse
from django.views import View

from api import models

def md5(user):
  import hashlib
  import time

  # 当前时间,相当于生成一个随机的字符串
  ctime = str(time.time())

  # token加密
  m = hashlib.md5(bytes(user, encoding='utf-8'))
  m.update(bytes(ctime, encoding='utf-8'))
  return m.hexdigest()

class AuthView(View):

  def get(self, request, *args, **kwargs):
    ret = {'code': 1000, 'msg': 'success', 'name': '偷偷'}
    ret = json.dumps(ret, ensure_ascii=False)

    return HttpResponse(ret)

  def post(self, request, *args, **kwargs):
    ret = {'code': 1000, 'msg': None}
    try:
      user = request.POST.get('username')
      pwd = request.POST.get('password')
      obj = models.UserInfo.objects.filter(username=user).first()

      if not obj:
        # 如果用户第一次登陆则创建用户
        obj = models.UserInfo.objects.create(username=user, password=pwd)
        ret['code'] = 1001
        ret['msg'] = '创建用户成功'

      # 为用户创建token
      token = md5(user)
      # 存在就更新,不存在就创建
      models.UserToken.objects.update_or_create(user=obj, defaults={'token': token})
      ret['token'] = token
    except Exception as e:
      ret['code'] = 1002
      ret['msg'] = '请求异常'
    return JsonResponse(ret)

第一次发送请求

返回请求信息

第二次发送请求

返回请求信息

这里没有使用drf的认证组件

三、使用Django rest framewok 认证组件

1、实例

假如用户想获取自己的订单信息,发送请求之后返回订单信息以json格式的数据返回。

from rest_framework.views import APIView
from django.http import JsonResponse
from rest_framework.authentication import BaseAuthentication
from rest_framework import exceptions

from api import models

# 这里直接表示订单
ORDER_DICT = {
  1:{
    'name':'apple',
    'price':15
  },
  2:{
    'name':'狗子',
    'price':100
  }
}

class FirstAuthenticate(BaseAuthentication):
  # 添加自己的认证逻辑,基类BaseAuthentication中有一个必须要重写的接口

  def authenticate(self, request):
    pass

  def authenticate_header(self, request):
    pass

class MyAuthenticate(BaseAuthentication):
  # 添加自己的认证逻辑,基类BaseAuthentication中有两个必须要重写的接口

  def authenticate(self, request):
    token = request._request.GET.get('token') # 获取token参数
    token_obj = models.UserToken.objects.filter(token=token).first() # 在数据库UserToken查找是否有相应的对象
    if not token_obj: # 如果没有,则报错
      raise exceptions.AuthenticationFailed('用户认证失败')
    return (token_obj.user, token_obj) # 这里需要返回两个对象,分别是UserInfo对象和UserToken对象

  def authenticate_header(self, request): # 返回相应头信息
     pass

class OrderView(APIView):
  # 用户想要获取订单,就要先通过身份认证、
  # 这里的authentication_classes 就是用户的认证类
  authentication_classes = [FirestAuthenticate, MyAuthenticate]

  def get(self, request, *args, **kwargs):
    ret = {
      'code': 1024,
      'msg': '订单获取成功',
    }
    try:
      ret['data'] = ORDER_DICT
    except Exception as e:
      pass
    return JsonResponse(ret)

这里继承了rest framek中的APIView,在APIView中将原生的request进行了封装,封装了一些用于认证,权限的类,在请求来的时候,会依次通过FirestAuthenticate MyAuthenticate两个类,并调用authenticate进行认证。

发送请求

返回订单的数据

认证成功

2、源码分析

这里推荐使用pycharm作为集成开发工具,可以ctrl+鼠标左键点击方法,或者类直接进入源码查看

<1>、第1步

在路由匹配之后会先进入到APIView中的as_view方法中,然后进入到djangoView中,

<2>、第2步

由于子类APIView已经实现了dispath方法,接着返回APIView中的disapth方法

<3>、第3步

然后会发现drf对原生request做的操作

<4>、第4步

这里的initialize_request,主要进行封装

<5>、第5步

而initial则会对调用封装类中的方法,实现各种功能

至此可以看到requestdrf中大概的流程。

3、drf认证流程

在上面第4步和第5步可以看到APIView中的两个方法的initialize_request,initial

我们进入到initialize_request,查看authenticators=self.get_authenticators()

这里的authentication_classes,其实是一个所有认证类的集合(指的是一个可以迭代的容器对象,如list,tuple等,而不是特指set()内置类型),

这里的api_settings其实就是django项目的全局配置文件settings.py,这说明我们可以在需要认证的视图函数多的情况下使用全局配置使得每一个进行认证。

<1>、全局与局部配置认证类

可以直接在settings.py中添加全局配置项

REST_FRAMEWORK = {
  'DEFAULT_AUTHENTICATION_CLASSES': ['api.utils.authenticate.FirstAuthenticate', 'api.utils.authenticate.MyAuthenticate'],
}

那么如果我的个别视图类不想认证呢?可以这样写

class OrderView(APIView):
  # 这里没有重写authentication_classes属性,则使用全局配置的authentication_classes,即在setting.py中的authentication_classes。
  def get(self, request, *args, **kwargs):
     pass

class CartView(APIView):
   authentication_classes = [authenticate.FirstAuthenticate,] # authentication_classes中只包含FirstAuthenticate,则只通过他的认证
  def get(self, request, *args, **kwargs):
     pass

class UserInfoView(APIView):
  authentication_classes = [] # authentication_classes为空,则不会进行认证
  def get(self, request, *args, **kwargs):
     pass

<2>、究竟如何进行认证

上面说了想要定义多个认证规则,其实就是封装多个认证类,那么这些认证类如何进行认证呢?

这里的perform_authentication就是进行主要的功能,在request类中有一个_authenticate

来分析下源码

def _authenticate(self):
    """
    Attempt to authenticate the request using each authentication instance
    in turn.
    """
    for authenticator in self.authenticators: # 找到 authentication_classes,并循环每一个认证类
      try:
        user_auth_tuple = authenticator.authenticate(self) # 调用认证类的authenticate方法,也就是上面我们实现的方法,并将返回值赋值给user_auth_tuple
      except exceptions.APIException:
        self._not_authenticated() # 如果出错调用_not_authenticated,方法,下面会说到
        raise

      if user_auth_tuple is not None: # 如果authenticate方法的返回值不为空
        self._authenticator = authenticator
        self.user, self.auth = user_auth_tuple # 这也就是为什么认证类的authenticate方法会返回两个对象的原因
        return

    self._not_authenticated() # 如果没有通过认证,则调用_not_authenticated方法

  def _not_authenticated(self):
    """
    Set authenticator, user & authtoken representing an unauthenticated request.

    Defaults are None, AnonymousUser & None.
    """
    self._authenticator = None

    if api_settings.UNAUTHENTICATED_USER:
      self.user = api_settings.UNAUTHENTICATED_USER()
    else:
      self.user = None

    if api_settings.UNAUTHENTICATED_TOKEN:
      self.auth = api_settings.UNAUTHENTICATED_TOKEN()
    else:
      self.auth = None

_authenticate方法中调用authenticator.authenticate(self) 方法,返回给user_auth_tuple,并通过判断user_auth_tuple是否为空,其实就像是我从浏览器发送请求,request中携带我的用户认证信息,在进入视图类之前,通过一次一次调用认证类来查看我携带的认证信息是否正确,如果正确则返回数据库中正确的User对象。如果不通过或者没有认证信息,则在_not_authenticated中按照匿名用户处理。

来看一下authenticator.authenticate(self)中的authenticate(self)具体做了什么

在authenticate中可以添加具体的认证逻辑,当然也可以在视图类中书写,但是drf中提供的组件,可以使得代码耦合度更低,维护性更强,更方便。

<3>、匿名用户认证

上面_not_authenticatedUNAUTHENTICATED_TOKENUNAUTHENTICATED_USER说明,也可以通过在setting.py中定义匿名用户的认证。
只要再setting.py中添加如下

REST_FRAMEWORK = {
  'DEFAULT_AUTHENTICATION_CLASSES': ['api.utils.authenticate.FirstAuthenticate', 'api.utils.authenticate.MyAuthenticate'],
  "UNAUTHENTICATED_USER": None, # 匿名,request.user = None
  "UNAUTHENTICATED_TOKEN": None,# 匿名,request.auth = None
}

4、认证总结

要理解django rest framework ,就要先理解面向对象。子类继承父类属性和方法,而在基类中往往以定义抽象接口的形式,强制使子类重写抽象接口。不过抽象接口这往往是框架开发者做的,而不是我们要需要做的。实例化的对象可以调用所类的属性和方法,其实方法也可以看作是一种属性。子类新定义或者重写父类的属性,实例化的对象可以调用父类中的方法查询到子类的属性,就是说实例化的对象集所有父类子类于一身。子类中的方法或者属性会覆盖掉父类中的方法和属性,实例化对象调用的时候不会管父类中怎么样,所以在变量和方法命名的时候应该注意,或者也可以使用super等操作。

而在django rest framework中,对原生request做了封装。原本我们可以再视图类中的进行的比如访问限流,用户认证,权限管理等逻辑,封装到一个一个类中的方法中,在用户请求进入视图类之前,会先查找并迭代相关封装的类,然后调用这些类的相关方法,根据返回值判断是否满足认证,权限等功能。如果不通过则不会进入到视图类执行下一步,并返回相应的提示信息。这样分开的好处是当然就是最大程度的解耦,各个相关功能相互不影响,又相互关联,维护性更高。

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持我们。

(0)

相关推荐

  • Django REST framework视图的用法

    前言 在了解了REST farmwork封装的视图类之后,我对python的面向对象有了更深刻的理解. Django RESR framework框架内置的视图类充分发挥了面向对象封装与继承的特性. 自己写一个类似于DRF内置视图类的功能 实现一个图书出版社的增.删.改.查.查功能,两个查一个是查所有出版社,一个是查具体的某一个出版社. 首先是一个简略的表结构设计models.py: from django.db import models class Publisher(models.Mode

  • Django REST Framework序列化外键获取外键的值方法

    需求:序列化外键,获取外键的除id之外的值 使用Django REST Framework虽然开发接口快速,但是如果想要获取到除外键id值之外的外键信息,直接继承serializers.ModelSerializer类,然后在fields中指定返回的字段是获取不到外键的其他值的,比如我现在需要外键的name属性值,下面就给大家介绍两种方法通过序列化外键来获取我们想要的外键的值. 这里有两个Model:问卷(Questionnaire):问题(Question).一张问卷中包含多个问题,问题通过外

  • Django restframework 源码分析之认证详解

    前言 最近学习了 django 的一个 restframework 框架,对于里面的执行流程产生了兴趣,经过昨天一晚上初步搞清楚了执行流程(部分方法还不太清楚),于是想详细的总结一下当来一个请求时,在该框架里面是如何执行的? 启动项目时 昨天在调试django时,发现在 APIView 中打的断点没有断下来,而是打在 View 中的断点断下来了,调试了很多次,最后发现,在 django 项目启动时,会首先加载 urls 中的文件,执行 views 中类的 as_view方法,其实是继承自 API

  • django rest framework 实现用户登录认证详解

    1.安装 pip install djangorestframework 2.创建项目及应用 创建项目 创建应用 目录结构如图 3.设置settings.py 设置数据库连接 # MySQL 增加mysql 连接 DATABASES = { 'default':{ 'ENGINE':'django.db.backends.mysql', 'HOST':'127.0.0.1', 'PORT':'3306', 'NAME':'dbname', # 数据库名 'USER':'username', 'P

  • Django Rest framework频率原理与限制

    前言 开发平台的API接口调用需要限制其频率,以节约服务器资源和避免恶意的频繁调用. DRF就为我们提供了一些频率限制的方法. DRF中的版本.认证.权限.频率组件的源码是一个流程,且频率组件在最后执行. DRF频率组件原理 DRF中的频率控制基本原理是基于访问次数和时间的,当然我们也可以通过自己定义的方法来实现. 当请求进来,走到我们的频率组件时,DRF内部会有一个字典来记录访问者的IP. 以这个字典的IP为key,value为一个列表,存放访问者每次访问的时间:{PI1: [第三次访问时间,

  • Django Rest framework认证组件详细用法

    本文详细讲述了DRF认证组件的原理以及用法. 源码剖析 讲解DRF版本的时候我们都知道了,在dispatch方法里执行了initial方法来初始化我们的版本. 而在initial方法里有我们的认证.权限.频率组件,如下图: 我们再点进去认证组件看看: 可以看到,我们的权限组件返回的是request.user,那么这里返回的request是新的还是旧的呢? initial方法是在request重新赋值之后执行的,所以我们这里的request是新的--也就是Request类的实例化对象. 所以,这个

  • Django Rest framework之认证的实现代码

    django rest framework 官网 在学习django rest framework(下面简称drf)之前需要知道 对RESTful API设计有一定了解 对django框架有一定认识,本身drf就是基于django做的 对python面向对象编程有了解(drf会对一些原生的django类做封装) 一.前言 在学习drf之前的时候,先简单说一下需要的预备知识.在django中,路由匹配之后,会进行路由分发,这个时候会有两种选择模式的选择.也就是FBV与CBV. 1.FBV fbv就

  • Django Rest Framework实现身份认证源码详解

    目录 一.Django框架 二.身份认证的两种实现方式: 三.身份认证源码解析流程 一.Django框架 Django确实是一个很强大,用起来很爽的一个框架,在Rest Framework中已经将身份认证全都封装好了,用的时候直接导入authentication.py这个模块就好了.这个模块中5个认证类.但是我们在开发中很少用自带的认证类,而是根据项目实际需要去自己实现认证类.下面是内置的认证类 BaseAuthentication(object):所有的认证相关的类都继承自这个类,我们写的认证

  • Django Rest framework之权限的实现示例

    一.权限实例 在阅读本文之前请先参考django rest framework 之 认证 中关于 django rest framework 的相关内容及实例 1.目录结构 为了更好的管理各个功能组件,在django rest framework 之 认证中我们说到可以将认证类单独的拿出来,放到其他目录下,然后导入到 views.py 文件中,在权限环节我们亦可以这么做,目录结构就变成这样 在api这个app下创建一个utils包专门用来存放相关的组件. 2.为模型类添加认证字段 我们在mode

  • Django rest framework基本介绍与代码示例

    本文研究的主要是Django rest framework的相关内容,分享了example,具体如下. Django REST框架是构建Web API的强大而灵活的工具包. 您可能希望使用REST框架的一些原因: Web浏览的API是您的开发人员的巨大的可用性胜利. 验证策略包括OAuth1a和OAuth2的包. 支持ORM和非ORM数据源的序列化. 如果不需要功能更强大的功能,可以自定义一切 - 只需使用基于功能的常规视图. 广泛的文档和极好的社区支持. 由Mozilla,Red Hat,He

  • Django REST framework 分页的实现代码

    官方文档[这里] 用于分页的模块: Pagination Django REST framework 有内置 Pagination 模块,无需额外安装, 只需做简单的配置. 配置什么呢? 就是告诉Django要用到什么样的分页样式, 比如: 返回哪些字段, 每页的大小, 请求参数的名称等等. 2种配置途径: 1.settings.py 文件里做全局的配置 2.单独为每个需要分页的 view 分配自定义分页器. 途径1是为所有继承ListViewAPI的接口做默认配置, 途径2对单独一个接口做个性

  • Django自定义用户登录认证示例代码

    前言 有时候 Django 自带的用户登录认证不能满足我们的需求,比如我不想要用户名+密码登录,我想手机号+验证码登录,这样就需要我们去修改 Django 自带的认证了. Django 默认使用用户认证的是ModelBackend,这个类也就是我们要下手的地方,ModelBackend里面有一个authenticate的方法,这个方法就是登录时对用户认证的方法.我们要改的就是这个方法. 先看看原码理解一下认证逻辑: 第15-16行先获取认证用的用户名字段,默认是username,如果在Userm

  • Django REST framework 视图和路由详解

    DRF中的Request 在Django REST Framework中内置的Request类扩展了Django中的Request类,实现了很多方便的功能--如请求数据解析和认证等. 比如,区别于Django中的request从request.GET中获取URL参数,从request.POST中取某些情况下的POST数据. 在APIView中封装的request,就实现了请求数据的解析: 对于GET请求的参数我们通过request.query_params来获取. 对于POST请求.PUT请求的

  • django rest framework vue 实现用户登录详解

    后端代码就不介绍了,可以参考 django rest framework 实现用户登录认证 这里介绍一下前端代码,和前后端的联调过程 在components下新建login.vue 文件 <template> <div class="login"> <el-form label-width="80px"> <el-form-item label="用户名"> <el-input v-model

  • Django rest framework工具包简单用法示例

    本文实例讲述了Django rest framework工具包简单用法.分享给大家供大家参考,具体如下: Django rest framework 工具包做API非常方便. 下面简单说一下几个功能的实现方法. 实现功能为,匿名用户访问首页一分钟能访问3次,登录用户一分钟访问6次,只有登录用户才能访问order页面. 第一步,注册app INSTALLED_APPS = [ 'django.contrib.admin', 'django.contrib.auth', 'django.contri

  • Django REST Framework 分页(Pagination)详解

    在前面的DRF系列教程中,我们以博客为例介绍了序列化器, 使用基于类的视图APIView和ModelViewSet开发了针对文章资源进行增删查改的完整API端点,并详细对权限和认证(含jwt认证)进行了总结与演示.在本篇文章中我们将向你演示如何在Django REST Framework中使用分页. 分页 为什么要分页? 当你的数据库数据量非常大时,如果一次将这些数据查询出来, 必然加大了服务器内存的负载,降低了系统的运行速度.一种更好的方式是将数据分段展示给用户.如果用户在展示的分段数据中没有

随机推荐