Restframework介绍

最新推荐文章于 2024-09-11 04:48:43 发布
最新推荐文章于 2024-09-11 04:48:43 发布
阅读量529 收藏 2
点赞数 1
文章标签： python 前端 json ViewUI
原文链接：http://www.cnblogs.com/LearningOnline/p/9396959.html
版权

1.REST介绍

　　REST与技术无关，它代表的是一种软件架构风格，全称Representational State Transfer，中文翻译为“表征状态转移”

　　REST从资源的角度类审视整个网络，它将分布在网络中某个节点的资源通过URL进行标识，客户端应用通过URL来获取资源的表征，获得这些表征致使这些应用转变状态

1.1.RESTful API设计

　　当前发展前端设备（手机，电脑，平板灯）层出不穷，而后端不会说随着前端的改变而去改变自身，去对应每一个进行通信，因此我们提出来一个统一接口进行调度，才有了API的概念，RESTful API是目前比较成熟的一套互联网应用程序的API设计理论。

　　同一套API接口，能使用多次

　　API:即所谓的接口，URL

restful规范：

　　1.API与用户的通信协议，总是使用HTTPs协议。

　　2.在自己写的URL中体现自己写的是API，将API部署在专有域名下

　　3.在url中体现版本共存（旧版本和新版本都能体现出）

　　4.路径，视网络上任何东西都是资源，均使用名词表示（可复数）

　　　　https://api.example.com/v1/animals

　　　　https://api.example.com/v1/employees

　　5.　方法

　　　　-get，从服务器获取资源
　　　　-post，新建资源
　　　　-put，更新资源
　　　　-patch，局部更新
　　　　-delete，删除

　　6.分页

　　　　https://api.example.com/v1/zoos?limit=10：指定返回记录的数量

　　7.状态码

　　8.错误信息

　　9.返回信息(尽量使用Json格式，避免使用xml)

　　10.超链接

　　　　即返回结果中提供链接，连向其他API方法，使得用户不查文档，也知道下一步应该做什么

1.2 django restframework生命周期
　 　发送请求-->Django的wsgi-->中间件-->路由系统_执行CBV的as_view()，就是执行内部的dispath方法-->在dispath内，对request封装-->版本-->认证-->权限-->限流-->视图-->如果视图用到缓存( request.data or request.query_params )就用到了 解析器-->视图处理数据，用到了序列化(对数据进行序列化或验证) -->视图返回数据可以用到分页

2.基于django实现API　

　　基于django实现的API许多功能都需要我们自己开发，这时候django restframework就给我们提供了方便，直接基于它来返回数据，总之原理都是一样的，就是给一个接口，让前端的人去请求这个url获取数据，在页面上显示出来。这样就达到了前后端分离的效果

2.1实现流程

　　使用Django REST Framework 框架的序列化工具类

　　1.安装（注意路径，我是在虚拟环境路径下，安装时候的切到该路径）：

pip install djangorestframework

　　2.导入（serializers/串行）

from rest_framework import serializers

　　3.使用

class ArticleSerializer(serializers.Serializer):
    ...　

2.2.给前端传值的几种操作

django下创建模型，这里以这三张表来举例：

models.py

class Article(models.Model):
    title = models.CharField(max_length=32)
    # auto_now_add 第一次创建的时候把当前时间保存
    create_time = models.DateField(auto_now_add=True)
    # auto_now每次更新的时候会把当前时间保存
    update_time = models.DateField(auto_now=True)
    # 后期获取这两个值，通过obj.get_type_display()
    type = models.SmallIntegerField(
        choices=((1,"原创"),(2,"转载")),
        default=1
        )
    school = models.ForeignKey(to="School",on_delete=models.CASCADE)
    tag = models.ManyToManyField(to="Tag")


class School(models.Model):
    name = models.CharField(max_length=32)


class Tag(models.Model):
    name = models.CharField(max_length=32)
View Code

我把表格创建后，直接在pycharm中给表格插入了相关数据（sqlite中），因为日期无法呈现，还需要我们通过特殊处理才能插入进来，此时需要我们创建一个单独py文件来运行django orm语句，

单文件操作django数据路演示：

　　在同级项目目录下创建一个py文件：

import os
if __name__ == "__main__":
	# "Restful.settings",这里的Restful是我的项目名
	os.environ.setdefault("DJANGO_SETTINGS_MODULE", "Restful.settings")
	import django
	django.setup()
	from app01 import models
	import datetime

# 这里主要是因为在sqlite中的时间是手动插入的，需要在这里进行转换成datatime类型
	article_list = models.Article.objects.all()
	for i in article_list:
		i.create_time = datetime.datetime.now()
		i.save()
	query_set = models.Article.objects.all().values("id", "title", "create_time", "type", "school__name")
	for i in query_set:
		print(i.get("create_time"))

	# 获取article表中type字段内的元祖下的那个后台对象
	obj = models.Article.objects.first()
	ret = obj.type
	print(ret)  # 2
	ret = obj.get_type_display()    
	print(ret)  # 转载

　此时直接运行该文件，就可以对数据进行相关修改

## 呈现数据方式一：

　　直接对数据进行序列化，在通过Httpresponse传给前台

def article_list(request):
    queryset = models.Article.objects.all().values("id","title","create_time","type","school__name")
    # create_time类型是datatime类型，需要转换成字符串格式
    for i in queryset:
        i["create_time"] = i["create_time"].strftime('%Y-%m-%d')
        print(i["create_time"])
    import json
    # 无法序列化queryset类型，需要转化格式
    data = json.dumps(list(queryset),ensure_ascii=False)
    return HttpResponse(data)

## 呈现数据方式二：

　　利用JsonResponse，这里要注意的是最终传给前台的是ASCII码，通过源码查看是如何转换的

from django.http import JsonResponse
def article_list(request):
    queryset = models.Article.objects.all().values("id", "title", "create_time", "type", "school")
    for i in queryset:
        school_obj = models.School.objects.filter(id=i["school"]).first()
        id = school_obj.id
        name = school_obj.name
        i["school"] = {"id": id, "name": name}
    # 查看源码JsonResponse，他必须接收的是一个字典类型，否则会报错，根据源码提示把safe改为False即可
    # 此时获取的数据类型是ASCII码，根据源码可以知道它内部实现的还是序列化的方法，json_dumps_params=None
    # 我们给这个值加上
    return JsonResponse(list(queryset),safe=False,json_dumps_params={"ensure_ascii":False})

## 呈现数据方式三：

　　利用restframework实现

from rest_framework import serializers
class ArticleSerializer(serializers.Serializer):
    id = serializers.IntegerField()
    title = serializers.CharField()
    create_time = serializers.DateField()
    type = serializers.IntegerField()
    # 没有source="school.name"，前台获取的则是一个School object对象，可以理解为跨表对它序列化
    school = serializers.CharField(source="school.name")

def article_list(request):
    queryset = models.Article.objects.all()
    # 对序列化后的对象进行实例化操作
    restful = ArticleSerializer(queryset,many=True)
    print(restful.data)     # [OrderedDict([('id', 1), ('title', '活着')---]
    return JsonResponse(restful.data,safe=False,json_dumps_params={"ensure_ascii":False})

## 呈现数据方式四：

　　上述使用的是Serializer类，但是大多数情况下，我们都是基于model字段去开发，建议使用ModelSerializer

　　ModelSerializer在Meta中设置fields字段，系统会自动进行映射，省去每个字段再写一个field

class Frame(serializers.ModelSerializer):
    # 通过这里的source把type字段下的
    # choices=((1,"原创"),(2,"转载"))的第二个值显现出来
    type = serializers.CharField(source="get_type_display")

    class Meta:
        model = models.Article
        fields = "__all__"   # ["id", "title", "type"]
        depth = 1         # 官方推荐不超过10层

# 发送指定数据,在路由端在创建一个url
# url(r'article_detail/(\d+)', views.article_detail),
def article_detail(request,id):
    article_obj = models.Article.objects.filter(id=id).first()
    frame = Frame(article_obj)
    return JsonResponse(frame.data,json_dumps_params={"ensure_ascii":False})

2.3RESTful API之视图操作

2.3.1可视化界面生成方式

 在setting的INSTALLED_APPS下加上"rest_framework":

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'app01.apps.App01Config',
    'rest_framework'
]
View Code

此时，在浏览器中运行就会出现一个可视化界面，方便我们的操作

2.3.2 CBV模式操作简介

在上述模型创建中，我们再创建一张评论表，来对该表进行相关操作：

class Comment(models.Model):
	content = models.CharField(max_length=128)
	article = models.ForeignKey(to="Article",on_delete=models.CASCADE)

（创建完后，自行添加几条数据，且记得进行数据迁移）　　

　

　　HTTP协议里面，四个表示操作方式的动词：GET、POST、PUT、DELETE。它们分别对应四种基本操作：GET用来获取资源，POST用来新建资源（也可以用于更新资源），PUT用来更新资源，DELETE用来删除资源。

　　我们对comment表的操作，在FBV模式下，对应代码如下：

def comment(request):
    if request.method == "GET":
        return HttpResponse("获取评论")
    elif request.method == "POST":
        return HttpResponse("创建新评论")
    elif request.method == "PUT":
        return HttpResponse("修改评论")
    elif request.method == "DELETE":
        return HttpResponse("删除评论")

　　这张表看着很符合小白的写法，但是你在考虑下，它还需要对应四个路由，大致如下，这样就显得很冗杂

url(r'comment_list/', ),
url(r'add_comment/', ),
url(r'delete_comment/', ),
url(r'edit_comment/', ),　　

 so，这时候就可以考虑使用CBV模式来进行我们的操作了

from django import views
class Comment(views.View):
    def get(self, request):
        return HttpResponse("获取评论")

    def post(self, request):
        return HttpResponse("创建新评论")

    def put(self, request):
        return HttpResponse("修改评论")

    def delete(self, request):
        return HttpResponse("删除评论")

　　而我们的路由：

 url(r'comment/', views.Comment.as_view()),

　　这样代码整体性看着就比较清晰与高端了

2.4 APIView以及serializers序列化

2.4.1介绍

APIView与View的区别：

  1. APIView是View的子类

  2. 传递给请求处理程序的request实例是REST框架的请求实例，而不是Django的HttpRequest实例

  3. 处理程序返回的基于REST框架的Response，而不是Django的HttpResponse,视图函数将会管理内容协商，然后设置正确的渲染方式

  4. 任何APIException将会被捕捉，然后转换成合适的response对象

  5. 接收到的请求首先被认证，然后赋予相应的权限，然后通过节流器分发给相应的请求处理函数，类似.get()和.post() 

serializers（序列化）说明：

　　1.serializers是什么，官网解释说它允许将复杂数据结构（ querysets and model）转换为Python数据类型，然后可以轻松地将其呈现为JSON，XML或其他格式

　　2.作用：

　　　　将queryset与model实例等进行序列化，转化成json格式，返回给用户(api接口)

　　　　将post与patch/put的上来的数据进行验证

　　　　对post与patch/put数据进行处理

　　3.django中，form更强调对提交的表单进行一种验证，而serializer的field不仅在进行数据验证时起着至关重要的作用，在将数据进行序列化后返回也发挥着重要作用

　　4.核心参数：

read_only：True表示不允许用户自己上传，只能用于api的输出。如果某个字段设置了read_only=True，
那么就不需要进行数据验证，只会在返回时，将这个字段序列化后返回 

write_only: 与read_only对应 

required: 顾名思义，就是这个字段是否必填。

allow_null/allow_blank：是否允许为NULL/空 。 

error_messages：出错时，信息提示。

label: 字段显示设置，如 label=’验证码’ 

help_text: 在指定字段增加一些提示文字，这两个字段作用于api页面比较有用 

style: 说明字段的类型

这里我结合了serializers进行简单验证，它和之前学的from组件一样都能用于数据验证，我在views.py同级目录下创建了一个app01_serializers.py文件，用于存放验证信息

代码：

urls.py

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

  app01_serializers.py

from app01.models import Comment
from rest_framework import serializers
from rest_framework.validators import ValidationError


# 序列化评论的类
class CommentSerializer(serializers.ModelSerializer):

	# 用于做校验的钩子函数，value就是等待被校验的content字段
	def validate_content(self,value):
		if '草' in value:
			raise ValidationError('不符合社会主义核心价值观！')
		else:
			return value

	class Meta:
		model = Comment
		fields = "__all__"
		# depth = 2
		# 定义额外的参数
		extra_kwargs = {
			"content": {
				"error_messages": {
					"required": '内容不能为空',
				}
			},
			"article": {
				"error_messages": {
					"required": '文章不能为空'
				}
			}
		}

views.py

from app01 import app01_serializers    # 导入验证表
from rest_framework.views import APIView
from rest_framework.response import Response

class Comment(APIView):
    def get(self,request):
        print(self.request)   # rest framework封装好的request
        # <rest_framework.request.Request object at 0x06EDAF10>
        print(self.request.data)    # { }
        print(self.request.query_params)
        # <QueryDict: {'age': ['18']}>
        res = {"code":0}
        all_comments = models.Comment.objects.all()
        ser_obj = app01_serializers.CommentSerializer(all_comments,many=True)
        res["data"] = ser_obj.data
        return Response(res)

    def post(self,request):
        res = {"code":0}
        print(self.request)
        # <rest_framework.request.Request object at 0x061DAD10>
        print(self.request.data)
        # <QueryDict: {'content': ['小草']}>
        comment_data =self.request.data
        ser_obj = app01_serializers.CommentSerializer(data=comment_data)
        if ser_obj.is_valid():
            # 表示数据没问题，可以创建
            ser_obj.save()
        else:
            res["code"] = 1
            res["error"] = ser_obj.errors
        return Response(res)

    def put(self,request):
        return HttpResponse("修改评论")

    def delete(self, request):
        print(self.request.data)
        return HttpResponse("删除评论")

　利用postman软件进行测试(没有写页面，如果在浏览器中打开是个大黄页，但是数据还是可以在url中进行交互)：

对于get方法：

　　点击Headers，设置对应参数key，value，此时会在url后自动追加上，你也可以在url上手动追加，再点击params进行保存，然后点击send，如图

　　后台所得数据，如get方法中显示

　

对于post方法：

　　在这里我测试一下检验方法

 　　在这里在进行添加数据：

下端打印{"code":0}，说明ok，去数据库刷新该表，既能看到你添加的数据

# 这里要进行说明的是：

　　APIView的请求参数，一般都在self.request.data里面。

　　但是对于GET，参数在self.request.query_params里面

2.4.2 超链接的URL

 　　现在我要实现如下请求，在我请求article的时候，因为，article与school是一对多的关系，所以查询的时候显示的school是以id字段显示的，我如何才能让让它以url的方式显示出来，并且点击能够切换呢？下面代码就是实现了如下效果

urls.py

# 这里的name属性一定要与app01_serializers.py下的view_name名相同
url(r'article/(?P<pk>\d+)', views.ArticleDetail.as_view(), name='article-detail'),
url(r'school/(?P<id>\d+)', views.SchoolDetail.as_view(), name='school-detail'),

app01_serializers.py

from app01.models import Article,School
from rest_framework import serializers

# 文章超链接序列化
class ArticleHyperLinkedSerializer(serializers.HyperlinkedModelSerializer):
	# 指定school字段生成超链接，lookup_url_kwarg这里匹配的字段是路由里面的有名分组名
	school = serializers.HyperlinkedIdentityField(view_name='school-detail', lookup_url_kwarg='id')

	class Meta:
		model = Article  # 绑定的ORM类是哪一个
		# 这里的tag是一个id字段，所以没有写，你也可以把它改成超链接
		fields = ["id", "title", "type", "create_time", "school"]

# 学校的序列化
class SchoolSerializer(serializers.ModelSerializer):
	
	class Meta:
		model = School
		fields = "__all__"

views.py

from app01 import models
from app01 import app01_serializers    # 导入验证表
from rest_framework.views import APIView
from rest_framework.response import Response

class ArticleDetail(APIView):
    def get(self, request, pk):
        res = {"code":0}
        article_obj = models.Article.objects.filter(pk=pk).first()
        # 序列化
        ser_obj = app01_serializers.ArticleHyperLinkedSerializer(article_obj, context={'request': request})
        res["data"] = ser_obj.data
        return Response(res)

# 学校详情CBV,id对应路由里面的有名分组名
class SchoolDetail(APIView):
    def get(self, request,id):
        res = {"code": 0}
        school_obj = models.School.objects.filter(pk=id).first()
        ser_obj = app01_serializers.SchoolSerializer(school_obj, context={'request': request})
        res["data"] = ser_obj.data
        return Response(res)

　在rest_framework的可视化操作界面下的效果：

　点击后：

# 补充说明：

　　1. 当实例化一个HyperlinkedModelSerializer时，你必须在序列化器的上下文中包含当前的request值:

ser_obj = app01_serializers.ArticleHyperLinkedSerializer(article_obj, context={'request': request})

　　这样才能确保生成完整的超链接，即绝对路径。如果传递的是context={'request': None})，则获取的仅仅是相对路径，无法实现超链接效果

 

　　2. 这里的路由其实还不完善我们可以通过路由分发实现解耦去操作路由部分，如可以在你的APP下创建一个app01_urls.py,里面包含了你在app项目下相关的路由操作，然后在你的总路由下（创建django自动生成的urls.py下）实现路由分发：

url(r'api/', include(app01_urls))

　　这样就做到了解耦操作，利于我们今后项目的维护工作

3.一个接口类的基本构架　　

　　我们创建好django框架后，通过命令（python managepy startapp api）在创建一个api的应用，承担一个接口的任务

models.py（创建完后自己添加值）

from django.db import models

class Course(models.Model):
    """课程"""
    name = models.CharField(max_length=128, unique=True)

 urls.py

from django.conf.urls import url
from api.views import course

# 这里注意一定要加$符结尾，防止覆盖
urlpatterns = [
	url(r'course/$',course.CourseView.as_view()),
	url(r'course/(?P<pk>\d+)/$',course.CourseDetailview.as_view())　　
]

 serilizers/course.py

from rest_framework import serializers

class CourseSerializer(serializers.Serializer):
    id = serializers.IntegerField()
    name = serializers.CharField()

 views/course.py

from api import models
from rest_framework.views import APIView
from rest_framework.response import Response
from api.serilizers.course import CourseSerializer


class CourseView(APIView):
	def get(self,request,*args,**kwargs):

		course_list = models.Course.objects.all()
		# 实例化对象，通过instance属性内部会自动找到相应字段进行序列化
		ser = CourseSerializer(instance=course_list,many=True)
		return Response(ser.data)


class CourseDetailview(APIView):
	def get(self,request,pk,*args,**kwargs):
		course = models.Course.objects.get(id=pk)
		ser = CourseSerializer(instance=course)
		return Response(ser.data)　　

 我们创建django下的原生urls.py　　-->路由分发

from django.conf.urls import url,include
from django.contrib import admin
urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^api/(?P<version>\w+)', include('api.urls')),
]

这里还要记得创建api应用后在setting里手动添加上该应用

运行效果：

 

　　

转载于:https://www.cnblogs.com/LearningOnline/p/9396959.html

daruan1111
关注
Rest Framework教程
dimingda的博客
03-01 710
主要内容
django rest framework 自定义返回方式
09-16
本文将详细介绍如何在Django REST Framework中自定义返回方式。 首先，我们需要创建一个新的Response子类来扩展默认的响应功能。这里我们定义了一个名为JsonResponse的类，它继承自rest_framework.response....
rest_framework框架的认识
weixin_30938149的博客
07-04 809
rest_framework框架的认识 　　它是基于Django的，帮助我们快速开发符合RESTful规范的接口框架。 一 路由 　　可以通过路由as_view()传参 根据请求方式的不同执行对应不同的方法 　　在routers模块下 封装了很多关于路由的方法 ， 最基础的BaseRouter类，给我提供自定制的接口。 　　下面这个方法给我们提...
Django REST framework 简介与中文教程_restframework教程中文版
最新发布
2401_86963487的博客
09-11 940
现在，我们已经在Web API上获得了一组相当细粒度的权限，以及系统用户和他们创建的代码片段的端点。在本教程的第5部分中，我们将研究如何通过为高亮显示的代码段创建HTML端点来将所有内容连接在一起，并通过使用超链接处理系统中的关系来提高API的内聚性。
Rest Framework
chexiansheng的博客
04-16 1024
４
RESTframework_一
WEi的博客
06-27 1591
RESTframework Web应用模式 前后端不分离 过程: 浏览器请求动态页面 –&amp;gt; 后端服务器响应(查询数据库,渲染模板) 前端页面看到的效果都是由后端控制,后端渲染页面或重定向 后端控制前端的展示,前端后端的耦合性很高. 这种应用模式只适用于纯网页应用,当后端对接APP时,App可能不需要后端网页,而只是需要数据,所有不适用,需要重新开发接口. 前后端分离...
Django REST framework 单元测试实例解析
09-18
本文将详细介绍如何在Django REST framework环境下进行单元测试。 首先，要进行Django REST framework的单元测试，你需要有一个运行中的Django项目环境。文中提到的环境是Windows 10操作系统配合Python 3.7版本以及...
django rest framework get 添加自定义参数的两种方式
12-21
本文将介绍两种在Django REST Framework中为GET请求添加自定义参数的方法。 ### 方法1：通过`AutoSchema`扩展 **描述**： 在`viewset`的`get`和`get/pk`方法中添加自定义参数的一种方式是通过扩展`AutoSchema`类。...
Django rest framework实现分页的示例
09-20
在给出的文件片段中，首先介绍了在Django REST framework中实现分页的基本思路和步骤。分页是一种常用的查询结果组织方式，它将大量数据分散到不同的页面上，用户可以通过导航到不同的页面来查看数据。Django REST ...
django rest framework 数据的查找、过滤、排序的示例
09-20
Django Rest Framework（DRF）是一个强大的、灵活的工具，用于构建Web API，它建立在Django框架之上。本文将介绍如何使用DRF实现数据的查找、过滤和排序功能，这对于开发基于Web的后端管理系统尤为关键。通过本示例...
restframework（一）
小白
05-22 7095
restframework restframework是django对restful架构扩展的第三方库 restful架构 主要原则 网络上的所有事物都被抽象成为资源 每个资源都有唯一的资源标识符 同一个资源具有多种表现形式（xml， json等） 对资源的各种操作不会修改资源标识符 所有操作均是无状态的 符合REST原则的架构 什么是restful 对应的中文是res...
REST framework
hh7140075819的博客
09-08 331
　　REST是什么呢？它是一种架构风格，腾讯公司或其他公司建立API时要遵守的一种规则/风格，当然也有其他规则可以用。 　　那么何为REST架构风格呢？首先我们来说说Web，因为rest是以web为平台的。我们知道，web是分布式信息系统为超文本文件和其他对象（资源）提供访问入口。 　　在web上访问一个资源，需要3点：标识，表示，交互。通过这三个操作，又引出了三个概念：uri（包括url和u...
rest framework
Areigninhell的博客
04-16 293
官方文档：http://www.django-rest-framework.org/
RESTframework简介
weixin_30371469的博客
07-15 182
什么是RESTful? RESTful是一种开发理念,REST是Roy Thomas Fileding在他博文提出的.REST特点;url简洁,将参数通过url传递到服务器,简单就是说URL定位资源,用HTTP动词描述操作. RESTful架构: 每一个URL代表一种资源； 客户端和服务器之间，传递这种资源的某种表现层； 客户端通过四个HTTP动词，对服务器端资源进行操作，实现...
Django Rest_Framework(DRF)
m0_61810345的博客
02-26 2032
Django REST framework中的Serializer使用类来定义，必须直接或间接继承于rest_framework.serializers.Serializer。rest_framework.serializers 是drf提供给开发者调用的序列化器模块里面声明了所有的可用序列化器的基类，常用的有：Serializer 序列化器基类，drf中所有的序列化器类都必须继承于 Serializer。
rest_framework之规范详解 00
aaronthon的博客
06-22 393
&#13; 接口开发&#13; 方式1：缺点：如果有10张表，则需要40个url.&#13; urls.py&#13; &#13; views.py&#13; &#13; 缺点：如果有10张表，则需要40个url.    接下来就出现了resrful 规范,比较简洁  &#13; 方式2：resrful 规范（建议）  url简洁了，只有一条。&#13; 1. 根据metho...
Rest_Framework简介
weixin_33755847的博客
05-12 206
Web应用模式 在开发Web应用中，有两种应用模式：前后端不分离和前后端分离 前后端不分离 前后端不分离通俗来讲就是不区分前端和后端，浏览器请求时服务器直接返回页面，其示意图如下 前后端分离 前后端分离是Web不断发展的结果，它将开发工作分为两块，前端和后端，前端负责静态页面的构建和数据展示，而数据则来自于后端，后端的工作在于对外提供统一的API接口，供前端调用获取数据，其示意图如下 AP...
Django rest framework分页实战教程
本示例将介绍如何使用Django REST Framework的内置分页方式以及如何自定义分页类。 首先，我们来看基本的`PageNumberPagination`分页方法： 1. 在`urls.py`中，你需要设置一个视图，比如`Pager1View`，并指定对应...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值