全局参数（get，post，put，delete）
接口：/api/parameter
GET：获取全局参数的所有数据
POST：创建全局参数
PUT：更新全局参数
DELETE：删除全局参数
1.创建app
python manage.py startapp example
2.models.py
1 from django.db import models 2 3 4 # Create your models here. 5 class BaseModel(models.Model): 6 '''公共字段''' 7 is_delete_choice = ( 8 (1, '删除'), 9 (0, '正常') 10 ) 11 is_delete = models.SmallIntegerField(choices=is_delete_choice, default=0, verbose_name='是否被删除') 12 create_time = models.DateTimeField(verbose_name='创建时间', auto_now_add=True) # auto_now_add的意思，插入数据的时候，自动取当前时间 13 update_time = models.DateTimeField(verbose_name='修改时间', auto_now=True) # 修改数据的时候，时间会自动变 14 15 class Meta: 16 abstract = True # 只是用来继承的,不会创建这个表 17 18 19 #全局参数model 20 class Parameter(BaseModel): 21 name = models.CharField(verbose_name='参数名',max_length=200,unique=True) 22 desc = models.CharField(verbose_name='描述', max_length=200) 23 value = models.CharField(verbose_name='参数值', max_length=200) 24 25 def __str__(self): 26 return self.name 27 28 class Meta: 29 db_table = 'parameter' 30 verbose_name = '全局参数信息表' 31 verbose_name_plural = verbose_name 32 #最后创建的在最上面 33 ordering = ['-id']#根据id降序排序
创建表，执行以下命令
python manage.py makemigrations example --指定app生成表的初始化文件
python manage.py migrate example --指定app创建表
3.example/urls.py
1 from django.urls import path 2 from .views import f_parameter,Parameter,SParameter 3 4 urlpatterns = [ 5 # FBV 6 path('parameter',f_parameter), 7 #CBV 8 path('c_parameter',Parameter.as_view()), 9 #简化代码 10 path('s_parameter',SParameter.as_view()),
4.项目的urls.py
1 from django.contrib import admin 2 from django.urls import path,include 3 #引入example中的urls 4 from example import urls 5 6 urlpatterns = [ 7 path('admin/', admin.site.urls), 8 #include是引入其他app的urls，每个请求都要加上api/ 9 path('api/',include(urls)), 10 ]
5.views.py
5.1 FBV模式 func base view
1 # FBV func base view 2 #用函数实现的view 3 def f_parameter(request): 4 data = {'name':'zzl','age':18} 5 if request.method == 'GET': 6 page = request.GET.get('page')#获取前台返回的第几页数据 7 qs = models.Parameter.objects.filter(is_delete=0)#查询出未删除的参数 8 page_obj = Paginator(qs,5) 9 page_data = page_obj.get_page(page)#获取分页的数据 10 data_list = [] 11 for data in page_data: 12 #model_to_dict(data,exclude=['is_delete']) 13 # fields:包含哪些字段， 14 # exclude：排除哪些字段 15 # django自带model_to_dict 不处理时间，用自己重写的model_to_dict 16 data_list.append(model_to_dict(data,exclude=['is_delete']))#将qs转成dict并放入list中 17 return JsonResponse({'msg':0,'data':data_list}) 18 elif request.method == 'POST': 19 form_obj = forms.ParameterForm(request.POST) 20 f = form_obj.is_valid() 21 if f: 22 models.Parameter.objects.create(**form_obj.cleaned_data)#插入数据 23 return JsonResponse({'code':200,'msg':'成功'}) 24 else: 25 return JsonResponse({'code':500,'msg':form_obj.errors.get_json_data()}) 26 elif request.method == 'PUT': 27 #django并没有处理PUT的数据 request.PUT 28 #实际put传过来的数据在request.body里 29 #request.body的数据不可用，要导入from django.http import QueryDict，来处理数据 30 #更新数据，需要告知，要更新哪条数据 31 put_data = QueryDict(request.body) 32 print('put_data',put_data) 33 34 p_id = put_data.get('id')#获取前端传过来的数据的id 35 print('p_id',p_id) 36 p_data = models.Parameter.objects.get(id=p_id) 37 38 #参数1是前端传过来的，参数2是数据库中获取的 39 form_obj = forms.ParameterForm(put_data,instance=p_data) 40 41 if form_obj.is_valid(): 42 form_obj.save()#如果数据校验通过，就通过form_obj.save方法来更新数据 43 return JsonResponse({'code': 200, 'msg': '成功'}) 44 else: 45 return JsonResponse({'code': 500, 'msg': form_obj.errors.get_json_data()}) 46 elif request.method == 'DELETE': 47 #删除要先确定是删除哪条数据，需要获取id 48 #删除有1，逻辑删除 2，物理删除 49 #1，逻辑删除：只是通过改变某个字段的状态，重要的数据，有可能在未来通过状态再改回来 50 #2，物理删除，数据不重要，直接delete掉 51 p_id = request.GET.get('id') 52 print(p_id) 53 #逻辑删除 54 #models.Parameter.objects.filter(id=p_id).update(is_delete = 1) #这种更新方式不会触发update_time更新 55 # p_obj = models.Parameter.objects.filter(id=p_id).first() 56 # print(p_obj) 57 # p_obj.is_delete = 1 58 # p_obj.save()#这种方式可以触发update_time更新 59 60 #物理删除 61 models.Parameter.objects.filter(id=p_id).delete()#删除数据 62 63 return JsonResponse({'msg':'delete'}) 64 else: 65 return JsonResponse({'msg':'error'})
5.2 CBV模式 class base view
1 #CBV class base view 2 #面向对象的语言，通过class，可以用到继承 多继承 面向对象 3 class Parameter(View): 4 def get(self,request): 5 page = request.GET.get('page') # 获取前台返回的第几页数据 6 qs = models.Parameter.objects.filter(is_delete=0) # 查询出未删除的参数 7 page_obj = Paginator(qs, 5) 8 page_data = page_obj.get_page(page) # 获取分页的数据 9 data_list = [] 10 for data in page_data: 11 # model_to_dict(data,exclude=['is_delete']) 12 # fields:包含哪些字段， 13 # exclude：排除哪些字段 14 # django自带model_to_dict 不处理时间，用自己重写的model_to_dict 15 data_list.append(model_to_dict(data, exclude=['is_delete'])) # 将qs转成dict并放入list中 16 return JsonResponse({'msg': 0, 'data': data_list}) 17 18 def post(self,request): 19 form_obj = forms.ParameterForm(request.POST) 20 f = form_obj.is_valid() 21 if f: 22 models.Parameter.objects.create(**form_obj.cleaned_data) # 插入数据 23 return JsonResponse({'code': 200, 'msg': '成功'}) 24 else: 25 return JsonResponse({'code': 500, 'msg': form_obj.errors.get_json_data()}) 26 27 def put(self,request): 28 # django并没有处理PUT的数据 request.PUT 29 # 实际put传过来的数据在request.body里 30 # request.body的数据不可用，要导入from django.http import QueryDict，来处理数据 31 # 更新数据，需要告知，要更新哪条数据 32 put_data = QueryDict(request.body) 33 print('put_data', put_data) 34 35 p_id = put_data.get('id') # 获取前端传过来的数据的id 36 print('p_id', p_id) 37 p_data = models.Parameter.objects.get(id=p_id) 38 39 # 参数1是前端传过来的，参数2是数据库中获取的 40 form_obj = forms.ParameterForm(put_data, instance=p_data) 41 42 if form_obj.is_valid(): 43 form_obj.save() # 如果数据校验通过，就通过form_obj.save方法来更新数据 44 return JsonResponse({'code': 200, 'msg': '成功'}) 45 else: 46 return JsonResponse({'code': 500, 'msg': form_obj.errors.get_json_data()}) 47 48 def delete(self,request): 49 # 删除要先确定是删除哪条数据，需要获取id 50 # 删除有1，逻辑删除 2，物理删除 51 # 1，逻辑删除：只是通过改变某个字段的状态，重要的数据，有可能在未来通过状态再改回来 52 # 2，物理删除，数据不重要，直接delete掉 53 p_id = request.GET.get('id') 54 print(p_id) 55 # 逻辑删除 56 # models.Parameter.objects.filter(id=p_id).update(is_delete = 1) #这种更新方式不会触发update_time更新 57 # p_obj = models.Parameter.objects.filter(id=p_id).first() 58 # print(p_obj) 59 # p_obj.is_delete = 1 60 # p_obj.save()#这种方式可以触发update_time更新 61 62 # 物理删除 63 models.Parameter.objects.filter(id=p_id).delete() # 删除数据 64 65 return JsonResponse({'msg': 'delete'})
5.3 CBV模式 代码优化
5.3.1 custom_view.py
1 #重写model_to_dict 2 import datetime 3 from itertools import chain 4 5 from django.core.paginator import Paginator 6 from django.db.models import Model, Q 7 from django.forms import BaseForm 8 from django.http import JsonResponse, QueryDict 9 from django.views import View 10 from .custom_response import NbResponse 11 12 from example import models 13 14 15 def model_to_dict(instance, fields=None, exclude=None): 16 opts = instance._meta 17 data = {} 18 for f in chain(opts.concrete_fields, opts.private_fields, opts.many_to_many): 19 if fields and f.name not in fields: 20 continue 21 if exclude and f.name in exclude: 22 continue 23 value = f.value_from_object(instance) 24 if isinstance(value, datetime.datetime): 25 value = value.strftime('%Y-%m-%d %H:%M:%S') 26 if isinstance(value, datetime.date): 27 value = value.strftime('%Y-%m-%d') 28 data[f.name] = value 29 return data 30 31 class BaseView(View): 32 search_fields = []#定义需要模糊搜素的字段 33 filter_fields = []#定义需要搜索的字段 34 model_class = None 35 fields = [] #指定返回的字段 36 exclude_fields = [] #指定返回时过滤的字段 37 form_class = None 38 39 @property#修饰方法，使方法可以像属性一样访问 40 def model(self): 41 #issubclass 参数1是否为参数2的子类 42 if self.model_class and issubclass(self.model_class,Model): 43 return self.model_class 44 raise Exception('未定义model_class') 45 46 @property # 修饰方法，使方法可以像属性一样访问 47 def form(self): 48 # issubclass 参数1是否为参数2的子类 49 if self.form_class and issubclass(self.form_class, BaseForm): 50 return self.form_class 51 raise Exception('未定义form_class') 52 53 def get_filter_dict(self): 54 filter_dict = {} 55 for field in self.filter_fields: 56 filter_value = self.request.GET.get(field)#获取前端传过来的值 57 if filter_value: 58 filter_dict[field] = filter_value 59 return filter_dict 60 61 #只支持一个字段的模糊查询 62 def get_search_dict(self): 63 search_dict = {} 64 value = self.request.GET.get('search')#获取前台传过来的字段 65 if value: 66 search_dict = {'%s__contains'%self.search_fields[0] : value} 67 print(search_dict) 68 return search_dict 69 70 #支持多个字段的模糊查询 71 def get_search_dict_or(self): 72 value = self.request.GET.get('search') 73 q = Q() 74 if value: 75 for field in self.search_fields: 76 d = {'%s__contains'%field : value} 77 q = Q(**d) | q 78 return q 79 80 81 class GetView(BaseView): 82 def get(self,request): 83 page = request.GET.get('page') # 获取前台返回的第几页数据 84 filter_dict = self.get_filter_dict()#获取需要搜索的字典 85 # search_dict = self.get_search_dict()#获取需要模糊查询的字典 86 # qs = self.model.objects.filter(is_delete=0).filter(**filter_dict).filter(**search_dict) # 查询出未删除的参数 87 search_q = self.get_search_dict_or()#获取需要模糊查询的q 88 qs = self.model.objects.filter(is_delete=0).filter(**filter_dict).filter(search_q) # 查询出未删除的参数 89 page_obj = Paginator(qs, 5) 90 page_data = page_obj.get_page(page) # 获取分页的数据 91 data_list = [] 92 for data in page_data: 93 # model_to_dict(data,exclude=['is_delete']) 94 # fields:包含哪些字段， 95 # exclude：排除哪些字段 96 # django自带model_to_dict 不处理时间，用自己重写的model_to_dict 97 data_list.append(model_to_dict(data, fields=self.fields,exclude=self.exclude_fields)) # 将qs转成dict并放入list中 98 return NbResponse(data=data_list) 99 100 101 class PostView(BaseView): 102 def post(self,request): 103 form_obj = self.form(request.POST) 104 f = form_obj.is_valid() 105 if f: 106 self.model.objects.create(**form_obj.cleaned_data) # 插入数据 107 return NbResponse() 108 else: 109 # return JsonResponse({'code': 500, 'msg': form_obj.errors.get_json_data()}) 110 return NbResponse(code=500,msg=form_obj.errors.get_json_data()) 111 112 113 class PutView(BaseView): 114 def put(self,request): 115 # django并没有处理PUT的数据 request.PUT 116 # 实际put传过来的数据在request.body里 117 # request.body的数据不可用，要导入from django.http import QueryDict，来处理数据 118 # 更新数据，需要告知，要更新哪条数据 119 120 p_id = request.PUT.get('id') # 获取前端传过来的数据的id 121 print('p_id', p_id) 122 p_data = models.Parameter.objects.get(id=p_id) 123 124 # 参数1是前端传过来的，参数2是数据库中获取的 125 form_obj = self.form(request.PUT, instance=p_data) 126 127 if form_obj.is_valid(): 128 form_obj.save() # 如果数据校验通过，就通过form_obj.save方法来更新数据 129 return JsonResponse({'code': 200, 'msg': '成功'}) 130 else: 131 return JsonResponse({'code': 500, 'msg': form_obj.errors.get_json_data()}) 132 133 134 class DeleteView(BaseView): 135 def delete(self,request): 136 # 删除要先确定是删除哪条数据，需要获取id 137 # 删除有1，逻辑删除 2，物理删除 138 # 1，逻辑删除：只是通过改变某个字段的状态，重要的数据，有可能在未来通过状态再改回来 139 # 2，物理删除，数据不重要，直接delete掉 140 p_id = request.GET.get('id') 141 print(p_id) 142 # 逻辑删除 143 # models.Parameter.objects.filter(id=p_id).update(is_delete = 1) #这种更新方式不会触发update_time更新 144 # p_obj = models.Parameter.objects.filter(id=p_id).first() 145 # print(p_obj) 146 # p_obj.is_delete = 1 147 # p_obj.save()#这种方式可以触发update_time更新 148 149 # 物理删除 150 self.model.objects.filter(id=p_id).delete() # 删除数据 151 152 return JsonResponse({'msg': 'delete'}) 153 154 155 class NbView(GetView,PostView,PutView,DeleteView): 156 pass
5.3.2 views.py
1 #简化代码--全局参数 2 class SParameter(NbView): 3 # 抽象出不同的地方，让相同的地方复用 4 model_class = models.Parameter#重写了父类的变量 5 #fields = ['name'] 6 exclude_fields = ['is_delete'] 7 filter_fields = ['value'] #搜索字段 8 search_fields = ['name','desc'] #模糊查询字段 9 form_class = forms.ParameterForm
6.myMiddleWires.py
当请求方式为PUT时，参数是在request.body中获取，且是经过编码后的，获取参数不方便
可以在中间件请求拦截器中，识别请求方式为PUT时，将参数转为request.put
1 from django.middleware.common import MiddlewareMixin 2 from django.http import HttpResponse,QueryDict 3 from sky.settings import DEBUG 4 from example.custom_response import NbResponse 5 6 class PutMethodMiddlerware(MiddlewareMixin): 7 def process_request(self,request): 8 if request.method == 'PUT': 9 request.PUT = QueryDict(request.body) 10 11 12 #出现异常时抛出异常 13 class ExceptionMiddleware(MiddlewareMixin): 14 def process_exception(self,request,exception): 15 if not DEBUG:#上线之后，直接将错误返回，未上线不做拦截，控制台可看 16 #拦截异常的 17 return NbResponse(code=500,msg='系统开小差了，请联系管理员...%s'%exception)
7.custom_response.py
JsonResponse返回json字符串时，如果每次需要返回固定的字段，可以重写JsonResponse里的方法
1 from django.http import JsonResponse 2 3 4 class NbResponse(JsonResponse): 5 def __init__(self,code=200,msg='操作成功',**kwargs): 6 data = {'code':code,'msg':msg} 7 data.update(kwargs) 8 super().__init__(data=data,json_dumps_params={"ensure_ascii": False})