DRF框架（三）——media資源路徑設置、多表設計復習及補充、序列化組件(ModelSerializer)操作多表（序列化與反序列化）、多表序列化與反序列化整合（重點）

media資源路徑設置  （設置好后把圖片放在這個文件夾中，通過鏈接能訪問到圖片）

1.先在根目錄設置一個media文件夾

2.配置settings.py,加上下面的

MEDIA_URL = '/media/'
MEDIA_ROOT = os.path.join(BASE_DIR, 'media')

3.在urls.py路由設置

from django.views.static import serve
from django.conf import settings

urlpatterns = [   
    url(r'^media/(?P<path>.*)', serve, {'document_root': settings.MEDIA_ROOT}),
]

多表設計

BaseModel基表
    is_delete、create_time
下面四表繼承基表，可以繼承兩個字段

Book表：name、price、img、authors、publish、is_delete、create_time
Publish表：name、address、is_delete、create_time   
Author表：name、age、is_delete、create_time
AuthorDetail表：mobile, author、is_delete、create_time

基表設置  （注意設置abstract = True）

class BaseModel(models.Model):
    is_delete = models.BooleanField(default=False)
    create_time = models.DateTimeField(auto_now_add=True)

    # 設置 abstract = True 來聲明基表，作為基表的Model不能在數據庫中形成對應的表
    class Meta:
        abstract = True

斷關聯多表關系 （******）     db_constraint=False （設置了這個就是斷關聯，設置在外鍵，刪除了作者詳情，也不會刪除作者）

1、外鍵位置：
    一對多 - 外鍵放多的一方
    一對一 - 從邏輯正反向考慮，如作者表與作者詳情表，作者刪除級聯作者詳情也刪除，詳情刪除作者依舊存在，所以建議外鍵在詳情表中
　　（和之前的一對一關系外鍵放置不一樣，之前都是把外鍵放在查詢頻率高的表）
    多對多 - 外鍵在關系表中
    
2、ORM正向方向連表查找：
    正向：通過外鍵字段 eg: author_detial_obj.author   #外鍵設置在作者詳情表，在作者詳情表中查詢作者直接.author就可以
    反向：通過設置反向查詢related_name的值 eg：author_obj.detail  #外鍵沒有設置在作者表中，在作者表中通過設置反向查詢.detail查詢作者詳情
    注：依賴代碼見下方
    
3、連表操作關系：（外鍵建在作者詳情表中） 1）作者刪除，詳情級聯 - on_delete=models.CASCADE    #跟着一起刪除 2）作者刪除，詳情置空 - null=True, on_delete=models.SET_NULL   #外鍵字段清空 3）作者刪除，詳情重置 - default=0, on_delete=models.SET_DEFAULT
    4）作者刪除，詳情不動 - on_delete=models.DO_NOTHING
    注：拿作者與作者詳情表舉例 4、外鍵關聯字段的參數 - 如何實現斷關聯、目前表間操作關系、方向查詢字段
    i）作者詳情表中的（外鍵設置在作者詳情表中）
    author = models.OneToOneField(
        to='Author',       #和作者表關聯
        related_name='detail',   #反查詢，作者表直接查作者詳情表的電話號碼，可以直接author_obj.detail.mobile
        db_constraint=False,     #斷關聯
        on_delete=models.CASCADE  #級聯刪除
    )
    
    ii）圖書表中的
    publish = models.ForeignKey(
        to='Publish',
        related_name='books',
        db_constraint=False,
        on_delete=models.DO_NOTHING,
    )
    authors = models.ManyToManyField(
        to='Author'
        related_name='books',
        db_constraint=False,
    )
    注：ManyToManyField不能設置on_delete，OneToOneField、ForeignKey必須設置on_delete（django1.x系統默認級聯，但是django2.x必須手動明確）

models.py

from django.db import models

#基類
class BaseModel(models.Model):
    is_delete = models.BooleanField(default=False)  #默認不是刪除，數據庫中是0/1
    create_time = models.DateTimeField(auto_now_add=True)

    # 設置 abstract = True 來聲明基表，作為基表的Model不能在數據庫中形成對應的表
    class Meta:
        abstract = True  #聲明該表只是一個抽象表不出現在數據庫中 #書籍表
class Book(BaseModel):
    name = models.CharField(max_length=64)
    price = models.DecimalField(max_digits=5,decimal_places=2)
    img = models.ImageField(upload_to='img',default='default.jpg')
    #關聯出版社表
    publish = models.ForeignKey(
        to='Publish',  #關聯publish表
        db_constraint=False,  #斷關聯（斷開Book表和Publish表的關聯,方便刪數據,雖然斷開了關聯但是還能正常使用）
        related_name='books',#反向查詢字段：publish_obj.books就能查出當前出版社出版的的所有書籍
        on_delete=models.DO_NOTHING,#設置連表操作關系
    )
    #關聯作者表
    authors = models.ManyToManyField(
        to='Author',
        db_constraint=True,  #斷開關聯
        related_name='books'  #反向查詢字段
    )


    class Meta:
        db_table='book'
        verbose_name='書籍'
        verbose_name_plural=verbose_name

    def __str__(self):
        return self.name

#出版社表
class Publish(BaseModel):
    """name、address、is_delete、create_time"""
    name = models.CharField(max_length=64)
    addres = models.CharField(max_length=64)

    class Meta:
        db_table='publish'
        verbose_name='出版社'
        verbose_name_plural=verbose_name

    def __str__(self):
        return self.name

#作者表
class Author(BaseModel):
    """name、age、is_delete、create_time"""
    name = models.CharField(max_length=64)
    age = models.IntegerField()

    class Meta:
        db_table = 'author'
        verbose_name='作者'
        verbose_name_plural=verbose_name

    def __str__(self):
        return self.name

#作者詳情
class AuthorDetail(BaseModel):
    """mobile, author、is_delete、create_time"""
    mobile = models.CharField(max_length=11)
    author = models.OneToOneField(
        to='Author',
        db_constraint=False,
        related_name='detail',
        on_delete=models.CASCADE
    )

    class Meta:
        db_table='author_detail'
        verbose_name='作者詳情'
        verbose_name_plural=verbose_name

    def __str__(self):
        return self.author.name

序列化     ModelSerializer 模型類序列化器

ModelSerializer與常規的Serializer相同，但提供了：

1.基於模型類自動生成一系列字段

2.包含默認的create()和update()的實現

3.基於模型類自動為Serializer生成validators,比如unique_together

序列化層：api/serializers.py

簡單的寫

from rest_framework.serializers import ModelSerializer,SerializerMethodField
from . import models

#publish接口的序列化
class PublishModelSerializers(ModelSerializer):
    class Me= ('name','address')   #選擇需要序列化的字段，前端只顯示這些字段（指明模型類的哪些字段生成）

#Book接口序列化
class BookModelSerializers(ModelSerializer):
　　#了解：1.還可以自定義設置序列化字段，但是必須在fields中聲明,在fields中寫publish_address
　　publish_address = SerializerMethodField()
　　def get_publish_address(self,obj)
　　　　return obj.publish.address
　　#2.自定義連表深度-子序列化方式-該方式不能參與反序列化，使用在序列化和反序列化共存時，不能書寫(******)
　　publish =

在models.py中Book類設置publish_name和author_list屬性方法    (插拔式獲取)

#序列化插拔式屬性 -完成自定義字段名完成連表查詢
    @property
    def publish_name(self):  #自定義查詢出版社名字
        return self.publish.name

    @property
    def author_list(self):
        return self.authors.values('name','age')

視圖層 :views.py

from rest_framework.views import APIView
from rest_framework.response import Response
from . import models,serializers

class Book(APIView):
    def get(self,request,*args,**kwargs):
        pk = kwargs.get('pk')
        #單查
        if pk:
            try:
                book_obj = models.Book.objects.filter(pk=pk,is_delete=False)
                book_data = serializers.BookModelSerializers(book_obj).data  #單條數據序列化 
            except:
                return Response({
                    'status':1,
                    'msg':'數據不存在'
                })
        #群查
        else:
            book_query = models.Book.objects.filter(is_delete=False).all() #先篩選查詢,再查所有
            book_data = serializers.BookModelSerializers(book_query,many=True).data  #不管是一條還是多條，只要數據是被[]嵌套，都要寫many=True 　　　　　#返回前端數據 return Response({  
            'status':0,
            'msg':'ok',
            'results':book_data
        })

 

 路由層：api/urls.py

urlpatterns = [
    url(r'^books/$', views.Book.as_view()),
    url(r'^books/(?P<pk>.*)/$', views.Book.as_view()),
]

反序列化

序列化層：api/serializers.py

class BookModelDeserializer(ModelSerializer):
　　#一些只參與反序列化的字段，但是不是與數據庫關聯的，自定義不入庫的反序列化的字段
　　 re_name = seializers.CharField(write_only=True) class Meta:
        model = models.Book
        fields = ('name', 'price', 'publish', 'authors')  #沒有默認值的字段必須序列化，為其傳值 # extra_kwargs 用來完成反序列化字段的 系統校驗規則
        extra_kwargs = {
            'name': {
                'required': True,  #設置name字段必填 'min_length': 1,
                'error_messages': {
                    'required': '必填項',
                    'min_length': '太短',
                }
            }
        }
    
    # 局部鈎子校驗單個字段  validate_字段名
    def validate_name(self, value):  #value是字段name的值 # 書名不能包含 g 字符
        if 'g' in value.lower():
            raise ValidationError('該g書不能出版')
        return value
    # 全局鈎子
    def validate(self, attrs):
        publish = attrs.get('publish')   #publish如果是外鍵字段，這個就是publish對象
        name = attrs.get('name')
        if models.Book.objects.filter(name=name, publish=publish):
            raise ValidationError({'book': '該書已存在'})
        return attrs

    # 注意：ModelSerializer類已經幫我們實現了 create 與 update 方法,不需要寫create就能創建

視圖層：views.py

    def post(self,request,*args,**kwargs):
        request_data = request.data  #獲取post提交的數據包
        book_ser = serializers.BookModelDeserializer(data=request_data)
        # raise_exception=True：當校驗失敗，馬上終止當前視圖方法，拋異常返回給前台
        book_ser.is_valid(raise_exception=True) #檢驗是否合格 raise_exception=True必填的
        book_obj = book_ser.save()  #保存得到一個對象
        return Response({
            'status':0,
            'msg':'ok',
            'results':serializers.BookModelSerializers(book_obj).data
        })

路由層：urls.py    在postman中訪問路徑時最后必須帶上/,post請求方式只有json格式能一個字段提交多個值,放在列表或者元組中，其余兩個只能傳遞單個值

urlpatterns = [
    url(r'^books/$', views.Book.as_view()),
    url(r'^books/(?P<pk>.*)/$', views.Book.as_view()),
]

注意：（******）

反序列化層：
1.在設置fields，沒有默認值的字段都必須設置反序列化保存到數據庫中 2.使用extra_kwargs 來設置系統校驗規則
3.設置局部鈎子和全局鈎子
4.ModelSerializer類已經幫我們實現了 create 與 update 方法，不需要再寫

視圖層：
1.POST請求通過request.data拿到數據包
2.傳給反序列化 ,通過data=request_data傳入需要反序列化的數據
3.is_valid判斷校驗是否合格 ，raise_exception=True必須要寫的
4.通過.save()保存到數據庫中

序列化與反序列化整合（******）

序列化層：api/serializers.py

class V2BookModelSerializer(ModelSerializer):
    class Meta:
        model = models.Book
        fields = ('name', 'price', 'img', 'author_list', 'publish_name', 'publish', 'authors')
        extra_kwargs = {
            'name': {
                'required': True,
                'min_length': 1,
                'error_messages': {
                    'required': '必填項',
                    'min_length': '太短',
                }
            },
            'publish': {
                'write_only': True
            },
            'authors': {
                'write_only': True
            },
            'img': {
                'read_only': True,
            },
            'author_list': {
                'read_only': True,
            },
            'publish_name': {
                'read_only': True,
            }
        }

    def validate_name(self, value):
        # 書名不能包含 g 字符
        if 'g' in value.lower():
            raise ValidationError('該g書不能出版')
        return value

    def validate(self, attrs):
        publish = attrs.get('publish')
        name = attrs.get('name')
        if models.Book.objects.filter(name=name, publish=publish):
            raise ValidationError({'book': '該書已存在'})
        return attrs

序列化層注意點：

1) fields中設置所有序列化與反序列化字段
2) extra_kwargs划分只序列化或只反序列化字段（一般我們把需要存入到數據庫中的使用write_only（反序列化）,只需要展示的就read_only(序列化)，看需求設計）
    write_only：只反序列化
    read_only：只序列化
    自定義字段默認只序列化(read_only)
    如果字段沒設置write_only或者read_only，那么該字段可以序列化和反序列化 3) 設置反序列化所需的 系統、局部鈎子、全局鈎子 等校驗規則

視圖層：views.py

class V2Book(APIView):
    def get(self,request,*args,**kwargs):
        pk = kwargs.get('pk')
        #單查
        if pk:
            try:
                book_obj = models.Book.objects.get(pk=pk,is_delete=False)
                book_data = serializers.V2BookModelSerializer(book_obj).data  #序列化 except:
                return Response({
                    'status':1,
                    'msg':'參數有誤'
                })
        #群查
        else:
            book_query=models.Book.objects.filter(is_delete=False).all()
            book_data = serializers.V2BookModelSerializer(book_query,many=True).data #序列化 return Response({
            'status':0,
            'msg':'ok',
            'results':book_data
        })

    def post(self,request,*args,**kwargs):
        #單增:傳的數據是與model對應的一個字典
        # 群增：設計傳遞的是多個model對應的字典列表,在postman中通過列表嵌套字典傳值
        request_data = request.data
        if isinstance(request_data,dict):        #判斷獲取的數據是否是dict
            many = False
        elif isinstance(request_data,list):      #判斷獲取的數據是否是list
            many = True
        else:
            return Response({
                'status':1,
                'msg':'數據錯誤'
            })
        book_ser = serializers.V2BookModelSerializer(data=request_data,many=many)  #反序列化
        book_ser.is_valid(raise_exception=True)
        book_result = book_ser.save()    #book_result是對象<class 'app01.models.Book'>，群增就是列表套一個個對象

　　　　 return Response({
            'status':0,
            'msg':'ok',
            'results':serializers.V2BookModelSerializer(book_result,many=many).data
        })

    #單刪: 有pk   #在postman中通過路徑傳參
    #群刪：有pks   {"pks": [1, 2, 3]}   #通過json傳參
    def delete(self,request,*args,**kwargs):
        pk = kwargs.get('pk')
        if pk:
            pks = [pk]
        else:
            pks = request.data.get('pks')
        if models.Book.objects.filter(pk__in=pks,is_delete=False).update(is_delete=True):
            return Response({
                'status':0,
                'msg':'刪除成功'
            })
        return Response({
            'status':1,
            'msg':'刪除失敗'
        })

視圖層注意點：(****)

1.序列化數據最后必須要.data  （因為要傳給前端）
2.反序列化通過data傳參，序列化通過instance傳參（當你只傳一個參數時，默認是instanca的參數）
3.反序列化與序列化都能使用many=True，序列化和反序列化數據只要被[]嵌套都要寫many=True

路由層：urls.py

urlpatterns = [
    url(r'^v2/books/$', views.V2Book.as_view()),
    url(r'^v2/books/(?P<pk>.*)/$', views.V2Book.as_view()),
]

 instance/data/many/partial四個關鍵參數的用法總結

instance/data/many/partial 影響序列化對象行為的四個關鍵參數。

序列化情況：
1.如果沒有data參數，只有instance，那么就不存在反序列化校驗一說，只有序列化對象instance。
反序列化情況：
2.如果有data，沒有instance，那么需要進行校驗data，然后將data進行反序列化，得到validated_data,此時再通過序列化對象獲取data，這個data和初始化提供的data可不一樣，這個序列化validated_data后的data，比起初始化data，可能減少了無效的字段（序列化沒有定義的字段）。
修改情況：
3.如果又提供了instance 又提供了data, 那么只要有data或者部分data，那么data都要進行驗證才能進行下面的save等操作，如果不經過is_valid過程，那么后面的獲取序列化數據或者反序列化數據都會無效。
ListSerializer使用情況：
4.many參數將直接影響序列化類的類型，如果是many=False，那么直接使用當前序列化類。如果many=True,將實例化一個ListSerializer類來序列化或者反序列化類。（這也是看源碼是漏掉的地方，一直奇怪普通Serialiszer類怎么沒看到對多對象序列化的特殊處理。查看BaseSerializer.__new__方法）或者class Meta:中定義了list_serializer_class指定的多對象序列化類。
修改情況要用instance指明要修改的對象：
5.終於弄懂了，partial用於部分更新，為啥子要伴隨instance,因為要指明給save用，在save操作時給那個instance部分更新。邏輯這回走到下面源碼中的get_initial()獲取要進行更新instance的字段數據。