django 整理二

跨站请求伪造

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

　　html中设置Token: {% csrf_token %}

全局：

　　中间件 django.middleware.csrf.CsrfViewMiddleware

局部：

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

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

文件上传

上传到代码目录

<form action="/lx/upload/" method="post" enctype="multipart/form-data">
    {% csrf_token %}
    <input type="file" name="fafa">
    <input type="submit" value="go">
</form>

def upload_file(request):
    if request.method == "POST":
        obj = request.FILES.get('fafa')
        print("obj.name:", obj.name)
        f = open(obj.name, 'wb')
        for chunk in obj.chunks():
            f.write(chunk)
        f.close()
    return render(request,'lx/file.html')

上传到数据库

from django import forms
from lx import models


class FileForm(forms.Form):
    ExcelFile = forms.FileField()


def upload(request):
    uf = FileForm(request.POST,request.FILES)

    if uf.is_valid():
        u_file = models.UploadFile()
        u_file.userid = 1
        u_file.file = uf.cleaned_data['ExcelFile']
        u_file.save()
        print(u_file.file)
    else:
        print('uf:', uf)

    return render(request, 'lx/file.html', {'uf': uf})

<form action="/lx/upload2/" method="post" enctype="multipart/form-data">
    {% csrf_token %}
    <p>{{ uf }}</p>
    <input type="submit" value="go">
</form>

class UploadFile(models.Model):
    userid = models.CharField(max_length=30)
    file = models.FileField(upload_to='./upload2/')
    date = models.DateTimeField(auto_now_add=True)

Session

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

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

数据库Session

    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_DOMAIN = '.baidu.com'
    SESSION_COOKIE_SECURE = False                            # 是否Https传输cookie（默认）
    SESSION_COOKIE_HTTPONLY = True                           # 是否Session的cookie只支持http传输（默认）
    SESSION_COOKIE_AGE = 86400 * 14                             # Session的cookie失效日期（2周）（默认）
    SESSION_EXPIRE_AT_BROWSER_CLOSE = False                  # 是否关闭浏览器使得Session过期（默认）
    SESSION_SAVE_EVERY_REQUEST = False                       # 是否每次请求都保存Session，默认修改之后才保存（默认）

缓存Session

CACHES = {
    'default': {       # 这个地方必须是'default'，否则会报错
        'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
        'LOCATION': [
            '127.0.0.1:11211',
            '127.0.0.1:11212',
        ]

    }
}

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，默认修改之后才保存

文件Session（文件路径必须存在）

SESSION_ENGINE = 'django.contrib.sessions.backends.file'  # 引擎
SESSION_FILE_PATH = os.path.join(BASE_DIR, 'cache')
# 缓存文件路径，如果为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，默认修改之后才保存

缓存+数据库Session

CACHES = {
    # 'default': {
    #     'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache',
    #     'LOCATION': os.path.join(BASE_DIR, 'cache_file'),
    #     'TIMEOUT': 600,
    #     'OPTIONS': {
    #         'MAX_ENTRIES': 1000
    #     }
    # }
    'default': {
        'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
        'LOCATION': [
            '127.0.0.1:11211',
            '127.0.0.1:11212',
        ]

    }
}

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

加密cookies Session

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

session操作如下：

def index(request):
    # request.session['k1'] = 123   # 赋值
    #
    # v1 = request.session['k1']

    # v2 = request.session.get('k1',None)  # 不存在则为None
    #
    # v3 = request.session.setdefault('k1', 456)  # 存在则不设置
    # print(v2, v3)
    # del request.session['k1']

    # 所有键、值 、键值对, 以列表的形式返回
    # request.session.setdefault('k1', 456)
    # v1 = request.session.keys()
    # v2 = request.session.values()
    # v3 = request.session.items()
    # print(v1,v2,v3)

    # v1 = request.session.session_key    # 用户session的随机字符串
    # v2 = request.session.clear_expired()   # 将所有Session失效日期小于当前日期的数据删除
    # v4 = request.session.exists('7m1k9hervqps7l131x22tnu4hvz1bf9j')   # 检查 用户session的随机字符串 在数据库中是否
    # v5 = request.session.delete('session_key')   # 删除当前用户的所有Session数据
    # # request.session.set_expiry(value)
    # #     *如果value是个整数，session会在些秒数后失效。
    # #     *如果value是个datatime或timedelta，session就会在这个时间后失效。
    # #     *如果value是0, 用户关闭浏览器session就会失效。
    # #     *如果value是None, session会依赖全局session失效策略。

    # print(v1, v2, v3, v4, v5)

    return HttpResponse("OK")

 django内置分页扩展

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:
        """
        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 page(request):
    current_page = request.GET.get('p', 1)
    # paginator = Paginator(L,10)
    paginator = CustomPaginator(current_page, 11, L, 10)
        # per_page: 每页显示条目数量
        # count:    数据总个数
        # num_pages:总页数
        # page_range:总页数的索引范围，如: (1,10),(1,200)
        # page:     page对象

    try:
        print('current_page:', current_page)
        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)

    print('posts:', posts, 'type posts:', type(posts))

    return render(request, 'lx/page.html', {'posts': posts})

<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>

 序列化

Django为我们提供了一个强大的序列化工具serializers,支持三种序列化格式：xml、json、yaml
serialize方法至少接收两个参数，
	第一: 要序列化成为的数据格式，这里是‘xml’
	第二: 要序列化的数据对象，数据通常是ORM模型的QuerySet，一个可迭代的对象
	
序列化数据：
	from django.core import serializers
	data = serializers.serialize("xml", models.UserType.objects.all())
	
序列化数据写入文件：
	with open("file.xml", "w") as out:
		xml_serializer.serialize(models.UserType.objects.all(), stream=out)
		
序列化指定字段：
	from django.core import serializers
	data = serializers.serialize('xml', models.UserType.objects.all(), fields=('name','size'))
	
序列化继承模型
	class Place(models.Model):
		name = models.CharField(max_length=50)

	class Restaurant(Place):
		serves_hot_dogs = models.BooleanField(default=False)
	
	############  序列化Restaurant中属性  ############
	data = serializers.serialize('xml', Restaurant.objects.all())
	
	############  序列化Restaurant与Place中属性  ############
	all_objects = list(Restaurant.objects.all()) + list(Place.objects.all())
	data = serializers.serialize('xml', all_objects)
	
反序列化：
	# deserialize()方法返回的是一个迭代器
	for obj in serializers.deserialize("xml", data):
		print(obj)

json.dumps无法处理datetime日期，可以通过自定义处理器来做扩展。

import json
from datetime import date
from datetime import datetime


class JsonCustomEncoder(json.JSONEncoder):
    def default(self, field):
        if isinstance(field, datetime):
            return field.strftime('%Y-%m-%d %H:%M:%S')
        elif isinstance(field, date):
            return field.strftime('%Y-%m-%d')
        else:
            return json.JSONEncoder.default(self, field)


d = date.today()
d2 = datetime.now()
print(d, d2)
ds = json.dumps(d, cls=JsonCustomEncoder)
ds2 = json.dumps(d2, cls=JsonCustomEncoder)
# ds = json.dumps(d)
print("ds:", ds)
print('ds2:', ds2)

 信号

 Django中提供了“信号调度”，用于在框架执行操作时解耦。就是一些动作发生的时候，去执行一些操作。

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

信号signal实例：

方法一（通过receiver()装饰器进行注册）：

    from django.core.signals import request_finished
    from django.dispatch import receiver

    @receiver(request_finished)
    def my_callback(sender, **kwargs):
        print("Resquest finished!")
        
方法二（手动注册）：
    
    from django.core.signals import request_finished

    def my_callback(sender, **kwargs):
        print("Resquest finished!")

    request_finished.connect(my_callback)
    
    # Signal.connect(receiver, sender=None, weak=True, dispatch_uid=None)[source]
    
        # receiver ：当前信号连接的回调函数，也就是处理信号的函数。 
        # sender ：指定从哪个发送方接收信号。 
        # weak ： 是否弱引用
        # dispatch_uid ：信号接收器的唯一标识符，以防信号多次发送。

from django.db.models.signals import pre_save
from django.dispatch import receiver
from .models import UploadFile

@receiver(pre_save, sender=UploadFile)
def my_callback(sender, **kwargs):
    print("Resquest finished!")

防止重复信号

	# 每个唯一的dispatch_uid值，接收器都只绑定到信号一次
	from django.core.signals import request_finished

	request_finished.connect(my_callback,dispatch_uid="my_unique_identifier")　　

自定义信号

from django.shortcuts import HttpResponse
import time
import django.dispatch
from django.dispatch import receiver

work_done = django.dispatch.Signal(providing_args=['path', 'time'])

def create_signal(request):
    url_path = request.path
    print("我已经做完了工作。现在我发送一个信号出去，给那些指定的接收器。")

    work_done.send(create_signal, path=url_path, time=time.strftime("%Y-%m-%d %H:%M:%S"))
    return HttpResponse("200, OK")


@receiver(work_done, sender=create_signal)
def my_callback(sender, **kwargs):
    print("我在%s时间收到来自%s的信号，请求url为%s" % (kwargs['time'], sender, kwargs["path"]))