$Django content_type组件 缓存组件

1  content_type组件(只能方便插入添加)

需求:课程，学位课（不同的课程字段不一样），价格策略

#免费课
class Free_classes (models.Model):
    id = models.AutoField (primary_key=True)
    name = models.CharField (max_length=32)
    def __str__(self):
        return self.name

#学位课
class degree_course (models.Model):
    id = models.AutoField (primary_key=True)
    name = models.CharField (max_length=32)
    def __str__(self):
        return self.name

#周期价格
class Price (models.Model):
    id = models.AutoField (primary_key=True)
    period = models.CharField (max_length=32)
    price = models.DecimalField (max_digits=8, decimal_places=2)
    table_id = models.ForeignKey (to=ContentType)
    course_id = models.IntegerField ()

model设计

from django.shortcuts import render,redirect,reverse,HttpResponse
from app01 import models
def test(request):
    #1为免费课程1 插入三个价格策略（方式1）
    course=models.degree_course.objects.filter(name='django全栈开发').first()
    from django.contrib.contenttypes.models import ContentType
    course_table=ContentType.objects.filter(model='degree_course').first()
    print(course_table)
    models.Price.objects.create(period='1个月',price=3000,table_id=course_table,course_id=course.id)
    models.Price.objects.create(period='2个月',price=6000,table_id=course_table,course_id=course.id)
    models.Price.objects.create(period='3个月',price=9000,table_id=course_table,course_id=course.id)
     #2查询所有价格策略，并且显示对应的课程名称
    #查出所有price对象,根据table_id,course_id到对应表拿到对应书籍对象
    #
    return HttpResponse('OK')    

model设计view视图（用到ContentType表）(查询复杂)

优化

from django.db import models
from django.contrib.contenttypes.models import ContentType
from django.contrib.contenttypes.fields import GenericForeignKey, GenericRelation

class Free_classes (models.Model):
    id = models.AutoField (primary_key=True)
    name = models.CharField (max_length=32)
    # 不需要做数据库迁移,这个字段不会在数据表中生成,只用来方便查询
    price = GenericRelation ('Price', object_id_field='course_id', content_type_field='table_id')

    def __str__(self):
        return self.name

class degree_course (models.Model):
    id = models.AutoField (primary_key=True)
    name = models.CharField (max_length=32)
    # 不需要做数据库迁移,这个字段不会在数据表中生成,只用来方便查询
    price = GenericRelation ('Price', object_id_field='course_id', content_type_field='table_id')

    def __str__(self):
        return self.name

class Price (models.Model):
    id = models.AutoField (primary_key=True)
    period = models.CharField (max_length=32)
    price = models.DecimalField (max_digits=8, decimal_places=2)

    table_id = models.ForeignKey (to=ContentType)
    course_id = models.IntegerField ()
    # 不需要做数据库迁移,这个字段不会在数据表中生成,只用来方便查询
    course_tablename_id = GenericForeignKey (ct_field='table_id', fk_field='course_id')

model设计(添加查询字段 相当于一个查询语句 无需做迁移)

def test(request):
    #为免费课程1 插入三个价格策略
    from django.contrib.contenttypes.models import ContentType
    course_table=ContentType.objects.filter(model='free_classes').first()
    course = models.Free_classes.objects.filter (name='免费课程2').first ()
    models.Price.objects.create(period='1个月',price=10,course_tablename_id=course)
    models.Price.objects.create(period='2个月',price=20,course_tablename_id=course)
    models.Price.objects.create(period='3个月',price=30,course_tablename_id=course
    # 查询所有价格策略，并且显示对应的课程名称
    all=models.Price.objects.all()
    for i in all:
        print(type(i.course_tablename_id))
        print(i.course_tablename_id.__class__)
        print(i.course_tablename_id)
    return HttpResponse('OK')

model设计view视图(用到了ContentType表)(查询方便)

重点(优化后优化前的照样用):

contentType组件
  干啥用的?django内置的一个组件,方便我们快速的连表操作

from django.contrib.contenttypes.models import ContentType
from django.contrib.contenttypes.fields import GenericForeignKey, GenericRelation

在课程表中:
   price = GenericRelation('PricePolicy', object_id_field='course_id', content_type_field='table_id')
  在价格策略表中:
   course_tablename_id = GenericForeignKey('table_id','course_id')
  --加的这两个字段都不会在数据库中生成,它只是用来查询,插入

2  缓存

缓存介绍

当一个网站的用户访问量很大的时候,每一次的后台增删改查等操作,都会消耗很多的服务端资源,所以必须使用缓存来减轻后端服务器的压力.

缓存的位置:(只需要改配置文件)
   内存
   文件
   数据库
   redis

Memcache缓存(使用pylibmc模块)

6种缓存配置

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）
  },
 }
}

1开发调试(此模式为开发调试使用,实际上不执行任何操作)

CACHES = {
 'default': {
  'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',  # 指定缓存使用的引擎
  'LOCATION': 'unique-snowflake',         # 写在内存中的变量的唯一值
  'TIMEOUT':300,             # 缓存超时时间(默认为300秒,None表示永不过期)
  'OPTIONS':{
   'MAX_ENTRIES': 300,           # 最大缓存记录的数量（默认300）
   'CULL_FREQUENCY': 3,          # 缓存到达最大个数之后，剔除缓存个数的比例，即：1/CULL_FREQUENCY（默认3）
  }
 }
}

2内存缓存(将缓存内容保存至内存区域中)

CACHES = {
 'default': {
  'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache', #指定缓存使用的引擎
  'LOCATION': '/var/tmp/django_cache',        #指定缓存的路径
  'TIMEOUT':300,              #缓存超时时间(默认为300秒,None表示永不过期)
  'OPTIONS':{
   'MAX_ENTRIES': 300,            # 最大缓存记录的数量（默认300）
   'CULL_FREQUENCY': 3,           # 缓存到达最大个数之后，剔除缓存个数的比例，即：1/CULL_FREQUENCY（默认3）
  }
 }
}

3文件缓存(把缓存数据存储在文件中)

CACHES = {
 'default': {
  'BACKEND': 'django.core.cache.backends.db.DatabaseCache',  # 指定缓存使用的引擎
  'LOCATION': 'cache_table',          # 数据库表
  'OPTIONS':{
   'MAX_ENTRIES': 300,           # 最大缓存记录的数量（默认300）
   'CULL_FREQUENCY': 3,          # 缓存到达最大个数之后，剔除缓存个数的比例，即：1/CULL_FREQUENCY（默认3）
  }
 }
}

#######################################

#注意,创建缓存的数据库表使用的语句:
#python manage.py createcachetable

4数据库缓存(把缓存数据存储在数据库中)

#Memcached是Django原生支持的缓存系统.要使用Memcached,需要下载Memcached的支持库python-memcached或pylibmc.

CACHES = {
 'default': {
  'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache', # 指定缓存使用的引擎
  'LOCATION': '192.168.10.100:11211',         # 指定Memcache缓存服务器的IP地址和端口
  'OPTIONS':{
   'MAX_ENTRIES': 300,            # 最大缓存记录的数量（默认300）
   'CULL_FREQUENCY': 3,           # 缓存到达最大个数之后，剔除缓存个数的比例，即：1/CULL_FREQUENCY（默认3）
  }
 }
}

5Memcache缓存(使用python-memcached模块连接memcache)

'LOCATION': 'unix:/tmp/memcached.sock',   # 指定局域网内的主机名加socket套接字为Memcache缓存服务器
'LOCATION': [         # 指定一台或多台其他主机ip地址加端口为Memcache缓存服务器
 '192.168.10.100:11211',
 '192.168.10.101:11211',
 '192.168.10.102:11211',
]

5LOCATION也可以配置成如下

#settings.py文件配置
 CACHES = {
  'default': {
   'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache',  # 指定缓存使用的引擎
   'LOCATION':'192.168.10.100:11211',         # 指定本机的11211端口为Memcache缓存服务器
   'OPTIONS':{
    'MAX_ENTRIES': 300,            # 最大缓存记录的数量（默认300）
    'CULL_FREQUENCY': 3,           # 缓存到达最大个数之后，剔除缓存个数的比例，即：1/CULL_FREQUENCY（默认3）
   },
  }
 }

6Memcache缓存(使用pylibmc模块连接memcache)

'LOCATION': '/tmp/memcached.sock',  # 指定某个路径为缓存目录
'LOCATION': [       # 分布式缓存,在多台服务器上运行Memcached进程,程序会把多台服务器当作一个单独的缓存,而不会在每台服务器上复制缓存值
 '192.168.10.100:11211',
 '192.168.10.101:11211',
 '192.168.10.102:11211',
]

6LOCATION也可以配置成如下

https://www.cnblogs.com/space007/p/6023933.html

缓存3种简单使用

           1全站缓存:
            两个中间件:
            MIDDLEWARE_CLASSES = (
            ‘django.middleware.cache.UpdateCacheMiddleware’, #第一
            'django.middleware.common.CommonMiddleware',
            ‘django.middleware.cache.FetchFromCacheMiddleware’, #最后
            )
　　　　　　　# 以秒为单位,缓存事件
　　　　　　　# CACHE_MIDDLEWARE_SECONDS=10
        2视图页面缓存:
            -from django.views.decorators.cache import cache_page
            -装饰器加载视图函数上即可
            @cache_page(5)
        3视图页面局部缓存:
            {% load cache %}
            #第一个参数是时间,第二个参数是别名
            {% cache 5 'test' %}
            缓存的时间:
            {{ ctime }}
            {% endcache %}