总结(缓存)

Posted 2020-11-28 zhuangshenhao

1. 缓存简介

　　在动态网站中, 用户所有的请求, 服务器都会到数据库进行相应的增, 删, 改, 查, 进行渲染模板,

　　执行业务逻辑, 最后生成用户看到的页面.

　　当一个网站的用户量很大的时候, 每一次的后台操作, 都会消耗很多的服务端资源

　　所以必须使用缓存来减轻后端服务器的压力.

　　缓存是将一些常用的数据保存到内存或redis, memcache中, 在一定的时间内有人来访问这些数据时,

　　则不再去执行数据库及渲染等操作, 而是直接从内存或redis, memcache的缓存中去提取数据, 然后

　　返回给用户. 这样就很大程度上缓解了后台服务器收到的压力.

2. Django中的6种缓存方式

　　1. 开发调试缓存

　　2. 内存缓存

　　3. 文件缓存

　　4. 数据库缓存

　　5. Memcache缓存(使用python-memcache模块)

　　6. memcache缓存(使用pylibmc模块)

　　经常使用的有文件缓存和memcache缓存

3. Django6种缓存配置

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

　　不执行任何操作即不会产生任何实质的反应

　　setting.py文件配置

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

　　2. 内存缓存

　　settings.py文件配置

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

　　3. 文件缓存

　　settings.py文件配置

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

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

　　settings.py文件配置

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

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

　　memcache是Django原生支持的缓存系统. 要使用memcache, 需要下载memcache的支持库

　　python-memcache或pylibmc

　　settings.py文件配置

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

　　LOCATION也可以配置成如下:

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

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

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

　　LOCATION也可以配置成如下:

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

　　memcache是基于内存的缓存, 数据存储在内存中. 所以如果服务器死机的话, 数据会丢失,

　　所以memcache一般与其他缓存配合使用

4. django中缓存应用

　　django提供了不同力度的缓存, 可以缓存摸个页面, 亦可以缓存一个页面的摸个部分, 

　　甚至可以缓存整个网站.

Django中不同力度的缓存:

　　1. 全站缓存

　　2. 单页面缓存

　　3. 页面中某个部分的局本部缓存

数据库:

1 class Book(models.Model):
2     name=models.CharField(max_length=32)
3     price=models.DecimalField(max_digits=6,decimal_places=1)

　　4.1 视图函数使用缓存

　　视图: 

1 from django.views.decorators.cache import cache_page
2 import time
3 from .models import *
4  
5 @cache_page(15)          #超时时间为15秒
6 def index(request):
7 　　t=time.time()      #获取当前时间
8 　　bookList=Book.objects.all()
9 　　return render(request,"index.html",locals())

　　模板(index.html):

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<h3>当前时间:-----{{ t }}</h3>
 
<ul>
    {% for book in bookList %}
       <li>{{ book.name }}--------->{{ book.price }}$</li>
    {% endfor %}
</ul>
 
</body>
</html>

　　上面的列子是基于内存的缓存配置, 基于文件的缓存配置

　　更改settings.py的配置

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

　　然后在次刷新浏览器, 可以看到在刚才配置的目录下生成的缓存文件

　　结果: 通过实验可以知道, Django会以自己的形式把缓存文件保存在配置文件中指定的目录中

　　4.2 全站使用缓存

　　既然是全站缓存, 当然要使用Django中的中间件.

　　用户的请求通过中间件, 经过一系列的认证等操作, 如果请求的内容在缓存中存在,

　　则使用FetchFromCacheMiddleware获取内容并返回给用户.

　　当返回给用户之前, 判断缓存中是否已经存在, 如果不存在, 则UpdateCacheMiddleware会将

　　缓存保存至Django的缓存中, 以实现全站缓存

缓存整个站点，是最简单的缓存方法
 
在 MIDDLEWARE_CLASSES 中加入 “update” 和 “fetch” 中间件
MIDDLEWARE_CLASSES = (
    ‘django.middleware.cache.UpdateCacheMiddleware’, #第一
    ‘django.middleware.common.CommonMiddleware‘,
    ‘django.middleware.cache.FetchFromCacheMiddleware’, #最后
)
“update” 必须配置在第一个
“fetch” 必须配置在最后一个

　　修改settings.py配置文件

 1 MIDDLEWARE_CLASSES = (
 2     ‘django.middleware.cache.UpdateCacheMiddleware‘,   #响应HttpResponse中设置几个headers
 3     ‘django.contrib.sessions.middleware.SessionMiddleware‘,
 4     ‘django.middleware.common.CommonMiddleware‘,
 5     ‘django.middleware.csrf.CsrfViewMiddleware‘,
 6     ‘django.contrib.auth.middleware.AuthenticationMiddleware‘,
 7     ‘django.contrib.auth.middleware.SessionAuthenticationMiddleware‘,
 8     ‘django.contrib.messages.middleware.MessageMiddleware‘,
 9     ‘django.middleware.clickjacking.XFrameOptionsMiddleware‘,
10     ‘django.middleware.security.SecurityMiddleware‘,
11     ‘django.middleware.cache.FetchFromCacheMiddleware‘,   #用来缓存通过GET和HEAD方法获取的状态码为200的响应
12  
13 )
14  
15  
16 CACHE_MIDDLEWARE_SECONDS=10

　　视图函数:

from django.views.decorators.cache import cache_page
import time
from .models import *
 
 
def index(request):
 
     t=time.time()      #获取当前时间
     bookList=Book.objects.all()
     return render(request,"index.html",locals())
 
def foo(request):
    t=time.time()      #获取当前时间
    return HttpResponse("HELLO:"+str(t))

　　模板(index.html)

 1 <!DOCTYPE html>
 2 <html lang="en">
 3 <head>
 4     <meta charset="UTF-8">
 5     <title>Title</title>
 6 </head>
 7 <body>
 8 <h3 style="color: green">当前时间:-----{{ t }}</h3>
 9  
10 <ul>
11     {% for book in bookList %}
12        <li>{{ book.name }}--------->{{ book.price }}$</li>
13     {% endfor %}
14 </ul>
15  
16 </body>
17 </html>

　　其余代码不变, 刷新浏览器是10秒, 页面上的时间变化一次, 这样就实现了全站缓存

　　4.3 局部视图缓存

　　列子: 刷新页面是, 整个网页有一部分实现缓存

　　视图函数:

1 from django.views.decorators.cache import cache_page
2 import time
3 from .models import *
4 def index(request):
5      t=time.time()      #获取当前时间
6      bookList=Book.objects.all()
7      return render(request,"index.html",locals())

　　模板(index.html)

{% load cache %}
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
 <h3 style="color: green">不缓存:-----{{ t }}</h3>
 
{% cache 2 ‘name‘ %}
 <h3>缓存:-----:{{ t }}</h3>
{% endcache %}
 
</body>
</html>

原文连接: https://blog.csdn.net/Onion_cy/article/details/88042779

5. redis,memcache,MongoDB的区别

　　1.   Redis相比memcache来说,拥有更多的数据结构和支持更丰富的数据库操作

　　2. memcache能够存储文件, 图片,视频等

　　3. redis可以做持久化, memcache不能

　　redis

　　redis用在读多写少的场景, 数据结构多, 支持持久化

　　单线程, 数据量小

　　memcache

　　能够利用多核优势, 单实例吞吐量极高

　　数据类型少, 不支持持久化

　　MongoDB

　　搜索和评论, 读写分离, 主要解决海量数据的访问效率问题

　　占用空间大

 NoSQL 非关系型数据库

RDBMS 关系型数据库Relational Database Management System

 

注意
　　1. redis的版本是3.2, 奇数是开发版本, 偶数是稳定版本.

　　2. django的版本是1.11

　　3. mysql的版本5.6

　　4. 公司的服务器有多少台

　　　　4台: 1台放Ngix, 一台web, 两台mysql, 其中一台是主数据库, 另一台数据库是从数据库, 用来备份用的

　　5. 公司有哪些部门

　　　　开发, 运维

　　　　1个前台, 3个后台, 1个运维

View Code