django中使用redis

一、单节点redis配置及使用

安装redis包：

　pip install django-redis

 

(一)、settings中配置redis

1.在INSTALLED_APPS中，添加'django_redis',

2.设置缓存

"""   缓存配置  """
CACHES = {
    "default": {
        "BACKEND": "django_redis.cache.RedisCache",
        "LOCATION": "redis://47.244.147.58:6379/1",
        "OPTIONS": {
            "CLIENT_CLASS": "django_redis.client.DefaultClient",
            "PASSWORD": '',
            "SOCKET_CONNECT_TIMEOUT": 5,  # socket 建立连接超时设置
            "SOCKET_TIMEOUT": 5,  # 连接建立后的读写操作超时设置
            # "COMPRESSOR": "django_redis.compressors.zlib.ZlibCompressor",  # 压缩
            "CONNECTION_POOL_KWARGS": {"max_connections": 30},  # 设置连接池的最大连接数
            "SERIALIZER": "django_redis.serializers.json.JSONSerializer",  # 默认使用pickle序列化，这里设置为json
        }
    }
}

(二)、使用cache

缓存字典：

from django.core.cache import cache
def set_user_cache():
    for user in User.objects.filter(status=1).defer('password').values():
        user_id = user['id']
        user_key = 'user_{}'.format(user_id)
        cache.set(user_key, user, time_out)

        auth_key = 'auth_{}'.format(user_id)
        auth_info = JurisdictionList.objects.filter(id=user['id']).values()
        cache.set(auth_key, auth_info, time_out)

    for group in Group.objects.filter(status=1).values():
        key = 'group_{}'.format(group['id'])
        cache.set(key, group, time_out)

缓存列表：

    agent_info_list = [1,2,3]
    if agent_info_list:
        key = AGENT_ID_KEY + str(uid)
        cache.set(key, agent_info_list, TIME_OUT)

缓存字符串：

    token = "%s.%s.%s" % (header, payload, signature)
    # 存储到缓存中
    cache.set(uid, token, default.TIME_OUT)

获取字典：

    def agent_power(self):
        agents = cache.get(self.agent_key)
        if agents:
            for agent in agents:
                if agent.get("role", None) == 23:
                    self.agent_role = 23
                if agent.get("jur", None).get("admin_user", None) == 2:
                    self.agent_admin = 2

获取列表：

    def check_agent(self):
        key = default.AGENT_ID_KEY + str(self.kw.get("uid", None))
        agent_list = cache.get(key)
        if agent_list:
            for agent in agent_list:
                if agent.get("role", None) == 23:
                    self.agent_role = 23
                if agent.get("jur", None).get("admin_user", None) == 2:
                    self.agent_power = 2

删除：

cache.delete(key)

(三)、使用原来的redis命令

from django_redis import get_redis_connection
conn = get_redis_connection("default")
conn.hgetall('key')

 

二、配置redis集群 

安装redis包：

　　pip install django-redis  # 注意 django-redis版本需要 >= 4.7.0 
　　pip install django-cluster-redis

在settings中配置

CACHES = {
  'default': {
    'BACKEND': 'django_redis.cache.RedisCache',
    'LOCATION': [　　　　'redis节点列表',　　],  # 格式为 redis://IP:PORT/db_index，数据库编号可为空，默认为0号
    'OPTIONS': {
      'REDIS_CLIENT_CLASS': 'rediscluster.RedisCluster',
      'CONNECTION_POOL_CLASS': 'rediscluster.connection.ClusterConnectionPool',
      'CONNECTION_POOL_KWARGS': {
        'skip_full_coverage_check': True # AWS ElasticCache has disabled CONFIG commands
      }
    }
  }
}

使用方法，同单节点的redis

三、作为 session backend 使用配置

Django 默认可以使用任何 cache backend 作为 session backend, 将 django-redis 作为 session 储存后端不用安装任何额外的 backend

SESSION_ENGINE = "django.contrib.sessions.backends.cache"
SESSION_CACHE_ALIAS = "default"

 四、其它redis配置选项

1.套接字超时

套接字超时设置使用 SOCKET_TIMEOUT 和 SOCKET_CONNECT_TIMEOUT 参数:

CACHES = {
    "default": {
        # ...
        "OPTIONS": {
            "SOCKET_CONNECT_TIMEOUT": 5,  # in seconds
            "SOCKET_TIMEOUT": 5,  # in seconds
        }
    }
}

 

 2.压缩支持

django-redis 支持压缩, 但默认是关闭的. 你可以激活它:

CACHES = {
    "default": {
        # ...
        "OPTIONS": {
            "COMPRESSOR": "django_redis.compressors.zlib.ZlibCompressor",
        }
    }
}

 

使用 lzma 压缩的例子:

import lzma

CACHES = {
    "default": {
        # ...
        "OPTIONS": {
            "COMPRESSOR": "django_redis.compressors.lzma.LzmaCompressor",
        }
    }
}

 3.memcached 异常行为

在某些情况下, redis 只作为缓存使用, 当它关闭时如果你不希望触发异常. 这是 memcached backend 的默认行为, 你可以使用 django-redis 模拟这种情况.

为了设置这种类似memcached 的行为 ( 忽略连接异常 ), 使用 IGNORE_EXCEPTIONS 参数:

CACHES = {
    "default": {
        # ...
        "OPTIONS": {
            "IGNORE_EXCEPTIONS": True,
        }
    }
}

当然,你也可以的setting中，给所有缓存配置相同的忽略行为:

DJANGO_REDIS_IGNORE_EXCEPTIONS = True

 

 4. 日志忽略异常

当使用 IGNORE_EXCEPTIONS 或者 DJANGO_REDIS_IGNORE_EXCEPTIONS 参数忽略异常时, 你也许会用到 DJANGO_REDIS_LOG_IGNORED_EXCEPTIONS 参数来配置日志异常:

DJANGO_REDIS_LOG_IGNORED_EXCEPTIONS = True

 

如果你想设置指定的 logger 输出异常, 只需要设置全局变量 DJANGO_REDIS_LOGGER 为 logger 的名称或其路径即可. 如果没有 logger 被设置并且 DJANGO_REDIS_LOG_IGNORED_EXCEPTIONS=True 时此参数将取 name :

DJANGO_REDIS_LOGGER = 'some.specified.logger'

 5.超时设置

django-redis 支持永不超时设置. 其表现和 django backend 指定的相同:

• timeout=0 立即过期
• timeout=None 永不超时

  cache.set("key", "value", timeout=None)

  cache.ttl("foo")  # 获取某key的过期时间

>>> cache.set("foo", "bar", timeout=22)
>>> cache.expire("foo", timeout=5)   #也可以使用expire对某个key设置过期时间
>>> cache.ttl("foo")
5
cache.persist("foo")   # persist设置某key永不过期

 6.redis 分布式锁.

django-redis 支持 redis 分布式锁，锁的线程接口是相同的, 因此你可以使用它作为替代.

使用 python 上下文管理器分配锁的例子:

with cache.lock("somekey"):
    do_some_thing()

 

7.搜索某键

>>> from django.core.cache import cache
>>> cache.iter_keys("foo_*")
<generator object algo at 0x7ffa9c2713a8>
>>> next(cache.iter_keys("foo_*"))
"foo_1"

 8. Redis 原子操作

(1).cache仅有限支持部分redis的原子操作，包括：SETNX 和 INCR，DCER 命令.

>>> from django.core.cache import cache
>>> cache.set("key", "value1", nx=True)
True
>>> cache.set("key", "value2", nx=True)
False
>>> cache.get("key")
"value1"

 当值 (value) 有合适的键 (key) 时, incr 和 decr 也可以使用 Redis 原子操作

(2).原生客户端使用

原生redis客户端，支持redis的所有原子性操作，操作方法使用原生的redis命令。

>>> from django_redis import get_redis_connection
>>> con = get_redis_connection("default")
>>> con
<redis.client.StrictRedis object at 0x2dc4510>

9.可扩展解析器（非必需）

redis-py (django-redis 使用的 Redis 客户端) 支持的纯净 Python Redis 解析器可以满足大部分普通任务。

但如果你想要性能更好, 可以使用 hiredis

hiredis 是一个用 C 写的 Redis 客户端, 并且他的解析器可以用在 django-redis 中:

"OPTIONS": {
    "PARSER_CLASS": "redis.connection.HiredisParser",
}

 10.可扩展客户端（非必需）

django_redis 设计的非常灵活和可配置。它提供了可扩展的后端，拥有易扩展的特性.

(1). 默认客户端

支持单节点的redis客户端

(2).主从客户端

如果需要主从设置, 你需要更改 LOCATION 参数:

"LOCATION": [
    "redis://127.0.0.1:6379/1",
    "redis://127.0.0.1:6378/1",
]

 

第一个字段代表 master 服务器, 第二个字段代表 slave 服务器.

警告 主从设置没有在生产环境中经过大量测试

（3） 分片客户端

此可扩展客户端实现了客户端分片, 它几乎继承了默认客户端的全部功能. 如果需要使用, 请将配置改成这样

CACHES = {
    "default": {
        "BACKEND": "django_redis.cache.RedisCache",
        "LOCATION": [
            "redis://127.0.0.1:6379/1",
            "redis://127.0.0.1:6379/2",
        ],
        "OPTIONS": {
            "CLIENT_CLASS": "django_redis.client.ShardClient",
        }
    }
}

警告 分片客户端仍处于试验阶段, 请在生产环境中谨慎使用

（4） 集群客户端

设置举例

CACHES = {
    "default": {
        "BACKEND": "django_redis.cache.RedisCache",
        "LOCATION": "redis://127.0.0.1:6379/1",
        "OPTIONS": {
            "CLIENT_CLASS": "django_redis.client.HerdClient",
        }
    }
}

一些其他的设置:

CACHE_HERD_TIMEOUT: 设置集群超时 (默认值为: 60s)

 (5). 可扩展 Redis 客户端

django-redis 默认使用 redis.client.StrictClient 作为 Redis 客户端,

你可以使用其他客户端替代, 比如之前在讲测试时我们用 fakeredis 代替真实客户端.

使用 REDIS_CLIENT_CLASS in the CACHES 来配置你的客户端, 使用 REDIS_CLIENT_KWARGS 提供配置客户端的参数 (可选).

设置举例

CACHES = {
    "default": {
        "OPTIONS": {
            "REDIS_CLIENT_CLASS": "my.module.ClientClass",
            "REDIS_CLIENT_KWARGS": {"some_setting": True},
        }
    }
}

 

 

11、 可扩展序列器

客户端在将数据发给服务器之前先会序列化数据. django-redis 默认使用 Python pickle 序列化数据.

如果需要使用 json 序列化数据, 使用 JSONSerializer

设置举例

CACHES = {
    "default": {
        "BACKEND": "django_redis.cache.RedisCache",
        "LOCATION": "redis://127.0.0.1:6379/1",
        "OPTIONS": {
            "CLIENT_CLASS": "django_redis.client.DefaultClient",
            "SERIALIZER": "django_redis.serializers.json.JSONSerializer",
        }
    }
}

使用 MsgPack http://msgpack.org/ 进行序列化 (需要 msgpack-python 库支持)

设置举例

CACHES = {
    "default": {
        "BACKEND": "django_redis.cache.RedisCache",
        "LOCATION": "redis://127.0.0.1:6379/1",
        "OPTIONS": {
            "CLIENT_CLASS": "django_redis.client.DefaultClient",
            "SERIALIZER": "django_redis.serializers.msgpack.MSGPackSerializer",
        }
    }
}

 12.连接池

django-redis 使用 redis-py 的连接池接口, 并提供了简单的配置方式. 除此之外, 你可以为 backend 定制化连接池的产生.

redis-py 默认不会关闭连接, 尽可能重用连接

(1) 配置默认连接池

配置默认连接池很简单, 你只需要在 CACHES 中使用 CONNECTION_POOL_KWARGS 设置连接池的最大连接数量即可:

CACHES = {
    "default": {
        "BACKEND": "django_redis.cache.RedisCache",
        ...
        "OPTIONS": {
            "CONNECTION_POOL_KWARGS": {"max_connections": 100}
        }
    }
}

 

你可以得知连接池已经打开多少连接:

from django.core.cache import get_cache
from django_redis import get_redis_connection

r = get_redis_connection("default")  # Use the name you have defined for Redis in settings.CACHES
connection_pool = r.connection_pool
print("Created connections so far: %d" % connection_pool._created_connections)

(2) 使用你自己的连接池子类

有时你想使用自己的连接池子类. django-redis 提供了 CONNECTION_POOL_CLASS 来配置连接池子类

myproj/mypool.py

from redis.connection import ConnectionPool

class MyOwnPool(ConnectionPool):
    # Just doing nothing, only for example purpose
    pass
setting.py

# Omitting all backend declaration boilerplate code.

"OPTIONS": {
    "CONNECTION_POOL_CLASS": "myproj.mypool.MyOwnPool",
}

 

(3) 定制化的 connection factory

如果之前的方法都不合适, 你可以定制 django-redis 的 connection factory 过程甚至完全重写.

django-redis 默认使用Django setting 中 DJANGO_REDIS_CONNECTION_FACTORY 参数指定的django_redis.pool.ConnectionFactory 类产生连接.

ConnectionFactory 类的部分接口：

# Note: Using Python 3 notation for code documentation ;)

class ConnectionFactory(object):
    def get_connection_pool(self, params:dict):
        # Given connection parameters in the `params` argument,
        # return new connection pool.
        # It should be overwritten if you want do something
        # before/after creating the connection pool, or return your
        # own connection pool.
        pass

    def get_connection(self, params:dict):
        # Given connection parameters in the `params` argument,
        # return a new connection.
        # It should be overwritten if you want to do something
        # before/after creating a new connection.
        # The default implementation uses `get_connection_pool`
        # to obtain a pool and create a new connection in the
        # newly obtained pool.
        pass

    def get_or_create_connection_pool(self, params:dict):
        # This is a high layer on top of `get_connection_pool` for
        # implementing a cache of created connection pools.
        # It should be overwritten if you want change the default
        # behavior.
        pass

    def make_connection_params(self, url:str) -> dict:
        # The responsibility of this method is to convert basic connection
        # parameters and other settings to fully connection pool ready
        # connection parameters.
        pass

    def connect(self, url:str):
        # This is really a public API and entry point for this
        # factory class. This encapsulates the main logic of creating
        # the previously mentioned `params` using `make_connection_params`
        # and creating a new connection using the `get_connection` method.
        pass