Django Rest framework 入门学习

所需插件

django
djangorestframework

准备工作

首先，创建虚拟环境

mkvirtualenv xxxx 【环境名称】

进入虚拟环境

workon xxxx [环境名称]

安装所需python包

pip install django
pip install djangorestframework
pip install markdown 
pip install django-filter

Pycharm 创建Django 项目

插入图片太麻烦，可百度去查找创建过程

基础工作

配置 Settings.py 文件

需要将 'rest_framework', 插入到settings.py文件的INSTALLED_APPS 中，具体格式见以下代码。

INSTALLED_APPS = [
    'rest_framework',
]

在settings.py中增加 一段

REST_FRAMEWORK = {
    'DEFAULT_PERMISSION_CLASSES': [
        'rest_framework.permissions.DjangoModelPermissionsOrAnonReadOnly',   #  权限控制
    ],
    'PAGE_SIZE': 10    #  显示页数
}

创建Models

进入app01 目录中的models.py 文件，进行数据创建。

from django.db import models


class Publisher(models.Modle):
    name = models.CharField(max_length=32, verbose_name="名称", unique=True)
    address = models.CharField(max_length=100, verbose_name="地址")

    def __str__(self):
        return self.name
        
    class Meta:
        verbose_name = "出版社"
        verbose_name_plural = verbose_name

Pycharm 技巧

创建代码片段

Ctrl+Shift+s 进入设置，搜索 live templates，进行代码片段设置，增加代码编写速度。

创建完成之后 需要进行manage.py

makemigrations
migrate

序列化

把数据库(models)中的数据转换为Json数据

views.py

from django.shortcuts import render
from django.views import View
from django.http import HttpResponse
import json
from .models import Publisher
# Create your views here.


def publisher_list(request):
    queryset= Publisher.objects.all()
    data =[]
    for i in queryset:
        p_tmp = {
            "name": i.name,
            "address": i.address
        }

        data.append(p_tmp)
    return HttpResponse(json.dumps(data), content_type="application/json")

配置Urls.py

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

urlpatterns = [
    path('admin/', admin.site.urls),
    path('publishers/', views.publisher_list),
    path('api-auth/', include('rest_framework.urls'))

]

运行项目在浏览器中执行，发现数据为空，手动添加数据。

添加数据完成后，进行浏览器访问，即可看到JSON数据。

这样编写views 比较麻烦，使用简便方式进行编写。

Views.py 优化

使用 from django.forms.models import model_to_dict 中的 model_to_dict() 方法。

缺点：图片等字段无法转换成字典。

from django.shortcuts import render
from django.views import View
from django.http import HttpResponse
import json
from .models import Publisher
# Create your views here.


def publisher_list(request):
    queryset= Publisher.objects.all()
    data =[]
    from django.forms.models import model_to_dict   #  引种这种方式进行编写，将数据直接转换为字典。
    for i in queryset:
        data.append(model_to_dict(i))
    return HttpResponse(json.dumps(data), content_type="application/json")

另一种方案，django 自带的序列化

from django.http import HttpResponse
from .models import Publisher
# Create your views here.


def publisher_list(request):
    queryset= Publisher.objects.all()
    from django.core import serializers
    # 通过django 核心的 序列化 进行 json序列化转换
    # 需要引用 diango.core 中的 serializers

    data = serializers.serialize("json", queryset)
    # 设置 序列化的 格式，和数据，进行转换。
    return HttpResponse(data, content_type="application/json")

因为安装了Django REST framework，so 使用它里面的序列化

以上两种序列化方案，仅需要了解即可

优点：先进，操作API，JSON 和 Models 进行相互转换。

首先，在APP中创建序列化文件serializers.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-




# 首先 引用rest framework中的 serializers

from rest_framework import serializers
from app01 import models


class PublisherSerializer(serializers.ModelSerializer):
    """
        通过模型(models) 继承 serializers
    """
    class Meta:
        model = models.Publisher
        # 注意： fields 是复数。
        fields = (
            "id",
            "name",
            "address"
        )

使用Views.py 调用 序列化

from django.http import HttpResponse
from .models import Publisher
# Create your views here.


def publisher_list(request):
    queryset = Publisher.objects.all()
    from app01 import serializers
    serializer = serializers.PublisherSerializer(queryset, many=True)
    # 设定变量，通过序列化 查找 序列化类型进行 序列化，
    # many = Ture 代表：允许多条数据进行序列化

    import json
    # 注意： serializer.data，需要加入data。。。。。
    return HttpResponse(json.dumps(serializer.data), content_type="application/json")

请求和响应

请求对象

request : POST   #   处理表单数据   是适用'POST'方法
request : data   #  处理任意数据  适用于'POST'，‘PUT’ 和 PATCH 方法

响应对象

return Request(data)   #  渲染成客户端请求内容的类型

状态码

200 OK - [GET]：服务器成功返回用户请求的数据，该操作是幂等的（Idempotent）。
201 CREATED - [POST/PUT/PATCH]：用户新建或修改数据成功。
202 Accepted - [*]：表示一个请求已经进入后台排队（异步任务）
204 NO CONTENT - [DELETE]：用户删除数据成功。
400 INVALID REQUEST - [POST/PUT/PATCH]：用户发出的请求有错误，服务器没有进行新建或修改数据的操作，该操作是幂等的。
401 Unauthorized - [*]：表示用户没有权限（令牌、用户名、密码错误）。
403 Forbidden - [*] 表示用户得到授权（与401错误相对），但是访问是被禁止的。
404 NOT FOUND - [*]：用户发出的请求针对的是不存在的记录，服务器没有进行操作，该操作是幂等的。
406 Not Acceptable - [GET]：用户请求的格式不可得（比如用户请求JSON格式，但是只有XML格式）。
410 Gone -[GET]：用户请求的资源被永久删除，且不会再得到的。
422 Unprocesable entity - [POST/PUT/PATCH] 当创建一个对象时，发生一个验证错误。
500 INTERNAL SERVER ERROR - [*]：服务器发生错误，用户将无法判断发出的请求是否成功。

视图编写 Views.py

from rest_framework.decorators import api_view   #  api 视图类
from app01 import models
from app01 import serializers
from rest_framework.response import Response   #  响应   Rest_framework中的
from rest_framework import status   # 状态码

@api_view(['GET','POST'])
def publisher_list(reqeuest):
    if reqeuest.method == 'GET':
        queryset = models.Publisher.objects.all() #   获取所有数据
        s = serializers.PublisherSerializer(queryset, many=True)  #  序列化多行数据
        return Response(s.data)
    elif reqeuest.method == 'POST':
        s = serializers.PublisherSerializer(data= reqeuest.data)
        # 从数据转换成序列化，使用request.data
        if s.is_valid():   #  验证表单是否正确
            s.save()   # 保存数据
            return Response(s.data, status=status.HTTP_201_CREATED)
            # 成功，返回数据，提示码= 200
        else:
            return Response(s.errors, status= status.HTTP_400_BAD_REQUEST)
            # 失败， 返回数据  提示404错误


@api_view(['GET','PUT','DELETE'])
def publisher_detail(request, pk):
    # 首先，要进行异常处理。
    try:
        publisher = models.Publisher.objects.get(pk = pk)
        #  获取PK 索引的数据
    except publisher.DoesNotExist:  # 出现异常后  抛出404错误
        return Response(status=status.HTTP_404_NOT_FOUND)

    # 开始对接收的类型进行处理。。

    if request.method == 'GET':
        s = serializers.PublisherSerializer(publisher)
        return Response(s.data)

    elif request.method == 'PUT':
        s = serializers.PublisherSerializer(publisher, data=request.data)
        # 序列化数据 从rqeuqest.data 中进行序列化
        if s.is_valid():
            s.save()
            return Response(s.data)
        return Response(s.errors,status= status.HTTP_400_BAD_REQUEST)

    elif request.method == 'DELETE':
        s = publisher.delete()
        return Response(s.data)

配置urls.py

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

urlpatterns = [
    path('admin/', admin.site.urls),
    path('publishers/', views.publisher_list),
    re_path(r'^publishers/(?P<pk>[0-9]+)$', views.publisher_detail),
    path('api-auth/', include('rest_framework.urls'))

]

安装httpie

pip install httpie

使用httpie 进行查看

http http://127.0.0.1:8000/publishers/    # 提示尚未登录
http -a admin:admin123  http://127.0.0.1:8000/publishers/    # -a 用户名:密码
http -a admin:admin123  http://127.0.0.1:8000/publishers/1   # 查看ID=1 的数据

视图(基于类的视图)

from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework import status
from django.http import Http404

from app01 import models
from app01 import serializers


class PublisherList(APIView):
    def get(self,request):
        queryset = models.Publisher.objects.all()
        s = serializers.PublisherSerializer(queryset,many=True)
        return Response(s.data)

    def post(self,request):
        s = serializers.PublisherSerializer(data=request.data)
        if s.is_valid():
            s.save()
            return Response(s.data, status=status.HTTP_201_CREATED)
        return Response(s.errors, status=status.HTTP_400_BAD_REQUEST)


class PublisherDetail(APIView):
    def get_object(self, pk): 
        # 设置一个方法 尝试设置一个方法，如果成功则返回，否则提示404错误
        try:
            return models.Publisher.objects.get(pk=pk)
        except models.Publisher.DoesNotExist:
            Http404   # 这个HTTP404，是通过diango.http 中进行引用的

    def get(self,request,pk):    # 获取数据   
        publisher = self.get_object(pk)   # 调用方法，查询pk的数据
        s = serializers.PublisherSerializer(publisher)    # 实例化 publisher 这个变量
        return Response(s.data)    #  返回实例化后的数据到页面

    def put(self,request, pk):
        publisher = self.get_object(pk)   # 调用方法，查询pk的数据
        s = serializers.PublisherSerializer(publisher, data=request.data)   #  通过request.data 进行数据publisher的实例化
        if s.is_valid():
            s.save()
            return Response(s.data)
        return Response(s.errors, status=status.HTTP_400_BAD_REQUEST)

    def delete(self,request,pk):
        publisher = self.get_object(pk)
        publisher.delete()
        return Response(status=status.HTTP_204_NO_CONTENT)

urls.py 配置

采用as_view() 进行数据的查看

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

from app01 import views

urlpatterns = [
    path('admin/', admin.site.urls),
    path('publishers/', views.PublisherList.as_view()),
    re_path(r'^publishers/(?P<pk>[0-9]+)$', views.PublisherDetail.as_view()),
    path('api-auth/', include('rest_framework.urls'))

]

以上方式可以满足使用，但并不是最后方案

使用混合模式(mixins)

视图 views.py -- 基于类

from rest_framework import mixins
from rest_framework import generics

from app01 import models
from app01 import serializers


class PublisherList(mixins.ListModelMixin,
                    mixins.CreateModelMixin,
                    generics.GenericAPIView):
    queryset = models.Publisher.objects.all()
    serializer_class = serializers.PublisherSerializer

    def get(self,request, *args, **kwargs):
        return self.list(request, *args,**kwargs)

    def post(self,request, *args, **kwargs):
        return self.create(request, *args,**kwargs)


class PublisherDetail(mixins.RetrieveModelMixin,
                    mixins.UpdateModelMixin,
                    mixins.DestroyModelMixin,
                    generics.GenericAPIView):

    queryset = models.Publisher.objects.all()
    serializer_class = serializers.PublisherSerializer

    def get(self,request, *args, **kwargs):
        return self.retrieve(request, *args,**kwargs)

    def put(self,request, *args, **kwargs):
        return self.put(request, *args,**kwargs)

    def delete(self, request, *args, **kwargs):
        return self.delete(request, *args, **kwargs)

最优方法

在视图中创建 以下内容，即可满足上面所有方法。

from rest_framework import generics

from app01 import models
from app01 import serializers


class PublisherList(generics.ListCreateAPIView):
    queryset = models.Publisher.objects.all()
    serializer_class = serializers.PublisherSerializer


class PublisherDetail(generics.RetrieveUpdateDestroyAPIView):
    queryset = models.Publisher.objects.all()
    serializer_class = serializers.PublisherSerializer

权限和认证

通过models 控制。

增加一个字段 operator = models.ForeignKey("auth.User")

执行 makemigrations

执行 migrate

在serializers.py 中，增加operator

具体代码如下：

# 首先 引用rest framework中的 serializers

from rest_framework import serializers
from app01 import models


class PublisherSerializer(serializers.ModelSerializer):
    """
        通过模型(models) 继承 serializers
    """
    operator = serializers.ReadOnlyField(source='operator.username')
    # 获取操作人员
    class Meta:
        model = models.Publisher
        fields = (
            "id",
            "name",
            "address",
            "operator",
        )

创建 permissions.py文件在APP中。

from rest_framework import permissions


class IsOwnerOrReadOnly(permissions.BasePermission):
    def has_object_permission(self, request, view, obj):
        if request.method in permissions.SAFE_METHODS:
            return True
        return obj.operator == request.user

在views.py 中引用 并操作

from rest_framework import generics

from rest_framework import permissions

from app01 import models
from app01 import serializers
from app01.permissions import IsOwnerOrReadOnly



class PublisherList(generics.ListCreateAPIView):
    queryset = models.Publisher.objects.all()
    serializer_class = serializers.PublisherSerializer
    permission_classes =(permissions.IsAuthenticated,IsOwnerOrReadOnly)


    """
    在提交表单的时候，因为不知道是哪个用户提交的，所以无法写入到数据库中。
    通过下面定义的函数解决这个问题。
    """
    def perform_create(self, serializer):
        serializer.save(operator=self.request.user)




class PublisherDetail(generics.RetrieveUpdateDestroyAPIView):
    queryset = models.Publisher.objects.all()
    serializer_class = serializers.PublisherSerializer
    permission_classes =(permissions.IsAuthenticated,IsOwnerOrReadOnly)

创建不同用户，检查是否能够更改对应人员的权限。

超链接 API

数据表与表的关系

在创建一个数据表

模型

models.py

class Book(models.Model):
    title = models.CharField(max_length=100, verbose_name="书名")
    publisher = models.ForeignKey("Publisher", on_delete=models.CASCADE, null=False)

    def __str__(self):
        return self.title

    class Meta:
        verbose_name ="书籍"
        verbose_name_plural = verbose_name

执行makemigrations 和 migrate

序列化

class BookSerializer(serializers.ModelSerializer):

    class Meta:
        model = models.Book
        fields = (
            "id",
            "title",
            "publisher",
        )

视图

class BookList(generics.ListCreateAPIView):
    queryset = models.Book.objects.all()
    serializer_class = serializers.BookSerializer
    permission_classes =(permissions.IsAuthenticated,)


class BookDetail(generics.RetrieveUpdateDestroyAPIView):
    queryset = models.Book.objects.all()
    serializer_class = serializers.BookSerializer
    permission_classes =(permissions.IsAuthenticated,)

路由

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

from app01 import views
from rest_framework.urlpatterns import format_suffix_patterns

urlpatterns = [
    path('admin/', admin.site.urls),
    path('publishers/', views.PublisherList.as_view()),
    re_path(r'^publishers/(?P<pk>[0-9]+)$', views.PublisherDetail.as_view()),

    path('books/', views.BookList.as_view()),
    re_path(r'^books/(?P<pk>[0-9]+)$', views.BookDetail.as_view()),

    path('api-auth/', include('rest_framework.urls'))

]

urlpatterns = format_suffix_patterns(urlpatterns)

浏览器显示字段名称

浏览器中预览，显示的字段是ID

更改serializers.py 文件，让其显示名称publisher = serializers.StringRelatedField(source="publisher.name")

class BookSerializer(serializers.ModelSerializer):

    publisher = serializers.StringRelatedField(source="publisher.name")
    # 显示 publisher.name，如果不这样写，浏览器查询这个字段时候将会显示ID
    class Meta:
        model = models.Book
        fields = (
            "id",
            "title",
            "publisher",
        )

超链接展示

修改serializers.py 文件

将继承模式修改一下，更改成为：HyperlinkedModelSerializer

class BookSerializer(serializers.HyperlinkedModelSerializer):


    class Meta:
        model = models.Book
        fields = (
            "id",
            "title",
            "publisher",
        )

浏览器访问报错，对路由进行name=分配

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

from app01 import views
from rest_framework.urlpatterns import format_suffix_patterns

urlpatterns = [
    path('admin/', admin.site.urls),
    path('publishers/', views.PublisherList.as_view(), name='publisher-list'),
    re_path(r'^publishers/(?P<pk>[0-9]+)$', views.PublisherDetail.as_view(), name='publisher-detail'),

    path('books/', views.BookList.as_view(), name='book-list'),
    re_path(r'^books/(?P<pk>[0-9]+)$', views.BookDetail.as_view(), name='book-detail'),

    path('api-auth/', include('rest_framework.urls'))

]

urlpatterns = format_suffix_patterns(urlpatterns)

根视图

在Views.py 中引用以下

from rest_framework.decorators import api_view
from rest_framework.reverse import reverse

在最下方加入以下内容

@api_view(['GET'])
def api_root(request, format=None):
    return Response({
        'publishers': reverse('publisher-list', request=request, format=format),
        'books': reverse('book-list', request=request, format=format),

    })

在APP中，新建一个urls.py文件

from django.urls import path, include, re_path

from app01 import views
from rest_framework.urlpatterns import format_suffix_patterns

urlpatterns = [
    re_path(r'^$',views.api_root),
    path('publishers/', views.PublisherList.as_view(), name='publisher-list'),
    re_path(r'^publishers/(?P<pk>[0-9]+)$', views.PublisherDetail.as_view(), name='publisher-detail'),

    path('books/', views.BookList.as_view(), name='book-list'),
    re_path(r'^books/(?P<pk>[0-9]+)$', views.BookDetail.as_view(), name='book-detail'),

    path('api-auth/', include('rest_framework.urls'))

]

urlpatterns = format_suffix_patterns(urlpatterns)

将project 项目中的urls.py 进行修改

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

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

通过定义api/路径，指向app01中的urls

分页

对settings.py 进行配置。

REST_FRAMEWORK = {
    'DEFAULT_PERMISSION_CLASSES': [
        # 'rest_framework.permissions.DjangoModelPermissionsOrAnonReadOnly',
        'rest_framework.permissions.IsAdminUser',

    ],
    # 以下是控制分页显示的地方。。。·ssss
    'DEFAULT_PAGINATION_CLASS': 'rest_framework.pagination.PageNumberPagination',
    'PAGE_SIZE': 1
}

视图集和路由

ViewSets

整合 视图重复代码

视图

from rest_framework import permissions
from rest_framework import viewsets

from app01 import models
from app01 import serializers
from app01.permissions import IsOwnerOrReadOnly


class PublisherViewSet(viewsets.ModelViewSet):
    queryset = models.Publisher.objects.all()
    serializer_class = serializers.PublisherSerializer
    permission_classes =(permissions.IsAuthenticated,IsOwnerOrReadOnly)


class BookViewSet(viewsets.ModelViewSet):
    queryset = models.Book.objects.all()
    serializer_class = serializers.BookSerializer
    permission_classes = (permissions.IsAuthenticated,)

路由

from django.urls import path, include, re_path

from app01 import views

from rest_framework.routers import DefaultRouter

router = DefaultRouter()
router.register(r'books', views.BookViewSet)
router.register(r'publishers', views.PublisherViewSet)

urlpatterns = [
    re_path(r'^',include(router.urls)),
    path('api-auth/', include('rest_framework.urls'))

]

概要信息

安装 pip install coreapi

对APP中的urls.py文件进行配置

from django.urls import path, include, re_path

from rest_framework.routers import DefaultRouter
from rest_framework.schemas import get_schema_view

from app01 import views


router = DefaultRouter()
router.register(r'books', views.BookViewSet)
router.register(r'publishers', views.PublisherViewSet)


schema_view = get_schema_view(title = "图书管理系统")


urlpatterns = [
    re_path(r'^',include(router.urls)),
    path('schema/', schema_view),
    path('api-auth/', include('rest_framework.urls'))

]

访问api/schema既可

文档工具

配置app下面的路由

from django.urls import path, include, re_path

from rest_framework.routers import DefaultRouter
from rest_framework.schemas import get_schema_view
from rest_framework.documentation import include_docs_urls

from app01 import views


router = DefaultRouter()
router.register(r'books', views.BookViewSet)
router.register(r'publishers', views.PublisherViewSet)


schema_view = get_schema_view(title = "图书管理系统")


urlpatterns = [
    re_path(r'^',include(router.urls)),
    path('schema/', schema_view),
    path('docs/', include_docs_urls(title="测试文档库")),
    path('api-auth/', include('rest_framework.urls'))

]

最终整理

目录结构

untitled
|   db.sqlite3
|   manage.py
+---app01
|   |   admin.py
|   |   apps.py
|   |   models.py
|   |   permissions.py
|   |   serializers.py
|   |   tests.py
|   |   urls.py
|   |   views.py
|   |   __init__.py
|   +---migrations
|   |   |   0001_initial.py
|   |   |   0002_auto_20180602_2037.py
|   |   |   0003_auto_20180602_2058.py
|   |   |   0004_auto_20180602_2100.py
|   |   |   0005_book.py
|   |   |   __init__.py
|   |   |
+---templates
\---untitled
    |   settings.py
    |   urls.py
    |   wsgi.py
    |   __init__.py

一、项目配置

1.1 settings 文件配置

"""
Django settings for untitled project.

Generated by 'django-admin startproject' using Django 2.0.5.

For more information on this file, see
https://docs.djangoproject.com/en/2.0/topics/settings/

For the full list of settings and their values, see
https://docs.djangoproject.com/en/2.0/ref/settings/
"""

import os

# Build paths inside the project like this: os.path.join(BASE_DIR, ...)
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))


# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/2.0/howto/deployment/checklist/

# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = 'f%3r8wa-#-9rkw-nnm(qfit5tb8sj3rc21sbwsk82xix(@$1t#'

# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = True

ALLOWED_HOSTS = []


# Application definition

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',    # 调用哦
]

#   这里需要注意
REST_FRAMEWORK = {
    'DEFAULT_PERMISSION_CLASSES': [
        # 'rest_framework.permissions.DjangoModelPermissionsOrAnonReadOnly',
        'rest_framework.permissions.IsAdminUser',

    ],
    'DEFAULT_PAGINATION_CLASS': 'rest_framework.pagination.PageNumberPagination',
    'PAGE_SIZE': 1
}

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 = 'untitled.urls'

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [os.path.join(BASE_DIR, 'templates')]
        ,
        '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 = 'untitled.wsgi.application'


# Database
# https://docs.djangoproject.com/en/2.0/ref/settings/#databases

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
    }
}


# Password validation
# https://docs.djangoproject.com/en/2.0/ref/settings/#auth-password-validators

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',
    },
]


# Internationalization
# https://docs.djangoproject.com/en/2.0/topics/i18n/

LANGUAGE_CODE = 'en-us'

TIME_ZONE = 'UTC'

USE_I18N = True

USE_L10N = True

USE_TZ = True


# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/2.0/howto/static-files/

STATIC_URL = '/static/'

1.2 urls 文件配置

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

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

二、APP文件配置

2.2 models 文件配置

from django.db import models


class Publisher(models.Model):
    name = models.CharField(max_length=32, verbose_name="名称", unique=True)
    address = models.CharField(max_length=100, verbose_name="地址")
    operator = models.ForeignKey("auth.User", on_delete=models.CASCADE, null=False)

    def __str__(self):
        return self.name
        
    class Meta:
        verbose_name = "出版社"
        verbose_name_plural = verbose_name


class Book(models.Model):
    title = models.CharField(max_length=100, verbose_name="书名")
    publisher = models.ForeignKey("Publisher", on_delete=models.CASCADE, null=False)

    def __str__(self):
        return self.title

    class Meta:
        verbose_name ="书籍"
        verbose_name_plural = verbose_name

2.3 权限控制模块(permissions.py)

这个需要创建

from rest_framework import permissions


class IsOwnerOrReadOnly(permissions.BasePermission):
    def has_object_permission(self, request, view, obj):
        if request.method in permissions.SAFE_METHODS:
            return True
        return obj.operator == request.user

2.4 序列化控制(serializers.py)

手动创建

#!/usr/bin/env python
# -*- coding: utf-8 -*-



from rest_framework import serializers
from app01 import models



class PublisherSerializer(serializers.ModelSerializer):
    
    operator = serializers.ReadOnlyField(source='operator.username')
    # 获取操作人员
    class Meta:
        model = models.Publisher
        fields = (
            "id",
            "name",
            "address",
            "operator",
        )



class BookSerializer(serializers.HyperlinkedModelSerializer):
"""
# class BookSerializer(serializers.ModelSerializer):
    # publisher = serializers.StringRelatedField(source="publisher.name")
    
    注释的代码，可以显示名称，而不是超链接格式。
"""
    class Meta:
        model = models.Book
        fields = (
            "id",
            "title",
            "publisher",
        )

2.5 项目中的URLS配置

from django.urls import path, include, re_path

from rest_framework.routers import DefaultRouter
from rest_framework.schemas import get_schema_view
from rest_framework.documentation import include_docs_urls

from app01 import views


router = DefaultRouter()
router.register(r'books', views.BookViewSet)
router.register(r'publishers', views.PublisherViewSet)


schema_view = get_schema_view(title = "图书管理系统")


urlpatterns = [
    re_path(r'^',include(router.urls)),
    path('schema/', schema_view),
    path('docs/', include_docs_urls(title="测试文档库")),
    path('api-auth/', include('rest_framework.urls'))

]

2.6 视图

from rest_framework import permissions
from rest_framework import viewsets

from app01 import models
from app01 import serializers
from app01.permissions import IsOwnerOrReadOnly


class PublisherViewSet(viewsets.ModelViewSet):
    queryset = models.Publisher.objects.all()
    serializer_class = serializers.PublisherSerializer
    permission_classes =(permissions.IsAuthenticated,IsOwnerOrReadOnly)


class BookViewSet(viewsets.ModelViewSet):
    queryset = models.Book.objects.all()
    serializer_class = serializers.BookSerializer
    permission_classes = (permissions.IsAuthenticated,)

AJAX 提交数据 到 REST

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">



    {% load staticfiles %}
    <script src=" {% static 'js/jquery.min.js' %}"></script>

    <title>Document</title>
</head>

<body>

</body>
<script>
    function getCookie(name) {
        var cookieValue = null;
        if (document.cookie && document.cookie != '') {
            var cookies = document.cookie.split(';');
                for (var i = 0; i < cookies.length; i++) {
                    var cookie = jQuery.trim(cookies[i]);
                    if (cookie.substring(0, name.length + 1) == (name + '=')) {
                        cookieValue = decodeURIComponent(cookie.substring(name.length + 1));
                        break;
                    }
                }
        }
        return cookieValue;
    }

    var csrftoken = getCookie('csrftoken');

    $.ajax({
            url: "http://127.0.0.1:8000/api/books/",
            type: "POST",
            headers: { 'X-CSRFToken': csrftoken },
            data: {
                'title': 'guoqiang',
                'publisher': '/api/publishers/3/'
            },
            success: function (responseText, textStatus, jqXHR) {
                if (jqXHR.status == '201'){
                   alert('success!' + "  "+ jqXHR.status)
                }
            },
            error: function(responseText){
                alert('添加失败！'+ "   错误代码：" +responseText.status);
            },
            dataType: "json"
        })


</script>

</html>

附录

一、 所需插件

certifi             2018.4.16
chardet             3.0.4
colorama            0.3.9
coreapi             2.3.3
coreschema          0.0.4
Django              2.0.5
django-cors-headers 2.2.0
django-filter       1.1.0
djangorestframework 3.8.2
httpie              0.9.9
idna                2.6
itypes              1.1.0
Jinja2              2.10
Markdown            2.6.11
MarkupSafe          1.0
pip                 10.0.1
Pygments            2.2.0
pytz                2018.4
requests            2.18.4
setuptools          39.2.0
uritemplate         3.0.0
urllib3             1.22
wheel               0.31.1

二、 restAPI 状态码

1xx（临时响应） 
表示临时响应并需要请求者继续执行操作的状态代码。

代码   说明 
100   （继续） 请求者应当继续提出请求。 服务器返回此代码表示已收到请求的第一部分，正在等待其余部分。  
101   （切换协议） 请求者已要求服务器切换协议，服务器已确认并准备切换。

2xx （成功） 
表示成功处理了请求的状态代码。

代码   说明 
200   （成功）  服务器已成功处理了请求。 通常，这表示服务器提供了请求的网页。 
201   （已创建）  请求成功并且服务器创建了新的资源。 
202   （已接受）  服务器已接受请求，但尚未处理。 
203   （非授权信息）  服务器已成功处理了请求，但返回的信息可能来自另一来源。 
204   （无内容）  服务器成功处理了请求，但没有返回任何内容。 
205   （重置内容） 服务器成功处理了请求，但没有返回任何内容。 
206   （部分内容）  服务器成功处理了部分 GET 请求。

3xx （重定向） 
表示要完成请求，需要进一步操作。 通常，这些状态代码用来重定向。

代码   说明 
300   （多种选择）  针对请求，服务器可执行多种操作。 服务器可根据请求者 (user agent) 选择一项操作，或提供操作列表供请求者选择。 
301   （永久移动）  请求的网页已永久移动到新位置。 服务器返回此响应（对 GET 或 HEAD 请求的响应）时，会自动将请求者转到新位置。 
302   （临时移动）  服务器目前从不同位置的网页响应请求，但请求者应继续使用原有位置来进行以后的请求。 
303   （查看其他位置） 请求者应当对不同的位置使用单独的 GET 请求来检索响应时，服务器返回此代码。 
304   （未修改） 自从上次请求后，请求的网页未修改过。 服务器返回此响应时，不会返回网页内容。 
305   （使用代理） 请求者只能使用代理访问请求的网页。 如果服务器返回此响应，还表示请求者应使用代理。 
307   （临时重定向）  服务器目前从不同位置的网页响应请求，但请求者应继续使用原有位置来进行以后的请求。

4xx（请求错误） 
这些状态代码表示请求可能出错，妨碍了服务器的处理。

代码   说明 
400   （错误请求） 服务器不理解请求的语法。 
401   （未授权） 请求要求身份验证。 对于需要登录的网页，服务器可能返回此响应。 
403   （禁止） 服务器拒绝请求。 
404   （未找到） 服务器找不到请求的网页。 
405   （方法禁用） 禁用请求中指定的方法。 
406   （不接受） 无法使用请求的内容特性响应请求的网页。 
407   （需要代理授权） 此状态代码与 401（未授权）类似，但指定请求者应当授权使用代理。 
408   （请求超时）  服务器等候请求时发生超时。 
409   （冲突）  服务器在完成请求时发生冲突。 服务器必须在响应中包含有关冲突的信息。 
410   （已删除）  如果请求的资源已永久删除，服务器就会返回此响应。 
411   （需要有效长度） 服务器不接受不含有效内容长度标头字段的请求。 
412   （未满足前提条件） 服务器未满足请求者在请求中设置的其中一个前提条件。 
413   （请求实体过大） 服务器无法处理请求，因为请求实体过大，超出服务器的处理能力。 
414   （请求的 URI 过长） 请求的 URI（通常为网址）过长，服务器无法处理。 
415   （不支持的媒体类型） 请求的格式不受请求页面的支持。 
416   （请求范围不符合要求） 如果页面无法提供请求的范围，则服务器会返回此状态代码。 
417   （未满足期望值） 服务器未满足”期望”请求标头字段的要求。

5xx（服务器错误） 
这些状态代码表示服务器在尝试处理请求时发生内部错误。 这些错误可能是服务器本身的错误，而不是请求出错。

代码   说明 
500   （服务器内部错误）  服务器遇到错误，无法完成请求。 
501   （尚未实施） 服务器不具备完成请求的功能。 例如，服务器无法识别请求方法时可能会返回此代码。 
502   （错误网关） 服务器作为网关或代理，从上游服务器收到无效响应。 
503   （服务不可用） 服务器目前无法使用（由于超载或停机维护）。 通常，这只是暂时状态。 
504   （网关超时）  服务器作为网关或代理，但是没有及时从上游服务器收到请求。 
505   （HTTP 版本不受支持） 服务器不支持请求中所用的 HTTP 协议版本。

RFC 6585 最近刚刚发布，该文档描述了 4 个新的 HTTP 状态码。

HTTP 协议还在变化？是的，HTTP 协议一直在演变，新的状态码对于开发 REST 服务或者说是基于 HTTP 的服务非常有用，下面我们为你详细介绍这四个新的状态码以及是否应该使用。

428 Precondition Required (要求先决条件)
先决条件是客户端发送 HTTP 请求时，如果想要请求能成功必须满足一些预设的条件。

一个好的例子就是 If-None-Match 头，经常在 GET 请求中使用，如果指定了 If-None-Match ，那么客户端只在响应中的 ETag 改变后才会重新接收回应。

先决条件的另外一个例子就是 If-Match 头，这个一般用在 PUT 请求上用于指示只更新没被改变的资源，这在多个客户端使用 HTTP 服务时用来防止彼此间不会覆盖相同内容。

当服务器端使用 428 Precondition Required 状态码时，表示客户端必须发送上述的请求头才能执行请求，这个方法为服务器提供一种有效的方法来阻止 'lost update' 问题。

429 Too Many Requests (太多请求)
当你需要限制客户端请求某个服务数量时，该状态码就很有用，也就是请求速度限制。

在此之前，有一些类似的状态码，例如 '509 Bandwidth Limit Exceeded'. Twitter 使用 420 （这不是HTTP定义的状态码）

如果你希望限制客户端对服务的请求数，可使用 429 状态码，同时包含一个 Retry-After 响应头用于告诉客户端多长时间后可以再次请求服务。

431 Request Header Fields Too Large (请求头字段太大)
某些情况下，客户端发送 HTTP 请求头会变得很大，那么服务器可发送 431 Request Header Fields Too Large 来指明该问题。

我不太清楚为什么没有 430 状态码，而是直接从 429 跳到 431，我尝试搜索但没有结果。唯一的猜测是 430 Forbidden 跟 403 Forbidden 太像了，为了避免混淆才这么做的，天知道！

511 Network Authentication Required (要求网络认证)
对我来说这个状态码很有趣，如果你在开发一个 HTTP 服务器，你不一定需要处理该状态码，但如果你在编写 HTTP 客户端，那这个状态码就非常重要。

如果你频繁使用笔记本和智能手机，你可能会注意到大量的公用 WIFI 服务要求你必须接受一些协议或者必须登录后才能使用。

这是通过拦截HTTP流量，当用户试图访问网络返回一个重定向和登录，这很讨厌，但是实际情况就是这样的。

使用这些“拦截”客户端，会有一些讨厌的副作用。在 RFC 中有提到这两个的例子：

如果你在登录WIFI前访问某个网站，网络设备将会拦截首个请求，这些设备往往也有自己的网站图标 ‘favicon.ico'。登录后您会发现，有一段时间内你访问的网站图标一直是WIFI登录网站的图标。
如果客户端使用HTTP请求来查找文档（可能是JSON），网络将会响应一个登录页，这样你的客户端就会解析错误并导致客户端运行异常，在现实中这种问题非常常见。
因此 511 状态码的提出就是为了解决这个问题。

如果你正在编写 HTTP 的客户端，你最好还是检查 511 状态码以确认是否需要认证后才能访问。