Redis進階實踐之九 獨立封裝的RedisClient客戶端工具類

一、引言

        今天開始有關Redis學習的第九篇文章了，以后肯定會大量系統使用Redis作為緩存介質，為了更好的更好的Redis，自己寫了兩個工具類，但是這兩個工具類，沒有提供一致的接口，是為了使用的獨立性。測試已經完畢，可以正常訪問Windows和Linux版本上的Redis服務，各種操作也沒問題。今天就把主要代碼貼出來，因為有一部分是需要配置文件的，我自己獨立寫了一套配置系統，這套配置系統就不貼出來，大家可以根據自己的理解來寫這個部分的內容，好了，開始我們今天的寫作吧。

二、簡介

        我寫了兩個工具類，第一個是以【StackExchange.Redis】為實現技術的Redis的客戶端工具類，另一個是以【ServiceStack.Redis】為實現技術的Redis客戶端工具類。【ServiceStack.Redis】的官網主頁：https://servicestack.net/redis，【ServiceStack.Redis】在github上的主頁：https://github.com/ServiceStack/ServiceStack.Redis，【ServiceStack.Redis】和Visual Studio 2015整個也很方便，微軟在這塊做的的很不過，我們可以通過命令直接安裝：Install-Package ServiceStack.Redis，當然我們也可以通過NuGet來安裝，安裝完成，在您項目的【引用】里面會生成四個dll，分別是：ServiceStack.Common，ServiceStack.Interfaces，ServiceStack.Redis，ServiceStack.Client 四個程序集，然后在項目中使用Using引入就可以正常使用了。【ServiceStack.Redis】是Redis官方推薦的C#客戶端，性能非常優越，使用也很方便，但是從v4版本已經逐漸商業化了，目的可以想而知，嗨，都是錢惹的禍。

       上面我說道了，【ServiceStack.Redis】后來就商業化了，我想了想光靠他也是不行了，還要在寫一個版本的工具類，所以就選擇了【StackExchange.Redis】，【StackExchange.Redis】也是開源的，到目前，一直都是開源的，它的地址是：https://github.com/StackExchange/StackExchange.Redis，我使用的是.net 4.5，工具采用 vs2015， StackExchange.Redis版本是1.0.488。工具類還會在持續的使用過程中，我還會更新和修改的。

三、實例代碼
 
         這是Redis客戶端的配置文件的格式，格式很簡單，可以分開配置，也可以合在一起配置。代碼中標紅的是和我的配置系統有關的代碼，大家請注意。

<configuration>
  <configSections>
    <section name="Framework" type="Enterprise.Framework.Configuration.ConfigurationFrameworkSectionHandler,Enterprise.Framework.Configuration" />
  </configSections>

  <Framework type="Enterprise.Framework.Configuration.ConfigurationFrameworkManager,Enterprise.Framework.Configuration">
    <Enterprise.Framework.NoSQL>
      <RedisClients>
          <RedisClient name="ServiceStack" technology="ServiceStack.Redis">
            <readWriteHosts>192.168.3.11:6379,192.168.3.11:6380</readWriteHosts>
            <!--<readOnlyHosts>可以省略該項</readOnlyHosts>-->
            <!--<maxWritePoolSize>可以省略該項</maxWritePoolSize>-->
            <!--<maxReadPoolSize>可以省略該項</maxReadPoolSize>-->
            <!--<password>可以省略該項</password>-->
            <!--<autoStart>可以省略該項</autoStart>-->
          </RedisClient>
          <RedisClient name="StackExchange" technology="StackExchange.Redis">
            <host>192.168.131.1:6379</host>
            <!--<password>可以省略該項</password>-->
          </RedisClient>
      </RedisClients>
    </Enterprise.Framework.NoSQL>
  </Framework>
</configuration>

 

        1、這是以【ServiceStack.Redis】為實現技術的工具類，對外界的訪問接口提供了2個，第一個是以配置文件中自定義的名稱參數的，紅色代碼是和我獨立的配置系統相關聯的，另一個訪問接口是以配置實體類參數的，代碼很簡單，不多說了。

      工具類：ServiceStackRedisClientProvider.cs

/// <summary>
    /// 通過ServiceStack.Redis實現的Redis的客戶端操作類型
    /// </summary>
    public sealed class ServiceStackRedisClientProvider
    {
        #region 私有變量

        //線程同步變量
        private static readonly object lockObject = new object();

        //redis鏈接池管理對象
        private static volatile PooledRedisClientManager _instance = null;

        //配置文件里面的ServiceStack詳細配置設置
        private static ServiceStackDetails _serviceStackDetails;

        //可以自行配置ServiceStack的配置對象
        private static ServiceStackConfigEntry _serviceStackConfigEntry;

        #endregion

        #region 私有構造函數

        /// <summary>
        /// 私有構造函數，禁止外部通過new關鍵字來創建該對象實例
        /// </summary>
        private ServiceStackRedisClientProvider() { }

        #endregion

        #region 獲取PooledRedisClientManager實例的方法

        /// <summary>
        /// 獲取redis鏈接池管理對象實例
        /// 實例發生變化的集中情況：
        /// 1.實例為空
        /// 2.配置文件發生變化
        /// </summary>
        /// <param name="startByConfigFile">這是一個布爾值，true表示根據配置文件的配置啟動，false表示是根據配置對象啟動</param>
        /// <returns>返回PooledRedisClientManager類型的對象實例</returns>
        private static PooledRedisClientManager GetInstance(bool startByConfigFile)
        {
            if (_instance == null)
            {
                lock (lockObject)
                {
                    if (_instance == null)
                    {
                        string[] readWriteServerList=null;
                        string[] readOnlyServerList=null;
                        RedisClientManagerConfig managerConfig=null;

                        //根據我們配置文件中數據來設置啟動信息（app.config或者web.config）
                        if (startByConfigFile && (_serviceStackDetails != null))
                        {
                            managerConfig = new RedisClientManagerConfig()
                            {
                                AutoStart = _serviceStackDetails.AutoStart,
                                MaxReadPoolSize = _serviceStackDetails.MaxReadPoolSize,
                                MaxWritePoolSize = _serviceStackDetails.MaxWritePoolSize,
                            };

                            readWriteServerList = GetRedisHosts(_serviceStackDetails.ReadWriteHosts);
                            readOnlyServerList = GetRedisHosts(_serviceStackDetails.ReadOnlyHosts);
                        }
                        else if (!startByConfigFile && (_serviceStackConfigEntry != null))//根據配置對象來設置啟動信息(ServiceStackConfigEntry)
                        {
                            managerConfig = new RedisClientManagerConfig()
                            {
                                AutoStart = _serviceStackConfigEntry.AutoStart,
                                MaxReadPoolSize = _serviceStackConfigEntry.MaxReadPoolSize,
                                MaxWritePoolSize = _serviceStackConfigEntry.MaxWritePoolSize,
                            };

                            readWriteServerList = GetRedisHosts(_serviceStackConfigEntry.ReadWriteHosts);
                            readOnlyServerList = GetRedisHosts(_serviceStackConfigEntry.ReadOnlyHosts);
                        }
                        else
                        {
                            throw new InvalidOperationException("Redis客戶端初始化配置失敗！");
                        }

                        if ((readWriteServerList != null && readWriteServerList.Length > 0)&&(readOnlyServerList != null && readOnlyServerList.Length <= 0))
                        {
                            _instance = new PooledRedisClientManager(readWriteServerList);
                        }

                        if ((readWriteServerList != null && readWriteServerList.Length > 0) && (readOnlyServerList != null && readOnlyServerList.Length > 0))
                        {
                            _instance = new PooledRedisClientManager(readWriteServerList, readOnlyServerList, managerConfig);
                        }
                    }
                }
            }
            return _instance;
        }

        /// <summary>
        /// 解析Redis服務器列表，該列表格式IP[:Port]
        /// </summary>
        /// <param name="redisHosts">包含一個或者多個Redis服務器地址的字符串列表，以逗號做為分隔符</param>
        /// <returns>返回Redis服務器地址列表</returns>
        private static string[] GetRedisHosts(string redisHosts)
        {
            if (string.IsNullOrWhiteSpace(redisHosts) || string.IsNullOrEmpty(redisHosts))
            {
                return new string[] { };
            }
            var hosts=redisHosts.Split(',');
            foreach (var host in hosts)
            {
                if (!Regex.IsMatch(host, @"^(25[0-5]|2[0-4][0-9]|[0-1]{1}[0-9]{2}|[1-9]{1}[0-9]{1}|[1-9])\.(25[0-5]|2[0-4][0-9]|[0-1]{1}[0-9]{2}|[1-9]{1}[0-9]{1}|[1-9]|0)\.(25[0-5]|2[0-4][0-9]|[0-1]{1}[0-9]{2}|[1-9]{1}[0-9]{1}|[1-9]|0)\.(25[0-5]|2[0-4][0-9]|[0-1]{1}[0-9]{2}|[1-9]{1}[0-9]{1}|[0-9]):\d{3,4}$"))
                {
                    throw new InvalidOperationException("Redis服務器地址格式不正確！");
                }
            }
            return hosts;
        }

        #endregion

        #region 提供對外訪問接口

        /// <summary>
        /// 獲取Redis客戶端對象實例
        /// </summary>
        /// <param name="redisClientName">在配置文件中，Redis客戶端的名稱</param>
        /// <param name="databaseIndex">redis邏輯分為16個數據庫，排序為：0-15，我們默認使用的是0號數據庫，數據庫當前的索引值</param>
        /// <returns>返回IRedisClient對象實例</returns>
        public static IRedisClient GetRedisClient(string redisClientName,int databaseIndex = 0)
        {
            //獲取配置數據
            ParameterValidityChecker.RequiredParameterStringNotNullOrWhiteSpace(redisClientName, "Redis客戶端的名稱不能為空！");
            var _configurationManager = (ConfigurationFrameworkManager)ConfigurationManager.GetSection("Framework");
            if (_configurationManager != null)
            {
                _serviceStackDetails = _configurationManager.RedisClientConfiguration.GetServiceStackDetails(redisClientName);
                if (_serviceStackDetails == null)
                {
                    throw new InvalidOperationException("以ServiceStack.Redis為實現技術的Redis客戶端的配置有誤！");
                }
            }
            else
            {
                throw new InvalidOperationException("以ServiceStack.Redis為實現技術的Redis客戶端的配置有誤！");
            }

            //實例化Redis客戶端實例對象
            var pooledRedisClientManager = GetInstance(true);
            var redisClient = pooledRedisClientManager.GetClient();
            if (!string.IsNullOrEmpty(_serviceStackDetails.Password))
            {
                redisClient.Password = _serviceStackDetails.Password;
            }
            redisClient.Db = databaseIndex;
            return redisClient;
        }

        /// <summary>
        /// 獲取Redis客戶端對象實例
        /// </summary>
        /// <param name="serviceStackConfigEntry">在配置文件中，Redis客戶端的名稱</param>
        /// <param name="databaseIndex">redis邏輯分為16個數據庫，排序為：0-15，我們默認使用的是0號數據庫，數據庫當前的索引值</param>
        /// <returns>返回IRedisClient對象實例</returns>
        public static IRedisClient GetRedisClient(ServiceStackConfigEntry serviceStackConfigEntry, int databaseIndex = 0)
        {
            //獲取配置數據
            if (serviceStackConfigEntry == null)
            {
                throw new ArgumentNullException("以ServiceStack.Redis為實現技術的Redis客戶端的配置對象不能為空！");
            }
            else
            {
                _serviceStackConfigEntry = serviceStackConfigEntry;
            }

            if (string.IsNullOrEmpty(_serviceStackConfigEntry.ReadWriteHosts) || string.IsNullOrWhiteSpace(_serviceStackConfigEntry.ReadWriteHosts))
            {
                throw new InvalidOperationException("【ReadWriteHosts】必須設置其值！");
            }

            //實例化Redis客戶端實例對象
            var pooledRedisClientManager = GetInstance(false);
            var redisClient = pooledRedisClientManager.GetClient();
            if (!string.IsNullOrEmpty(_serviceStackConfigEntry.Password)&&!string.IsNullOrWhiteSpace(_serviceStackConfigEntry.Password))
            {
                redisClient.Password = _serviceStackConfigEntry.Password;
            }
            redisClient.Db = databaseIndex;
            return redisClient;
        }

        #endregion
    }

 

     配置實體類 ServiceStackConfigEntry.cs的代碼：

/// <summary>
    ///  配置文件中，以ServiceStack.Redis為實現技術的配置Redis的詳情
    /// </summary>
    public sealed class ServiceStackConfigEntry
    {
        #region 構造函數

        /// <summary>
        /// 給配置參數初始化默認值
        /// </summary>
        public ServiceStackConfigEntry()
        {
            ReadWriteHosts = "127.0.0.1:6379";
            ReadOnlyHosts = string.Empty;
            MaxWritePoolSize = 200;
            MaxReadPoolSize = 200;
            Password = string.Empty;
            AutoStart = true;
        }

        #endregion

        #region 配置屬性

        /// <summary>
        /// 可讀可寫的Redis服務器地址，多個地址以逗號分隔，例如：192.168.127.11:6379,192.168.127.128:6380
        /// </summary>
        public string ReadWriteHosts { get; set; }

        /// <summary>
        /// 只能讀的Redis服務器地址，多個地址以逗號分隔，例如：192.168.127.11:6379,192.168.127.128:6380
        /// </summary>
        public string ReadOnlyHosts { get; set; }

        /// <summary>
        /// 最大寫鏈接數
        /// </summary>
        public int MaxWritePoolSize { get; set; }

        /// <summary>
        /// 最大讀鏈接數
        /// </summary>
        public int MaxReadPoolSize { get; set; }

        /// <summary>
        /// 登陸Redis服務器的密碼
        /// </summary>
        public string Password { get; set; }

        /// <summary>
        /// 是否自動啟動
        /// </summary>
        public bool AutoStart { get; set; }

        #endregion
    }

 

      獲取配置文件詳情的類型：ServiceStackDetails.cs

    

/// <summary>
    ///  配置文件中，以ServiceStack.Redis為實現技術的配置Redis的詳情
    /// </summary>
    public sealed class ServiceStackDetails
    {
        #region 構造函數

        /// <summary>
        /// 給配置參數初始化默認值
        /// </summary>
        public ServiceStackDetails()
        {
            ReadWriteHosts = "127.0.0.1:6379";
            ReadOnlyHosts = string.Empty;
            MaxWritePoolSize = 200;
            MaxReadPoolSize = 200;
            Password = string.Empty;
            AutoStart = true;
        }

        #endregion

        #region 配置屬性

        /// <summary>
        /// 可讀可寫的Redis服務器地址，多個地址以逗號分隔，例如：192.168.127.11:6379,192.168.127.128:6380
        /// </summary>
        public string ReadWriteHosts { get; internal set; }

        /// <summary>
        /// 只能讀的Redis服務器地址，多個地址以逗號分隔，例如：192.168.127.11:6379,192.168.127.128:6380
        /// </summary>
        public string ReadOnlyHosts { get; internal set; }

        /// <summary>
        /// 最大寫鏈接數
        /// </summary>
        public int MaxWritePoolSize { get; internal set; }

        /// <summary>
        /// 最大讀鏈接數
        /// </summary>
        public int MaxReadPoolSize { get; internal set; }

        /// <summary>
        /// 登陸Redis服務器的密碼
        /// </summary>
        public string Password { get; internal set; }

        /// <summary>
        /// 是否自動啟動
        /// </summary>
        public bool AutoStart { get; internal set; }

        #endregion
    }

 

          2、這是以【StackExchange.Redis】為實現技術的工具類，對外界的訪問接口提供了2個，第一個是以配置文件中自定義的名稱參數的，紅色代碼是和我獨立的配置系統相關聯的，另一個訪問接口是以配置實體類參數的，代碼很簡單，不多說了。

 

       工具類： StackExchangeRedisClientProvider.cs

 

/// <summary>
    /// 通過StackExchange.Redis實現的Redis的客戶端操作類型
    /// </summary>
    public sealed class StackExchangeRedisClientProvider
    {
        #region 私有字段

        /// <summary>
        /// 線程同步變量
        /// </summary>
        private static readonly object lockObject = new object();

        /// <summary>
        /// redis鏈接池管理對象
        /// </summary>
        private static volatile ConnectionMultiplexer _instance;

        /// <summary>
        /// 日志記錄器
        /// </summary>
        private static readonly ILog _log = LogManager.GetLogger(typeof(StackExchangeRedisClientProvider));

        private static StackExchangeDetails _stackExchangeDetails;

        private static StackExchangeConfigEntry _stackExchangeConfigEntry;

        #endregion

        #region 私有構造函數

        /// <summary>
        /// 私有構造函數，禁止不允許通過new 來實例化該對象
        /// </summary>
        private StackExchangeRedisClientProvider() { }

        #endregion

        #region 獲取Redis客戶端實例

        /// <summary>
        /// 使用一個靜態屬性來返回已連接的實例
        /// 實例發生變化的幾種情況：
        /// 1.實例為空
        /// 2.連接關閉
        /// 3.文件發生變化時
        /// </summary>
        /// <param name="startByConfigFile">這是一個布爾值，true表示根據配置文件的配置啟動，false表示是根據配置對象啟動</param>
        /// <returns>返回ConnectionMultiplexer類型的對象實例</returns>
        private static ConnectionMultiplexer GetInstance(bool startByConfigFile)
        {
            if (startByConfigFile)
            {
                GetRedisHosts(_stackExchangeDetails.Hosts);
            }
            else
            {
                GetRedisHosts(_stackExchangeConfigEntry.Hosts);
            }
            
            if (_instance == null || !_instance.IsConnected)
            {
                lock (lockObject)
                {
                    if (_instance == null || !_instance.IsConnected)
                    {
                        if (startByConfigFile)
                        {
                            _instance = ConnectionMultiplexer.Connect(_stackExchangeDetails.Hosts);
                        }
                        else
                        {
                            _instance = ConnectionMultiplexer.Connect(_stackExchangeConfigEntry.Hosts);
                        }
                    }
                }
            }
            _instance.ErrorMessage += MuxerErrorMessage;
            _instance.HashSlotMoved += MuxerHashSlotMoved;
            _instance.InternalError += MuxerInternalError;
            _instance.ConnectionFailed += MuxerConnectionFailed;
            _instance.ConnectionRestored += MuxerConnectionRestored;
            _instance.ConfigurationChanged += MuxerConfigurationChanged;
            return _instance;
        }

        /// <summary>
        /// 解析Redis服務器列表，該列表格式IP:Port
        /// </summary>
        /// <param name="redisHosts">包含一個或者多個Redis服務器地址的字符串列表，以逗號做為分隔符</param>
        private static void GetRedisHosts(string redisHosts)
        {
            if (string.IsNullOrWhiteSpace(redisHosts) || string.IsNullOrEmpty(redisHosts))
            {
                return;
            }
            var hosts = redisHosts.Split(',');
            foreach (var host in hosts)
            {
                if (!Regex.IsMatch(host, @"^(25[0-5]|2[0-4][0-9]|[0-1]{1}[0-9]{2}|[1-9]{1}[0-9]{1}|[1-9])\.(25[0-5]|2[0-4][0-9]|[0-1]{1}[0-9]{2}|[1-9]{1}[0-9]{1}|[1-9]|0)\.(25[0-5]|2[0-4][0-9]|[0-1]{1}[0-9]{2}|[1-9]{1}[0-9]{1}|[1-9]|0)\.(25[0-5]|2[0-4][0-9]|[0-1]{1}[0-9]{2}|[1-9]{1}[0-9]{1}|[0-9]):\d{3,4}$"))
                {
                    throw new InvalidOperationException("Redis服務器地址格式不正確！");
                }
            }
        }

        /// <summary>
        /// 獲取Redis客戶端對象實例
        /// </summary>
        /// <param name="redisClientName">在配置文件中，Redis客戶端的名稱</param>
        /// <param name="databaseIndex">redis邏輯分為16個數據庫，排序為：0-15，我們默認使用的是0號數據庫，數據庫當前的索引值</param>
        /// <returns></returns>
        public static IDatabase GetRedisClient(string redisClientName, int databaseIndex =0)
        {
            //獲取配置數據
            ParameterValidityChecker.RequiredParameterStringNotNullOrWhiteSpace(redisClientName, "Redis客戶端的名稱不能為空！");
            var _configurationManager = (ConfigurationFrameworkManager)ConfigurationManager.GetSection("Framework");
            if (_configurationManager != null)
            {
                _stackExchangeDetails = _configurationManager.RedisClientConfiguration.GetStackExchangeDetails(redisClientName);
                if (_stackExchangeDetails == null)
                {
                    throw new InvalidOperationException("以StackExchange.Redis為實現技術的Redis客戶端的配置有誤！");
                }
            }
            else
            {
                throw new InvalidOperationException("以StackExchange.Redis為實現技術的Redis客戶端的配置有誤！");
            }

            //實例化Redis客戶端實例對象
            var instance = GetInstance(true);
            return instance.GetDatabase(databaseIndex);
        }

        /// <summary>
        /// 獲取Redis客戶端對象實例
        /// </summary>
        /// <param name="stackExchangeConfigEntry">StackExchange配置對象</param>
        /// <param name="databaseIndex">redis邏輯分為16個數據庫，排序為：0-15，我們默認使用的是0號數據庫，數據庫當前的索引值</param>
        /// <returns></returns>
        public static IDatabase GetRedisClient(StackExchangeConfigEntry stackExchangeConfigEntry, int databaseIndex =0)
        {
            //獲取配置數據
            if (stackExchangeConfigEntry == null)
            {
                throw new ArgumentNullException("以StackExchange.Redis為實現技術的Redis客戶端的配置對象不能為空！");
            }
            else
            {
                _stackExchangeConfigEntry = stackExchangeConfigEntry;
            }

            if (string.IsNullOrEmpty(_stackExchangeConfigEntry.Hosts) || string.IsNullOrWhiteSpace(_stackExchangeConfigEntry.Hosts))
            {
                throw new InvalidOperationException("【Hosts】必須設置其值！");
            }

            //實例化Redis客戶端實例對象
            var instance = GetInstance(false);
            return instance.GetDatabase(databaseIndex);
        }

        #endregion
    }

     配置實體類：StackExchangeConfigEntry.cs

/// <summary>
    ///  配置文件中，以StackExchange.Redis為實現技術的配置Redis的詳情
    /// </summary>
    public sealed class StackExchangeConfigEntry
    {
        #region 構造函數

        /// <summary>
        /// 給配置參數初始化默認值
        /// </summary>
        public StackExchangeConfigEntry()
        {
            Hosts = "127.0.0.1:6379";
            Password = string.Empty;
        }

        #endregion

        #region 配置屬性

        /// <summary>
        /// Redis服務器地址，多個地址以逗號分隔，例如：192.168.127.11:6379,192.168.127.128:6380
        /// </summary>
        public string Hosts { get; set; }

        /// <summary>
        /// 登陸Redis服務器的密碼
        /// </summary>
        public string Password { get; set; }

        #endregion
    }

 
   根據配置信息獲取數據的類型：StackExchangeDetails.cs

/// <summary>
    ///  配置文件中，以StackExchange.Redis為實現技術的配置Redis的詳情
    /// </summary>
    public sealed class StackExchangeDetails
    {
        #region 構造函數

        /// <summary>
        /// 給配置參數初始化默認值
        /// </summary>
        public StackExchangeDetails()
        {
            Hosts = "127.0.0.1:6379";
            Password = string.Empty;
        }

        #endregion

        #region 配置屬性

        /// <summary>
        /// Redis服務器的主機地址，如果多個地址則以逗號分隔，格式：127.0.0.1:6379,127.0.0.1:6380
        /// </summary>
        public string Hosts{ get; internal set; }

        /// <summary>
        /// 登陸Redis服務器的密碼
        /// </summary>
        public string Password { get; internal set; }

        #endregion
    }

 

四、結束

       好了，今天就寫到這里了，先說明一下，這兩個類暫時沒有提供統一的接口，看以后的需要吧，如果有需要，我在重構。StackExchangeDetails 和 ServiceStackDetails 這兩個類在這個 Enterprise.Framework.Configuration 命名空間，配置的系統暫時就不貼代碼了，代碼很多，其他的類型都在 Enterprise.Framework.NoSQL.RedisClient 這個命名空間下邊。