Djando框架进阶

摘要

  • 跨站请求
  • Cookie
  • Session
  • 缓存
  • 分页
  • 序列化
  • 信号
  • Mixin
  • django邮件配置
  • xss过滤

跨站请求伪造

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

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

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

应用

普通表单

1
2
3
4
5
6
7
# veiw中设置返回值:
return render_to_response('Account/Login.html',data,context_instance=RequestContext(request))  

return render(request, 'xxx.html', data)

# html中设置Token:
{% csrf_token %}

Ajax

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

1
2
3
4
5
6
7
8
9
10
11
# view
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))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
# 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>

更多:https://docs.djangoproject.com/en/dev/ref/csrf/#ajax

Cookie

数据保存在客户端,可以减少服务端数据存储压力,但是不适合放敏感信息

获取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: 后台控制过期时间

设置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: '/' });

Session

session与cookie相比保存在服务端,可以存放一些敏感信息

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

  • 数据库(默认)
  • 缓存
  • 文件
  • 缓存+数据库
  • 加密cookie

数据库Session

Django默认将Session数据存储在数据库中,即:django_session 表中。

  • request.session.set_expiry(60*10)

配置 settings.py

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# 引擎(默认)
SESSION_ENGINE = 'django.contrib.sessions.backends.db'
# Session的cookie保存在浏览器上时的key,即:sessionid=随机字符串(默认)
SESSION_COOKIE_NAME = "sessionid"
# Session的cookie保存的路径(默认)
SESSION_COOKIE_PATH = "/"
# Session的cookie保存的域名(默认)
SESSION_COOKIE_DOMAIN = None
# 是否Https传输cookie(默认)
SESSION_COOKIE_SECURE = False
# 是否Session的cookie只支持http传输(默认)
SESSION_COOKIE_HTTPONLY = True
# Session的cookie失效日期(2周)(默认)
SESSION_COOKIE_AGE = 1209600
# 是否关闭浏览器使得Session过期(默认)
SESSION_EXPIRE_AT_BROWSER_CLOSE = False
# 是否每次请求都保存Session,默认修改之后才保存(默认)
# 设置之后只有在没有操作的时间超过了超时时间才会失效
# 也就是说每次请求都会更新session的超时时间
SESSION_SAVE_EVERY_REQUEST = False

使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
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")

request.session.set_expiry(value)
* 如果value是个整数,session会在些秒数后失效。
* 如果value是个datatime或timedelta,session就会在这个时间后失效。
* 如果value是0,用户关闭浏览器session就会失效。
* 如果value是None,session会依赖全局session失效策略。

缓存Session

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# 引擎
SESSION_ENGINE = 'django.contrib.sessions.backends.cache'
# 使用的缓存别名(默认内存缓存,也可以是memcache),此处别名依赖缓存的设置
SESSION_CACHE_ALIAS = 'default'
# Session的cookie保存在浏览器上时的key,即:sessionid=随机字符串
SESSION_COOKIE_NAME = "sessionid"
# Session的cookie保存的路径
SESSION_COOKIE_PATH = "/"
# Session的cookie保存的域名
SESSION_COOKIE_DOMAIN = None
# 是否Https传输cookie
SESSION_COOKIE_SECURE = False
# 是否Session的cookie只支持http传输
SESSION_COOKIE_HTTPONLY = True
# Session的cookie失效日期(2周)
SESSION_COOKIE_AGE = 1209600
# 是否关闭浏览器使得Session过期
SESSION_EXPIRE_AT_BROWSER_CLOSE = False
# 是否每次请求都保存Session,默认修改之后才保存
SESSION_SAVE_EVERY_REQUEST = False

文件Session

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# 引擎
SESSION_ENGINE = 'django.contrib.sessions.backends.file'
# 缓存文件路径,如果为None,则使用tempfile模块获取一个临时地址tempfile.gettempdir()
# 如:/var/folders/d3/j9tj0gz93dg06bmwxmhh6_xm0000gn/T
SESSION_FILE_PATH = None
# Session的cookie保存在浏览器上时的key,即:sessionid=随机字符串
SESSION_COOKIE_NAME = "sessionid"
# Session的cookie保存的路径
SESSION_COOKIE_PATH = "/"
# Session的cookie保存的域名
SESSION_COOKIE_DOMAIN = None
# 是否Https传输cookie
SESSION_COOKIE_SECURE = False
# 是否Session的cookie只支持http传输
SESSION_COOKIE_HTTPONLY = True
# Session的cookie失效日期(2周)
SESSION_COOKIE_AGE = 1209600
# 是否关闭浏览器使得Session过期
SESSION_EXPIRE_AT_BROWSER_CLOSE = False
# 是否每次请求都保存Session,默认修改之后才保存
SESSION_SAVE_EVERY_REQUEST = False

缓存+数据库Session

1
SESSION_ENGINE = 'django.contrib.sessions.backends.cached_db'

加密cookie Session

1
SESSION_ENGINE = 'django.contrib.sessions.backends.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是动态网站,所有每次请求均会去数据进行相应的操作,当程序访问量大时,耗时必然会更加明显,最简单解决方式是使用:缓存,缓存将一个某个views的返回值保存至内存或者memcache中,5分钟内再有人来访问时,则不再去执行view中的操作,而是直接从内存或者Redis中之前缓存的内容拿到,并返回。

Django中提供了6种缓存方式:

  • 开发调试
  • 内存
  • 文件
  • 数据库
  • Memcache缓存(python-memcached模块)
  • Memcache缓存(pylibmc模块)
  • 通过第三方模块调用redis

开发调试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
# 此为开始调试用,实际内部不做任何操作
# 配置:
CACHES = {
'default': {
'BACKEND': 'django.core.cache.backends.dummy.DummyCache', # 引擎
'TIMEOUT': 300, # 缓存超时时间(默认300,None表示永不过期,0表示立即过期)
'OPTIONS':{
'MAX_ENTRIES': 300, # 最大缓存个数(默认300)
'CULL_FREQUENCY': 3, # 缓存到达最大个数之后,剔除缓存个数的比例,即:1/CULL_FREQUENCY(默认3)
},
'KEY_PREFIX': '', # 缓存key的前缀(默认空)
'VERSION': 1, # 缓存key的版本(默认1)
'KEY_FUNCTION': 函数名 # 生成key的函数(默认函数会生成为:【前缀:版本:key】)
}
}


# 自定义key
def default_key_func(key, key_prefix, version):
"""
Default function to generate keys.

Constructs the key used by all other methods. By default it prepends
the `key_prefix'. KEY_FUNCTION can be used to specify an alternate
function with custom key making behavior.
"""
return '%s:%s:%s' % (key_prefix, version, key)

def get_key_func(key_func):
"""
Function to decide which key function to use.

Defaults to ``default_key_func``.
"""
if key_func is not None:
if callable(key_func):
return key_func
else:
return import_string(key_func)
return default_key_func

内存

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

# 注:其他配置同开发调试版本

文件

1
2
3
4
5
6
7
8
9
10
# 此缓存将内容保存至文件
# 配置:

CACHES = {
'default': {
'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache',
'LOCATION': '/var/tmp/django_cache',
}
}
# 注:其他配置同开发调试版本

数据库

1
2
3
4
5
6
7
8
9
10
11
# 此缓存将内容保存至数据库

# 配置:
CACHES = {
'default': {
'BACKEND': 'django.core.cache.backends.db.DatabaseCache',
'LOCATION': 'my_cache_table', # 数据库表
}
}

# 注:执行创建表命令 python manage.py createcachetable

Memcache缓存(python-memcached模块)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
# 此缓存使用python-memcached模块连接memcache

CACHES = {
'default': {
'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
'LOCATION': '127.0.0.1:11211',
}
}

CACHES = {
'default': {
'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
'LOCATION': 'unix:/tmp/memcached.sock',
}
}

CACHES = {
'default': {
'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
'LOCATION': [
'172.19.26.240:11211',
'172.19.26.242:11211',
# 设置权重,memcache模块做的
('172.19.26.240:11211',1)
('172.19.26.242:11211',10)
]
}
}

Memcache缓存(pylibmc模块)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
# 此缓存使用pylibmc模块连接memcache

CACHES = {
'default': {
'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache',
'LOCATION': '127.0.0.1:11211',
}
}

CACHES = {
'default': {
'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache',
'LOCATION': '/tmp/memcached.sock',
}
}

CACHES = {
'default': {
'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache',
'LOCATION': [
'172.19.26.240:11211',
'172.19.26.242:11211',
]
}
}

Redis缓存(依赖:pip3 install django-redis)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
CACHES = {
"default": {
"BACKEND": "django_redis.cache.RedisCache",
"LOCATION": "redis://127.0.0.1:6379",
"OPTIONS": {
'DB': 0,
"CLIENT_CLASS": "django_redis.client.DefaultClient",
"CONNECTION_POOL_KWARGS": {"max_connections": 100}
# "PASSWORD": "密码",
'SOCKET_TIMEOUT': 10,
}
}
}

#配置redis django-redis-cache
CACHES = {
'default': {
'BACKEND': 'redis_cache.RedisCache',
'LOCATION': '127.0.0.1:6379',
'OPTIONS': {
'DB': 0,
'PASSWORD': 'abxdcfgda',
'PARSER_CLASS': 'redis.connection.HiredisParser',
# 'PICKLE_VERSION': 2,
#'CONNECTION_POOL_CLASS': 'redis.ConnectionPool',
'SOCKET_TIMEOUT': 10,
#'CONNECTION_POOL_CLASS_KWARGS': {
# 'max_connections': 2,
# }
},
},
}

# 视图中链接并操作
from django_redis import get_redis_connection
conn = get_redis_connection("default")

全站使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 使用中间件,经过一系列的认证等操作,
# 如果内容在缓存中存在,则使用FetchFromCacheMiddleware获取内容并返回给用户
# 当返回给用户之前,判断缓存中是否已经存在
# 如果不存在则UpdateCacheMiddleware会将缓存保存至缓存
# 从而实现全站缓存

MIDDLEWARE = [
'django.middleware.cache.UpdateCacheMiddleware',
# 其他中间件...
'django.middleware.cache.FetchFromCacheMiddleware',
]

CACHE_MIDDLEWARE_ALIAS = ""
CACHE_MIDDLEWARE_SECONDS = ""
CACHE_MIDDLEWARE_KEY_PREFIX = ""

单独视图缓存

1
2
3
4
5
6
7
8
9
10
11
12
13
# 方式一:
from django.views.decorators.cache import cache_page

@cache_page(60 * 15)
def my_view(request):
...

# 方式二:
from django.views.decorators.cache import cache_page

urlpatterns = [
url(r'^foo/([0-9]{1,2})/$', cache_page(60 * 15)(my_view)),
]

局部视图使用

1
2
3
4
5
6
7
8
9
# 引入TemplateTag

{% load cache %}

# 使用缓存

{% cache 5000 缓存key %}
缓存内容
{% endcache %}

序列化

关于Django中的序列化主要应用在将数据库中检索的数据返回给客户端用户,特别的Ajax请求一般返回的为Json格式。

serializers

1
2
3
4
5
from django.core import serializers

ret = models.BookType.objects.all()

data = serializers.serialize("json", ret)

json.dumps

1
2
3
4
5
6
7
8
import json

#ret = models.BookType.objects.all().values('caption')
ret = models.BookType.objects.all().values_list('caption')

ret=list(ret)

result = json.dumps(ret)

由于json.dumps时无法处理datetime日期,所以可以通过自定义处理器来做扩展,如:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import json 
from datetime import date
from datetime import datetime

class JsonCustomEncoder(json.JSONEncoder):

def default(self, field):

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


# ds = json.dumps(d, cls=JsonCustomEncoder)

信号

Django中提供了“信号调度”,用于在框架执行操作时解耦。通俗来讲,就是一些动作发生的时候,信号允许特定的发送者去提醒一些接受者。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
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 # 创建数据库连接时,自动触发
User
user_logged_in
user_login_failed
user_logged_out

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
from django.core.signals import request_finished
from django.core.signals import request_started
from django.core.signals import got_request_exception

from django.db.models.signals import class_prepared
from django.db.models.signals import pre_init, post_init
from django.db.models.signals import pre_save, post_save
from django.db.models.signals import pre_delete, post_delete
from django.db.models.signals import m2m_changed
from django.db.models.signals import pre_migrate, post_migrate

from django.test.signals import setting_changed
from django.test.signals import template_rendered

from django.db.backends.signals import connection_created

from django.contrib.auth.signals import user_logged_in,user_logged_out,user_login_failed


def callback(sender, **kwargs):
print("xxoo_callback")
print(sender,kwargs)

xxoo.connect(callback)
# xxoo指上述导入的内容

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

@receiver(request_finished)
def my_callback(sender, **kwargs):
print("Request finished!")

自定义信号

定义信号

1
2
import django.dispatch
pizza_done = django.dispatch.Signal(providing_args=["toppings", "size"])

注册信号

1
2
3
4
5
def callback(sender, **kwargs):
print("callback")
print(sender,kwargs)

pizza_done.connect(callback)

触发信号

1
2
3
from 路径 import pizza_done

pizza_done.send(sender='seven',toppings=123, size=456)

由于内置信号的触发者已经集成到Django中,所以其会自动调用,而对于自定义信号则需要开发者在任意位置触发。

Mixin

什么是Mixin

在面向对象编程中,Mixin是一种类,这种类包含了其他类要使用的方法,但不必充当其他类的父类。其他类是如何获取Mixin中的方法因语言的不同而不同。所以有时候Mixin被描述为include(包含)而不是 inheritance(继承)

Mixins鼓励代码重用,并且可以用于避免多重继承可能导致(”如钻石问题”)的继承歧义,或者解决一个缺乏对一种语言的多重继承的支持。mixin也可以被看作实现方法的接口。这种模式是强制依赖性反转原理的一个例子。

Mixin来源

mix-in是一种冰淇淋,提供一些基础口味(香草,巧克力等),在这种基础口味上可以添加其他食品(坚果,小饼干)。Mixin术语由此得来。

定义

Mixin是一种语言概念,允许程序员将一些代码注入到一个类中。Mixin编程是一种软件开发的风格,其中功能单元在一个类中创建,然后与其他类混合。

mixin类扮演父类的角色,包含其他类想要的功能。然后,一个子类可以继承或简单地重用此功能,但不能作为专业化的手段。通常,mixin将会将所需的功能导出到子类中,而不会创建一个单一的is a关系。 这是mixin和继承的概念之间的重要区别,因为子类仍然可以继承父类的所有功能,但是,不必一定应用关于子对象”作为一种”父语义的语义。

优点

  • 通过允许多个类使用通用功能,但没有多重继承的复杂语义,为多重继承提供了一种机制.
  • 代码可重用性:当程序员希望在不同类之间共享功能时,Mixins很有用。不是一遍又一遍地重复相同的代码,通用功能可以简单地分组成一个混合,然后继承到需要它的每个类中。
  • Mixins允许继承和使用只有父类的所需功能,不一定是父类的所有功能.

Django中Mixin和View组合技巧

  • Mixin提供数据
  • View提供模板和渲染
  • 所以一般get_context_data在Mixin中
  • get(),post(),head()在View中。
  • Mixin和View不是能随意组合的,必须要注意他们之间的方法的解析顺序,也就是MRO(method resolution order)。

关于MRO

1
2
3
4
5
6
7
8
class TemplateView(TemplateResponseMixin, ContextMixin, View):
"""
A view that renders a template. This view will also pass into the context
any keyword arguments passed by the URLconf.
"""
def get(self, request, *args, **kwargs):
context = self.get_context_data(**kwargs)
return self.render_to_response(context)
  • TemplateView继承自TemplateResponseMixin,ContextMixin以及View
  • 通过get方法将上面的三个东西联系在一起
  • TempalteResponseMixin和ContextMixin实现分别如下:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
class TemplateResponseMixin(object):
"""
A mixin that can be used to render a template.
"""
template_name = None
template_engine = None
response_class = TemplateResponse
content_type = None

def render_to_response(self, context, **response_kwargs):
"""
Returns a response, using the `response_class` for this
view, with a template rendered with the given context.
If any keyword arguments are provided, they will be
passed to the constructor of the response class.
"""
response_kwargs.setdefault('content_type', self.content_type)
return self.response_class(
request=self.request,
template=self.get_template_names(),
context=context,
using=self.template_engine,
**response_kwargs
)

def get_template_names(self):
"""
Returns a list of template names to be used for the request. Must return
a list. May not be called if render_to_response is overridden.
"""
if self.template_name is None:
raise ImproperlyConfigured(
"TemplateResponseMixin requires either a definition of "
"'template_name' or an implementation of 'get_template_names()'")
else:
return [self.template_name]

class ContextMixin(object):
"""
A default context mixin that passes the keyword arguments received by
get_context_data as the template context.
"""

def get_context_data(self, **kwargs):
if 'view' not in kwargs:
kwargs['view'] = self
return kwargs

Django中Mixin和View把原来的试图函数中的三个东西分开了,模板(TemplateResponseMixin),上下文数据(ContextMixin),负责将这些联系起来的一个东西(View)

  • ContextMixin:直接就是一个get_context_data,用于返回context数据。
  • View:会调用所有的get方法,post方法,View中是没有返回一个response的,所以光继承View的话,必须要重写get等,以返回一个response。
  • TemplateResponseMixin:故名思议,这个Mixin会加入Template的基本信息,也就是template的名字。

但这里并不适合把这两个Mixin类解释为TemplatesView的父类,而更倾向于解释为提供接口及数据。把这两个类封装成mixin格式可以提高代码的重用性,所以可以说Mixin应该是一种设计思想。

Django中的实际应用

在FBV中,如果希望为视图的访问加上限制的话可以直接使用装饰器,但在CBV中就不能直接使用装饰器了。

比如说django auth提供的默认的login_required装饰器和permission_required装饰器,在CBV中则为LoginRequiredMixin以及PermissionRequiredMixin

这两个Mixin都继承于AccessMixin(导致了它们引起的异常跳转指向同一个url)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
class LoginRequiredMixin(AccessMixin):
"""
CBV mixin which verifies that the current user is authenticated.
"""
def dispatch(self, request, *args, **kwargs):
if not request.user.is_authenticated:
# 该方法继承于AccessMixin
return self.handle_no_permission()
return super(LoginRequiredMixin, self).dispatch(request, *args, **kwargs)


class PermissionRequiredMixin(AccessMixin):
"""
CBV mixin which verifies that the current user has all specified
permissions.
"""
permission_required = None

def get_permission_required(self):
"""
Override this method to override the permission_required attribute.
Must return an iterable.
"""
if self.permission_required is None:
raise ImproperlyConfigured(
'{0} is missing the permission_required attribute. Define {0}.permission_required, or override '
'{0}.get_permission_required().'.format(self.__class__.__name__)
)
if isinstance(self.permission_required, six.string_types):
perms = (self.permission_required, )
else:
perms = self.permission_required
return perms

def has_permission(self):
"""
Override this method to customize the way permissions are checked.
"""
perms = self.get_permission_required()
return self.request.user.has_perms(perms)

def dispatch(self, request, *args, **kwargs):
if not self.has_permission():
# 该方法继承于AccessMixin
return self.handle_no_permission()
return super(PermissionRequiredMixin, self).dispatch(request, *args, **kwargs)

两个Mixin都实现了dispatch方法,并且在执行完以后调用的是按照MRO数组中的下一个类的dispatch方法,如果我们定义一个cbv,继承这两个mixin方法

1
2
class MyView(LoginRequiredMixin, PermissionRequiredMixin, View)
pass

那么,dispatch按照依次调用的顺序则是,LoginRequiredMixinPermissionRequiredMixnAccessMixin(没有disptach方法),View。因此,基类View一定要放在多重继承的最后面,因为它的dispatch方法调用就是代表业务逻辑的handler了。

LoginRequiredMixin或者PermissionRequiredMixin调用继承自AccessMixinhandle_no_permission方法时,如果raise_exception被设置为True,会抛出一个PermissionDenied的异常,否则跳转到login_url

邮件配置

1
2
3
4
5
6
7
8
9
10
11
# 阿里云封掉了25端口,这里使用SSL/465发送邮件
# 先安装 django_smtp_ssl
pip install django_smtp_ssl

# settings 配置
EMAIL_HOST = "smtp.163.com"
EMAIL_PORT = 465
EMAIL_HOST_USER = "******@163.com"
EMAIL_HOST_PASSWORD = '******'
EMAIL_FROM = "******@163.com"
EMAIL_BACKEND = 'django_smtp_ssl.SSLEmailBackend'

xss过滤

  • 通过使用BeautifulSoup过滤标签以及属性进行处理
1
2
3
4
5
6
7
8
9
10
11
12
from bs4 import BeautifulSoup
soup = BeautifulSoup(content, 'html.parser')
tag = soup.find('script')
tag.hidden = True
tag.clear()

span = soup.find('span')
print(span.attrs)
del span.attrs['style']

content = soup.decode()
print(content)

分页

Django内置分页

views

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
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})

html

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
<!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>

扩展内置分页:views.py

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
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})

扩展内置分页:Html

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
<!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>

自定义分页

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

  • 设定每页显示数据条数
  • 用户输入页码(第一页、第二页…)
  • 根据设定的每页显示条数和当前页码,计算出需要取数据表的起始位置
  • 在数据表中根据起始位置取值,页面上输出数据

需要在页面上显示分页的页面。如:[上一页][1][2][3][4][5][下一页]

  • 设定每页显示数据条数
  • 用户输入页码(第一页、第二页…)
  • 设定显示多少页号
  • 获取当前数据总条数
  • 根据设定显示多少页号和数据总条数计算出,总页数
  • 根据设定的每页显示条数和当前页码,计算出需要取数据表的起始位置
  • 在数据表中根据起始位置取值,页面上输出数据
  • 输出分页html,如:[上一页][1][2][3][4][5][下一页]

分页实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
#!/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][下一页]