Rest_framework 和路由配置（一）

简介

Django REST framework是一个建立在Django基础之上的Web 应用开发框架，可以快速的开发REST API接口应用。

Rest_framework 核心思想: 缩减代码。

中文文档：https://q1mi.github.io/Django-REST-framework-documentation/#django-rest-framework

github: https://github.com/encode/django-rest-framework/tree/master

特点

• 提供了定义序列化器Serializer的方法，可以快速根据 Django ORM 或者其它库自动序列化/反序列化；

• 提供了丰富的类视图、Mixin扩展类，简化视图的编写；

• 丰富的定制层级：函数视图、类视图、视图集合到自动生成 API，满足各种需要；

• 多种身份认证和权限认证方式的支持；[jwt]

• 内置了限流系统；

• 直观的 API web 界面；

• 可扩展性，插件丰富

非drf 实现简单接口

1.创建django 项目

django-admin startproject drf

2. 创建子应用目录booktest,在项目根目录下执行以下命令
python manage.py startapp booktest

创建一个数据库,drf
create database drf charset=utf8;
grant all privileges on book.* to root@localhost identified by '123456';
flush privileges;

3. 配置数据库信息
   3.1 在主应用drf目录下的drf/__init__.py添加以下代码:
   import pymysql
   pymysql.install_as_MySQLdb()
   
   3.2 在项目配置文件中，settings中修改数据链接信息。
   
   DATABASES = {
    # 'default': {
    #     'ENGINE': 'django.db.backends.sqlite3',
    #     'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
    # }
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'drf',
        'USER': 'root',
        'PASSWORD': '123456',
        'HOST': '127.0.0.1',
        'PORT': '3306',
    },
    }

路由配置：

1. 视图    booktest  应用中的views.py  

from django.shortcuts import render

from django.http import JsonResponse

from django.views import View

# Create your views here.


class BookAPI(View):

    def get(self,request):


        return JsonResponse({"name":"deng"})

 2.分路由         booktest  应用中的urls.py  

from django.urls import path

from .views import BookAPI

urlpatterns = [

    path(r'books/',BookAPI.as_view())
]

3. 主路由      主应用drf  中的url.py   

from django.contrib import admin
from django.urls import path,re_path,include

urlpatterns = {
    path('admin/', admin.site.urls),
    path('api/',include('booktest.urls') )

}

  访问接口结果：

drf 实现简单接口

1.环境安装与配置

DRF需要以下依赖：

• Python (2.7, 3.2, 3.3, 3.4, 3.5, 3.6)

• Django (1.10, 1.11, 2.0)

DRF是以Django扩展应用的方式提供的，所以我们可以直接利用已有的Django环境而无需从新创建。

（若没有Django环境，需要先创建环境安装Django）

 

1.安装

pip install djangorestframework

2. 终端创建创建django 项目

　　在终端执行以下命令创建django项目，比较纯净， 建议用此方法创建项目，而不是用pycharm 创建。

django-admin  startproject  drf

3. 添加rest_framework应用

  在settings.py的INSTALLED_APPS中添加'rest_framework'。

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

接下来就可以使用DRF进行开发了。在项目中如果使用rest_framework框架实现API接口，主要有以下三个步骤：

• 将请求的数据（如JSON格式）转换为模型类对象

• 操作数据库

• 将模型类对象转换为响应的数据（如JSON格式）

在booktest应用目录中新建serializers.py用于保存该应用的序列化器。

创建一个BookInfoSerializer用于序列化与反序列化。

创建序列化器   

1.底层的方式实现的序列化：

serializers.py  :

from rest_framework import serializers

# 序列化器 序列化
class BookSerializer(serializers.Serializer):
    # 自定义序列化的字段
    id = serializers.IntegerField(label='主键ID',read_only=True)#read_only=True只给用户看不让输入和修改
    title= serializers.CharField(label='书名',max_length=32)

    pub_date = serializers.DateField()

    bread = serializers.IntegerField(min_value=0)
    bcomment = serializers.IntegerField(min_value=0)

2. 编写视图

book 应用下的视图   view.py ：

# 序列化器 序列化阶段

from django.http import JsonResponse
from django.views import View

from book.models import Book # 导入模型类
from book.serializers import BookSerializer # 导入序列化器类


class BookView(View):

    # 展示所有数据
    def get(self,request):

        # 1 操作数据库

        books = Book.objects.all()

        # 2 .序列化
        '''
        创建序列化器对象
        参数1：instance 要序列化的模型数据   （数据库中的数据）
        参数2： data 要反序列化器的字典数据  （前端传来的数据）
        参数3：many 是否要序列化多个模型数据，多条数据many=True    默认False 一条
        参数4： context 序列化器使用的上下文，字典类型数据，可以通过context把视图中的数据传递给序列化器内部使用
        '''
        serializer = BookSerializer(instance=books,many=True) #  此处需要many=True 不然会报错
        # 通过 serializer.data 获取序列化完成以后的数据
        # print(serializer.data)
        #3. 返回响应
        return JsonResponse(serializer.data,safe=False)

3. 配置路由

      3.1在booktest应用的urls.py中定义路由信息。

from django.urls import path


from .views import BookView

urlpatterns=[
path('book/',BookView.as_view())
]

　　3.2 总路由中  drf主应用中 url.py :

from django.contrib import admin
from django.urls import path,re_path,include


urlpatterns = {
    path('admin/', admin.site.urls),
    path('api/', include('book.urls')),

}

2.底层的方式实现的反序列化：

serializers.py  :

# 序列化器 的反序列化阶段
# 全局自定义验证方法
def check_title(data):
    if data=='金梅':
        raise serializers.ValidationError('金梅是禁书！')

    return data   #自定义验证方法一定要返回数据

class Book2Serializer(serializers.Serializer):
    #自定义要反序列化的字段
    id = serializers.IntegerField(label='主键ID', read_only=True)  # read_only=True只给用户看不让输入和修改
    title = serializers.CharField(label='书名', max_length=32,required=True,min_length=1,validators=[check_title]) # validators 参数用来装全局自定义验证方法
    pub_date = serializers.DateField()
    bread = serializers.IntegerField(min_value=0)
    bcomment = serializers.IntegerField(min_value=0)
    # required = False 反序列化时，当前字段可以不填
    # 自定义验证方法  ，验证单个字段可以多个方法
    # 格式： def validate_字段名（self,data): # data当前字段对应的值

    def validate_title(self, data):
        if data=='金梅':
            raise serializers.ValidationError('金梅是禁书！')
        return data  # 一定要返回数据

    # 自定义验证对个方法 ，验证多个或所有字段，只能出现一次
    def validate(self, data):# data 这个是所有字段内容 ，字典类型

        bread = data.get('bread')
        bcomment = data.get('bcomment')
        if bcomment>bread:
            raise serializers.ValidationError('数据不真实！')

        return data


    def create(self, validated_data):
        # 保存数据，把字典转化成模型
        # validated_data 客户端提交过来的数据，并经过验证的数据
        instance = Book.objects.create(
            title=validated_data.get('title'),
            pub_date=validated_data.get('pub_date'),
            bread = validated_data.get('bread'),
            bcomment=validated_data.get('bcomment')
        )
        return instance

    def update(self, instance, validated_data):

        # 更新一条数据
        instance.title = validated_data.get('title')
        instance.pub_date = validated_data.get('pub_date')
        instance.bread = validated_data.get('bread')
        instance.bcomment = validated_data.get('bcomment')

        # 调用orm 进行保存
        instance.save()
        # 返回模型对象
        return instance

2. 编写视图

book 应用下的视图   view.py ：

from django.http import JsonResponse
from django.views import View

from book.models import Book # 导入模型类
from book.serializers import BookSerializer # 导入序列化器类

from book.serializers import Book2Serializer
class BookView(View):# 反序列化

    def post(self,request):

        # 添加一本书
        #1 接收数据
        data = request.POST
        # 反序列化
        from book.serializers import Book2Serializer
        serializer = Book2Serializer(data=data)
        # 2 验证数据
        serializer.is_valid(raise_exception=True)
        ## raise_exception=True 把验证的错误信息返回给客户端,同时阻止程序继续往下执行
        # # is_valid调用验证方式: 字段选项validators->自定义验证方法[单字段]->自定义验证方法[多字段]
        # 验证成功后的数据
        # print(serializer.validated_data)
        # 3. 转换数据成模型,同步到数据库中
        serializer.save()
        ## save会自动调用序列化器类里面声明的create/update方法，返回值是当前新增/更新的模型对象

        # 4 响应数据
        return JsonResponse(serializer.data)


    def put(self,request,pk):
        # 更新一条数据
        # 1 根据主键获取指定图书信息
        instance = Book.objects.get(pk=pk)
        # 2. 获取put 数据
        from django.http import QueryDict
        data = QueryDict(request.body)

        # 3.使用序列化器 反序列化
        # partial=True 接下里在反序列化中允许部分数据更新
        serializer = Book2Serializer(instance=instance,data=data,partial=True)

        # 4 验证数据
        serializer.is_valid(raise_exception=True)
        # save之所以可以自动识别，什么时候执行create ，什么时候执行update
        # 主要是看创建序列化器对象时，是否有传入instance参数，
        # 有instance参数，则save会调用序列化器内部的update方法
        # 没有instance参数，则save会调用序列化器内部的create方法

        #5 保存数据
        serializer.save()

        return JsonResponse(serializer.data)

3. 配置路由

      3.1在booktest应用的urls.py中定义路由信息。

from django.urls import path,re_path

from book.views import BookView
urlpatterns=[
    #path("book/",BookView.as_view()),

    re_path("book/(?P<pk>d+)/",BookView.as_view()),

]

3.2 总路由中  drf主应用中 url.py :

from django.contrib import admin
from django.urls import path,include


urlpatterns = [
    path('admin/', admin.site.urls),
    path('api/',include('book.urls'))
]

模型序列化器

1. serializers.py  :

 3 模型序列化器
# 1. 可以帮我们自动完成字段的声明[主要是从模型中的字段声明里面提取过来]
# 2. 模型序列化器也可以帮我们声明了create和update方法的代码
from rest_framework import serializers
from book.models import Book
class BookModelSerializer(serializers.ModelSerializer):
    # 模型序列化器也可以自定义验证字段[当某些数据不存在于数据库时,但是需要前端提交过来的,可以进行自定义,
    # 例如,验证码,确认密码]

    class Meta:
        model=Book
        fields = ["id","title"]
        # 可以给模型序列化器里面指定的字段设置限制选项
        extra_kwargs = {
            "bread":{"min_length":0,"required":True},
        }

    # 自定义验证方法[验证单个字段,可以有多个方法]
    # def validate_<字段名>(self,data): # data当前字段对应的值
    def validate_btitle(self,data):
        # 例如,图书名不能是红楼梦
        if data=="红楼梦":
            # 抛出错误
            raise serializers.ValidationError("红楼梦是禁书~")
        # 验证方法中,把数据值必须返回给字段,否则字段值为空
        return data

    # 自定义验证方法[验证多个或者所有字段,只能出现一次]
    def validate(self,data): # data 这个是所有字段的内容,字典类型
        bread = data.get("bread")
        bcomment = data.get("bcomment")

        if bread>=bcomment:
            return data
        raise serializers.ValidationError("阅读量小于评论量,数据太假了")

2. 视图编写

3 模型序列化器
# 1. 可以帮我们自动完成字段的声明[主要是从模型中的字段声明里面提取过来]
# 2. 模型序列化器也可以帮我们声明了create和update方法的代码
######################################################
from django.views import View
from django.http import JsonResponse
from .serializers import BookModelSerializer
class Book3View(View):
    def post(self,request):
        """添加一本图书"""
        # 接受数据
        data = request.POST
        # 反序列化
        serializer = BookModelSerializer(data=data)
        serializer.is_valid(raise_exception=True)
        result = serializer.save()
        # 响应数据
        return JsonResponse(serializer.data)

    def put(self,request,pk):
        """更新一个图书"""
        book = Book.objects.get(pk=pk)

        # 获取put提交的数据
        data = QueryDict(request.body)

        serializer = BookModelSerializer(instance=book,data=data,partial=True)
        serializer.is_valid(raise_exception=True)
        serializer.save()
        # 响应数据
        return JsonResponse(serializer.data)

3. 路由

from django.urls import path, re_path
from . import views
urlpatterns = [
   
    path("books3/",views.Book3View.as_view()),
]

使用序列化器的简单版

1.创建序列化器 ，在app 1下 新建一个serializer.py 文件

from rest_framework import serializers

from booktest.models import BookInfo

class BookInfoSerializer(serializers.ModelSerializer):

    # 当前序列化器在序列化和反序列的类  序列化器类
    class Meta:
        model = BookInfo

        fields='__all__'

• model 指明该序列化器处理的数据字段从模型类BookInfo参考生成

• fields 指明该序列化器包含模型类中的哪些字段，'all'指明包含所有字段

2. 编写视图   app1       view.py

from django.shortcuts import render

from booktest.models import BookInfo
from .serializers import BookInfoSerializer
from rest_framework.viewsets import ModelViewSet

class BookInfoAPIView(ModelViewSet):

    queryset = BookInfo.objects.all()

    # 当前视图类使用序列化器类是谁
    serializer_class = BookInfoSerializer

• queryset 指明该视图集在查询数据时使用的查询集

• serializer_class 指明该视图在进行序列化或反序列化时使用的序列化器。

3. 定义路由

在app1 应用的urls.py中定义路由信息。

from rest_framework.routers import DefaultRouter

from .views import BookInfoAPIView

urlpatterns=[

]

# 创建路由对象
routers = DefaultRouter()

# 通过路由对象对视图进行路由生成
routers.register('books',BookInfoAPIView)# books为路径

urlpatterns += routers.urls

把上面的urls 添加到总路由中去：

from django.contrib import admin
from django.urls import path, re_path, include

urlpatterns = [
    path('admin/', admin.site.urls),
 
    path('api/',include('app1.urls') )

]