DAY103 - Rest Framework(八）- contentType组件和Django缓存机制
一、contentType组件
1.项目背景
路飞学城项目，目前暂时有课程表(有各种课程)以及价格策略表(不同的学时，价格不同)
2.数据库的分析
版本一
课程表
| id | 课程名 | 类型 |
|---|---|---|
| 1 | Django基础 | 专题课 |
| 2 | Python全栈 | 学位课 |
| 3 | 前端基础 | 专题课 |
价格表
| id | 周期 | 价格 | 课程ID |
|---|---|---|---|
| 1 | 1 | 19.9 | 1 |
| 2 | 2 | 29.9 | 1 |
| 3 | 3 | 39.9 | 1 |
| 4 | 1 | 100 | 2 |
| 5 | 2 | 200 | 2 |
| 6 | 3 | 300 | 2 |
缺点：可维护性差，不同课程的所需字段可能不一致，这样会导致课程表结构混乱
版本二
学位课表
| id | 课程名 |
|---|---|
| 1 | Python全栈 |
专题课表
| id | 课程名 |
|---|---|
| 1 | Django基础 |
| 2 | 前端基础 |
价格表
| id | 周期 | 价格 | 学位课程ID | 专题课ID |
|---|---|---|---|---|
| 1 | 1 | 19.9 | 1 | |
| 2 | 2 | 29.9 | 1 | |
| 3 | 3 | 39.9 | 1 | |
| 4 | 1 | 100 | 1 | |
| 5 | 2 | 200 | 1 | |
| 6 | 3 | 300 | 1 |
优点：课程表结构清晰，如果有新的课程类型，可以直接创建新的表
缺点：但是价格表的结构变得混乱，可维护性差
版本三
学位课表
| id | 课程名 |
|---|---|
| 1 | Python全栈 |
专题课表
| id | 课程名 |
|---|---|
| 1 | Django基础 |
| 2 | 前端基础 |
价格表
| id | 周期 | 价格 | 课程名 | 课程ID |
|---|---|---|---|---|
| 1 | 1 | 19.9 | 学位课 | 1 |
| 2 | 2 | 29.9 | 学位课 | 1 |
| 3 | 3 | 39.9 | 学位课 | 1 |
| 4 | 1 | 100 | 专题课 | 1 |
| 5 | 2 | 200 | 专题课 | 1 |
| 6 | 3 | 300 | 专题课 | 1 |
contentType表
| id | app_lable | model |
|---|---|---|
| 1 | admin | logentry |
| 2 | auth | group |
| 3 | auth | permission |
| 4 | auth | user |
| 5 | contenttypes | contenttype |
| 6 | sessions | session |
| 7 | app01 | course |
| 8 | app01 | degreecourse |
| 9 | app01 | pricepolicy |
通过Django提供的ContentType表，来构建
3.contentType使用
# models.py
from django.db import models
from django.contrib.contenttypes.models import ContentType
from django.contrib.contenttypes.fields import GenericForeignKey, GenericRelation
class Course(models.Model):
title = models.CharField(max_length=32)
# 获得PricePolicy对象
price = GenericRelation(to='PricePolicy',object_id_field='course', content_type_field='course_type')
class DegreeCourse(models.Model):
title = models.CharField(max_length=32)
class PricePolicy(models.Model):
period = models.CharField(max_length=32)
price = models.FloatField()
# 跟ContentType表做外键关联
course_type = models.ForeignKey(to=ContentType)
course = models.PositiveIntegerField()
# ct_field:ContentType表做外键关联的字段
# fk_field:获得obj指向的model表的对象，并把主键给course字段
obj = GenericForeignKey(ct_field='course_type', fk_field='course')
# views.py
def test(request):
# 往价格表添加数据
# 方式一
# ret=models.ContentType.objects.filter(model='course').first()
# course=models.Course.objects.filter(pk=1).first()
# print(ret.id)
# models.PricePolicy.objects.create(period='1',price=19.9,course=course.id,course_type=ret.id)
# 方式二
# models中的：obj = GenericForeignKey(ct_field='course_type', fk_field='course')
# fk_field：会拿到course对象的ID
# ct_field：会通过course对象的表名，去'course_type'外键连接的contentType表中找到对应的，并返回ID
course = models.Course.objects.filter(pk=1).first()
models.PricePolicy.objects.create(period='1',price=19.9,obj = course)
models.PricePolicy.objects.create(period='2',price=29.9,obj = course)
models.PricePolicy.objects.create(period='3',price=39.9,obj = course)
return HttpResponse('ok')
二、Django缓存机制
1.什么是缓存
在动态网站中,用户所有的请求,服务器都会去数据库中进行相应的增,删,查,改,渲染模板,执行业务逻辑,最后生成用户看到的页面.
当一个网站的用户访问量很大的时候,每一次的的后台操作,都会消耗很多的服务端资源,所以必须使用缓存来减轻后端服务器的压力.
缓存是将一些常用的数据保存内存或者memcache中,在一定的时间内有人来访问这些数据时,则不再去执行数据库及渲染等操作,而是直接从内存或memcache的缓存中去取得数据,然后返回给用户.
2.Django中缓存的6种方式
- 开发调试缓存
- 内存缓存
- 文件缓存
- 数据库缓存
- Memcache缓存(使用python-memcached模块)
- Memcache缓存(使用pylibmc模块)
经常使用的有文件缓存和Mencache缓存
3.缓存的配置
CACHES = {
'default': {
# 缓存后台使用的引擎
# 1.开发调试缓存
'BACKEND':'django.core.cache.backends.dummy.DummyCache',
# 2.内存缓存
'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
'LOCATION': 'unique-snowflake', # 写在内存中的变量的唯一值
# 3.文件缓存
'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache', #指定缓存使用的引擎
'LOCATION': '/var/tmp/django_cache', #指定缓存的路径
# 4.数据库缓存
'BACKEND': 'django.core.cache.backends.db.DatabaseCache', # 指定缓存使用的引擎
'LOCATION': 'cache_table', # 数据库表
# 5.Memcache缓存(使用python-memcached模块连接memcache)
'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache', # 指定缓存使用的引擎
'LOCATION': '192.168.10.100:11211', # 指定Memcache缓存服务器的IP地址和端口,可以以列表的形式指定多台
# 6.Memcache缓存(使用pylibmc模块连接memcache)
'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache', # 指定缓存使用的引擎
'LOCATION':'192.168.10.100:11211', # 指定本机的11211端口为Memcache缓存服务器,分布式缓存
# 缓存超时时间（默认300秒，None表示永不过期，0表示立即过期）
# 每300秒清空一次缓存
'TIMEOUT': 300,
'OPTIONS':{
# 最大缓存记录的数量（默认300）
'MAX_ENTRIES': 300,
# 缓存到达最大个数之后，剔除缓存个数的比例，即：1/CULL_FREQUENCY（默认3）
'CULL_FREQUENCY': 3,
},
}
}
# 注：如果seting.py里不配置，会使用默认的，也是内存缓存
CACHES = {
'default': {
'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
}
}
4.Django中缓存的使用
- 全站缓存
既然是全站缓存,当然要使用Django中的中间件.
用户的请求通过中间件,经过一系列的认证等操作,如果请求的内容在缓存中存在,则使用FetchFromCacheMiddleware获取内容并返回给用户
当返回给用户之前,判断缓存中是否已经存在,如果不存在,则UpdateCacheMiddleware会将缓存保存至Django的缓存之中,以实现全站缓存
# 全站缓存
# views.py
import time
def test(request):
ctime = time.time()
return HttpResponse(ctime)
def test2(request):
ctime = time.time()
return HttpResponse(ctime)
# setting.py
MIDDLEWARE_CLASSES = (
# 当返回给用户之前,判断缓存中是否已经存在,如果不存在,则UpdateCacheMiddleware会将缓存保存至Django的缓存之中,以实现全站缓存
'django.middleware.cache.UpdateCacheMiddleware', #响应HttpResponse中设置几个headers
'django.contrib.sessions.middleware.SessionMiddleware',
'django.middleware.common.CommonMiddleware',
'django.middleware.csrf.CsrfViewMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.auth.middleware.SessionAuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
'django.middleware.clickjacking.XFrameOptionsMiddleware',
'django.middleware.security.SecurityMiddleware',
# 当请求经过了所有的中间件验证后，如果请求的内容在缓存中存在,则从缓存获取
'django.middleware.cache.FetchFromCacheMiddleware', #用来缓存通过GET和HEAD方法获取的状态码为200的响应
)
# 多少秒刷新一次缓存
CACHE_MIDDLEWARE_SECONDS=10
-
单视图缓存
import time
from django.views.decorators.cache import cache_page
# 缓存刷新时间5秒
@cache_page(5)
def test(request):
ctime = time.time()
return HttpResponse(ctime)
def test2(request):
ctime = time.time()
return HttpResponse(ctime)
-
页面局部缓存
import time
def test(request):
ctime = time.time()
return render(request, 'test.html', locals())
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
{% load cache %}
<!-- {% cache 缓存刷新时间 名字 %} -->
{% cache 5 'test' %}
页面局部缓存
{{ ctime }}
{% endcache %}
<hr>
{{ ctime }}
</body>
</html>
