C#客戶端Redis服務器的分布式緩存

作者：小峰 2015-08-17 09:48:29

開發后端分布式 Redis

在這篇文章中，我想介紹我知道的一種最緊湊的安裝和配置Redis服務器的方式。另外，我想簡短地概述一下在.NET / C#客戶端下Redis hash（哈希類型）和list（鏈表）的使用。

介紹

在這篇文章主要講到：

安裝Redis服務器（附完整的應用程序文件設置）
Redis服務器保護（配置身份驗證）
配置服務器復制
從C#應用程序訪問緩存
使用Redis ASP.NET會話狀態
Redis 集合（Set）、列表（List）和事務處理用法示例
說明附加的源（Redis Funq LoC MVC項目：舉例）
緩存的優化思路

背景

Redis是最快也是功能最豐富的內存Key-Value數據存儲系統之一。

缺點

沒有本地數據緩存（如在Azure緩存同步本地數據緩存）
沒有完全集群化的支持（不過，可能今年年底會實現）

優點

易于配置
使用簡單
高性能
支持不同的數據類型（如hash（哈希類型）、list（鏈表）、set（集合）、sorted set（有序集））
ASP.NET會話集成
Web UI用于瀏覽緩存內容

下面我將簡單說明如何在服務器上安裝和配置Redis，并用C#使用它。

Redis的安裝

從https://github.com/dmajkic/redis/downloads（win32 win64直接鏈接）下載二進制文件，解包檔案到應用程序目錄（如C：\Program Files\Redis）

下載從https://github.com/kcherenkov/redis-windows-service/downloads編譯的Redis服務，然后復制到程序文件夾（如C：\Program Files\Redis）。如果配置文件丟失，也可以下載復制到應用程序目錄。有效的Redis配置文件的范例在https://raw.github.com/antirez/redis/2.6/redis.conf。

Redis應用程序的完整文件也可以從壓縮文件（x64）得到。

當你擁有了全套的應用程序文件（如下圖所示），

redis application folder conten

導航到應用程序目錄，然后運行以下命令：

sc create %name% binpath= "\"%binpath%\" %configpath%" start= "auto" DisplayName= "Redis"

其中：

%name%——服務實例的名稱，例如：redis-instance；
%binpath%——到項目exe文件的路徑，例如：C：\Program Files\Redis\RedisService_1.1.exe；
%configpath%——到Redis配置文件的路徑，例如：C：\Program Files\Redis\redis.conf；

舉例：

sc create Redis start= auto DisplayName= Redis binpath= "\"C:\Program Files\Redis\RedisService_1.1.exe\
" \"C:\Program Files\Redis\redis.conf\""

即應該是這樣的：

請確保有足夠的權限啟動該服務。安裝完畢后，請檢查該服務是否創建成功，當前是否正在運行：

或者，你可以使用安裝程序（我沒試過）：https://github.com/rgl/redis/downloads。

Redis服務器保護：密碼，IP過濾

保護Redis服務器的主要方式是使用Windows防火墻或活躍的網絡連接屬性設置IP過濾。此外，還可以使用Redis密碼設置額外保護。這需要用下面的方式更新Redis配置文件（redis.conf）：

首先，找到這行：

# requirepass foobared

刪除開頭的#符號，用新密碼替換foobared：

requirepass foobared

然后，重新啟動Redis Windows服務！

當具體使用客戶端的時候，使用帶密碼的構造函數：

RedisClient client = new RedisClient(serverHost, port, redisPassword);

Redis服務器復制（主—從配置）

Redis支持主從同步，即，每次主服務器修改，從服務器得到通知，并自動同步。大多復制用于讀取（但不能寫）擴展和數據冗余和服務器故障轉移。設置兩個Redis實例（在相同或不同服務器上的兩個服務），然后配置其中之一作為從站。為了讓Redis服務器實例是另一臺服務器的從屬，可以這樣更改配置文件：

找到以下代碼：

# slaveof <masterip> <masterport>

替換為：

slaveof 192.168.1.1 6379

（可以自定義指定主服務器的真實IP和端口）。如果主服務器配置為需要密碼（驗證），可以如下所示改變redis.conf，找到這一行代碼：

# masterauth <master-password>

刪除開頭的#符號，用主服務器的密碼替換<master-password>，即：

masterauth mastpassword

現在這個Redis實例可以被用來作為主服務器的只讀同步副本。

用C#代碼使用Redis緩存

用C#代碼使用Redis運行Manage NuGet包插件，找到ServiceStack.Redis包，并進行安裝。

直接從實例化客戶端使用Set/Get方法示例：

string host = "localhost"; 
string elementKey = "testKeyRedis"; 
 
using (RedisClient redisClient = new RedisClient(host)) 
{ 
      if (redisClient.Get<string>(elementKey) == null) 
      { 
           // adding delay to see the difference 
           Thread.Sleep(5000); 
           // save value in cache 
           redisClient.Set(elementKey, "some cached value"); 
      } 
      // get value from the cache by key 
      message = "Item value is: " + redisClient.Get<string>("some cached value"); 
}

類型化實體集更有意思和更實用，這是因為它們操作的是確切類型的對象。在下面的代碼示例中，有兩個類分別定義為Phone和Person——phone的主人。每個phone實例引用它的主人。下面的代碼演示我們如何通過標準添加、刪除和發現緩存項：

public class Phone 
{ 
   public int Id { get; set; } 
   public string Model { get; set; } 
   public string Manufacturer { get; set; } 
   public Person Owner { get; set; } 
} 
 
public class Person 
{ 
    public int Id { get; set; } 
    public string Name { get; set; } 
    public string Surname { get; set; } 
    public int Age { get; set; } 
    public string Profession { get; set; } 
} 
 
using (RedisClient redisClient = new RedisClient(host)) 
{ 
     IRedisTypedClient<phone> phones = redisClient.As<phone>(); 
     Phone phoneFive = phones.GetValue("5"); 
     if (phoneFive == null) 
     { 
          // make a small delay 
          Thread.Sleep(5000); 
          // creating a new Phone entry 
          phoneFive = new Phone 
          { 
               Id = 5, 
               Manufacturer = "Motorolla", 
               Model = "xxxxx", 
               Owner = new Person 
               { 
                    Id = 1, 
                    Age = 90, 
                    Name = "OldOne", 
                    Profession = "sportsmen", 
                    Surname = "OldManSurname" 
               } 
          }; 
          // adding Entry to the typed entity set 
          phones.SetEntry(phoneFive.Id.ToString(), phoneFive); 
     } 
     message = "Phone model is " + phoneFive.Manufacturer; 
     message += "Phone Owner Name is: " + phoneFive.Owner.Name; 
}

在上面的例子中，我們實例化了輸入端IRedisTypedClient，它與緩存對象的特定類型——Phone類型一起工作。

Redis ASP.NET會話狀態

要用Redis提供商配置ASP.NET會話狀態，添加新文件到你的Web項目，命名為RedisSessionStateProvider.cs，可以從https://github.com/chadman/redis-service-provider/raw/master/RedisProvider/SessionProvider/RedisSessionProvider.cs復制代碼，然后添加或更改配置文件中的以下部分（sessionState標簽已經內置于system.web標簽），或者你也可以下載附加來源和復制代碼。

<sessionstate timeout="1" mode="Custom" 
customprovider="RedisSessionStateProvider" cookieless="false"> 
      <providers> 
        <add name="RedisSessionStateProvider" writeexceptionstoeventlog="false" 
        type="RedisProvider.SessionProvider.CustomServiceProvider" 
        server="localhost" port="6379" password="pasword"> 
      </add> </providers> 
</sessionstate>

注意，此密碼是可以選擇的，看服務器是否需要認證。它必須被真實的值替換或刪除，如果Redis服務器不需要身份驗證，那么服務器屬性和端口得由具體的數值代替（默認端口為6379）。然后在項目中，你才可以使用會話狀態：

// in the Global.asax 
public class MvcApplication1 : System.Web.HttpApplication 
{ 
    protected void Application_Start() 
    { 
        //.... 
    } 
 
    protected void Session_Start() 
    { 
        Session["testRedisSession"] = "Message from the redis ression"; 
    } 
} 
 
在Home controller（主控制器）： 
 
public class HomeController : Controller 
{ 
    public ActionResult Index() 
    { 
       //... 
       ViewBag.Message = Session["testRedisSession"]; 
       return View(); 
    } 
//... 
}

結果：

ASP.NET輸出緩存提供者，并且Redis可以用類似的方式進行配置。

Redis Set（集合）和List（列表）

主要要注意的是，Redis列表實現IList<T>，而Redis集合實現ICollection<T>。下面來說說如何使用它們。

當需要區分相同類型的不同分類對象時，使用列表。例如，我們有“mostSelling（熱銷手機）”和“oldCollection（回收手機）”兩個列表：

string host = "localhost"; 
using (var redisClient = new RedisClient(host)) 
{ 
    //Create a 'strongly-typed' API that makes all Redis Value operations to apply against Phones 
    IRedisTypedClient<phone> redis = redisClient.As<phone>(); 
 
    IRedisList<phone> mostSelling = redis.Lists["urn:phones:mostselling"]; 
    IRedisList<phone> oldCollection = redis.Lists["urn:phones:oldcollection"]; 
 
    Person phonesOwner = new Person 
        { 
            Id = 7, 
            Age = 90, 
            Name = "OldOne", 
            Profession = "sportsmen", 
            Surname = "OldManSurname" 
        }; 
 
    // adding new items to the list 
    mostSelling.Add(new Phone 
            { 
                Id = 5, 
                Manufacturer = "Sony", 
                Model = "768564564566", 
                Owner = phonesOwner 
            }); 
 
    oldCollection.Add(new Phone 
            { 
                Id = 8, 
                Manufacturer = "Motorolla", 
                Model = "324557546754", 
                Owner = phonesOwner 
            }); 
 
    var upgradedPhone  = new Phone 
    { 
        Id = 3, 
        Manufacturer = "LG", 
        Model = "634563456", 
        Owner = phonesOwner 
    }; 
 
    mostSelling.Add(upgradedPhone); 
 
    // remove item from the list 
    oldCollection.Remove(upgradedPhone); 
 
    // find objects in the cache 
    IEnumerable<phone> LGPhones = mostSelling.Where(ph => ph.Manufacturer == "LG"); 
 
    // find specific 
    Phone singleElement = mostSelling.FirstOrDefault(ph => ph.Id == 8); 
 
    //reset sequence and delete all lists 
    redis.SetSequence(0); 
    redisClient.Remove("urn:phones:mostselling"); 
    redisClient.Remove("urn:phones:oldcollection"); 
}

當需要存儲相關的數據集和收集統計信息，例如answer -> queustion給答案或問題投票時，Redis集合就非常好使。假設我們有很多的問題（queustion）和答案（answer ），需要將它們存儲在緩存中。使用Redis，我們可以這么做：

/// <summary> 
/// Gets or sets the Redis Manager. The built-in IoC used with ServiceStack autowires this property. 
/// </summary> 
IRedisClientsManager RedisManager { get; set; } 
/// <summary> 
/// Delete question by performing compensating actions to 
/// StoreQuestion() to keep the datastore in a consistent state 
/// </summary> 
/// <param name="questionId"> 
public void DeleteQuestion(long questionId) 
{ 
    using (var redis = RedisManager.GetClient()) 
    { 
        var redisQuestions = redis.As<question>(); 
 
        var question = redisQuestions.GetById(questionId); 
        if (question == null) return; 
 
        //decrement score in tags list 
        question.Tags.ForEach(tag => redis.IncrementItemInSortedSet("urn:tags", tag, -1)); 
 
        //remove all related answers 
        redisQuestions.DeleteRelatedEntities<answer>(questionId); 
 
        //remove this question from user index 
        redis.RemoveItemFromSet("urn:user>q:" + question.UserId, questionId.ToString()); 
 
        //remove tag => questions index for each tag 
        question.Tags.ForEach("urn:tags>q:" + tag.ToLower(), questionId.ToString())); 
 
        redisQuestions.DeleteById(questionId); 
    } 
} 
 
public void StoreQuestion(Question question) 
{ 
    using (var redis = RedisManager.GetClient()) 
    { 
        var redisQuestions = redis.As<question>(); 
 
        if (question.Tags == null) question.Tags = new List<string>(); 
        if (question.Id == default(long)) 
        { 
            question.Id = redisQuestions.GetNextSequence(); 
            question.CreatedDate = DateTime.UtcNow; 
 
            //Increment the popularity for each new question tag 
            question.Tags.ForEach(tag => redis.IncrementItemInSortedSet("urn:tags", tag, 1)); 
        } 
 
        redisQuestions.Store(question); 
        redisQuestions.AddToRecentsList(question); 
        redis.AddItemToSet("urn:user>q:" + question.UserId, question.Id.ToString()); 
 
        //Usage of tags - Populate tag => questions index for each tag 
        question.Tags.ForEach(tag => redis.AddItemToSet 
        ("urn:tags>q:" + tag.ToLower(), question.Id.ToString())); 
    } 
} 
 
/// <summary> 
/// Delete Answer by performing compensating actions to 
/// StoreAnswer() to keep the datastore in a consistent state 
/// </summary> 
/// <param name="questionId"> 
/// <param name="answerId"> 
public void DeleteAnswer(long questionId, long answerId) 
{ 
    using (var redis = RedisManager.GetClient()) 
    { 
        var answer = redis.As<question>().GetRelatedEntities<answer> 
        (questionId).FirstOrDefault(x => x.Id == answerId); 
        if (answer == null) return; 
 
        redis.As<question>().DeleteRelatedEntity<answer>(questionId, answerId); 
 
        //remove user => answer index 
        redis.RemoveItemFromSet("urn:user>a:" + answer.UserId, answerId.ToString()); 
    } 
} 
 
public void StoreAnswer(Answer answer) 
{ 
    using (var redis = RedisManager.GetClient()) 
    { 
        if (answer.Id == default(long)) 
        { 
            answer.Id = redis.As<answer>().GetNextSequence(); 
            answer.CreatedDate = DateTime.UtcNow; 
        } 
 
        //Store as a 'Related Answer' to the parent Question 
        redis.As<question>().StoreRelatedEntities(answer.QuestionId, answer); 
        //Populate user => answer index 
        redis.AddItemToSet("urn:user>a:" + answer.UserId, answer.Id.ToString()); 
    } 
} 
 
public List<answer> GetAnswersForQuestion(long questionId) 
{ 
    using (var redis = RedisManager.GetClient()) 
    { 
        return redis.As<question>().GetRelatedEntities<answer>(questionId); 
    } 
} 
 
public void VoteQuestionUp(long userId, long questionId) 
{ 
    //Populate Question => User and User => Question set indexes in a single transaction 
    RedisManager.ExecTrans(trans => 
    { 
        //Register upvote against question and remove any downvotes if any 
        trans.QueueCommand(redis => 
        redis.AddItemToSet("urn:q>user+:" + questionId, userId.ToString())); 
        trans.QueueCommand(redis => 
        redis.RemoveItemFromSet("urn:q>user-:" + questionId, userId.ToString())); 
 
        //Register upvote against user and remove any downvotes if any 
        trans.QueueCommand(redis => 
        redis.AddItemToSet("urn:user>q+:" + userId, questionId.ToString())); 
        trans.QueueCommand(redis => 
        redis.RemoveItemFromSet("urn:user>q-:" + userId, questionId.ToString())); 
    }); 
} 
 
public void VoteQuestionDown(long userId, long questionId) 
{ 
    //Populate Question => User and User => Question set indexes in a single transaction 
    RedisManager.ExecTrans(trans => 
    { 
        //Register downvote against question and remove any upvotes if any 
        trans.QueueCommand(redis => 
        redis.AddItemToSet("urn:q>user-:" + questionId, userId.ToString())); 
        trans.QueueCommand(redis => 
        redis.RemoveItemFromSet("urn:q>user+:" + questionId, userId.ToString())); 
 
        //Register downvote against user and remove any upvotes if any 
        trans.QueueCommand(redis => 
        redis.AddItemToSet"urn:user>q-:" + userId, questionId.ToString())); 
        trans.QueueCommand(redis => 
        redis.RemoveItemFromSet("urn:user>q+:" + userId, questionId.ToString())); 
    }); 
} 
 
public void VoteAnswerUp(long userId, long answerId) 
{ 
    //Populate Question => User and User => Question set indexes in a single transaction 
    RedisManager.ExecTrans(trans => 
    { 
        //Register upvote against answer and remove any downvotes if any 
        trans.QueueCommand(redis => 
        redis.AddItemToSet("urn:a>user+:" + answerId, userId.ToString())); 
        trans.QueueCommand(redis => 
        redis.RemoveItemFromSet("urn:a>user-:" + answerId, userId.ToString())); 
 
        //Register upvote against user and remove any downvotes if any 
        trans.QueueCommand(redis => 
        redis.AddItemToSet("urn:user>a+:" + userId, answerId.ToString())); 
        trans.QueueCommand(redis => 
        redis.RemoveItemFromSet("urn:user>a-:" + userId, answerId.ToString())); 
    }); 
} 
 
public void VoteAnswerDown(long userId, long answerId) 
{ 
    //Populate Question => User and User => Question set indexes in a single transaction 
    RedisManager.ExecTrans(trans => 
    { 
        //Register downvote against answer and remove any upvotes if any 
        trans.QueueCommand(redis => 
        redis.AddItemToSet("urn:a>user-:" + answerId, userId.ToString())); 
        trans.QueueCommand(redis => 
        redis.RemoveItemFromSet("urn:a>user+:" + answerId, userId.ToString())); 
 
        //Register downvote against user and remove any upvotes if any 
        trans.QueueCommand(redis => 
        redis.AddItemToSet("urn:user>a-:" + userId, answerId.ToString())); 
        trans.QueueCommand(redis => 
        redis.RemoveItemFromSet("urn:user>a+:" + userId, answerId.ToString())); 
    }); 
} 
 
public QuestionResult GetQuestion(long questionId) 
{ 
    var question = RedisManager.ExecAs<question> 
    (redisQuestions => redisQuestions.GetById(questionId)); 
    if (question == null) return null; 
 
    var result = ToQuestionResults(new[] { question })[0]; 
    var answers = GetAnswersForQuestion(questionId); 
    var uniqueUserIds = answers.ConvertAll(x => x.UserId).ToHashSet(); 
    var usersMap = GetUsersByIds(uniqueUserIds).ToDictionary(x => x.Id); 
 
    result.Answers = answers.ConvertAll(answer => 
        new AnswerResult { Answer = answer, User = usersMap[answer.UserId] }); 
 
    return result; 
} 
 
public List<user> GetUsersByIds(IEnumerable<long> userIds) 
{ 
    return RedisManager.ExecAs<user>(redisUsers => redisUsers.GetByIds(userIds)).ToList(); 
} 
 
public QuestionStat GetQuestionStats(long questionId) 
{ 
    using (var redis = RedisManager.GetReadOnlyClient()) 
    { 
        var result = new QuestionStat 
        { 
            VotesUpCount = redis.GetSetCount("urn:q>user+:" +questionId), 
            VotesDownCount = redis.GetSetCount("urn:q>user-:" + questionId) 
        }; 
        result.VotesTotal = result.VotesUpCount - result.VotesDownCount; 
        return result; 
    } 
} 
 
public List<tag> GetTagsByPopularity(int skip, int take) 
{ 
    using (var redis = RedisManager.GetReadOnlyClient()) 
    { 
        var tagEntries = redis.GetRangeWithScoresFromSortedSetDesc("urn:tags", skip, take); 
        var tags = tagEntries.ConvertAll(kvp => new Tag { Name = kvp.Key, Score = (int)kvp.Value }); 
        return tags; 
    } 
} 
 
public SiteStats GetSiteStats() 
{ 
    using (var redis = RedisManager.GetClient()) 
    { 
        return new SiteStats 
        { 
            QuestionsCount = redis.As<question>().TypeIdsSet.Count, 
            AnswersCount = redis.As<answer>().TypeIdsSet.Count, 
            TopTags = GetTagsByPopularity(0, 10) 
        }; 
    } 
}

附加資源說明

項目中引用的一些包在packages.config文件中配置。

Funq IoC的相關配置，以及注冊類型和當前控制器目錄，在Global.asax文件中配置。

基于IoC的緩存使用以及Global.asax可以打開以下URL：http://localhost:37447/Question/GetQuestions?tag=test 查看。

你可以將tag字段設置成test3，test1，test2等。

Redis緩存配置——在web config文件（<system.web><sessionState>節點）以及RedisSessionStateProvider.cs文件中。

在MVC項目中有很多待辦事項，因此，如果你想改進/繼續，請更新，并上傳。

如果有人能提供使用Redis（以及Funq IOC）緩存的MVC應用程序示例，本人將不勝感激。Funq IOC已經配置，使用示例已經在Question controller中。

注：部分取樣于“ServiceStack.Examples-master”解決方案。

結論。優化應用程序緩存以及快速本地緩存

由于Redis并不在本地存儲（也不在本地復制）數據，那么通過在本地緩存區存儲一些輕量級或用戶依賴的對象（跳過序列化字符串和客戶端—服務端數據轉換）來優化性能是有意義的。例如，在Web應用中，對于輕量級的對象使用’System.Runtime.Caching.ObjectCache‘ 會更好——用戶依賴，并且應用程序時常要用。否則，當經常性地需要使用該對象時，就必須在分布式Redis緩存中存儲大量容積的內容。用戶依賴的對象舉例——個人資料信息，個性化信息。常用對象——本地化數據，不同用戶之間的共享信息，等等。

下載源代碼（Redis Funq LoC MVC 4版本）

鏈接

如何運行Redis服務：

https://github.com/kcherenkov/redis-windows-service

文檔：

http://redis.io/documentation

.NET / C#示例：

https://github.com/ServiceStack/ServiceStack.Examples

關于如何用C＃在Windows上使用Redis的好建議：

http://maxivak.com/getting-started-with-redis-and-asp-net-mvc-under-windows/：

http://www.piotrwalat.net/using-redis-with-asp-net-web-api/

關于Redis：