Python Django rest framework

本節內容

1. Django rest framework 安裝

2. Django rest framwwork 環境配置

3. 簡單舉例說明

4. Django中使用 rest framework

1.1 安裝 Django rest framework

創建新的環境    能夠忽略

virtualenv env
source env/bin/activate

安裝 djangorestframework 模塊

pip install django
pip install djangorestframework
pip install markdown # Markdown support for the browsable API.
pip install django-filter # Filtering support

2 Django rest framework 環境配置

1.配置settings文件

在項目配置文件settings的INSTALLED_APPS中添加 ‘rest_framework’

在settings最後一行增長一下內容：容許未認證的用戶只讀權限

REST_FRAMEWORK = {
    # Use Django's standard `django.contrib.auth` permissions,
    # or allow read-only access for unauthenticated users.
    'DEFAULT_PERMISSION_CLASSES': [
        'rest_framework.permissions.DjangoModelPermissionsOrAnonReadOnly'
    ]
}

3 簡單的舉例說明

先來看下我Django項目的目錄結構

 

第一步咱們須要在 crm_1的 urls下添加 rest framework 的指向信息，這裏咱們把api的請求指向到app01下的urls.py

urlpatterns = [
    url(r'^api/',include('app01.urls') ),
]

在app01的urls.py中寫以下內容

#!/usr/bin/env python
# -*- coding:utf-8 -*-
__author__ = '40kuai'

from django.conf.urls import url, include
from django.contrib.auth.models import User
from rest_framework import routers, serializers, viewsets


# Serializers define the API representation.
class UserSerializer(serializers.HyperlinkedModelSerializer):
    class Meta:
        model = User
        fields = ('url', 'username', 'email', 'is_staff')


# ViewSets define the view behavior.
class UserViewSet(viewsets.ModelViewSet):
    queryset = User.objects.all()
    serializer_class = UserSerializer


# Routers provide an easy way of automatically determining the URL conf.
router = routers.DefaultRouter()
router.register(r'users', UserViewSet)

# Wire up our API using automatic URL routing.
# Additionally, we include login URLs for the browsable API.
urlpatterns = [
    url(r'^', include(router.urls)),
    url(r'^api-auth/', include('rest_framework.urls',namespace='rest_framework'))
]

配置了這些以後你就能夠啓動你的Django項目而且來訪問api，

python manage makemigrations
python manage migrate
python manage createsuperuser  # 建立第一個用戶數據方便在api中查看信息

頁面顯示

登陸後能夠查看和編輯數據

下面咱們來建立兩個有關聯關係的表。來看看api怎麼顯示。

先來建立兩個表， 一個角色表。一個菜單表，一個角色能夠後多個菜單

from django.db import models

# Create your models here.

class Role(models.Model):
    """角色表"""
    name = models.CharField(max_length=64,unique=True)
    menus = models.ManyToManyField("Menu",blank=True,null=True)

    def __str__(self):
        return self.name


class Menu(models.Model):
    """一級菜單"""
    name = models.CharField(max_length=64)
    url_type_choices = ((0,'absolute'),(1,'relative'))
    url_type =  models.PositiveIntegerField(choices=url_type_choices,default=1)
    url_string = models.CharField(max_length=128)
    order = models.SmallIntegerField(default=0)

    def __str__(self):
        return self.name

    class Meta:
        unique_together = ("url_string",'url_type')

models.py

 

在admin.py中註冊下， 咱們經過Django admin來添加幾條數據

from app01 import models


admin.site.register(models.Menu)
admin.site.register(models.Role)

admin.py

 

建立完成後表中的數據

Roles

Menus

下面根據上面實例的配置來先配置Role表，讓表Role經過api來顯示，而且把各個處理的方法單獨分開

先只配置了Role表，來看看效果

在你要顯示的表中存在關聯關係的時候，須要給關聯表也作相應配置

完整的配置   app01目錄下的配置

#!/usr/bin/env python
# -*- coding:utf-8 -*-
__author__ = '40kuai'

from django.conf.urls import url, include
from app01 import rest_routers

# Wire up our API using automatic URL routing.
# Additionally, we include login URLs for the browsable API.
urlpatterns = [
    url(r'^', include(rest_routers.router.urls)),
    url(r'^api-auth/', include('rest_framework.urls',namespace='rest_framework'))
]

urls.py

 

#!/usr/bin/env python
# -*- coding:utf-8 -*-
__author__ = '40kuai'

from rest_framework import routers
from app01.rest_viewsets import *
"""
負責對url進行綁定
相似與Django admin的註冊
"""

router = routers.DefaultRouter()
router.register(r'role', RoleViewSet)
router.register(r'menu', MenuViewSet)

rest_routers.py

 

#!/usr/bin/env python
# -*- coding:utf-8 -*-
__author__ = '40kuai'
from rest_framework import viewsets
from app01.rest_serializers import *
from app01 import models
"""
把數據庫中的數據取出來，交給序列化進行處理
相似Django中的的視圖函數
"""
class RoleViewSet(viewsets.ModelViewSet):
    queryset = models.Role.objects.all()
    serializer_class = RoleSerializer

class MenuViewSet(viewsets.ModelViewSet):
    queryset = models.Menu.objects.all()
    serializer_class = MenuSerializer

rest_viewsets.py  

 

#!/usr/bin/env python
# -*- coding:utf-8 -*-
__author__ = '40kuai'

from rest_framework import serializers
from app01 import models
"""
序列化要展現的數據
"""
class RoleSerializer(serializers.HyperlinkedModelSerializer):
    class Meta:
        # depth = 1  # 展現的深度
        model = models.Role
        fields = ('url','name', 'menus', )

class MenuSerializer(serializers.HyperlinkedModelSerializer):
    class Meta:
        model = models.Menu
        fields = ('url','name', 'url_type','url_string','order' )

rest_serializers.py

 

如今頁面就能夠正常訪問了。  

顯示關聯表裏的詳細信息：

serializers 類的配置的class Meta中添加   depth = 2 來指定 數據查詢的深度

serializers.HyperlinkedModelSerializer   # 顯示對象的url

ModelSerializer　　# 顯示對象的id

4 Django 視圖函數和rest framework 結合使用

# 接口新加兩條路由信息
    url(r'^eventlog_list/', views.eventrole_list),
    url(r'^eventlog_detail/(\d+)/', views.eventrole_detail),

from django.shortcuts import render

# Create your views here.
from rest_framework import serializers
from app01 import models

from django.http import HttpResponse, JsonResponse
from django.views.decorators.csrf import csrf_exempt
from rest_framework.renderers import JSONRenderer
from rest_framework.parsers import JSONParser
from rest_framework.decorators import api_view

from rest_framework import status
from rest_framework.response import Response


class EventRoleSerializer(serializers.ModelSerializer):
    class Meta:
        model = models.Role
        fields = ('id','name', 'menus')


@api_view(['GET', 'POST'])
def eventrole_list(request):
    """
    List all snippets, or create a new snippet.
    """
    if request.method == 'GET':
        eventroles = models.Role.objects.all()
        serializer = EventRoleSerializer(eventroles, many=True)
        return Response(serializer.data)

    elif request.method == 'POST':
        print("request", request.data)
        serializer = EventRoleSerializer(data=request.data)
        if serializer.is_valid():
            serializer.save()
            return Response(serializer.data, status=status.HTTP_201_CREATED)
        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)


@api_view(['GET', 'POST','PUT','DELETE'])
@csrf_exempt
def eventrole_detail(request, pk):
    """
    Retrieve, update or delete a code eventlog.
    """
    try:
        eventrole_obj = models.Role.objects.get(pk=pk)
    except models.Role.DoesNotExist:
        return HttpResponse(status=404)

    if request.method == 'GET':
        serializer = EventRoleSerializer(eventrole_obj)
        return JsonResponse(serializer.data)

    elif request.method == 'PUT':
        print(request)
        data = JSONParser().parse(request)
        serializer = EventRoleSerializer(eventrole_obj, data=data)
        if serializer.is_valid():
            serializer.save()
            return JsonResponse(serializer.data)
        return JsonResponse(serializer.errors, status=400)

    elif request.method == 'DELETE':
        eventrole_obj.delete()
        return HttpResponse(status=204)

views.py

 

 本身測得玩玩就好， 這只是個入門。