#前言

为什么要配置一个view模板（视图模板）？

  1. 接口开发更加简便，不用单独编写增删改查接口的视图；
  2. 在对应应用下的 views.py 文件中编写接口视图函数时，直接继承 视图模板类 就可以了
  3. 继承 视图模板类 后，这个视图函数（接口）实现了增删改查（POST、DELETE、PUT、GET）功能

1、视图模板文件配置（基础版本）

  • 新建一个公共代码文件夹 common 文件夹
  • 在 common 文件夹中新建一个公共的视图模板custom_class.py文件（名字自定义即可）；
  • 在这个文件中定义一个公共的视图模板类（类名自定义即可）。

1.1、视图模板类 的优点：

  1. 接口开发更加简便，不用单独编写增删改查接口；
  2. 在对应应用下的 views.py 文件中编写接口视图函数时，直接继承 视图模板类 就可以了
  3. 继承 视图模板类 后，这个视图函数（接口）实现了增删改查（POST、DELETE、PUT、GET）功能

1.2、视图模板类源码

  1. from django.views import View
  2. from django.core.paginator import Paginator
  3. from django.db.models import Q
  4. from django.http.response import JsonResponse
  5. from common.utils import model_to_dict  # 导入自定义函数 model_to_dict
  8. class ThzView(View):    
  9.     # 实现（增删改查）接口的 视图模板类（支持分页、模糊/精确查询）
  10.     search_fields = []  # 指定哪些字段支持模糊查询
  11.     filter_fields = []  # 指定哪些字段支持精确查询 
  12.     form_class = None   # 指定的form 类
  13.     model_class = None  # 指定的model类
  15.     def get(self, request):
  16.         # 实现查询数据功能的 视图模板方法（支持分页、模糊/精确查询）
  18.         limit = request.GET.get("limit", 10)
  19.         page = request.GET.get("page", 1)
  20.         search = request.GET.get("search")
  22.         query_dict = {}  # {id:1,name:xxx}
  23.         q = Q()  # None
  24.         for field in self.filter_fields:
  25.             value = request.GET.get(field)
  26.             if value != None:
  27.                 query_dict[field] = value
  28.         if search:
  29.             for field in self.search_fields:
  30.                 d = {"%s__contains" % field: search}
  31.                 q = q | Q(**d)
  32.         # all_data =  models.Grade.objects.filter(q).filter(**query_dict) #先模糊，后精确
  33.         all_data = self.model_class.objects.filter(**query_dict).filter(q)  # 先精确，后模糊
  35.         paginator = Paginator(all_data, limit)
  36.         page_data = paginator.get_page(page)  # [<grade<1>,<garde2>]
  37.         data_list = [model_to_dict(data) for data in page_data]
  38.         data = {"code": 0, "msg": "查询成功", "data": data_list, "count": paginator.count}
  39.         return JsonResponse(data)
  42.     def post(self, request):
  43.          # 实现新增数据功能的 视图模板方法
  44.         form = self.form_class(request.POST,files=request.FILES)
  45.         # files=request.FILES  是为了将请求中的文件参数传递进来
  46.         if form.is_valid():
  47.             obj = form.save()  # 保存到数据库
  48.             return JsonResponse({"code": 0, "msg": "操作成功", "id": obj.id})
  49.         return JsonResponse({"code": -1, "msg": form.errors.get_json_data()})
  51.         # form,model
  53.     def put(self, request):
  54.          # 实现修改数据功能的 视图模板方法
  55.         id = request.PUT.get("id")
  56.         if not id:
  57.             return JsonResponse({"code": -1, "msg": "请传入要修改的id"})
  58.         if not id.isdigit():
  59.             return JsonResponse({"code": -1, "msg": "id是数字"})
  61.         query_set = self.model_class.objects.filter(id=id)
  62.         if not query_set.exists():
  63.             return JsonResponse({"code": -1, "msg": "要修改的id不存在"})
  64.         grade = query_set.first()
  66.         form = self.form_class(request.PUT, instance=grade,files=request.FILES)
  67.         # files=request.FILES  是为了将请求中的文件参数传递进来
  68.         if form.is_valid():
  69.             obj = form.save()  # 保存到数据库
  70.             return JsonResponse({"code": 0, "msg": "操作成功", "id": obj.id})
  71.         return JsonResponse({"code": -1, "msg": form.errors.get_json_data()})
  73.         # model Grade
  75.     def delete(self, request):
  76.          # 实现删除数据功能的 视图模板方法
  77.         id = request.GET.get("id")
  78.         if not id:
  79.             return JsonResponse({"code": -1, "msg": "请传入要修改的id"})
  80.         if not id.isdigit():
  81.             return JsonResponse({"code": -1, "msg": "id是数字"})
  82.         query_set = self.model_class.objects.filter(id=id)
  83.         if not query_set.exists():
  84.             return JsonResponse({"code": -1, "msg": "要修改的id不存在"})
  86.         query_set.delete()
  87.         return JsonResponse({"code": 0, "msg": "删除成功！"})

1.3、视图函数继承视图模板类

  • 使用CBV：Class Based View（基于类的视图）开发
  • 在 CBV 视图类中继承视图模板类即可
    • 继承后，这个视图拥有了视图模板类的 增删改查功能

应用视图文件中，编写视图函数，开发接口

  1. from common.custom_class import ThzView
  2. # 从公共文件夹下的 公共类文件里  导入视图模板类
  4. class StudentView(ThzView): # 实现了学生信息增删改查功能的接口
  5.     # 继承这个 视图模板类
  6.     search_fields = ["name", "phone"] 
  7.     # 指定哪些字段支持模糊查询
  8.     filter_fields = ["id","grade"]
  9.     # 指定哪些字段支持精确查询
  10.     form_class = forms.StudentForm
  11.     # 指定校验的form类
  12.     model_class = models.Student
  13.     # 指定model模型类（接口要操作的数据表）
  15. class GradeView(ThzView): # 实现了班级信息增删改查功能的接口
  16.     search_fields = ["name", "desc"]
  17.     filter_fields = ["id"]
  18.     form_class = forms.GradeForm
  19.     model_class = models.Grade

2、视图模板文件优化（优化版本）

2.1、视图模板类 的优点：

  1. 接口开发更加简便，不用单独编写增删改查接口；
  2. 在对应应用下的 views.py 文件中编写接口视图函数时，直接继承 视图模板类 就可以了
  3. 继承 视图模板类 后，这个视图函数（接口）实现了增删改查（POST、DELETE、PUT、GET）功能
  4. 将模板视图的功能拆分，实现了按需继承（增删改查功能可单独配置）

2.2、视图模板类（优化版）源码

  1. from django.views import View
  2. from django.core.paginator import Paginator
  3. from django.db.models import Q
  4. from django.http.response import JsonResponse
  5. from .utils import model_to_dict
  8. class BaseView(View):   
  9.     # 接口视图模板的基类
  10.     #（必须继承的）
  11.     search_fields = []  # 指定哪些字段支持模糊查询
  12.     filter_fields = []  # 指定哪些字段支持精确查询
  13.     form_class = None   # 指定的form（forms校验 类）
  14.     model_class = None  # 指定的model（模型类）
  17. class GetView:
  18.     # 实现查询接口的 视图模板类（支持分页、模糊/精确查询）
  19.     # （可选继承）
  21.     def get(self, request):
  22.         limit = request.GET.get("limit", 10) # 每页多少条数据
  23.         page = request.GET.get("page", 1)    # 第几页
  24.         search = request.GET.get("search")   # 模糊查询的内容
  26.         query_dict = {}  # {id:1,name:xxx}
  27.         q = Q()  # None
  28.         for field in self.filter_fields:
  29.             value = request.GET.get(field)
  30.             if value != None:
  31.                 query_dict[field] = value
  32.         if search:
  33.             for field in self.search_fields:
  34.                 d = {"%s__contains" % field: search}
  35.                 q = q | Q(**d)
  36.         all_data = self.model_class.objects.filter(**query_dict).filter(q)  
  37.         # 先精确，后模糊
  39.         paginator = Paginator(all_data, limit)
  40.         page_data = paginator.get_page(page)  # [<grade<1>,<garde2>]
  41.         data_list = [model_to_dict(data) for data in page_data]
  42.         data = {"code": 0, "msg": "查询成功", "data": data_list, "count": paginator.count}
  43.         return JsonResponse(data)
  46. class PostView:
  47.     # 实现新增接口的 视图模板类
  48.     # （可选继承）
  49.     def post(self, request):
  50.         form = self.form_class(request.POST,files=request.FILES)
  51.         # files=request.FILES  是为了将请求中的文件参数传递进来
  52.         self.form = form        # 传递进来的数据 添加到实例属性
  53.         if form.is_valid():     # 如果form校验通过
  54.             obj = form.save()   # 保存到数据库
  55.             self.instance = obj # 新增的这一条数据（表记录） 添加到实例属性
  56.             return JsonResponse({"code": 0, "msg": "操作成功", "id": obj.id})
  57.         return JsonResponse({"code": -1, "msg": form.errors.get_json_data()})
  58.         # 优化前 返回form校验的错误信息
  59.         # return JsonResponse({"code": -1, "msg": form.error_msg})
  60.         # 优化后 返回格式化form错误信息
  62.         # form,model
  65. class PutView:
  66.     # 实现修改接口的 视图模板类
  67.     # （可选继承）
  68.     def put(self, request):
  69.         id = str(request.PUT.get("id"))
  70.         if not id:
  71.             return JsonResponse({"code": -1, "msg": "请传入要修改的id"})
  72.         if not id.isdigit():
  73.             return JsonResponse({"code": -1, "msg": "id是数字"})
  75.         query_set = self.model_class.objects.filter(id=id)
  76.         if not query_set.exists():
  77.             return JsonResponse({"code": -1, "msg": "要修改的id不存在"})
  78.         grade = query_set.first()
  80.         form = self.form_class(request.PUT, instance=grade,files=request.FILES)
  81.         # files=request.FILES  是为了将请求中的文件参数传递进来
  82.         self.form = form
  83.         self.instance = query_set.first()
  84.         if form.is_valid():
  85.             obj = form.save()  # 保存到数据库
  86.             return JsonResponse({"code": 0, "msg": "操作成功", "id": obj.id})
  87.         return JsonResponse({"code": -1, "msg": form.errors.get_json_data()})
  89.         # model Grade
  92. class DeleteView:
  93.     # 实现删除接口的 视图模板类
  94.     # （可选继承）
  95.     def delete(self, request):
  96.         id = str(request.GET.get("id"))
  97.         if not id:
  98.             return JsonResponse({"code": -1, "msg": "请传入要修改的id"})
  99.         if not id.isdigit():
  100.             return JsonResponse({"code": -1, "msg": "id是数字"})
  101.         query_set = self.model_class.objects.filter(id=id)
  102.         self.instance  = query_set.first()
  103.         if not query_set.exists():
  104.             return JsonResponse({"code": -1, "msg": "要修改的id不存在"})
  106.         query_set.delete()
  107.         return JsonResponse({"code": 0, "msg": "删除成功！"})
  110. class ThzView(BaseView,PutView,PostView,GetView,DeleteView):
  111.     # 继承了（基类、增删改查类）
  112.     # 实现了增删改查接口的 视图模板类
  113.     # （可选继承）
  114.     pass

2.3、视图函数按需继承视图模板类

应用视图文件中，编写视图函数，开发接口

  1. from common.custom_class import ThzView
  2. # 从公共文件夹下的 公共类文件里  导入视图配置的类
  4. class StudentView(ThzView):# 实现了学生信息增删改查功能的接口
  5.     # 继承这个 视图模板类
  6.     search_fields = ["name", "phone"] 
  7.     # 指定哪些字段支持模糊查询
  8.     filter_fields = ["id","grade"]
  9.     # 指定哪些字段支持精确查询
  10.     form_class = forms.StudentForm
  11.     # 指定校验的form类
  12.     model_class = models.Student
  13.     # 指定model模型类（接口要操作的数据表）
  15. class GradeView(BaseView,GetView,PostView):# 实现了班级信息 查询/新增功能的接口
  16.     # 按需继承 基类、查询、新增功能的类
  17.     search_fields = ["name", "desc"]
  18.     filter_fields = ["id"]
  19.     form_class = forms.GradeForm
  20.     model_class = models.Grade

3、视图模板文件再优化（格式化form错误信息）

  • 新建一个公共代码文件夹 common 文件夹
  • 在 common 文件夹中新建一个公共工具 utils.py文件（名字自定义即可）；

  • 在这个文件中定义一个实现格式化form错误信息类（类名自定义即可）。

    3.1、优化后优点

  • 在需要返回form校验后的出错信息，不用在使用 form.errors.get_json_data() 了；

  • 直接使用 form.error_msg 即可（将多条错误信息合并成一条信息输出，更简洁）；

3.2、格式化错误信息的类源码

  1. class FormatFormError:
  2.     # 格式化form错误信息
  3.     # 用来简化 调用forms校验出错信息 的类
  4.     # 需要在forms 的类中继承这个类
  5.     @property # 属性方法（可以不加括号调用）
  6.     def error_msg(self):
  7.         error_msg_list = []
  8.         error_msg_dict = self.errors.get_json_data()
  9.         for k,v in error_msg_dict.items():
  10.             error_dic  = v[0]
  11.             msg = error_dic.get("message")
  12.             msg = k + msg
  13.             error_msg_list.append(msg)
  14.         return " ".join(error_msg_list)
  15.         #将多条错误信息合并成一条信息输出，更简洁

3.3、使用方法

需要在forms.py文件的类中继承这个类

  1. from . import models
  2. from django import forms
  4. from common.utils import FormatFormError
  7. # 如果form对应了一个model
  8. class GradeForm(forms.ModelForm,FormatFormError):# 继承FormatFormError这个类
  10.     # password2 = forms.CharField(min_length=6,max_length=13)
  11.     # 数据库表中没有的字段，业务上需要校验的字段，可以在这里定义，和普通的form一样
  13.     class Meta:
  14.         model = models.Grade
  15.         fields = "__all__"     # 校验表里面所有字段
  16.         # fields = ["name",""] # 校验表里面哪些字段
  17.         # exclude = []         # 不校验表里哪些字段
  19.     # 如果字段需要单独校验，也可以像普通的form一样 单独 用clean_xxx 去校验
  20.     # def clean_name(self):
  21.     #     name = self.cleaned_data["name"]
  22.     #     if not name.startswith("班级"):
  23.     #         raise forms.ValidationError("班级名需要以“班级”开头")
  24.     #     return name
  26. class StudentForm(forms.ModelForm,FormatFormError):# 继承FormatFormError这个类
  27.     class Meta:
  28.         model = models.Student
  29.         fields = "__all__"

继承后，这个表单验证的类 多了一个error_msg方法，后面再需要返回form的错误信息时，
直接使用 form.error_msg 即可（将多条错误信息合并成一条信息输出，更简洁）

视图模板类（优化版）源码中使用

在视图模板类中的 PostView 实现新增接口的 视图模板类，使用 格式化form错误信息 

  1. from django.views import View
  2. from django.core.paginator import Paginator
  3. from django.db.models import Q
  4. from django.http.response import JsonResponse
  5. from .utils import model_to_dict
  8. class BaseView(View):   
  9.     # 接口视图模板的基类
  10.     #（必须继承的）
  11.     search_fields = []  # 指定哪些字段支持模糊查询
  12.     filter_fields = []  # 指定哪些字段支持精确查询
  13.     form_class = None   # 指定的form（forms校验 类）
  14.     model_class = None  # 指定的model（模型类）
  17. class GetView:
  18.     # 实现查询接口的 视图模板类（支持分页、模糊/精确查询）
  19.     # （可选继承）
  21.     def get(self, request):
  22.         limit = request.GET.get("limit", 10) # 每页多少条数据
  23.         page = request.GET.get("page", 1)    # 第几页
  24.         search = request.GET.get("search")   # 模糊查询的内容
  26.         query_dict = {}  # {id:1,name:xxx}
  27.         q = Q()  # None
  28.         for field in self.filter_fields:
  29.             value = request.GET.get(field)
  30.             if value != None:
  31.                 query_dict[field] = value
  32.         if search:
  33.             for field in self.search_fields:
  34.                 d = {"%s__contains" % field: search}
  35.                 q = q | Q(**d)
  36.         all_data = self.model_class.objects.filter(**query_dict).filter(q)  
  37.         # 先精确，后模糊
  39.         paginator = Paginator(all_data, limit)
  40.         page_data = paginator.get_page(page)  # [<grade<1>,<garde2>]
  41.         data_list = [model_to_dict(data) for data in page_data]
  42.         data = {"code": 0, "msg": "查询成功", "data": data_list, "count": paginator.count}
  43.         return JsonResponse(data)
  46. class PostView:
  47.     # 实现新增接口的 视图模板类
  48.     # （可选继承）
  49.     def post(self, request):
  50.         form = self.form_class(request.POST,files=request.FILES)
  51.         # files=request.FILES  是为了将请求中的文件参数传递进来
  52.         self.form = form        # 传递进来的数据 添加到实例属性
  53.         if form.is_valid():     # 如果form校验通过
  54.             obj = form.save()   # 保存到数据库
  55.             self.instance = obj # 新增的这一条数据（表记录） 添加到实例属性
  56.             return JsonResponse({"code": 0, "msg": "操作成功", "id": obj.id})
  57.         # return JsonResponse({"code": -1, "msg": form.errors.get_json_data()})
  58.         # （优化前的 返回form错误信息）
  59.         return JsonResponse({"code": -1, "msg": form.error_msg})
  60.         # （优化后的 返回form错误信息）
  61.         # （看这里！！！！！！！！！！！！！！！！！！！！！！！！！！！！！）
  62.         # 返回格式化form错误信息！！！！！！！！！！！！！！！！！！！！！！！
  67. class PutView:
  68.     # 实现修改接口的 视图模板类
  69.     # （可选继承）
  70.     def put(self, request):
  71.         id = str(request.PUT.get("id"))
  72.         if not id:
  73.             return JsonResponse({"code": -1, "msg": "请传入要修改的id"})
  74.         if not id.isdigit():
  75.             return JsonResponse({"code": -1, "msg": "id是数字"})
  77.         query_set = self.model_class.objects.filter(id=id)
  78.         if not query_set.exists():
  79.             return JsonResponse({"code": -1, "msg": "要修改的id不存在"})
  80.         grade = query_set.first()
  82.         form = self.form_class(request.PUT, instance=grade,files=request.FILES)
  83.         # files=request.FILES  是为了将请求中的文件参数传递进来
  84.         self.form = form
  85.         self.instance = query_set.first()
  86.         if form.is_valid():
  87.             obj = form.save()  # 保存到数据库
  88.             return JsonResponse({"code": 0, "msg": "操作成功", "id": obj.id})
  89.         #return JsonResponse({"code": -1, "msg": form.errors.get_json_data()})
  90.         # （优化前的 返回form错误信息）
  91.         return JsonResponse({"code": -1, "msg": form.error_msg})
  92.         # （优化后的 返回form错误信息）
  93.         # （看这里！！！！！！！！！！！！！！！！！！！！！！！！！！！！！）
  94.         # 返回格式化form错误信息！！！！！！！！！！！！！！！！！！！！！！！
  96.         # model Grade
  99. class DeleteView:
  100.     # 实现删除接口的 视图模板类
  101.     # （可选继承）
  102.     def delete(self, request):
  103.         id = str(request.GET.get("id"))
  104.         if not id:
  105.             return JsonResponse({"code": -1, "msg": "请传入要修改的id"})
  106.         if not id.isdigit():
  107.             return JsonResponse({"code": -1, "msg": "id是数字"})
  108.         query_set = self.model_class.objects.filter(id=id)
  109.         self.instance  = query_set.first()
  110.         if not query_set.exists():
  111.             return JsonResponse({"code": -1, "msg": "要修改的id不存在"})
  113.         query_set.delete()
  114.         return JsonResponse({"code": 0, "msg": "删除成功！"})
  117. class ThzView(BaseView,PutView,PostView,GetView,DeleteView):
  118.     # 继承了（基类、增删改查类）
  119.     # 实现了增删改查接口的 视图模板类
  120.     # （可选继承）
  121.     pass

4、视图模板文件再优化（优化JsonResponse）

4.1、优化后优点

  • 每次返回响应不用再单独写一个字典了，例如 return JsonResponse({“code”: 0, “msg”: “删除成功！”})
  • 简化代码

4.2、优化JsonResponse 的源码

  1. from django.http.response import JsonResponse
  3. # 优化JsonResponse的函数
  4. # 优化后，返回响应时  不用每次定义一个字典了
  5. def ThzResponse(code=0, msg="操作成功", **kwargs):
  6.     data = {"code": code, "msg": msg}
  7.     data.update(kwargs)
  8.     return JsonResponse(data, json_dumps_params={"ensure_ascii": False})

4.3、视图模板类中使用

  1. from django.views import View
  2. from django.core.paginator import Paginator
  3. from django.db.models import Q
  4. from common.utils import model_to_dict,ThzResponse # 导入优化后的JsonResponse
  8. class BaseView(View):
  9.     search_fields = []  # 指定哪些字段支持模糊查询
  10.     filter_fields = []
  11.     form_class = None  # 指定的form
  12.     model_class = None  # 指定的model
  15. class GetView:
  17.     def get(self, request):
  18.         limit = request.GET.get("limit", 10)
  19.         page = request.GET.get("page", 1)
  20.         search = request.GET.get("search")
  22.         query_dict = {}  # {id:1,name:xxx}
  23.         q = Q()  # None
  24.         for field in self.filter_fields:
  25.             value = request.GET.get(field)
  26.             if value != None:
  27.                 query_dict[field] = value
  28.         if search:
  29.             for field in self.search_fields:
  30.                 d = {"%s__contains" % field: search}
  31.                 q = q | Q(**d)
  32.         all_data = self.model_class.objects.filter(**query_dict).filter(q)  # 先精确，后模糊
  34.         paginator = Paginator(all_data, limit)
  35.         page_data = paginator.get_page(page)  # [<grade<1>,<garde2>]
  36.         data_list = [model_to_dict(data) for data in page_data]
  37.         return ThzResponse(data=data_list,count=paginator.count)
  38.         # 优化后，返回响应时  不用每次定义一个字典了
  41. class PostView:
  42.     def post(self, request):
  43.         form = self.form_class(request.POST,files=request.FILES)
  44.         # files=request.FILES  是为了将请求中的文件参数传递进来
  45.         self.form = form
  46.         if form.is_valid(): #false
  47.             obj = form.save()  # 保存到数据库
  48.             self.instance = obj #新增的这一条数据
  49.             return ThzResponse(id=obj.id)
  50.             # 优化后，返回响应时  不用每次定义一个字典了
  51.         return ThzResponse(-1,form.error_msg)
  52.         # 优化后，返回响应时  不用每次定义一个字典了
  54.         # form,model
  57. class PutView:
  58.     def put(self, request):
  59.         id = str(request.PUT.get("id"))
  60.         if not id:
  61.             return ThzResponse(-1,"请传入要修改的id")
  62.             # 优化后，返回响应时  不用每次定义一个字典了
  63.         if not id.isdigit():
  64.             return ThzResponse(-1,"id是数字")
  65.             # 优化后，返回响应时  不用每次定义一个字典了
  67.         query_set = self.model_class.objects.filter(id=id)
  68.         if not query_set.exists():
  69.             return ThzResponse(-1, "要修改的id不存在")
  70.             # 优化后，返回响应时  不用每次定义一个字典了
  71.         grade = query_set.first()
  73.         form = self.form_class(request.PUT, instance=grade,files=request.FILES)
  74.         # files=request.FILES  是为了将请求中的文件参数传递进来
  75.         self.form = form
  76.         self.instance = query_set.first()
  77.         if form.is_valid():
  78.             obj = form.save()  # 保存到数据库
  79.             return ThzResponse(id=obj.id)
  80.         return ThzResponse(-1,form.error_msg)
  81.         # 优化后，返回响应时  不用每次定义一个字典了
  83.         # model Grade
  86. class DeleteView:
  87.     def delete(self, request):
  88.         id = str(request.GET.get("id"))
  89.         if not id:
  90.             return ThzResponse(-1,"请传入要修改的id")
  91.             # 优化后，返回响应时  不用每次定义一个字典了
  92.         if not id.isdigit():
  93.             return ThzResponse(-1,"id是数字")
  94.             # 优化后，返回响应时  不用每次定义一个字典了
  95.         query_set = self.model_class.objects.filter(id=id)
  96.         self.instance  = query_set.first()
  97.         if not query_set.exists():
  98.             return ThzResponse(-1, "要修改的id不存在")
  99.             # 优化后，返回响应时  不用每次定义一个字典了
  101.         query_set.delete()
  102.         return ThzResponse()
  103.         # 优化后，返回响应时  不用每次定义一个字典了
  106. class ThzView(BaseView,PutView,PostView,GetView,DeleteView):
  107.     pass