一种基于django-restFramework通用型增删改查方案

方案理论基础

在Web开发中对于数据模型的操作不可避免，常见的数据资源的对象一般有两种：

1. 对某一数据资源集合的操作
2. 对某一数据资源对象的的操作

对于数据资源操作及其前端HTTP请求方法通常有：

1. 增—-> POST or PUT
2. 删—-> DELETE
3. 改—-> POST or PUT
4. 查—-> POST or GET

而业界RESTful API设计风格的对资源的操作类型和HTTP动词关系设计通常采用如下方案：

1. 增—-> POST (在服务器新建资源)
2. 删—-> DELETE (从服务器删除资源)
3. 改—-> PUT (在服务器更新资源，客户端提供资源改变属性)
4. 查—-> GET (从服务器获去资源)
5. 改—-> PATCH (在服务器更新资源，服务器提供资源改变属性)

利用上述原理和django-restFramework的序列化器serialiaer我们设计一种适用于django框架项目的通用型增删改查方案。

项目架构

project---
         |--project--|
                     |__init__.py
                     |urls.py
                     |settings.py
                     |wsgi.py

         |---app-----|__init__.py
                     |app.py
                     |urls.py
                     |views.py
                     |serializers.py     
                     |models.py
                     |admin.py
        ....

        |--manage.py

实现方案

#views.py
from django.shortcuts import render
from django.http import HttpResponse
from rest_framework import status
from django.db.models import Q
from functools import reduce
import operator
from app import serializers
from app import model
from app.serializers import JSONResponse
from rest_framework.parsers import JSONParserl
import importlib

def model_list(request):
     
    """
    列出所有的code snippet，或创建一个新的snippet。
    """
    model_str=request.META.get('HTTP_MODEL')
    global model
    global serializers
    if model_str:
        Model=getattr(model,model_str)
        ModelSerializer=getattr(serializers,model_str+'Serializer')
        if request.method == 'GET':
            # 获取资源列表
            models = Model.objects.ALL()
            serializer = ModelSerializer(models, many=True)
            return JSONResponse(serializer.data)

        elif request.method == 'POST':
            # 根据条件获取资源列表
            data = JSONParser().parse(request))
            serializer = ModelSerializer(data=data)
            fields=Model.get_fields()
            q_list=[]
            for field in fields:
                value=data.get(field)
                if value:
                    q_list.append(Q(**{field+'__icontains':value}))
            id_list=Model.get_indexs()
            for field in id_list:
                value=data.get(field)
                if isinstance(value,list):
                    if data.get(field):
                        q_list.append(Q(**{field+'__in':value}))
                if isinstance(value,int):
                    if data.get(field):
                        q_list.append(Q(**{field+'':value}))
                if isinstance(value,str):
                    if data.get(field):
                        q_list.append(Q(**{field+'':int(value)}))
            models=Model.objects.filter((reduce(operator.and_, q_list)))
            serializer = ModelSerializer(models, many=True)
            return JSONResponse(serializer.data)
        elif request.method == 'PUT':
        # 新建资源
            data = JSONParser().parse(request)
            serializer = ModelSerializer(data=data)
            if serializer.is_valid():
                serializer.save()
                return JSONResponse(serializer.data, status=status.HTTP_201_CREATED)
            return JSONResponse(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
    return JSONResponse('not definde request headers model', status=status.HTTP_400_BAD_REQUEST)



def model_detail(request,pk):
    """
    获取，更新或删除一个 code snippet。
    """
    model_str=request.META.get('HTTP_MODEL')
    global model
    global serializers
    if model_str:
        Model=getattr(model,model_str)
        ModelSerializer=getattr(serializers,model_str+'Serializer')
        try:
            model = Model.objects.get(pk=pk)
        except Model.DoesNotExist:
            return HttpResponse(status=status.HTTP_404_NOT_FOUND)

        if request.method == 'GET':
        #获取一个资源对象
            serializer = ModelSerializer(model)
            return JSONResponse(serializer.data)

        elif request.method == 'PUT':
        # 更新一个资源对象
            data = JSONParser().parse(request)
            serializer = ModelSerializer(model, data=data)
            if serializer.is_valid():
                serializer.save()
                return Response(serializer.data)
            return JSONResponse(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

        elif request.method == 'DELETE':
        #删除一个资源对象
            model.delete()
            return HttpResponse(status=status.HTTP_204_NO_CONTENT)
    return JSONResponse('not definde request headers model', status=status.HTTP_400_BAD_REQUEST)

# serializers.py
from rest_framework import serializers
from rest_framework.renderers import JSONRenderer
from app.model import Modal
from django.http import HttpResponse

class JSONResponse(HttpResponse):
    """
    An HttpResponse that renders its content into JSON.
    """
    def __init__(self, data, **kwargs):
        content = JSONRenderer().render(data)
        kwargs['content_type'] = 'application/json'
        super(JSONResponse, self).__init__(content, **kwargs)

class ModalSerializer(serializers.ModelSerializer):
    class Meta:
        model = Modal
        fields = '__all__'

请求封装

首先在前端请求的headers中添加我们需要获取的资源类名

import requests
headers={'model':'Model','Content-Type':'application/json'}
url='http://127.0.0.1:8000/app/model/model_list/'
response=requests.get(url, headers=headers)
print(response.text)

为了防止django拦截headers中的参数，我们需要在settings文件中配置request跨域的允许访问的headers字段

CORS_ALLOW_HEADERS = (
    'accept',
    ...,
    'model',
)

解析并获取资源类

前台请求制定资源对象类名和请求HTTP动词即可通过反射定位到对应方法，完成对资源的相关操作

# app 下的model文件
from app import model
from app import serializers
# 反射获取model 类
Model=getattr(model,model_str)
# 反射获取 model类对象的序列化对象
ModelSerializer=getattr(serializers,model_str+'Serializer')

动态构建资源对象的查询条件

通常我们对资源查询对于像id、pk、fk等索引性条件采用field__in=list_obj或者field=int_obj,对于其他字段通常采用field__icontains=obj的模糊匹配的方法，进行条件查询，利用这些特性，我们使用Q查询动态构建查询条件。

为了让改方法适用于所有的模型，我们讲查询条件定义到 ｀model.py｀中的资源对象类中静态方法

class UserDetail(models.Model):
    name=models.CharField(max_length=50,  null=True)
    sex=models.CharField(max_length=2, null=True)
    age=models.IntegerField()
    address=models.CharField(max_length=100, null=True)
    user=models.ForeignKey(User,null=True, blank=True, on_delete=models.SET_NULL))

    @staticmethod
    def get_indexs():
        return ['id''age','pk']

    @staticmethod
    def get_fields(Self):
        return ['name','sex','address']

至此我们基本完成了jango项目通用型增删改查的方案，所有跟资源模型相关在model文件中定义，如果要使用django-restframwork序列化方法的相关则在serializers.py中定义，对资源模型的操作在views文件中定义，当然你完全可以重新定义当多个APP使用同一个model_list()和model_detail()方法，也可以不采用django-restframwork