sql >> データベース >  >> NoSQL >> Redis

リスト要素をRedisキャッシュに保存する方法

    Stackechange.Redisを使用する場合は、APIでListメソッドを使用できます。これは、Redisリストを使用してアイテムを格納するIListの単純な実装です。

    うまくいけば、リストAPIメソッドのいくつかを理解するのに役立つでしょう:

    public class RedisList<T> : IList<T>
    {
        private static ConnectionMultiplexer _cnn;
        private string key;
        public RedisList(string key)
        {
            this.key = key;
            _cnn = ConnectionMultiplexer.Connect("localhost");
        }
        private IDatabase GetRedisDb()
        {
            return _cnn.GetDatabase();
        }
        private string Serialize(object obj)
        {
            return JsonConvert.SerializeObject(obj);
        }
        private T Deserialize<T>(string serialized)
        {
            return JsonConvert.DeserializeObject<T>(serialized);
        }
        public void Insert(int index, T item)
        {
            var db = GetRedisDb();
            var before = db.ListGetByIndex(key, index);
            db.ListInsertBefore(key, before, Serialize(item));
        }
        public void RemoveAt(int index)
        {
            var db = GetRedisDb();
            var value = db.ListGetByIndex(key, index);
            if (!value.IsNull)
            {
                db.ListRemove(key, value);
            }
        }
        public T this[int index]
        {
            get
            {
                var value = GetRedisDb().ListGetByIndex(key, index);
                return Deserialize<T>(value.ToString());
            }
            set
            {
                Insert(index, value);
            }
        }
        public void Add(T item)
        {
            GetRedisDb().ListRightPush(key, Serialize(item));
        }
        public void Clear()
        {
            GetRedisDb().KeyDelete(key);
        }
        public bool Contains(T item)
        {
            for (int i = 0; i < Count; i++)
            {
                if (GetRedisDb().ListGetByIndex(key, i).ToString().Equals(Serialize(item)))
                {
                    return true;
                }
            }
            return false;
        }
        public void CopyTo(T[] array, int arrayIndex)
        {
            GetRedisDb().ListRange(key).CopyTo(array, arrayIndex);
        }
        public int IndexOf(T item)
        {
            for (int i = 0; i < Count; i++)
            {
                if (GetRedisDb().ListGetByIndex(key, i).ToString().Equals(Serialize(item)))
                {
                    return i;
                }
            }
            return -1;
        }
        public int Count
        {
            get { return (int)GetRedisDb().ListLength(key); }
        }
        public bool IsReadOnly
        {
            get { return false; }
        }
        public bool Remove(T item)
        {
            return GetRedisDb().ListRemove(key, Serialize(item)) > 0;
        }
        public IEnumerator<T> GetEnumerator()
        {
            for (int i = 0; i < this.Count; i++)
            {
                yield return Deserialize<T>(GetRedisDb().ListGetByIndex(key, i).ToString());
            }
        }
        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            for (int i = 0; i < this.Count; i++)
            {
                yield return Deserialize<T>(GetRedisDb().ListGetByIndex(key, i).ToString());
            }
        }
    }
    

    シリアル化にNewtonsoft.Jsonを使用していることに注意してください。次のnu-getパッケージが必要です。

    Install-Package Newtonsoft.Json
    Install-Package StackExchange.Redis
    

    質問とコメントを読んだ後、キーで要素にアクセスしたいので、値に関連付けられたフィールドで構成されるマップであるRedisハッシュを探していると思います。

    したがって、すべての顧客を含むハッシュのRedisキーを作成できます。各顧客は、フィールドに関連付けられた値です。フィールドとしてCustomerIdを選択できるため、O(1)のIDで顧客を取得できます。

    IDictionaryを実装することは、それが機能することを確認するための良い方法だと思います。したがって、RedisListに似ているが、Redisハッシュを使用するRedisDictionaryクラスは次のようになります。

    public class RedisDictionary<TKey, TValue> : IDictionary<TKey, TValue>
    {
        private static ConnectionMultiplexer _cnn;
        private string _redisKey;
        public RedisDictionary(string redisKey)
        {
            _redisKey = redisKey;
            _cnn = ConnectionMultiplexer.Connect("localhost");
        }
        private IDatabase GetRedisDb()
        {
            return _cnn.GetDatabase();
        }
        private string Serialize(object obj)
        {
            return JsonConvert.SerializeObject(obj);
        }
        private T Deserialize<T>(string serialized)
        {
            return JsonConvert.DeserializeObject<T>(serialized);
        }
        public void Add(TKey key, TValue value)
        {
            GetRedisDb().HashSet(_redisKey, Serialize(key), Serialize(value));
        }
        public bool ContainsKey(TKey key)
        {
            return GetRedisDb().HashExists(_redisKey, Serialize(key));
        }
        public bool Remove(TKey key)
        {
            return GetRedisDb().HashDelete(_redisKey, Serialize(key));
        }
        public bool TryGetValue(TKey key, out TValue value)
        {
            var redisValue = GetRedisDb().HashGet(_redisKey, Serialize(key));
            if (redisValue.IsNull)
            {
                value = default(TValue);
                return false;
            }
            value = Deserialize<TValue>(redisValue.ToString());
            return true;
        }
        public ICollection<TValue> Values
        {
            get { return new Collection<TValue>(GetRedisDb().HashValues(_redisKey).Select(h => Deserialize<TValue>(h.ToString())).ToList()); }
        }
        public ICollection<TKey> Keys
        {
            get { return new Collection<TKey>(GetRedisDb().HashKeys(_redisKey).Select(h => Deserialize<TKey>(h.ToString())).ToList()); }
        }
        public TValue this[TKey key]
        {
            get
            {
                var redisValue = GetRedisDb().HashGet(_redisKey, Serialize(key));
                return redisValue.IsNull ? default(TValue) : Deserialize<TValue>(redisValue.ToString());
            }
            set
            {
                Add(key, value);
            }
        }
        public void Add(KeyValuePair<TKey, TValue> item)
        {
            Add(item.Key, item.Value);
        }
        public void Clear()
        {
            GetRedisDb().KeyDelete(_redisKey);
        }
        public bool Contains(KeyValuePair<TKey, TValue> item)
        {
            return GetRedisDb().HashExists(_redisKey, Serialize(item.Key));
        }
        public void CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
        {
            GetRedisDb().HashGetAll(_redisKey).CopyTo(array, arrayIndex);
        }
        public int Count
        {
            get { return (int)GetRedisDb().HashLength(_redisKey); }
        }
        public bool IsReadOnly
        {
            get { return false; }
        }
        public bool Remove(KeyValuePair<TKey, TValue> item)
        {
            return Remove(item.Key);
        }
        public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
        {
            var db = GetRedisDb();
            foreach (var hashKey in db.HashKeys(_redisKey))
            {
                var redisValue = db.HashGet(_redisKey, hashKey);
                yield return new KeyValuePair<TKey, TValue>(Deserialize<TKey>(hashKey.ToString()), Deserialize<TValue>(redisValue.ToString()));
            }
        }
        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            yield return GetEnumerator();
        }
        public void AddMultiple(IEnumerable<KeyValuePair<TKey, TValue>> items)
        {
            GetRedisDb()
                .HashSet(_redisKey, items.Select(i => new HashEntry(Serialize(i.Key), Serialize(i.Value))).ToArray());
        }
    }
    

    そして、これを使用するいくつかの例があります:

    // Insert customers to the cache            
    var customers = new RedisDictionary<int, Customer>("customers");
    customers.Add(100, new Customer() { Id = 100, Name = "John" });
    customers.Add(200, new Customer() { Id = 200, Name = "Peter" });
    
    // Or if you have a list of customers retrieved from DB:
    IList<Customer> customerListFromDb;
    customers.AddMultiple(customerListFromDb.ToDictionary(k => k.Id));
    
    // Query a customer by its id
    var customers = new RedisDictionary<int, Customer>("customers");
    Customer customer100 = customers[100];
    

    更新(2015年10月)

    これらのコレクションのより良い実装は、CachingFramework.Redisライブラリにあります。

    これがコードです。



    1. マスターとスレーブからのすべてのキーがデータベースから削除されるように、クラスターですべてをフラッシュする方法はありますか?

    2. MongoDB-ドキュメントを更新する

    3. MongoDB3.0Javaドライバーで結果をカウントする

    4. MongoDBのバックアップと復元