缓存

提升服务器响应速度

将执行过的操作数据存储下来，在一定的时间内，再次获取数据时从缓存中取

比较理想的方案，缓存使用内存级缓存

Django内置缓存框架

数据库缓存：

1.创建缓存表

python manage.py createcachetable 【表名】

2.settings里面配置

CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.db.DatabaseCache',
        # 缓存表名
        'LOCATION': 'my_cache_table',
        # 缓存过期时间，单位秒
        'TIMEOUT': 60 * 5
    }
}

这样就完成了最基本的配置。

缓存使用：

在views里面使用。

@cache_page(time,cache,key_prefix)   缓存时间（秒），缓存配置（default），前置字符串

比如@cache_page(30)     30秒缓存

缓存底层（操作缓存）：

获取cache对象：

from django.core.cache import caches

cache = caches['cache_name']

如果只有一个缓存对象：

from django.core.cache import cache

操作缓存：

cache.set   key  value   timeout

get  add  get_or_set  get_many  set_many  delete  delete_many  clear  incr(key, value) 增加  decr(key, value) 减少 value不写默认为1

使用例子：

def hello(request):
    # 先看看有没有缓存
    result = cache.get("hello")
    if result:
        return HttpResponse(result)
    sleep(3)
    # 没有的话写入缓存
    response = HttpResponse('Hello')
    cache.set("hello", response.content, timeout=60)
    return response

使用Radis缓存

上述的数据库缓存虽然很快，但是实际上还是存到了数据库里（磁盘里），所以效率还不够高。

于是可以缓存存到内存里：

Django原生没有Radis实现。

需要安装django-radis和django-radis-cache

安装完成之后在settings里面设置cache

CACHES = {
    'default': {
        'BACKEND': 'django_redis.cache.RedisCache',
        # 存储位置
        'LOCATION': 'redis://127.0.0.1:6379/1',
        'OPTIONS': {
            # 客户端类
            'CLIENT_CLASS': "django_redis.client.DefaultClient",
        }
    }
}

Mysq的默认最大连接数是100个，多了就连不上了

缓存的使用方法和上述方法一致，完全不用改。

需要启动redis服务：redis -server

如果是Linux环境，这个命令可以直接运行。但如果是windows，需要在github下载windows版的redis的msi包

Releases · microsoftarchive/redis (github.com)

安装的时候记得勾选上添加PATH环境变量，也就是Add the Redis installation folder to the PATH environment variable.

然后输入redis-server运行（注意没有空格）

如果出现如下错误： # Creating Server TCP listening socket *:6379: bind: No such file or directory

输入redis-cli shutdown

然后再重新redis-server启动redis服务

                _._
           _.-``__ ''-._
      _.-``    `.  `_.  ''-._           Redis 3.2.100 (00000000/0) 64 bit
  .-`` .-```.  ```\/    _.,_ ''-._
 (    '      ,       .-`  | `,    )     Running in standalone mode
 |`-._`-...-` __...-.``-._|'` _.-'|     Port: 6379
 |    `-._   `._    /     _.-'    |     PID: 13512
  `-._    `-._  `-./  _.-'    _.-'
 |`-._`-._    `-.__.-'    _.-'_.-'|
 |    `-._`-._        _.-'_.-'    |           http://redis.io
  `-._    `-._`-.__.-'_.-'    _.-'
 |`-._`-._    `-.__.-'    _.-'_.-'|
 |    `-._`-._        _.-'_.-'    |
  `-._    `-._`-.__.-'_.-'    _.-'
      `-._    `-.__.-'    _.-'
          `-._        _.-'
              `-.__.-'

 # Server started, Redis version 3.2.100
 * The server is now ready to accept connections on port 6379

看见这个就说明启动成功了。

【注意】如果没有运行Redis服务就启动Django项目的话，好的情况是Django会报错ConnectionError，坏的情况（就是我的情况），Python就好像会进死循环一样，CPU和内存占用疯涨，我看到Python的内存已经涨到5个G了就赶紧关上了（我电脑当时只有8G内存）

查看Redis库中的缓存：

redis-cli 进入redis的命令行

select 1 

keys *

get :1: hello

C:\Users\dell>redis-cli
127.0.0.1:6379> select 1
OK
127.0.0.1:6379[1]> keys *
(empty list or set)
127.0.0.1:6379[1]> keys *
1) ":1:hello"
127.0.0.1:6379[1]> get :1:hello
"\x80\x04\x95\t\x00\x00\x00\x00\x00\x00\x00C\x05Hello\x94."
127.0.0.1:6379[1]>

这样就获取到了缓存的数据（注意，不要过了缓存时间，否则就获取不到了）

127.0.0.1:6379[1]> ttl :1:hello
(integer) -2
-2代表过期了，刷新一下
127.0.0.1:6379[1]> ttl :1:hello
(integer) 54
可以看到过期时间是54秒

多缓存设置

Django可可以设置多个缓存方式，比如可以同时使用数据库缓存和Redis

CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.db.DatabaseCache',
        # 缓存表名
        'LOCATION': 'my_cache_table',
        # 缓存过期时间，单位秒
        'TIMEOUT': 60 * 5
    },
    
    'redis_backend': {  'BACKEND': 'django_redis.cache.RedisCache',
        # 存储位置
        'LOCATION': 'redis://127.0.0.1:6379/1',
        'OPTIONS': {
            # 客户端类
            'CLIENT_CLASS': "django_redis.client.DefaultClient",
        }
    }
}

设置里面这样写上就可以，实际用的时候指定一个即可

from django.core.cache import caches

cache = caches['redis_backend']

或者用修饰器的方法：

@cache_page(60, cache='default')

中间件

是一个轻量级的，底层的插件，可以介入到Django的请求和响应流程当中。

本质是一个Python类（装饰器）

属于面向切面编程（AOP，Aspect Oriented Programming）

切入函数

__init__ ：服务器响应第一个请求时自动调用

process_request(self, request)：在执行视图函数前调用，不主动进行返回或返回HttpResponse（被拦断之间返回）

process_view(self, request, view_func, view_aegs, view_kwargs)：调用视图函数前执行，不主动返回或返回HttpResponse

process_template_response(self, reques, response):在视图刚好执行完后调用，不主动返回或返回HttpResponse

process_response(self, request, response):所有响应返回浏览器前调用，不主动返回或返回HttpResponse对象

process_exception(self, request, exception)：当视图函数抛出异常时调用，不主动返回或返回HttpResponse对象

【不主动返回则会接着进行，返回HttpResponse对象就相当于在这里切断了，不往下进行了】

自定义中间件

1.创建middleware目录

2.创建一个py

3.导入中间件的基类

from django.utils.deprecation import MiddlewareMixin

4.根据功能需求，创建切入需求类（下面的是访问的时候打印IP，可以做访问统计）

class HelloMiddle(MiddlewareMixin):

    def process_request(self, request):
        print(request.META.get("REMOTE_ADDR"))

5.在settings里面的MIDDLEWARE里面注册

'middleware.learn_middle.HelloMiddle',   【一定要注意后面有没有加逗号】

常用：request.path == '/app/hello'     request.META.get('REMOTE_ADDR')  ip.startwith('192.168.0.1')末位ip以1开头的

可以实现权重控制、黑名单白名单；反爬虫、访问频率控制（使用cache）

处理带有中文的时间时需要安装中文环境包，否则无法使用。

Cent OS 6： yum groupinstall chinese-support

Cent OS 7:  yum install  kde-l10n-Chinese

搜索