restful知识点之二restframework视图

restful协议理解：面向资源开发

restful协议

     ----  一切皆是资源,操作只是请求方式
     
     ----book表增删改查
         /books/                 books
         /books/add/             addbook
         /books/(\d+)/change/    changebook
         /books/(\d+)/delete/    delbook
         
    ----book表增删改查
         /books/     -----get            books      -----  返回当前所有数据
         /books/     -----post           books      -----  返回提交数据 
         
         /books/(\d+)-----get            bookdetail -----  返回当前查看的单条数据 
         /books/(\d+)-----put            bookdetail -----  返回更新数据 
         /books/(\d+)-----delete         bookdetail -----  返回空
         
              
         class  Books(View):
              def get(self,request):
                  pass  # 查看所有书籍
                  
              def post(self,request)：
                  pass  # 添加书籍
                  
                  
         class  BooksDetail(View):
              def get(self,request,id):
                  pass  # 查看具体书籍
         
              def put(self,request,id):
                  pass  # 更新某本书籍
                  
              def delete(self,request,id)：
                  pass  # 删除某本书籍      

安装restframework

pip3 install djangorestframework 

 

Django序列化方式
# 方式1：
        # publish_list=list(Publish.objects.all().values("name","email"))

        # 方式2：
        # from django.forms.models import model_to_dict
        # publish_list=Publish.objects.all()
        # temp=[]
        # for obj in publish_list:
        #     temp.append(model_to_dict(obj))

        # 方式3：（使用django框架的serializers方法）
 　　　　　　　　# from django.core import serializers # ret=serializers.serialize("json",publish_list)

　　　　　　方式4：使用rest_framework进行序列化

　　　　　　　　功能1：从querySet--->json
　　　　　　　　功能2：从json---->querySet

　　　　　　　　步骤1：from rest_framework import serializers
　　　　　　　　步骤2：用modelserializer(类似modelForm)

　　　　　　　　　　序列化querySet:
　　　　　　　　　　　　　　book_list=Book.objects.all()
　　　　　　　　　　　　　　bs=BookSerializers(book_list,many=True)

　　　　　　　　　　序列化对象：
　　　　　　　　　　　　obj=Book.objects.filter(pk=id).first()
　　　　　　　　　　　　bs=BookSerializers(obj)
　　　　　　　　 　　备注：需要继承APIView类才能与rest-framwork序列化类相配合使用

 一、初级处理视图方式

urls.py;两个url 一个处理全部数据，一个处理单条数据

　　　处理全部数据：

　　　　get与post

　　   处理单条数据

　　　　get、put(更新)与delete

 

urls.py

from django.conf.urls import url
from django.contrib import admin
from app01 import views

urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^Books/$', views.Books.as_view(),name='book'),
    url(r'^Books_detail/(\d+)/$', views.Book_detail.as_view(),name='Books_detail'),
    url(r'^Author/$', views.AuthorView.as_view(),name='Author'),
    url(r'^AuthorDetail/(\d+)/$', views.perBookView.as_view(),name='AuthorDetail'),

]

views.py:

from django.shortcuts import render,HttpResponse,redirect
from app01.serilizer import *
from django.views import View
from app01.models import *
from rest_framework.response import Response
from rest_framework import serializers
# Create your views here.
from rest_framework.views import APIView


from rest_framework import mixins
from rest_framework import generics

全部视图查看处理类
class Books(APIView):
    def get(self,request):
        book_list=Book.objects.all()
        bs=BookSerializers(book_list,many=True)
        return Response(bs.data)

    def post(self,request):
        bs=BookSerializers(data=request.data)
        if bs.is_valid():
            bs.save()
            return Response(bs.data)
        else:
            return Response(bs.errors)

某条数据处理类
class Book_detail(APIView):
    def get(self,request,id):
        obj=Book.objects.filter(pk=id).first()
        bs=BookSerializers(obj)
        return Response(bs.data)

    def put(self,request,id):
        obj=Book.objects.filter(pk=id).first()
        bs=BookSerializers(obj,data=request.data)
        if bs.is_valid():
            bs.save()
            return Response(bs.data)
        else:
            return Response(bs.errors)

    def delete(self,request,id):
        Book.objects.filter(pk=id).delete()
        return Response()


class AuthorView(APIView):
    def get(self,request):
        author_list=Author.objects.all()
        bs=Authorserializers(author_list,many=True)
        return Response(bs.data)

    def post(self,request):

        ps=Authorserializers(data=request.data)
        if ps.is_valid():
            print(ps.validated_data)
            ps.save()  # create方法
            return Response(ps.data)
        else:
            return Response(ps.errors)


class perBookView(APIView):
    #查看一条
    def get(self,request,id):
        authors_obj=Author.objects.filter(pk=id).first()
        aa=Authorserializers(authors_obj)
        return Response(aa.data)

    #更新一条
    def put(self,request,id):
        obj=Author.objects.filter(pk=id).first()
        sobj=Authorserializers(obj,data=request.data)
        if sobj.is_valid():
            sobj.save()
            return Response(sobj.data)
        else:
            return Response(sobj.errors)

    #删除一条
    def delete(self,request,id):
        Author.objects.filter(pk=id).delete()
        return Response()

数据库

from django.db import models

# Create your models here.
from django.db import models

# Create your models here.


class Book(models.Model):
    title=models.CharField(max_length=32)
    price=models.IntegerField()
    pub_date=models.DateField(null=True)
    publish=models.ForeignKey("Publish")
    authors=models.ManyToManyField("Author")
    def __str__(self):
        return self.title

class Publish(models.Model):
    name=models.CharField(max_length=32)
    email=models.EmailField()
    def __str__(self):
        return self.name

class Author(models.Model):
    name=models.CharField(max_length=32)
    age=models.IntegerField()
    def __str__(self):
        return self.name

使用rest_framework序列化前转化成类方式

from rest_framework import serializers
from app01.models import *
class Authorserializers(serializers.ModelSerializer):
    class Meta:
       model=Author
       fields="__all__"


class BookSerializers(serializers.ModelSerializer):
    class Meta:
        model=Book
        fields='__all__'

 

二、mixin类处理视图方式

generics.GenericAPIView继承了APIView,扩写的方法有：
处理全部数据：

　get全部：　mixins.ListModelMixin,
　post:　mixins.CreateModelMixin

处理单条数据：

　　get某条:　　mixins.RetrieveModelMixin
　　put（修改某条）：　　　mixins.UpdateModelMixin
　　delete（删除某条）：　mixins.DestroyModelMixin

from django.conf.urls import url
from django.contrib import admin
from app01 import views
urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^Publishs/$', views.Publishs.as_view()),
    url(r'^Publish_detail/(?P<pk>\d+)/$', views.PublishDetail.as_view())

from django.db import models

# Create your models here.
from django.db import models

# Create your models here.

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

class Token(models.Model):
    user=models.OneToOneField("User")
    token = models.CharField(max_length=128)

    def __str__(self):
        return self.token


class Book(models.Model):
    title=models.CharField(max_length=32)
    price=models.IntegerField()
    pub_date=models.DateField()
    publish=models.ForeignKey("Publish")
    authors=models.ManyToManyField("Author")
    def __str__(self):
        return self.title

class Publish(models.Model):
    name=models.CharField(max_length=32)
    email=models.EmailField()
    def __str__(self):
        return self.name

class Author(models.Model):
    name=models.CharField(max_length=32)
    age=models.IntegerField()
    def __str__(self):
        return self.name

from app01.models import *
from rest_framework import serializers

class Publishkserializer(serializers.ModelSerializer):
    class Meta:
        model=Publish
        fields='__all__'

from app01.myserializer import *
# Create your views here.
from rest_framework import mixins
from rest_framework import generics
from django.views import View
from rest_framework.views import APIView
from app01.models import *

#1mixin类编写视图---------------------------------

class Publishs(mixins.ListModelMixin,
                  mixins.CreateModelMixin,
                  generics.GenericAPIView):#扩写了APIView
    #必须是固定死的queryset
    queryset = Publish.objects.all()
    print('queryset---------------------',queryset)
    #必须是serializer_class
    serializer_class = Publishkserializer
    print(serializer_class, '1111111111111111111')

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

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

class PublishDetail(mixins.RetrieveModelMixin,mixins.UpdateModelMixin,mixins.DestroyModelMixin,generics.GenericAPIView):
    queryset = Publish.objects.all()
    print(queryset,'88888888888888888888')
    serializer_class = Publishkserializer


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

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

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

 

三、基于通用类的处理视图方式

相比mixin视图处理方式

处理全部数据：

　　generics.ListCreateAPIView
处理单条：

　　generics.RetrieveUpdateDestroyAPIView

from django.conf.urls import url
from django.contrib import admin
from app01 import views
urlpatterns = [
    url(r'^Author/$', views.Authors.as_view()),
    url(r'^Author_detail/(?P<pk>\d+)/$', views.AuthorDetail.as_view()),

]

#2使用通用的基于类的视图---------------------------------------
from rest_framework import mixins
from rest_framework import generics
from app01.models import *
from app01.myserializer import *
class Authors(generics.ListCreateAPIView):

    queryset = Author.objects.all()
    # print(queryset,'111111111111')
    print(queryset,'1111111111111111111111')
    serializer_class = Authorserializer

class AuthorDetail(generics.RetrieveUpdateDestroyAPIView):
    queryset = Author.objects.all()
    serializer_class = Authorserializer

from django.db import models

# Create your models here.
from django.db import models

# Create your models here.

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

class Token(models.Model):
    user=models.OneToOneField("User")
    token = models.CharField(max_length=128)

    def __str__(self):
        return self.token


class Book(models.Model):
    title=models.CharField(max_length=32)
    price=models.IntegerField()
    pub_date=models.DateField()
    publish=models.ForeignKey("Publish")
    authors=models.ManyToManyField("Author")
    def __str__(self):
        return self.title

class Publish(models.Model):
    name=models.CharField(max_length=32)
    email=models.EmailField()
    def __str__(self):
        return self.name

class Author(models.Model):
    name=models.CharField(max_length=32)
    age=models.IntegerField()
    def __str__(self):
        return self.name

from app01.models import *
from rest_framework import serializers
class Authorserializer(serializers.ModelSerializer):
    class Meta:
        model=Author
        fields='__all__'

 

四、viewsets.ModelViewSet

 

from django.conf.urls import url
from django.contrib import admin
from app01 import views
urlpatterns = [
 
    url(r'^Authors/$', views.AuthorsViewSet.as_view({"get": "list", "post": "create"}), name="book_list"),
    url(r'^Authors/(?P<pk>\d+)/$', views.AuthorsViewSet.as_view({
        'get': 'retrieve',
        'put': 'update',
        'patch': 'partial_update',
        'delete': 'destroy'
    }), name="book_detail"),

]

from rest_framework import mixins
from rest_framework import generics
from rest_framework import viewsets
from app01.models import *
from app01.myserializer import *
class AuthorsViewSet(viewsets.ModelViewSet):
    queryset = Author.objects.all()
    serializer_class = Authorserializer

from django.db import models

# Create your models here.

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

class Token(models.Model):
    user=models.OneToOneField("User")
    token = models.CharField(max_length=128)

    def __str__(self):
        return self.token


class Book(models.Model):
    title=models.CharField(max_length=32)
    price=models.IntegerField()
    pub_date=models.DateField()
    publish=models.ForeignKey("Publish")
    authors=models.ManyToManyField("Author")
    def __str__(self):
        return self.title

from app01.models import *
from rest_framework import serializers

class Publishkserializer(serializers.ModelSerializer):
    class Meta:
        model=Publish
        fields='__all__'



class Bookserializer(serializers.ModelSerializer):
    class Meta:
        model=Book
        fields='__all__'

class Authorserializer(serializers.ModelSerializer):
    class Meta:
        model=Author
        fields='__all__'

 五注册方式