一、contentType组件

1.项目背景

路飞学城项目，目前暂时有课程表(有各种课程)以及价格策略表(不同的学时，价格不同)

2.数据库的分析

版本一

? 课程表

? 价格表

缺点：可维护性差，不同课程的所需字段可能不一致，这样会导致课程表结构混乱

版本二

学位课表

? 专题课表

? 价格表

优点：课程表结构清晰，如果有新的课程类型，可以直接创建新的表

缺点：但是价格表的结构变得混乱，可维护性差

版本三

? 学位课表

? 专题课表

? 价格表

? contentType表

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

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

原文：https://www.cnblogs.com/xvchengqi/p/10150558.html