Detailed explanation of the usage of redis cache server in Django

I believe everyone is familiar with redis. Like memcached, it is a high-performance key-value database. As for what a cache server is, Du Niang has a very clear introduction, so I will not introduce it one by one here.

So under what circumstances do we usually use the cache server? It is not necessary in all situations. Generally speaking, it is only when a field needs to be read frequently that it is necessary to put this field on the cache server. And since key-value databases generally only store very simple data, So be careful when selecting objects to save.

Next I will introduce how to configure and use the redis database in Django. First, install redis. Execute the following command in Ubuntu:

#Install Redis server

sudo apt-get install redis-server

Then in order to use redis in Django, you also need to install the redis for Django plug-in:

pip install django-redis

This is an open source project, the github address is https://github.com/niwibe/django -redis, thanks to the author.

Then it is now configured in Django settings.

CACHES = {
    'default': {
        'BACKEND': 'redis_cache.cache.RedisCache',
        'LOCATION': '127.0.0.1:6379',
        "OPTIONS": {
            "CLIENT_CLASS": "redis_cache.client.DefaultClient",
        },
    },
}
REDIS_TIMEOUT=7*24*60*60
CUBES_REDIS_TIMEOUT=60*60
NEVER_REDIS_TIMEOUT=365*24*60*60

In fact, you only need those items in CACHES. The following three sentences are not needed, but they are needed in my later examples, so I configured them here.

Okay, now that the connection and configuration have been completed, how to use it in the project? Let’s look at the following example.

from django.conf import settings
from django.core.cache import cache
#read cache user id
def read_from_cache(self, user_name):
    key = 'user_id_of_'+user_name
    value = cache.get(key)
    if value == None:
        data = None
    else:
        data = json.loads(value)
    return data
#write cache user id
def write_to_cache(self, user_name):
    key = 'user_id_of_'+user_name
    cache.set(key, json.dumps(user_name), settings.NEVER_REDIS_TIMEOUT)

Through the above two methods, you can realize the reading operation of redis. You only need to pass the required fields as parameters into the method.

So what about memcached mentioned before? In fact, it is the same configuration:

CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
        'LOCATION': '127.0.0.1:11211',
    }
}

Of course, the usage is the same as my example above. In fact, for cache servers like redis, the configuration is very simple, and the specific use is not difficult. There are many simple and clear examples on the official website for our reference. There is only one thing to note, that is, what to use Saving this kind of information to redis is what we really need to care about.

The above is the detailed content of Detailed explanation of the usage of redis cache server in Django. For more information, please follow other related articles on the PHP Chinese website!