DAY103 - Rest Framework(八）- contentType组件和Django缓存机制

1、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')

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