django进阶-优快云博客

本文详细介绍了 Django 框架中多对多关系的创建和使用方法，包括自定义关联表和自动创建关系表两种方式。此外还讲解了如何通过视图函数进行数据库操作，如分页、获取用户请求头信息等。文中还涉及了 session 和 cookie 的使用，以及 CSRF 攻击防御措施。

，多对多：
创建多对多：
方式一：自定义关系表

class Host(models.Model):
    nid=models.AutoField(primary_key=True)
    hostname=models.CharField(max_length=32,db_index=True)
    ip=models.GenericIPAddressField(db_index=True)
    port=models.IntegerField()
    b=models.ForeignKey('Business',to_field='id')

#自定义关联
class HostToApp(models.Model):
     hobj=models.ForeignKey(to='Host',to_fields='nid')
     aobj=models.ForeignKey(to='Application',to_fields='id')

对表的操作和foreignkey一样，并且可以直接对这个表进行操作
HostToApp.objects.create(hobj_id=1,aobj_id=2)

方式二：自动创建关系表

 1 class Host(models.Model):
 2     nid=models.AutoField(primary_key=True)
 3     hostname=models.CharField(max_length=32,db_index=True)
 4     ip=models.GenericIPAddressField(db_index=True)
 5     port=models.IntegerField()
 6     b=models.ForeignKey('Business',to_field='id')
 7 
 8 class Application(models.Model):
 9       name=models.CharField(max_length=64)
10       auto=models.ManyToManyField("Host")

缺点就是无法直接对第三张表进行操作，只能间接的方式来操作并且也无法在这个表增加多余字段
#现获取对象
obj = Application.objects.get(id=1)

# 然后间接操作第三张表中的内容

#增加
obj.r.add(1)#Application=1 host=1 obj中已经存在了app id 所以这里的add=1就是host表中的id
obj.r.add(2)#Application=1 host=2
obj.r.add(2,3,4)#Application=1 host=2/3/4
obj.r.add(*[1,2,3,4])

#移除
obj.r.remove(1)
obj.r.remove(2,4)
obj.r.remove(*[1,2,3])

#清空obj中的app id =1的所有内容
obj.r.clear()

#更新
obj.r.set([3,5,7])

# 所有相关的主机对象“列表” QuerySet
obj.r.all()

增删改查例子　　

def app(reques):
    obj=models.Application.objects.all()
    print(obj)
    for i in obj:
        #查询
        print(i.name,i.auto.all())

    #增加app项目并且返回这个obj对象
    #obj=models.Application.objects.create(name='oracle')
    #增加1,3,4host到app
    #obj.auto.add(*[1,4,3])


    #删除
    # obj=models.Application.objects.get(id=1)
    # obj.auto.remove(1)
    # return render(reques,'app.html',{'obj':obj})
    return HttpResponse("ok")

获取用户请求头

def test(request):
    #查看源码
    #<class 'django.core.handlers.wsgi.WSGIRequest'>
    from django.core.handlers.wsgi import WSGIRequest
    print(type(request))
    #查询
    for x,v in request.environ.items():
        print(x,v)
    return HttpResponse("Ok")

结果(用到最多的就是HTTP_USER_AGENT，判断客户端用的什么设备类型)：

 1 ('TMP', 'C:\\Users\\ADMIN~1.MEN\\AppData\\Local\\Temp')
 2 ('PYTHONIOENCODING', 'UTF-8')
 3 ('COMPUTERNAME', 'MENKEYI')
 4 ('wsgi.multiprocess', False)
 5 ('PROCESSOR_LEVEL', '6')
 6 ('RUN_MAIN', 'true')
 7 ('HTTP_COOKIE', 'csrftoken=mjMaE6agb2Si4NrdFacQpUIkviQIFv3C; _ga=GA1.1.627222119.1494076915; Hm_lvt_a033dafefef77193d4d80cc7103c9772=1493689044,1494076914,1494228704,1'494597132')
 8 ('USERDOMAIN', xxxxxxxx')
 9 ('GOROOT', 'C:\\Go\\app')
10 ('SERVER_PROTOCOL', 'HTTP/1.1')
11 ('SERVER_SOFTWARE', 'WSGIServer/0.1 Python/2.7.9')
12 ('PSMODULEPATH', 'C:\\Windows\\system32\\WindowsPowerShell\\v1.0\\Modules\\')
13 ('SCRIPT_NAME', u'')
14 ('COMMONPROGRAMFILES', 'C:\\Program Files\\Common Files')
15 ('PROCESSOR_IDENTIFIER', 'Intel64 Family 6 Model 70 Stepping 1, GenuineIntel')
16 ('REQUEST_METHOD', 'GET')
17 ('wsgi.version', (1, 0))
18 ('PROGRAMFILES', 'C:\\Program Files')
19 ('PROCESSOR_REVISION', '4601')
20 ('SYSTEMROOT', 'C:\\Windows')
21 ('QUERY_STRING', '')
22 ('PATH', 'C:\\ProgramData\\Oracle\\Java\\javapath;C:\\Program Files (x86)\\Common Files\\NetSarang;C:\\Program Files (x86)\\Intel\\iCLS Client\\;C:\\Program Files\\Intel\\iCLS Client\\;C:\\Windows\\system32;C:\\Windows;C:\\Windows\\System32\\Wbem;C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\;C:\\Program Files\\Intel\\Intel(R) Management Engine Components\\DAL;C:\\Program Files\\Intel\\Intel(R) Management Engine Components\\IPT;C:\\Program Files (x86)\\Intel\\Intel(R) Management Engine Components\\DAL;C:\\Program Files (x86)\\Intel\\Intel(R) Management Engine Components\\IPT;C:\\Program Files\\Intel\\WiFi\\bin\\;C:\\Program Files\\Common Files\\Intel\\WirelessCommon\\;C:\\Program Files\\Hewlett-Packard\\SimplePass\\;C:\\Program Files\\Microsoft SQL Server\\110\\Tools\\Binn\\;C:\\Python27;C:\\Python27\\Scripts;C:\\Program Files (x86)\\MySQL\\MySQL Server 5.5\\bin;C:\\Python27\\Lib\\site-packages\\Django-1.7.7-py2.7.egg\\django\\bin;C:\\Program Files (x86)\\IDM Computer Solutions\\UltraEdit;C:\\Program Files\\Windows Imaging\\;C:\\Program Files (x86)\\OpenVPN\\bin;C:\\Program Files\\Git\\cmd;C:\\Go\\bin;d:\\Program Files (x86)\\erl5.10.4\\bin;D:\\Program Files (x86)\\RabbitMQ Server\\rabbitmq_server-3.2.4\\sbin')
23 ('PYTHONUNBUFFERED', '1')
24 ('PROGRAMFILES(X86)', 'C:\\Program Files (x86)')
25 ('#ENVKKPRBC_CMDILNE', '')
26 ('CONTENT_LENGTH', '')
27 ('HTTP_UPGRADE_INSECURE_REQUESTS', '1')
28 ('HTTP_CACHE_CONTROL', 'max-age=0')
29 ('HTTP_CONNECTION', 'keep-alive')
30 ('REMOTE_HOST', '')
31 ('TEMP', 'C:\\Users\\ADMIN~1.MEN\\AppData\\Local\\Temp')
32 ('REMOTE_ADDR', '127.0.0.1')
33 ('COMMONPROGRAMFILES(X86)', 'C:\\Program Files (x86)\\Common Files')
34 ('#ENVTSLOGRBCSHELLEXT3340', '64101024')
35 ('PROCESSOR_ARCHITECTURE', 'AMD64')
36 ('wsgi.url_scheme', 'http')
37 ('ALLUSERSPROFILE', 'C:\\ProgramData')
38 ('SHELLLAUNCH{A81BA54B-CCFE-4204-8E79-A68C0FDFA5CF}', 'ShellExt')
39 ('LOCALAPPDATA', 'C:\\Users\\admin.menkeyi\\AppData\\Local')
40 ('HOMEPATH', '\\Users\\admin.menkeyi')
41 ('USERDOMAIN_ROAMINGPROFILE', 'xxxxxx')
42 ('VS120COMNTOOLS', 'D:\\Program Files (x86)\\Microsoft Visual Studio 12.0\\Common7\\Tools\\')
43 ('ERLANG_HOME', 'd:\\Program Files (x86)\\erl5.10.4')
44 ('USERNAME', 'admin')
45 ('HTTP_ACCEPT', 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8')
46 ('#ENVTSLOGSSS3340', '64102944')
47 ('LOGONSERVER', '\\\\MENKEYI')
48 ('COMSPEC', 'C:\\Windows\\system32\\cmd.exe')
49 ('PROGRAMDATA', 'C:\\ProgramData')
50 ('wsgi.file_wrapper', <class wsgiref.util.FileWrapper at 0x0000000003A08E88>)
51 ('PYTHONPATH', 'E:\\mydjango')
52 ('RABBITMQ_SERVER', 'D:\\Program Files (x86)\\RabbitMQ Server')
53 ('wsgi.multithread', True)
54 ('wsgi.input', <socket._fileobject object at 0x0000000003C0AA20>)
55 ('HTTP_USER_AGENT', 'Mozilla/5.0 (Windows NT 6.3; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.81 Safari/537.36')
56 ('HTTP_HOST', '127.0.0.1:8000')
57 ('SESSIONNAME', 'Console')
58 ('PATHEXT', '.COM;.EXE;.BAT;.CMD;.VBS;.VBE;.JS;.JSE;.WSF;.WSH;.MSC')
59 ('PATH_INFO', u'/app01/test/')
60 ('FP_NO_HOST_CHECK', 'NO')
61 ('WINDIR', 'C:\\Windows')
62 ('#ENVTSLOGTSLOG3340', '64101664')
63 ('HTTP_ACCEPT_ENCODING', 'gzip, deflate, sdch, br')
64 ('SERVER_PORT', '8000')
65 ('MOZ_PLUGIN_PATH', 'C:\\Program Files (x86)\\Foxit Software\\Foxit Reader\\plugins\\')
66 ('HOMEDRIVE', 'C:')
67 ('SERVER_NAME', 'axxxxxi')
68 ('wsgi.run_once', False)
69 ('#ENVTSLOGXMEDIALIBRARY3340', '280591264')
70 ('SYSTEMDRIVE', 'C:')
71 ('GATEWAY_INTERFACE', 'CGI/1.1')
72 ('HTTP_ACCEPT_LANGUAGE', 'zh-CN,zh;q=0.8')
73 ('PYCHARM_HOSTED', '1')
74 ('NUMBER_OF_PROCESSORS', '8')
75 ('APPDATA', 'C:\\Users\\admin.menkeyi\\AppData\\Roaming')
76 ('DJANGO_SETTINGS_MODULE', 'mydjango.settings')
77 ('PROGRAMW6432', 'C:\\Program Files')
78 ('CONTENT_TYPE', 'text/plain')
79 ('wsgi.errors', <open file '<stderr>', mode 'w' at 0x00000000020FB150>)
80 ('COMMONPROGRAMW6432', 'C:\\Program Files\\Common Files')
81 ('OS', 'Windows_NT')
82 ('PUBLIC', 'C:\\Users\\Public')
83 ('USERPROFILE', 'C:\\Users\\admin')

View Code

分页(手动写)

view

  1 def user_list(request):
  2     #模拟数据库数据
  3     users=range(200)
  4 
  5     #从前端接受过来的都是字符串,request.GET.get('p',1)如果p为空那么值为1
  6     #获取当前页
  7     curr_pager_num=int(request.GET.get('p',1))
  8 
  9     #每个页面显示几条数据
 10     page_data_num=10
 11 
 12 
 13 
 14     #开始索引
 15     start=(curr_pager_num-1)*page_data_num
 16     #结束索引
 17     end=curr_pager_num*page_data_num
 18     #根据star和end做页面数据切分
 19     data=users[start:end]
 20 
 21     #获取数据总页数
 22     all_count=len(users)
 23 
 24     #计算分页数量
 25     total_count,y=divmod(all_count,page_data_num)
 26     #y>1分页就总数就加1
 27     if y:
 28         total_count += 1
 29 
 30     #存储分页内容列表
 31     page_str_list=[]
 32 
 33     #页面页码尽量是基数不能小于5
 34     pager_num=11
 35 
 36     #总页数小于11
 37     if total_count < pager_num :
 38         start_index=1
 39         end_index=total_count+1
 40 
 41     else:
 42         #当前页小于6
 43         if curr_pager_num  <6:
 44             start_index=1
 45             #end_index=11 + 1
 46             end_index=pager_num + 1
 47         else:
 48             #总页数大于11:start_index= curr_pager_num -5
 49             start_index= curr_pager_num - (pager_num - 1)/2
 50             #end_index=curr_pager_num + 6
 51             end_index=curr_pager_num + (pager_num + 1)/2
 52             #curr_pager_num+ 5)
 53             if (curr_pager_num+ (pager_num - 1)/2) > total_count:
 54                 #start_index=total_count - 11 + 1
 55                 start_index=total_count - pager_num + 1
 56                 end_index=total_count+1
 57 
 58 
 59     if curr_pager_num ==1:
 60         prev='<a class="page" href="javascript:void(0)">上一页</a>'
 61     else:
 62         #上一页
 63         prev='<a class="page" href="/user_list/?p=%s">上一页</a>'%(curr_pager_num - 1)
 64     page_str_list.append(prev)
 65     #循环增加
 66     for i in range(int(start_index),int(end_index)):
 67 
 68         #当前页面class中增加active属性
 69         if i == curr_pager_num:
 70             temp='<a class="page active" href="/user_list/?p=%s">%s</a>'%(i,i)
 71         else:
 72             temp='<a class="page" href="/user_list/?p=%s">%s</a>'%(i,i)
 73 
 74         #追加到列表
 75         page_str_list.append(temp)
 76 
 77 
 78     #当前页等于最大页数就不在加1
 79     if curr_pager_num  == total_count:
 80         next_page='<a class="page" href="javascript:void(0)">下一页</a>'
 81     else:
 82        next_page='<a class="page" href="/user_list/?p=%s">下一页</a>'%(curr_pager_num + 1)
 83     page_str_list.append(next_page)
 84 
 85 
 86     #跳转页
 87     jump="""
 88     <input type='text'/><a onclick='jumpTo(this,"/user_list/?p=")' id='jump_id'>GO</a>
 89     <script>
 90         function jumpTo(ths,base){
 91              var val = ths.previousSibling.value;
 92              location.href = base + val;
 93         }
 94     </script>
 95     """
 96     page_str_list.append(jump)
 97 
 98     #将列表进行字符串拼接返回前端
 99     page_str="".join(page_str_list)
100 
101 
102 
103     #page_str=mark_safe("",join(page_list))前端将信任这代码
104 
105     return render(request,'user_list.html',{'li':data,'page_str':page_str})

View Code

url

url(r'^user_list/$', views.user_list),

html，中的incloud 的html和上一个例子中的一样

 1 <!DOCTYPE html>
 2 <html lang="en">
 3 <head>
 4     <meta charset="UTF-8">
 5     <title>Title</title>
 6     <style>
 7             .pagediv .page{
 8                 display: inline-block;
 9                 padding: 5px;
10                 background-color: aqua;
11                 margin: 5px;
12             }
13         .pagediv .page.active{
14             background-color: darkgreen;        }
15     </style>
16 </head>
17 <body>
18 
19 <ul >
20     {% include 'li.html' %}
21 </ul>
22 <div class="pagediv">
23      {{ page_str|safe }}
24 </div>
25 </body>
26 </html>

html

1 {% for user in li %}
2   <li> {{ user }}</li>
3 {% endfor %}

include li.html

将上面的代码改造成类方式实现

view

 1 from  utlis import pagination
 2 
 3 def user_list(request):
 4     #模拟数据库数据
 5     users=range(200)
 6 
 7     #获取当前页
 8     current_page = request.GET.get('p', 1)
 9     #转成int
10     current_page = int(current_page)
11     #获取cookie展示的当前页，默认为10条数据
12     val = request.COOKIES.get('per_page_count',10)
13     val1 = request.COOKIES
14     print(val)
15     print(val1)
16     val = int(val)
17 
18 
19     page_obj = pagination.Page(current_page,len(users),val)
20 
21     data = users[page_obj.start:page_obj.end]
22 
23     page_str = page_obj.page_str("/user_list/")
24 
25     result=render(request,'user_list.html',{'li':data,'page_str':page_str})
26     result.set_cookie('per_page_count',val,path='/user_list/')
27     return result

View Code

封装类方法

 1 #-*- coding:utf-8  -*-
 2 from django.utils.safestring import mark_safe
 3 
 4 
 5 class Page:
 6     def __init__(self, current_page, data_count, per_page_count=10, pager_num=7):
 7         #当前页
 8         self.current_page = current_page
 9         #数据总数
10         self.data_count = data_count
11         #每个页面显示几条数据，不是页码
12         self.per_page_count = per_page_count
13         #页码
14         self.pager_num = pager_num
15 
16     @property
17     def start(self):
18         return (self.current_page - 1) * self.per_page_count
19 
20     @property
21     def end(self):
22         return self.current_page * self.per_page_count
23 
24     @property
25     def total_count(self):
26         v, y = divmod(self.data_count, self.per_page_count)
27         if y:
28             v += 1
29         return v
30 
31     def page_str(self, base_url):
32         page_list = []
33 
34         if self.total_count < self.pager_num:
35             start_index = 1
36             end_index = self.total_count + 1
37         else:
38             if self.current_page <= (self.pager_num + 1) / 2:
39                 start_index = 1
40                 end_index = self.pager_num + 1
41             else:
42                 start_index = self.current_page - (self.pager_num - 1) / 2
43                 end_index = self.current_page + (self.pager_num + 1) / 2
44                 if (self.current_page + (self.pager_num - 1) / 2) > self.total_count:
45                     end_index = self.total_count + 1
46                     start_index = self.total_count - self.pager_num + 1
47 
48         if self.current_page == 1:
49             prev = '<a class="page" href="javascript:void(0);">上一页</a>'
50         else:
51             prev = '<a class="page" href="%s?p=%s">上一页</a>' % (base_url, self.current_page - 1,)
52         page_list.append(prev)
53 
54         for i in range(int(start_index), int(end_index)):
55             if i == self.current_page:
56                 temp = '<a class="page active" href="%s?p=%s">%s</a>' % (base_url, i, i)
57             else:
58                 temp = '<a class="page" href="%s?p=%s">%s</a>' % (base_url, i, i)
59             page_list.append(temp)
60 
61         if self.current_page == self.total_count:
62             nex = '<a class="page" href="javascript:void(0);">下一页</a>'
63         else:
64             nex = '<a class="page" href="%s?p=%s">下一页</a>' % (base_url, self.current_page + 1,)
65         page_list.append(nex)
66 
67         jump = """
68         <input type='text'  /><a onclick='jumpTo(this, "%s?p=");'>GO</a>
69         <script>
70             function jumpTo(ths,base){
71                 var val = ths.previousSibling.value;
72                 location.href = base + val;
73             }
74         </script>
75         """ % (base_url,)
76 
77         page_list.append(jump)
78 
79         page_str = mark_safe("".join(page_list))
80 
81         return page_str

pagination

html,incloud hst

 1 <!DOCTYPE html>
 2 <html lang="en">
 3 <head>
 4     <meta charset="UTF-8">
 5     <title>Title</title>
 6     <style>
 7             .pagediv .page{
 8                 display: inline-block;
 9                 padding: 5px;
10                 background-color: aqua;
11                 margin: 5px;
12             }
13         .pagediv .page.active{
14             background-color: darkgreen;        }
15     </style>
16 </head>
17 <body>
18 
19 <ul >
20     {% include 'li.html' %}
21 </ul>
22 <div>
23         <select id="ps" onchange="changePageSize(this)">
24             <option value="10">10</option>
25             <option value="30">30</option>
26             <option value="50">50</option>
27             <option value="100">100</option>
28         </select>
29     </div>
30 <div class="pagediv">
31      {{ page_str|safe }}
32 </div>
33 <script src="/static/jquery-1.12.4.js"></script>
34     <script src="/static/jquery.cookie.js"></script>
35     <script>
36 
37         $(function(){
38                 var v= $.cookie('per_page_count');
39 
40                 $('#ps').val(v);
41         });
42 
43         function changePageSize(ths){
44             var v = $(ths).val();
45             console.log(v);
46             $.cookie('per_page_count',v, {'path': "/user_list/"});
47             location.reload();
48         }
49     </script>
50 </body>
51 </html>

View Code

cookie操作

实现简单的cookie操作

url(r'^index/', views.index),
url(r'^login/$', views.login),

def index(request):
    v=request.COOKIES.get('cookie_username')
    if v:
       return  render(request,'index.html',{'username':v})
    else:
      return  redirect('/app01/login/')

def login(request):
    user_data={
        'test1':'123456',
        'test2':'123123',
    }

    if request.method == 'GET':
        return render(request,'login.html')
    if request.method == 'POST':
          username=request.POST.get('username')
          #py2中取回参数默认是u编码，转成utf-8
          password=request.POST.get('password').encode(encoding='utf-8')
          if user_data.get(username):
              if password == user_data[username]:
                  #获取对象，用render的方法也是这样
                  res=redirect('/app01/index/')
                  #设置对象cookie的K,V信息
                  res.set_cookie('cookie_username',username)
                  #返回对象
                  return  res

          return render(request,'login.html'

页面结果：

cookie参数设置

 1 rep = HttpResponse(...) 或 rep ＝ render(request, ...)
 2  
 3 rep.set_cookie(key,value,...)
 4 rep.set_signed_cookie(key,value,salt='加密盐',...)
 5     参数：
 6         key,              键
 7         value='',         值
 8         max_age=None,     超时时间
 9         expires=None,     超时时间(IE requires expires, so set it if hasn't been already.)
10         path='/',         Cookie生效的路径，/ 表示根路径，特殊的：跟路径的cookie可以被任何url的页面访问
11         domain=None,      Cookie生效的域名
12         secure=False,     https传输是为True
13         httponly=False    只能http协议传输，无法被JavaScript获取（不是绝对，底层抓包可以获取到也可以被覆盖）

由于cookie保存在客户端的电脑上，所以，JavaScript和jquery也可以操作cookie

<script src='/static/js/jquery.cookie.js'></script>
$.cookie("list_pager_num", 30,{ path: '/' });

加密cookie(带签名)

 1 加密
 2 request.COOKIES['key']
 3 request.get_signed_cookie(key, default=RAISE_ERROR, salt='', max_age=None)
 4     参数：
 5         default: 默认值
 6            salt: 加密盐
 7         max_age: 后台控制过期时间
 8 
 9 解密
10  request.get_signed_cookie('key',salt='这里需要和加密的值一样')

加密和解密cookie

利用cookie做登录装饰器

 1             FBV:
 2                 #装饰器函数
 3                 def auth(func):
 4                     def inner(reqeust,*args,**kwargs):
 5                         v = reqeust.COOKIES.get('username')
 6                         if not v:
 7                             return redirect('/login/')
 8                         return func(reqeust, *args,**kwargs)
 9                     return inner
10                     
11                     
12                 @auth    
13                 def xxx(request,*args,**kwargs):
14                 
15                 @auth    
16                 def xxx1(request,*args,**kwargs)
17         
18         
19         
20         
21         
22             CBV:
23                 from django import views
24                 from django.utils.decorators import method_decorator
25                 
26                 #这个方法主要是不用写下面的dispatch方法。调用auth方法执行在Order类下的dispatch方法。这样在这个类下的所有方法对会登录验证
27                 @method_decorator(auth,name='dispatch')
28                 class Order(views.View):
29                     #自己写dispatch方法，在方法前面增加@method_decorator(auth)装饰器
30                     # @method_decorator(auth)
31                     # def dispatch(self, request, *args, **kwargs):
32                     #     return super(Order,self).dispatch(request, *args, **kwargs)
33 
34                     # @method_decorator(auth)
35                     def get(self,reqeust):
36                         v = reqeust.COOKIES.get('username111')
37                         return render(reqeust,'index.html',{'current_user': v})
38 
39                     def post(self,reqeust):
40                         v = reqeust.COOKIES.get('username111')
41                         return render(reqeust,'index.html',{'current_user': v})

View Code

PS：不设置超时默认关闭浏览器就没有效果了

Session

cookie是保存在客户浏览器中的键值对

session是保存在服务器端的键值对

利用session做一个登陆

url

1 from django.conf.urls import include, url
2 from django.contrib import admin
3 from app03 import views
4 urlpatterns = [
5     url(r'^admin/', include(admin.site.urls)),
6     url(r'^login',views.login),
7     url(r'^index',views.index),
8 ]

View Code

view

 1 #-*- coding=utf-8 -*-
 2 from django.shortcuts import render,HttpResponse,redirect
 3 
 4 # Create your views here.
 5 
 6 
 7 def index(request):
 8     #获取当前用户随机字符串
 9     #根据随机字符串查询对应信息
10     if request.session['is_login']:
11          return HttpResponse("ok")
12     else:
13          return  redirect('/login/')
14 
15 
16 def login(request):
17     if request.method == 'GET':
18         return render(request,'login.html')
19     elif request.method == 'POST':
20         user = request.POST.get('user').encode(encoding='utf-8')
21         password =request.POST.get('pass').encode(encoding='utf-8')
22         print(user,password)
23         if user == 'root' and password == '123456':
24             #生成随机字符串
25             #写到客户端浏览器cookie
26             #内存中创建session
27             #在随机字符串对应的字典中生成信息
28             #创建session必须先初始化数据库，python manage.py  migrate
29             request.session['username']=user
30             request.session['is_login']=True
31             return  redirect('/index/')
32         else:
33             return render(request,'login.html')

View Code

template

 1 <!DOCTYPE html>
 2 <html lang="en">
 3 <head>
 4     <meta charset="UTF-8">
 5     <title>Title</title>
 6 </head>
 7 <body>
 8    <form action="/login/" method="POST" >
 9         <p>
10             <input type="text" name="user" placeholder="用户名" />
11         </p>
12         <p>
13             <input type="password" name="pass" placeholder="密码" />
14         </p>
15 
16         <input type="submit" value="提交"/>
17     </form>
18 </body>
19 </html>

View Code

session缓存

由于Django是动态网站，所有每次请求均会去数据进行相应的操作，当程序访问量大时，耗时必然会更加明显，最简单解决方式是使用：缓存，缓存将一个某个views的返回值保存至内存或者memcache中，5分钟内再有人来访问时，则不再去执行view中的操作，而是直接从内存或者Redis中之前缓存的内容拿到，并返回。

Django中默认支持Session，其内部提供了5种类型的Session供开发者使用：

数据库（默认）

缓存

文件

缓存+数据库

加密cookie

1数据库

 1 Django默认支持Session，并且默认是将Session数据存储在数据库中，即：django_session 表中。
 2  
 3 a. 配置 settings.py
 4  
 5     SESSION_ENGINE = 'django.contrib.sessions.backends.db'   # 引擎（默认）
 6      
 7     SESSION_COOKIE_NAME ＝ "sessionid"                       # Session的cookie保存在浏览器上时的key，即：sessionid＝随机字符串（默认）
 8     SESSION_COOKIE_PATH ＝ "/"                               # Session的cookie保存的路径（默认）
 9     SESSION_COOKIE_DOMAIN = None                             # Session的cookie保存的域名（默认）
10     SESSION_COOKIE_SECURE = False                            # 是否Https传输cookie（默认）
11     SESSION_COOKIE_HTTPONLY = True                           # 是否Session的cookie只支持http传输（默认）
12     SESSION_COOKIE_AGE = 1209600                             # Session的cookie失效日期（2周）（默认）
13     SESSION_EXPIRE_AT_BROWSER_CLOSE = False                  # 是否关闭浏览器使得Session过期（默认）
14     SESSION_SAVE_EVERY_REQUEST = False                       # 是否每次请求都保存Session,例如超时时间10秒,刷新一下网页那么这个超时时间就继续加10秒,这个功能默认关闭
15  
16  
17  
18 b. 使用
19  
20     def index(request):
21         # 获取
22         request.session['k1']
23         #获取k1，如果值不存在值设置为None
24         request.session.get('k1',None)
25         #不论k1是否存在都设置k/v
26         request.session['k1'] = 123
27         #存在不设置
28         request.session.setdefault('k1',123) 
29         #删除k
30         del request.session['k1']
31  
32         # 所有 键、值、键值对
33         request.session.keys()
34         request.session.values()
35         request.session.items()
36         request.session.iterkeys()
37         request.session.itervalues()
38         request.session.iteritems()
39  
40         #删除所有
41         request.session.clear()
42         
43         # 用户session的随机字符串，这个很少能用到
44         request.session.session_key
45      
46         #如果session没有超过超时日期,但是客户端自己清除了cookie.这样在此登录数据库中就会存在一条新的session信息,产生了垃圾数据
47         #首先哪到所有session，然后失效的日期<当前日期我们就 把这个数据删除掉
48         request.session.clear_expired()
49  
50         # 检查 用户session的随机字符串 在数据库中是否
51         request.session.exists("session_key")
52  
53         # 删除当前用户的所有Session数据
54         request.session.delete("session_key")
55         
56         #默认2周超时时间
57         request.session.set_expiry(value)
58             * 如果value是个整数，session会在些秒数后失效。
59             * 如果value是个datatime或timedelta，session就会在这个时间后失效。
60             * 如果value是0,用户关闭浏览器session就会失效。
61             * 如果value是None,session会依赖全局session失效策略。

View Code

2缓存session(memcache/内存)

 1 配置 settings.py
 2  
 3     SESSION_ENGINE = 'django.contrib.sessions.backends.cache'  # 引擎
 4     SESSION_CACHE_ALIAS = 'default'                            # 使用的缓存别名（默认内存缓存，也可以是memcache），此处别名依赖缓存的设置default就是chaches下的default方法
 5 
 6     
 7     # 此缓存使用python-memcached模块连接memcache
 8     #ps可以在CACHES写多个不同的缓存方式,
 9    
10     CACHES = {
11         'default': {
12             'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
13             'LOCATION': '127.0.0.1:11211',
14         }
15     }
16     
17     CACHES = {
18         'default1': {
19             'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
20             'LOCATION': 'unix:/tmp/memcached.sock',
21         }
22     }   
23 
24     CACHES = {
25         'default2': {
26             'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
27             'LOCATION': [
28                 '172.19.26.240:11211',
29                 '172.19.26.242:11211',
30             ]
31         }
32     }

memcache

 1 # 此缓存将内容保存至内存的变量中
 2     # 配置：
 3         CACHES = {
 4             'default': {
 5                 'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
 6                 'LOCATION': 'unique-snowflake',
 7             }
 8         }
 9 
10     # 注：其他配置同开发调试版本

内存

 1 # 此缓存使用pylibmc模块连接memcache
 2     
 3     CACHES = {
 4         'default': {
 5             'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache',
 6             'LOCATION': '127.0.0.1:11211',
 7         }
 8     }
 9 
10     CACHES = {
11         'default': {
12             'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache',
13             'LOCATION': '/tmp/memcached.sock',
14         }
15     }   
16 
17     CACHES = {
18         'default': {
19             'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache',
20             'LOCATION': [
21                 '172.19.26.240:11211',
22                 '172.19.26.242:11211',
23             ]
24         }
25     }

pylibmc模块(memcache)

3文件缓存

 1 # 此缓存将内容保存至文件
 2     # 配置：
 3 
 4         CACHES = {
 5             'default': {
 6                 'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache',
 7                 'LOCATION': '/var/tmp/django_cache',
 8             }
 9         }
10     # 注：其他配置同开发调试版本

文件

4缓存+数据库

1 数据库用于做持久化，缓存用于提高效率。先找cache在找数据库
2  
3 a. 配置 settings.py
4  
5     SESSION_ENGINE = 'django.contrib.sessions.backends.cached_db'        # 引擎
6

View Code

5加密cookie

1  配置 settings.py，就将session加密后放置在cookie中
2      
3     SESSION_ENGINE = 'django.contrib.sessions.backends.signed_cookies'   # 引擎

加密cookie

简单例子

csrf

举例：
　　CSRF攻击的主要目的是让用户在不知情的情况下攻击自己已登录的一个系统，类似于钓鱼。如用户当前已经登录了邮箱，或bbs，同时用户又在使用另外一个，已经被你控制的站点，我们姑且叫它钓鱼网站。这个网站上面可能因为某个图片吸引你，你去点击一下，此时可能就会触发一个js的点击事件，构造一个bbs发帖的请求，去往你的bbs发帖，由于当前你的浏览器状态已经是登陆状态，所以session登陆cookie信息都会跟正常的请求一样，纯天然的利用当前的登陆状态，让用户在不知情的情况下，帮你发帖或干其他事情。

解决办法：

在post请求的时候加上django给的随机字符串

1、form提交

 1  <form action="/login/" method="POST" >
 2        {% csrf_token %}
 3         <p>
 4             <input type="text" name="user" placeholder="用户名" />
 5         </p>
 6         <p>
 7             <input type="password" name="pass" placeholder="密码" />
 8         </p>
 9         <input type="checkbox" name='timeoutval' value="1" />10秒钟免登陆
10         <input type="submit" value="提交"/>
11     </form>

View Code

返回头中有csrftoken

form也有token，django自动设置了一个隐藏的input

2、ajax 提交

 1 <!DOCTYPE html>
 2 <html lang="en">
 3 <head>
 4     <meta charset="UTF-8">
 5     <title>Title</title>
 6 </head>
 7 <body>
 8    <form action="/login/" method="POST" >
 9         <p>
10             <input type="text"  id="username" placeholder="用户名" />
11         </p>
12         <p>
13             <input type="password" id="password" placeholder="密码" />
14         </p>
15         <input type="checkbox" name='timeoutval' value="1" />10秒钟免登陆
16         <input id="btn" type="button" value="提交"/>
17     </form>
18 <script src="/static/jquery-1.12.4.js"></script>
19 <script src="/static/jquery.cookie.js"></script>
20 <script>
21     $(function(){
22 
23         //验证ajax请求头
24         function csrfSafeMethod(method) {
25             // GET|HEAD|OPTIONS|TRACE 这4种请求头不需要加token
26             return (/^(GET|HEAD|OPTIONS|TRACE)$/.test(method));
27         }
28 
29 
30         //在执行任何ajax提交之前都会先执行这个方法增加token。这样相当于对所有ajax进行了一次装饰
31         $.ajaxSetup({
32             beforeSend:function(xhr,settings){
33                 //判断请求方法是否需要增加token
34                 if (!csrfSafeMethod(settings.type) && !this.crossDomain) {
35                      xhr.setRequestHeader('X-CSRFtoken', $.cookie('csrftoken'));
36                  }
37             }
38         });
39 
40 
41         $('#btn').click(function(){
42             var token=$.cookie('csrftoken')
43             console.log(token)
44 
45             var  username = $('#username').val()
46             var  password = $('#password').val()
47             $.ajax({
48                 url:'/login/',
49                 type:"POST",
50                 data:{"user":username,'pwd':password},
51                 //headers:{'X-CSRFtoken':$.cookie('csrftoken')},少量方法可以
52                 success:function(arg){
53 
54                 }
55             })
56         })
57     })
58 </script>
59 </body>
60 </html>

View Code

中间件

拿一下中间件举例，中间件的结大致可以分成reqeust和response。request请求从下往上走，最后到view视图，然后在从view返回response从下往上

MIDDLEWARE_CLASSES = (
'django.middleware.common.CommonMiddleware',
'django.contrib.sessions.middleware.SessionMiddleware',
'django.middleware.csrf.CsrfViewMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
)

每个中间件都是一个简单的python类，类中定义了很多如下的方法：
process_request(self,request)

在django决定调用哪个视图函数之前

需要返回一个值，可以是None或者HttpResponse对象。如果返回None，则继续执行。如果返回HttpResponse对象，则停止执行，返回HttpResponse对象。

process_view(self,request,view_func,view_args,view_kwargs)

view_func是django选择的视图处理函数（是一个函数对象，而不是一个简单的字符串），而最后两个则是非关键字参数和关键字参数。

它会在调用视图函数之前调用。也是返回None或者HttpResponse对象

process_template_response(self,request,response)

在render()调用之后，模板调用之前。

process_response(self,request,response)

始终会被调用，在响应时被第一个调用。

process_exception(self,request,exception)

在异常视图函数调用前调用

代码

代码结构

中间件

 1 #-*- coding=utf-8 -*-
 2 from django.shortcuts import HttpResponse
 3 class midd_one(object):
 4     def process_request(self, request):
 5         print("process_request张三")
 6         #在request时候return 那么将不会在继续执行中间件了
 7         #return HttpResponse("再见")
 8     def process_response(self, request, response):
 9         print("process_response张三")
10         return response
11 
12 class midd_two(object):
13     def process_request(self, request):
14         print("process_request李四")
15 
16     def process_response(self, request, response):
17         print("process_response李四")
18         return response

div1.py

view

1 def test(request):
2     print("view_func")
3     return HttpResponse("ok")

View Code

结果：这样顺序就很容看出来

process_request张三
process_request李四
view_func
process_response李四
process_response张三

这里在做一下更改

class midd_one(object):
    def process_request(self, request):
        print("process_request张三")
        #让张三直接返回结果
        return HttpResponse("再见")
    def process_response(self, request, response):
        print("process_response张三")
        return response

结果：

process_request张三
process_response李四
process_response张三

张三的return 会直接传递给李四的response然后在往上传递这个值，django1.7 1.8 1.9 都是按照这个方法做的，django10 以上就不一样了张三就直接返回response

再看下process_template_response方法(这个方法用的不多)：

div1.py

class midd_two(object):
    def process_request(self, request):
        print("process_request李四")

    def process_view(self,request,view_func,view_args,view_kwargs):
        print("process_view 李四")

    def process_response(self, request, response):
        print("process_response李四")
        return response
    #当view函数用render返回的时候才会执行这个
    def process_template_response(self,request,response):
        print("process_template_response李四")
        return  response

view

#伪造一个类然后里面有render方法
class Foo(object):
    def render(self):
        return HttpResponse("OK")

def test(request):
    print("view_func")
    return Foo()

结果：

process_request张三
process_request李四
process_view 张三
process_view 李四
view_func
process_template_response李四
process_response李四
process_response张三

在来看下process_exception不常用：

div1.py view中报错才会执行process_exception

class midd_two(object):
    def process_request(self, request):
        print("process_request李四")

    def process_view(self,request,view_func,view_args,view_kwargs):
        print("process_view 李四")

    def process_response(self, request, response):
        print("process_response李四")
        return response

    def process_template_response(self,request,response):
        print("process_template_response李四")
        return  response

    def process_exception(self,request,exception):
        print("process_exception李四")

view

def test(request):
    int(a)#故意出错
    print("view_func")
    return HttpResponse("ok")

结果：

process_request张三
process_request李四
process_view 张三
process_view 李四
process_exception李四
process_response李四
process_response张三

缓存

1开发测试版缓存

2内存

3文件

4数据库

1基础

 1 # 此为开始调试用，实际内部不做任何操作
 2     # 通用配置：
 3         CACHES = {
 4             'default': {
 5                 'BACKEND': 'django.core.cache.backends.dummy.DummyCache',     # 引擎有很多，下面的参数都是通用的
 6                 'TIMEOUT': 300,                                               # 缓存超时时间（默认300，None表示永不过期，0表示立即过期）
 7                 'OPTIONS':{
 8                     'MAX_ENTRIES': 300,                                       # 最大缓存个数（默认300）
 9                     'CULL_FREQUENCY': 3,                                      # 缓存到达最大个数之后，剔除缓存个数的比例，即：1/CULL_FREQUENCY（默认3）
10                 },
11                 'KEY_PREFIX': '',                                             # 缓存key的前缀（默认空）
12                 'VERSION': 1,                                                 # 缓存key的版本（默认1）
13                 'KEY_FUNCTION' 函数名                                         # 生成key的函数（默认函数会生成为：【前缀:版本:key】）
14             }
15         }
16 
17 
18     # 底层实现获取和定义key方法,想更改key的格式就可以修改这里
19     def default_key_func(key, key_prefix, version):
20         """
21         Default function to generate keys.
22 
23         Constructs the key used by all other methods. By default it prepends
24         the `key_prefix'. KEY_FUNCTION can be used to specify an alternate
25         function with custom key making behavior.
26         """
27         return '%s:%s:%s' % (key_prefix, version, key)
28 
29     def get_key_func(key_func):
30         """
31         Function to decide which key function to use.
32 
33         Defaults to ``default_key_func``.
34         """
35         if key_func is not None:
36             if callable(key_func):
37                 return key_func
38             else:
39                 return import_string(key_func)
40         return default_key_func

View Code

2内存

 1 # 此缓存将内容保存至内存的变量中
 2     # 配置：
 3         CACHES = {
 4             'default': {
 5                 'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
 6                 'LOCATION': 'unique-snowflake',
 7             }
 8         }
 9 
10 
11 'LOCATION': 'unique-snowflake', 定义的唯一key，底层就是放在了一个大的字典中

View Code

3文件

 1 # 此缓存将内容保存至文件
 2     # 配置：
 3 CACHES = {
 4     'default': {
 5                 'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache',
 6                 'LOCATION': os.path.join(BASE_DIR,'cache'),
 7             }
 8         }
 9    
10     # 注：其他配置同开发调试版本

View Code

4数据库

 1 # 此缓存将内容保存至数据库
 2 
 3     # 配置：
 4         CACHES = {
 5             'default': {
 6                 'BACKEND': 'django.core.cache.backends.db.DatabaseCache',
 7                 'LOCATION': 'my_cache_table', # 数据库表
 8             }
 9         }
10 
11     # 注：执行创建表命令 python manage.py createcachetable

View Code

5 memcache（python-memcached模块）

 1 # 此缓存使用python-memcached模块连接memcache
 2 
 3     CACHES = {
 4         'default': {
 5             'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
 6             'LOCATION': '127.0.0.1:11211',
 7         }
 8     }
 9 
10     CACHES = {
11         'default': {
12             'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
13             'LOCATION': 'unix:/tmp/memcached.sock',
14         }
15     }   
16 
17     CACHES = {
18         'default': {
19             'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
20             'LOCATION': [
21                 '172.19.26.240:11211',
22                 '172.19.26.242:11211',
23             ]
24         }
25      #权重设置
26      CACHES = {
27         'default': {
28             'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
29             'LOCATION': [
30                 （'172.19.26.240:11211',2）,
31                 ('172.19.26.242:11211',16),
32             ]
33         }
34     }

View Code

memcache（pylibmc模块）

 1 # 此缓存使用pylibmc模块连接memcache
 2     
 3     CACHES = {
 4         'default': {
 5             'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache',
 6             'LOCATION': '127.0.0.1:11211',
 7         }
 8     }
 9 
10     CACHES = {
11         'default': {
12             'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache',
13             'LOCATION': '/tmp/memcached.sock',
14         }
15     }   
16 
17     CACHES = {
18         'default': {
19             'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache',
20             'LOCATION': [
21                 '172.19.26.240:11211',
22                 '172.19.26.242:11211',
23             ]
24         }
25     }

View Code

缓存应用

1独立视图缓存

新建cache目录

setting

1 CACHES = {
2     'default': {
3                 'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache',
4                 'LOCATION': os.path.join(BASE_DIR,'cache'),
5             }
6         }

View Code

view

1 from django.views.decorators.cache import cache_page
2 #缓存10秒
3 @cache_page(10)
4 def cache(request):
5     import time
6     cachedata  = time.time()
7     cachedata1 = time.time()
8     return render(request,'cache.html',{'cachedata':cachedata,'cachedata1':cachedata1})

View Code

html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<h1>{{ cachedata }}</h1>
<h1>{{ cachedata1 }}</h1>
</body>
</html>

2局部页面缓存

 1 {% load cache %}
 2 <!DOCTYPE html>
 3 <html lang="en">
 4 <head>
 5     <meta charset="UTF-8">
 6     <title>Title</title>
 7 </head>
 8 <body>
 9     //key_idv是key的名字，但是这个名字需要跟setting中设置的前缀组合起来
10  {% cache 5 key_idv %}
11         <h1>{{ cachedata }}缓存5秒</h1>
12  {% endcache %}
13 <h1>{{ cachedata1 }}</h1>
14 </body>
15 </html>

View Code

3全站缓存(适合基本不改变的如博客)

 1 使用中间件，经过一系列的认证等操作，如果内容在缓存中存在，则使用FetchFromCacheMiddleware获取内容并返回给用户，当返回给用户之前，判断缓存中是否已经存在，如果不存在则UpdateCacheMiddleware会将缓存保存至缓存，从而实现全站缓存
 2 
 3     MIDDLEWARE = [
 4         'django.middleware.cache.UpdateCacheMiddleware',
 5         # 其他中间件...
 6         'django.middleware.cache.FetchFromCacheMiddleware',
 7     ]
 8 
 9     CACHE_MIDDLEWARE_ALIAS = ""
10     CACHE_MIDDLEWARE_SECONDS = ""
11     CACHE_MIDDLEWARE_KEY_PREFIX = ""

View Code

信号

django内置信号

 1 Model signals
 2     pre_init                    # django的modal执行其构造方法前，自动触发
 3     post_init                   # django的modal执行其构造方法后，自动触发
 4     pre_save                    # django的modal对象保存前，自动触发
 5     post_save                   # django的modal对象保存后，自动触发
 6     pre_delete                  # django的modal对象删除前，自动触发
 7     post_delete                 # django的modal对象删除后，自动触发
 8     m2m_changed                 # django的modal中使用m2m字段操作第三张表（add,remove,clear）前后，自动触发
 9     class_prepared              # 程序启动时，检测已注册的app中modal类，对于每一个类，自动触发
10 Management signals
11     pre_migrate                 # 执行migrate命令前，自动触发
12     post_migrate                # 执行migrate命令后，自动触发
13 Request/response signals
14     request_started             # 请求到来前，自动触发
15     request_finished            # 请求结束后，自动触发
16     got_request_exception       # 请求异常后，自动触发
17 Test signals
18     setting_changed             # 使用test测试修改配置文件时，自动触发
19     template_rendered           # 使用test测试渲染模板时，自动触发
20 Database Wrappers
21     connection_created          # 创建数据库连接时，自动触发

View Code

对于Django内置的信号，仅需注册指定信号，当程序执行相应操作时，自动触发注册函数：

启动django的时候会加载app下的__init__.py，因为注册信号必须是自动加载，这样django才可用。不一定非的写在这里。

 1 from django.core.signals import request_finished
 2 from django.core.signals import request_started
 3 from django.core.signals import got_request_exception
 4 
 5 from django.db.models.signals import class_prepared
 6 from django.db.models.signals import pre_init, post_init
 7 from django.db.models.signals import pre_save, post_save
 8 from django.db.models.signals import pre_delete, post_delete
 9 from django.db.models.signals import m2m_changed
10 from django.db.models.signals import pre_migrate, post_migrate
11 
12 from django.test.signals import setting_changed
13 from django.test.signals import template_rendered
14 
15 from django.db.backends.signals import connection_created
16 
17 
18 #request请求完事的方法
19 def callback(sender, **kwargs):
20         print("xxoo_callback")
21         print(sender,kwargs)
22 
23 #完成请求后执行callback方法
24 request_finished.connect(callback)

__init__.py

结果：

test_sg
xxoo_callback
(<class 'django.core.handlers.wsgi.WSGIHandler'>, {'signal': <django.dispatch.dispatcher.Signal object at 0x0000000002AC5B70>})

自定义信号

目录结构

 1 import django.dispatch
 2 pizza_done = django.dispatch.Signal(providing_args=["toppings", "size"])
 3 
 4 
 5 
 6 def callback(sender, **kwargs):
 7     print("diy_callback")
 8     print(sender,kwargs)
 9 
10 pizza_done.connect(callback)

test_sg.py

view.py

1 #导入自定义信号
2 from sg.test_sg import pizza_done
3 def test_sg(request):
4     #sender ,toppings, size随便写
5     pizza_done.send(sender='seven',toppings=123, size=456)
6     print("test_sg")
7     return  HttpResponse("OK")