Django之Cookie、Session、CSRF、Admin

Django之Cookie、Session、CSRF、Admin

 

Cookie

1、获取Cookie：

1 2 3 4 5 6

request.COOKIES['key'] request.get_signed_cookie(key, default=RAISE_ERROR, salt='', max_age=None)     参数：         default: 默认值            salt: 加密盐         max_age: 后台控制过期时间

2、设置Cookie：

1 2 3 4 5 6 7 8 9 10 11 12 13

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

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

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

注：

1、max_age = None 和 expires = None：

max_age=秒数，表示多少秒数之后失效。

expires = 时间，表示失效的时间。支持datetime 和 time.time。

二选一，只要写一个，Django会自动将另一个写上。

2、path:默认无论哪个url都可以访问到此cookie。

 

def cook1(request):
    rep = HttpResponse("cook1")
    rep.set_cookie("k999",123,path="/cook1/")
    rep.set_cookie("k888",123)
    return rep

def cook2(request):
    #request.COOKIES能读到当前url的cookie和全局的cookie
    #能获取到k888，无法获取k999
    print(request.COOKIES)
    return HttpResponse("ok")

 

3、domain：只在当前域名生效（http://127.0.0.1:8000/）

4、secure：以安全的方式传输（HTTPS，加证书进行认证 ）

5、httponly：自己写的cookie只能来回传送，别人不能修改和查看。有局限性

示例：

普通cookie：

 

from django.shortcuts import render,HttpResponse

def cook(request):
    #拿到所有的cookie
    print(request.COOKIES)
    rep = HttpResponse("ok")
    # 设置普通cookie
    rep.set_cookie("k1",123)
    return rep

 

加密后的cookie：

默认salt为空

 

from django.shortcuts import render,HttpResponse

def cook(request):
    #拿到所有的cookie
    print(request.COOKIES)
    #根据加盐的值来获取cookie
    print(request.get_signed_cookie("k2",None,salt="uuu"))
    rep = HttpResponse("ok")
    #设置加密的cookie，根据salt加密
    rep.set_signed_cookie("k2",222,salt="uuu")
    return rep

 

Session

tornado里面要自定义Session，Django中默认支持Session，其内部提供了5种类型的Session供开发者使用：

• 数据库（默认）
• 缓存
• 文件
• 缓存+数据库
• 加密cookie

1、数据库Session

首先启动数据库：

python manage.py makemigrations

python manage.py migrate

views.py:

 

def sess(request):
    request.session["k1"] = 123
    return HttpResponse("session")
def index(request):
    return HttpResponse(request.session["k1"])

def cook(request):
    rep = HttpResponse("cook")
    rep.set_cookie("kk",111)
    return rep

 

urls.py:

 

from django.conf.urls import url
from django.contrib import admin
from app01 import views
urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^session/', views.sess),
    url(r'^index/', views.index),
    url(r'^cook/', views.cook),
]

 

这里为了实现设置session的效果，我们先访问cook的url，先设置成功cookie。然后访问index的url，发现获取不了session，这时我们需要访问session的url，访问的同时，就设置了session，当我们再次访问index的时候，就可以看到获取的session的值了。

注：

request.session['k1']：获取session，如果没有会报错

request.session.get('k1',None)：获取session，如果没有会返回None

request.session['k1'] = 123：设置session，如果k1存在就覆盖

request.session.setdefault('k1',123)：设置session，如果存在则不设置

del request.session["k1"] ：只删除k1，随机字符串和其他session值还存在

request.session.session_key：当前用户随机字符串

如图：

注：随机字符串会在客户端浏览器存在，而默认在数据库也会存在，可查看：django_session表

request.session.clear_expired()：将所有Session失效日期小于当前日期的数据删除，默认失效日期是两周（14天）。如果修改失效日期：通过配置文件中SESSION_COOKIE_AGE修改

更多配置与操作：

Django默认支持Session，并且默认是将Session数据存储在数据库中，即：django_session 表中。

a. 配置 settings.py

    SESSION_ENGINE = 'django.contrib.sessions.backends.db'   # 引擎（默认）

    SESSION_COOKIE_NAME ＝ "sessionid"                       # Session的cookie保存在浏览器上时的key，即：sessionid＝随机字符串（默认）
    SESSION_COOKIE_PATH ＝ "/"                               # Session的cookie保存的路径（默认）
    SESSION_COOKIE_DOMAIN = None                             # Session的cookie保存的域名（默认）
    SESSION_COOKIE_SECURE = False                            # 是否Https传输cookie（默认）
    SESSION_COOKIE_HTTPONLY = True                           # 是否Session的cookie只支持http传输（默认）
    SESSION_COOKIE_AGE = 1209600                             # Session的cookie失效日期（2周）（默认）
    SESSION_EXPIRE_AT_BROWSER_CLOSE = False                  # 是否关闭浏览器使得Session过期（默认）
    SESSION_SAVE_EVERY_REQUEST = False                       # 是否每次请求都保存Session，默认修改之后才保存（默认）

b. 使用

    def index(request):
        # 获取、设置、删除Session中数据
        request.session['k1']
        request.session.get('k1',None)
        request.session['k1'] = 123
        request.session.setdefault('k1',123) # 存在则不设置
        del request.session['k1']

        # 所有 键、值、键值对
        request.session.keys()
        request.session.values()
        request.session.items()
        request.session.iterkeys()
        request.session.itervalues()
        request.session.iteritems()

        # 用户session的随机字符串
        request.session.session_key

        # 将所有Session失效日期小于当前日期的数据删除
        request.session.clear_expired()

        # 检查 用户session的随机字符串 在数据库中是否
        request.session.exists("session_key")

        # 删除当前用户的所有Session数据
        request.session.delete("session_key")

2、缓存Session

默认情况下Django版本的session存在内存里面，使用缓存session需要修改配置，详见如下：

a. 配置 settings.py

    SESSION_ENGINE = 'django.contrib.sessions.backends.cache'  # 引擎
    SESSION_CACHE_ALIAS = 'default'                            # 使用的缓存别名（默认内存缓存，也可以是memcache），此处别名依赖缓存的设置

    SESSION_COOKIE_NAME ＝ "sessionid"                        # Session的cookie保存在浏览器上时的key，即：sessionid＝随机字符串
    SESSION_COOKIE_PATH ＝ "/"                                # Session的cookie保存的路径
    SESSION_COOKIE_DOMAIN = None                              # Session的cookie保存的域名
    SESSION_COOKIE_SECURE = False                             # 是否Https传输cookie
    SESSION_COOKIE_HTTPONLY = True                            # 是否Session的cookie只支持http传输
    SESSION_COOKIE_AGE = 1209600                              # Session的cookie失效日期（2周）
    SESSION_EXPIRE_AT_BROWSER_CLOSE = False                   # 是否关闭浏览器使得Session过期
    SESSION_SAVE_EVERY_REQUEST = False                        # 是否每次请求都保存Session，默认修改之后才保存

b. 使用

    同上

3、文件Session

在本地生成一个文件，把session保存到本地文件中

a. 配置 settings.py

    SESSION_ENGINE = 'django.contrib.sessions.backends.file'    # 引擎
    SESSION_FILE_PATH = None                                    # 缓存文件路径，如果为None，则使用tempfile模块获取一个临时地址tempfile.gettempdir()                                                            # 如：/var/folders/d3/j9tj0gz93dg06bmwxmhh6_xm0000gn/T

    SESSION_COOKIE_NAME ＝ "sessionid"                          # Session的cookie保存在浏览器上时的key，即：sessionid＝随机字符串
    SESSION_COOKIE_PATH ＝ "/"                                  # Session的cookie保存的路径
    SESSION_COOKIE_DOMAIN = None                                # Session的cookie保存的域名
    SESSION_COOKIE_SECURE = False                               # 是否Https传输cookie
    SESSION_COOKIE_HTTPONLY = True                              # 是否Session的cookie只支持http传输
    SESSION_COOKIE_AGE = 1209600                                # Session的cookie失效日期（2周）
    SESSION_EXPIRE_AT_BROWSER_CLOSE = False                     # 是否关闭浏览器使得Session过期
    SESSION_SAVE_EVERY_REQUEST = False                          # 是否每次请求都保存Session，默认修改之后才保存

b. 使用

    同上

4、缓存+数据库Session

优先在缓存里面获取session，如果没有，就到数据库获取然后放到缓存里

数据库用于做持久化，缓存用于提高效率

a. 配置 settings.py

    SESSION_ENGINE = 'django.contrib.sessions.backends.cached_db'        # 引擎

b. 使用

    同上

5、加密cookie Session

这次session就不保存在服务器端了，而是保存在浏览器端，会给session的值加密再发送

a. 配置 settings.py

    SESSION_ENGINE = 'django.contrib.sessions.backends.signed_cookies'   # 引擎

b. 使用

    同上

查看源码：from django.contrib.sessions.backends import signed_cookies

扩展：Session用户验证

1 2 3 4 5 6 7

def login(func):     def wrap(request, *args, **kwargs):         # 如果未登陆，跳转到指定页面         if request.path == '/test/':             return redirect('http://www.baidu.com')         return func(request, *args, **kwargs)     return wrap

Django内置分页: 

from django.shortcuts import render
from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger

L = []
for i in range(999):
    L.append(i)

def index(request):
    current_page = request.GET.get('p')

    paginator = Paginator(L, 10)
    # per_page: 每页显示条目数量
    # count:    数据总个数
    # num_pages:总页数
    # page_range:总页数的索引范围，如: (1,10),(1,200)
    # page:     page对象
    try:
        posts = paginator.page(current_page)
        # has_next              是否有下一页
        # next_page_number      下一页页码
        # has_previous          是否有上一页
        # previous_page_number  上一页页码
        # object_list           分页之后的数据列表
        # number                当前页
        # paginator             paginator对象
    except PageNotAnInteger:
        posts = paginator.page(1)
    except EmptyPage:
        posts = paginator.page(paginator.num_pages)
    return render(request, 'index.html', {'posts': posts})

views.py

<!DOCTYPE html>
<html>
<head lang="en">
    <meta charset="UTF-8">
    <title></title>
</head>
<body>
<ul>
    {% for item in posts %}
        <li>{{ item }}</li>
    {% endfor %}
</ul>

<div class="pagination">
      <span class="step-links">
        {% if posts.has_previous %}
            <a href="?p={{ posts.previous_page_number }}">Previous</a>
        {% endif %}
          <span class="current">
            Page {{ posts.number }} of {{ posts.paginator.num_pages }}.
          </span>
          {% if posts.has_next %}
              <a href="?p={{ posts.next_page_number }}">Next</a>
          {% endif %}
      </span>

</div>
</body>
</html>

Html

from django.shortcuts import render
from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger

class CustomPaginator(Paginator):
    def __init__(self, current_page, max_pager_num, *args, **kwargs):
        """
        :param current_page: 当前页
        :param max_pager_num:最多显示的页码个数
        :param args:
        :param kwargs:
        :return:
        """
        self.current_page = int(current_page)
        self.max_pager_num = max_pager_num
        super(CustomPaginator, self).__init__(*args, **kwargs)

    def page_num_range(self):
        # 当前页面
        # self.current_page
        # 总页数
        # self.num_pages
        # 最多显示的页码个数
        # self.max_pager_num
        print(1)
        if self.num_pages < self.max_pager_num:
            return range(1, self.num_pages + 1)
        print(2)
        part = int(self.max_pager_num / 2)
        if self.current_page - part < 1:
            return range(1, self.max_pager_num + 1)
        print(3)
        if self.current_page + part > self.num_pages:
            return range(self.num_pages + 1 - self.max_pager_num, self.num_pages + 1)
        print(4)
        return range(self.current_page - part, self.current_page + part + 1)

L = []
for i in range(999):
    L.append(i)

def index(request):
    current_page = request.GET.get('p')
    paginator = CustomPaginator(current_page, 11, L, 10)
    # per_page: 每页显示条目数量
    # count:    数据总个数
    # num_pages:总页数
    # page_range:总页数的索引范围，如: (1,10),(1,200)
    # page:     page对象
    try:
        posts = paginator.page(current_page)
        # has_next              是否有下一页
        # next_page_number      下一页页码
        # has_previous          是否有上一页
        # previous_page_number  上一页页码
        # object_list           分页之后的数据列表
        # number                当前页
        # paginator             paginator对象
    except PageNotAnInteger:
        posts = paginator.page(1)
    except EmptyPage:
        posts = paginator.page(paginator.num_pages)

    return render(request, 'index.html', {'posts': posts})

扩展内置分页：views.py

<!DOCTYPE html>
<html>
<head lang="en">
    <meta charset="UTF-8">
    <title></title>
</head>
<body>

<ul>
    {% for item in posts %}
        <li>{{ item }}</li>
    {% endfor %}
</ul>

<div class="pagination">
<span class="step-links">
{% if posts.has_previous %}
    <a href="?p={{ posts.previous_page_number }}">Previous</a>
{% endif %}

    {% for i in posts.paginator.page_num_range %}
        <a href="?p={{ i }}">{{ i }}</a>
    {% endfor %}

    {% if posts.has_next %}
        <a href="?p={{ posts.next_page_number }}">Next</a>
    {% endif %}
</span>

<span class="current">
Page {{ posts.number }} of {{ posts.paginator.num_pages }}.
</span>

</div>
</body>
</html>

扩展内置分页：Html

自定义分页:

分页功能在每个网站都是必要的，对于分页来说，其实就是根据用户的输入计算出应该在数据库表中的起始位置。

1、设定每页显示数据条数

2、用户输入页码（第一页、第二页...）

3、根据设定的每页显示条数和当前页码，计算出需要取数据表的起始位置

4、在数据表中根据起始位置取值，页面上输出数据

---

需求又来了，需要在页面上显示分页的页面。如：［上一页］［1］［2］［3］［4］［5］［下一页］

1、设定每页显示数据条数

2、用户输入页码（第一页、第二页...）

3、设定显示多少页号

4、获取当前数据总条数

5、根据设定显示多少页号和数据总条数计算出，总页数

6、根据设定的每页显示条数和当前页码，计算出需要取数据表的起始位置

7、在数据表中根据起始位置取值，页面上输出数据

8、输出分页html，如：［上一页］［1］［2］［3］［4］［5］［下一页］

#!/usr/bin/env python
# _*_coding:utf-8_*_
from django.utils.safestring import mark_safe

class PageInfo(object):
    def __init__(self,current,totalItem,peritems=5):
        self.__current=current
        self.__peritems=peritems
        self.__totalItem=totalItem
    def From(self):
        return (self.__current-1)*self.__peritems
    def To(self):
        return self.__current*self.__peritems
    def TotalPage(self):  #总页数
        result=divmod(self.__totalItem,self.__peritems)
        if result[1]==0:
            return result[0]
        else:
            return result[0]+1

def Custompager(baseurl,currentPage,totalpage):  #基础页，当前页，总页数
    perPager=11
    #总页数<11
    #0 -- totalpage
    #总页数>11
        #当前页大于5 currentPage-5 -- currentPage+5
            #currentPage+5是否超过总页数,超过总页数，end就是总页数
        #当前页小于5 0 -- 11
    begin=0
    end=0
    if totalpage <= 11:
        begin=0
        end=totalpage
    else:
        if currentPage>5:
            begin=currentPage-5
            end=currentPage+5
            if end > totalpage:
                end=totalpage
        else:
            begin=0
            end=11
    pager_list=[]
    if currentPage<=1:
        first="<a href=''>首页</a>"
    else:
        first="<a href='%s%d'>首页</a>" % (baseurl,1)
    pager_list.append(first)

    if currentPage<=1:
        prev="<a href=''>上一页</a>"
    else:
        prev="<a href='%s%d'>上一页</a>" % (baseurl,currentPage-1)
    pager_list.append(prev)

    for i in range(begin+1,end+1):
        if i == currentPage:
            temp="<a href='%s%d' class='selected'>%d</a>" % (baseurl,i,i)
        else:
            temp="<a href='%s%d'>%d</a>" % (baseurl,i,i)
        pager_list.append(temp)
    if currentPage>=totalpage:
        next="<a href='#'>下一页</a>"
    else:
        next="<a href='%s%d'>下一页</a>" % (baseurl,currentPage+1)
    pager_list.append(next)
    if currentPage>=totalpage:
        last="<a href=''>末页</a>"
    else:
        last="<a href='%s%d'>末页</a>" % (baseurl,totalpage)
    pager_list.append(last)
    result=''.join(pager_list)
    return mark_safe(result)   #把字符串转成html语言

分页实例

总结，分页时需要做三件事：

• 创建处理分页数据的类
• 根据分页数据获取数据
• 输出分页HTML，即：［上一页］［1］［2］［3］［4］［5］［下一页］

跨站请求伪造：CSRF

一、简介

django为用户实现防止跨站请求伪造的功能，通过中间件 django.middleware.csrf.CsrfViewMiddleware 来完成。而对于django中设置防跨站请求伪造功能有分为全局和局部。

全局：

　　中间件 django.middleware.csrf.CsrfViewMiddleware

csrf默认情况下只对post提交有效。

实例：

默认settings.py中间件里面设置了csrf，只要有post提交就要遵循这个规则，所以要在html页面form里面写上{% csrf_token %}，并且views.py返回时要用render方法。

HTML：

 

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <form action="/csrf/" method="post">
        {% csrf_token %}
        <input name="n1">
        <input type="submit" value="submit" >
    </form>
</body>
</html>

 

views.py:

def csrf(request):
    return render(request,"csrf.html")

注：settings.py里面去掉django.middleware.csrf.CsrfViewMiddleware时，任何地方都用不上csrf，所有的地方都失效

局部：

• @csrf_protect，为当前函数强制设置防跨站请求伪造功能，即便settings中没有设置全局中间件。
• @csrf_exempt，取消当前函数防跨站请求伪造功能，即便settings中设置了全局中间件。

注：from django.views.decorators.csrf import csrf_exempt,csrf_protect

代码：

 

from django.views.decorators.csrf import csrf_exempt,csrf_protect
#settings.py里面注销了中间件CSRF，如果想把某一个方法必须遵循CSRF，就要写上该装饰器
#html写{% csrf_token %}
#函数里面写render
@csrf_protect
def csrf(request):
    return render(request,"csrf.html")

#settings.py里面就算设置了中间件CSRF，只要写上该装饰器，html就不用写{% csrf_token %}，函数里面也不用写render
@csrf_exempt
def csrf(request):
    return HttpResponse("CSRF")

 

二、应用

1、普通表单

 

veiw中设置返回值：
　　return render_to_response('Account/Login.html',data,context_instance=RequestContext(request))　　
     或者
     return render(request, 'xxx.html', data)

html中设置Token:
　　{% csrf_token %}

 

注：如果返回值使用render_to_response，一定要写上context_instance=RequestContext(request)。原来render_to_response，不具有生成随机字符串的功能，render内部是自动生成该参数。

2、Ajax

对于传统的form，可以通过表单的方式将token再次发送到服务端，而对于ajax的话，使用如下方式。

view.py

 

from django.template.context import RequestContext
# Create your views here.

def test(request):

    if request.method == 'POST':
        print request.POST
        return HttpResponse('ok')
    return  render_to_response('app01/test.html',context_instance=RequestContext(request))

 

text.html

<!DOCTYPE html>
<html>
<head lang="en">
    <meta charset="UTF-8">
    <title></title>
</head>
<body>
    {% csrf_token %}

    <input type="button" onclick="Do();"  value="Do it"/>

    <script src="/static/plugin/jquery/jquery-1.8.0.js"></script>
    <script src="/static/plugin/jquery/jquery.cookie.js"></script>
    <script type="text/javascript">
        var csrftoken = $.cookie('csrftoken');

        function csrfSafeMethod(method) {
            // these HTTP methods do not require CSRF protection
            return (/^(GET|HEAD|OPTIONS|TRACE)$/.test(method));
        }
        $.ajaxSetup({
            beforeSend: function(xhr, settings) {
                if (!csrfSafeMethod(settings.type) && !this.crossDomain) {
                    xhr.setRequestHeader("X-CSRFToken", csrftoken);
                }
            }
        });
        function Do(){

            $.ajax({
                url:"/app01/test/",
                data:{id:1},
                type:'POST',
                success:function(data){
                    console.log(data);
                }
            });

        }
    </script>
</body>
</html>

注：ajaxSetup在所有ajax执行之前都要执行该方法，相当于ajax全局配置

admin

django amdin是django提供的一个后台管理页面，改管理页面提供完善的html和css，使得你在通过Model创建完数据库表之后，就可以对数据进行增删改查，而使用django admin 则需要以下步骤：

• 创建后台管理员
• 配置url
• 注册和配置django admin后台管理页面

1、创建后台管理员

1	python manage.py createsuperuser

输入用户名、密码、邮箱。。。

2、配置后台管理url

1	url(r'^admin/', include(admin.site.urls))

3、注册和配置django admin 后台管理页面

a、在admin中执行如下配置

 

from django.contrib import admin

from app01 import  models

admin.site.register(models.UserType)
admin.site.register(models.UserInfo)
admin.site.register(models.UserGroup)
admin.site.register(models.Asset)

 

b、设置数据表名称

 

class UserType(models.Model):
    name = models.CharField(max_length=50)

    class Meta:
        verbose_name = '用户类型'  #在admin里面不显示UserType，直接显示中文的：用户类型
        verbose_name_plural = '用户类型'  #用户类型后面加个s

 

c、打开表之后，设定默认显示，需要在model中作如下配置

class UserType(models.Model):
    name = models.CharField(max_length=50)

    def __unicode__(self):
        return self.name  #显示name

 

from django.contrib import admin

from app01 import  models

class UserInfoAdmin(admin.ModelAdmin):
    list_display = ('username', 'password', 'email') #显示多列

admin.site.register(models.UserType)
admin.site.register(models.UserInfo,UserInfoAdmin)  #配置
admin.site.register(models.UserGroup)
admin.site.register(models.Asset)

 

d、为数据表添加搜索功能

 

from django.contrib import admin

from app01 import  models

class UserInfoAdmin(admin.ModelAdmin):
    list_display = ('username', 'password', 'email')
    search_fields = ('username', 'email')  #输入关键字进行搜索，类似like模糊查询

admin.site.register(models.UserType)
admin.site.register(models.UserInfo,UserInfoAdmin)
admin.site.register(models.UserGroup)
admin.site.register(models.Asset)

 

e、添加快速过滤

 

from django.contrib import admin

from app01 import  models

class UserInfoAdmin(admin.ModelAdmin):
    list_display = ('username', 'password', 'email')
    search_fields = ('username', 'email')
    list_filter = ('username', 'email')

admin.site.register(models.UserType)
admin.site.register(models.UserInfo,UserInfoAdmin)
admin.site.register(models.UserGroup)
admin.site.register(models.Asset)