Comment utiliser le serveur de cache Redis sous Windows

1. Serveur Redis

Téléchargez d'abord le serveur Redis, cliquez pour télécharger la version .msi, double-cliquez pour installer le serveur Redis, et il sera installé en tant que service. Le système démarre ensemble :

La première chose après l'installation du serveur Redis est de définir un mot de passe et d'entrer dans le répertoire d'installation : C:Program FilesRedis - Recherchez le fichier de configuration : redis.windows-service .conf - Recherchez : # requirepass foobared - Entrez et saut de ligne et ajoutez : requirepass Écrivez votre nouveau mot de passe ici (écrivez-le sur la ligne du haut, sans laisser d'espace devant) - Accédez au service pour redémarrer le service Redis ou redémarrer l'ordinateur

Non Les inconvénients de la définition de mots de passe peuvent être compris en regardant ce qui est arrivé à ce type de Ctrip : Souvenez-vous d'un incident où Redis a été attaqué

2. Client Redis (ligne de commande et outil de visualisation RDM)

Démonstration en ligne de commande : démarrer le client Redis, lire et écrire le serveur Redis

Explication de la commande ci-dessus :

cd C : Program FilesRedis : La commande cd entre dans le répertoire d'installation de Redis, ce qui équivaut à un double-clic pour entrer dans le répertoire d'installation de Redis dans le système Windows <.>

redis-cli.exe : ouvre le programme client redis-cli, ce qui équivaut à un double-clic pour exécuter un exe dans le programme système Windows (après avoir installé le programme serveur Redis ci-dessus, un programme client est requis. pour vous connecter au serveur. Pour vous connecter au serveur redis local, tapez directement cette commande. Pour vous connecter au serveur distant, vous devez ajouter l'adresse IP et le port, par exemple : redis-cli.exe -h 111.11 .11.111 -p. 6379)

keys * : Afficher toutes les paires clé-valeur (si le serveur Redis a défini un mot de passe, cette commande signalera une erreur, vous devez d'abord saisir le mot de passe , exécutez cette commande : authentifiez votre mot de passe)

set blog oppoic.cnblogs.com : définissez une paire clé-valeur, la clé est : blog, la valeur est : oppoic.cnblogs.com (stockée par répertoire : set directory name: key value)

get blog: Obtenez la valeur correspondant à la clé du blog

keys *: Afficher toutes les paires clé-valeur

Autres commandes couramment utilisées :

config get dir : Récupère le répertoire d'installation redis

ping : Renvoie PONG pour indiquer que le serveur redis est normal

redis-cli.exe : Saisissez la première base de données ( par défaut), redis a un total de 16 bibliothèques de 0 à 15, entrez la troisième bibliothèque redis-cli -n 2 (déjà saisie, sélectionnez 0~15 pour basculer à volonté)

quitter : quittez le programme redis

exit : quitter la fenêtre dos

flushdb : supprimer toutes les clés de la base de données actuellement sélectionnée

flushall : supprimer les bases de données dans toutes les bases de données

Plus de commandes : https://redis.io/commands

À ce stade, un serveur de cache Redis exécuté sur la machine locale a été configuré et peut être lu et écrit. Cependant, la ligne de commande n'est évidemment pas conviviale pour les utilisateurs novices. L'outil de visualisation est ici : Redis Desktop Manager (https://redisdesktop.com/download)

L'arborescence. à gauche montre qu'il y en a déjà. Une fois connecté, cliquez sur Se connecter au serveur Redis en bas pour ajouter une autre connexion :

Nom : nom de la connexion, récupérez-le avec désinvolture

Hôte : adresse de l'hôte, cette machine est 127.0.0.1, saisie à distance IP correspondante

Port : Port, port par défaut du serveur Redis 6379

Auth : Mot de passe, saisissez-le s'il est défini, laissez-le vide s'il n'est pas défini

Vous pouvez le voir après vous être connecté au serveur Redis, la valeur par défaut est de 16 bibliothèques (le fichier de configuration peut être modifié) et l'index commence à 0. Une utilisation courante consiste à avoir un projet et une bibliothèque, et différents modules fonctionnels du projet sont stockés dans différents répertoires de cette bibliothèque.

Inutile de dire que l'opération après avoir obtenu l'outil de visualisation consiste à double-cliquer, cliquer avec le bouton droit pour créer et supprimer. . . Quiconque sait utiliser le système Windows utilisera cet outil. Comparé à la ligne de commande, Redis Desktop Manager est un outil visuel plus convivial et il est également plus pratique de déboguer les données sur le serveur distant.

Remarque : Cette machine peut faire cela. Pour vous connecter au serveur distant, vous devez accéder au répertoire d'installation Redis sur le serveur, rechercher le fichier redis.windows-service.conf, rechercher bind 127.0.0.1. , commentez-le avec "#" devant, puis faites un clic droit sur le service pour redémarrer le service Redis, ou redémarrez le système Windows

3. Serveur Redis exécutant C#

Les lignes de commande et les outils visuels ci-dessus permettant de faire fonctionner le serveur Redis doivent utiliser StackExchange.Redis (https://github.com/StackExchange/StackExchange.Redis). ), afin de l'appeler uniformément, une classe d'assistance RedisHelper est encapsulée :

using Newtonsoft.Json;
using StackExchange.Redis;
using System;
using System.ComponentModel;
using System.Configuration;
using System.Reflection;
using System.Text;

namespace redis_Demo
{
    /// <summary>
    /// Redis 帮助类
    /// </summary>
    public static class RedisHelper
    {
        private static string _conn = ConfigurationManager.AppSettings["redis_connection_string"] ?? "127.0.0.1:6379";
        private static string _pwd = ConfigurationManager.AppSettings["redis_connection_pwd"] ?? "123456";

        static ConnectionMultiplexer _redis;
        static readonly object _locker = new object();

        #region 单例模式
        public static ConnectionMultiplexer Manager
        {
            get
            {
                if (_redis == null)
                {
                    lock (_locker)
                    {
                        if (_redis != null) return _redis;

                        _redis = GetManager();
                        return _redis;
                    }
                }
                return _redis;
            }
        }

        private static ConnectionMultiplexer GetManager(string connectionString = null)
        {
            if (string.IsNullOrEmpty(connectionString))
            {
                connectionString = _conn;
            }
            var options = ConfigurationOptions.Parse(connectionString);
            options.Password = _pwd;
            return ConnectionMultiplexer.Connect(options);
        }
        #endregion

        /// <summary>
        /// 添加
        /// </summary>
        /// <param name="folder">目录</param>
        /// <param name="key">键</param>
        /// <param name="value">值</param>
        /// <param name="expireMinutes">过期时间，单位：分钟。默认600分钟</param>
        /// <param name="db">库，默认第一个。0~15共16个库</param>
        /// <returns></returns>
        public static bool StringSet(CacheFolderEnum folder, string key, string value, int expireMinutes = 600, int db = -1)
        {
            string fd = GetDescription(folder);
            return Manager.GetDatabase(db).StringSet(string.IsNullOrEmpty(fd) ? key : fd + ":" + key, value, TimeSpan.FromMinutes(expireMinutes));
        }

        /// <summary>
        /// 获取
        /// </summary>
        /// <param name="folder">目录</param>
        /// <param name="key">键</param>
        /// <param name="db">库，默认第一个。0~15共16个库</param>
        /// <returns></returns>
        public static string StringGet(CacheFolderEnum folder, string key, int db = -1)
        {
            try
            {
                string fd = GetDescription(folder);
                return Manager.GetDatabase(db).StringGet(string.IsNullOrEmpty(fd) ? key : fd + ":" + key);
            }
            catch (Exception)
            {
                return null;
            }
        }

        /// <summary>
        /// 删除
        /// </summary>
        /// <param name="folder">目录</param>
        /// <param name="key">键</param>
        /// <param name="db">库，默认第一个。0~15共16个库</param>
        /// <returns></returns>
        public static bool StringRemove(CacheFolderEnum folder, string key, int db = -1)
        {
            try
            {
                string fd = GetDescription(folder);
                return Manager.GetDatabase(db).KeyDelete(string.IsNullOrEmpty(fd) ? key : fd + ":" + key);
            }
            catch (Exception)
            {
                return false;
            }
        }
        /// <summary>
        /// 是否存在
        /// </summary>
        /// <param name="key">键</param>
        /// <param name="db">库，默认第一个。0~15共16个库</param>
        public static bool KeyExists(CacheFolderEnum folder, string key, int db = -1)
        {
            try
            {
                string fd = GetDescription(folder);
                return Manager.GetDatabase(db).KeyExists(string.IsNullOrEmpty(fd) ? key : fd + ":" + key);
            }
            catch (Exception)
            {
                return false;
            }
        }

        /// <summary>
        /// 延期
        /// </summary>
        /// <param name="folder">目录</param>
        /// <param name="key">键</param>
        /// <param name="min">延长时间，单位：分钟，默认600分钟</param>
        /// <param name="db">库，默认第一个。0~15共16个库</param>
        public static bool AddExpire(CacheFolderEnum folder, string key, int min = 600, int db = -1)
        {
            try
            {
                string fd = GetDescription(folder);
                return Manager.GetDatabase(db).KeyExpire(string.IsNullOrEmpty(fd) ? key : fd + ":" + key, DateTime.Now.AddMinutes(min));
            }
            catch (Exception)
            {
                return false;
            }
        }

        /// <summary>
        /// 添加实体
        /// </summary>
        /// <param name="folder">目录</param>
        /// <param name="key">键</param>
        /// <param name="t">实体</param>
        /// <param name="ts">延长时间，单位：分钟，默认600分钟</param>
        /// <param name="db">库，默认第一个。0~15共16个库</param>
        public static bool Set<T>(CacheFolderEnum folder, string key, T t, int expireMinutes = 600, int db = -1)
        {
            string fd = GetDescription(folder);
            var str = JsonConvert.SerializeObject(t);
            return Manager.GetDatabase(db).StringSet(string.IsNullOrEmpty(fd) ? key : fd + ":" + key, str, TimeSpan.FromMinutes(expireMinutes));
        }

        /// <summary>
        /// 获取实体
        /// </summary>
        /// <param name="folder">目录</param>
        /// <param name="key">键</param>
        /// <param name="db">库，默认第一个。0~15共16个库</param>
        public static T Get<T>(CacheFolderEnum folder, string key, int db = -1) where T : class
        {
            string fd = GetDescription(folder);
            var strValue = Manager.GetDatabase(db).StringGet(string.IsNullOrEmpty(fd) ? key : fd + ":" + key);
            return string.IsNullOrEmpty(strValue) ? null : JsonConvert.DeserializeObject<T>(strValue);
        }

        /// <summary>
        /// 获得枚举的Description
        /// </summary>
        /// <param name="value">枚举值</param>
        /// <param name="nameInstead">当枚举值没有定义DescriptionAttribute，是否使用枚举名代替，默认是使用</param>
        /// <returns>枚举的Description</returns>
        private static string GetDescription(this Enum value, Boolean nameInstead = true)
        {
            Type type = value.GetType();
            string name = Enum.GetName(type, value);
            if (name == null)
            {
                return null;
            }

            FieldInfo field = type.GetField(name);
            DescriptionAttribute attribute = Attribute.GetCustomAttribute(field, typeof(DescriptionAttribute)) as DescriptionAttribute;

            if (attribute == null && nameInstead == true)
            {
                return name;
            }
            return attribute == null ? null : attribute.Description;
        }
    }
}

Ajouter un enregistrement avec le nom de la clé et la valeur wangjie au répertoire fd1 de la première bibliothèque du serveur redis :

RedisHelper.StringSet(CacheFolderEnum.Folder1, "name", "wangjie");

Récupérer cet enregistrement :

string key = RedisHelper.StringGet(CacheFolderEnum.Folder1, "name");
Console.WriteLine("键为name的记录对应的值：" + key);

Supprimer cet enregistrement :

bool result = RedisHelper.StringRemove(CacheFolderEnum.Folder1, "name");
if (result)
{
    Console.WriteLine("键为name的记录删除成功");
}
else
{
    Console.WriteLine("键为name的记录删除失败");
}

Vérifier si cet enregistrement existe :

bool ifExist = RedisHelper.KeyExists(CacheFolderEnum.Folder1, "name");
if (ifExist)
{
    Console.WriteLine("键为name的记录存在");
}
else
{
    Console.WriteLine("键为name的记录不存在");
}

Demander Dans le répertoire fd2 de la deuxième bibliothèque du serveur redis, ajoutez un enregistrement avec la clé sd1 et la valeur an object :

Student student = new Student() { Id = 1, Name = "张三", Class = "三年二班" };
RedisHelper.Set<Student>(CacheFolderEnum.Folder2, "sd1", student, 10, 1);

Récupérez cet objet :

Student sdGet = RedisHelper.Get<Student>(CacheFolderEnum.Folder2, "sd1", 1);
if (sdGet != null)
{
    Console.WriteLine("Id：" + sdGet.Id + " Name：" + sdGet.Name + " Class：" + sdGet.Class);
}
else
{
    Console.WriteLine("找不到键为sd1的记录");
}

Code source : (http ://files.cnblogs.com/files/oppoic/redis_Demo.zip)

L'environnement est VS 2013. S'il ne peut pas s'exécuter, copiez le code dans cs, compilez-le et exécutez-le vous-même

4. Autres

Le serveur de cache Redis développé par MSOpenTech est livré avec persistance Après l'écriture, redémarrez l'ordinateur et la paire clé-valeur existera toujours. . Généralement, le délai d'expiration doit être défini lors de l'écriture de la paire clé-valeur, sinon il restera La mémoire occupée ne sera pas libérée. La méthode de stockage Redis a non seulement des clés correspondant aux chaînes, mais correspond également à List, HashTable, etc. Bien entendu, les utilisations plus avancées de Redis se font toujours sous Linux.

Pour plus d'articles liés à l'utilisation du serveur de cache Redis sous Windows, veuillez faire attention au site PHP chinois !