快取工廠之Redis快取

這幾天沒有按照計劃分享技術博文，主要是去醫院了，這裡一想到在醫院經歷的種種，我真的有話要說；醫院裡的醫務人員曾經被吹捧為美麗+和藹+可親的天使，在經受5天左右相互接觸後不得不讓感慨；遇見的有些人員在掛號隊伍猶如長龍的時候坐在收費視窗玩手機，理由是自己是換班的差幾分鐘才上班呢；遇見態度極其惡劣的主任醫師，做諮詢幾個問題聲音馬上提高並言語中攜帶諷刺話語；還有其他幾個遇見哈哈這裡就不多說了，可能是某些醫務人員覺得多您個不少，我有的是客源，所以個別是這種態度吧，還是市醫院真不知道怎麼混進去的。

 

以上是個人的看法，下面來正式分享今天的文章吧：

。搭建Redis服務端，並用客戶端連線

。封裝快取父類，定義Get，Set等常用方法

。定義RedisCache快取類，執行Redis的Get，Set方法

。構造出快取工廠呼叫方法

 

下面一步一個腳印的來分享：

。搭建Redis服務端，並用客戶端連線

首先，咋們去這個地址下載安裝檔案https://github.com/dmajkic/redis/downloads，我這裡的版本是：redis-2.4.5-win32-win64裡面有32位和64位的執行檔案，我這裡伺服器是64位的下面給出截圖和用到部分程式的說明：

現在，咋們直接可以用滑鼠雙擊redis-server.exe這個應用程式，這樣就開啟了redis服務窗體（您也可以下載一個windows服務承載器，把redis服務執行在windows的服務中，就不用擔心每次關閉redis服務黑色窗體後無法訪問redis了），執行起來是這樣：

有紅色框的資訊就表示成功了，這裡redis服務監聽的埠預設是6379，要修改埠或者更多的配置資訊請找到redis.conf配置檔案，具體配置資訊介紹可以來這裡http://www.shouce.ren/api/view/a/6231

再來，開啟客戶端連線服務端，咋們退到64bit資料夾的目錄中，滑鼠移到64bit資料夾上並且安裝Shift鍵，同時點選滑鼠的右鍵，選中"在此處開啟命令視窗"這樣快速進入到了該資料夾的cmd命令視窗中（當然不同的作業系統不同，這裡演示的是windows的操作；還有其他進入的方式這裡不做介紹，因為個人感覺這是最快的）；然後，在命令視窗中錄入redis-cli.exe -h localhost -p 6379回車來訪問服務端，效果圖：

再來看下服務端窗體截圖：

沒錯這樣客戶端就連線上服務端了，可以簡單在客戶端執行下set，get命令：

如果是客戶端要訪問遠端的redis服務端，只需要把localhost換成可訪問的ip就行了如果還需要密碼等更多配置請去上面的那個地址連結；

 

。封裝快取父類，定義Get，Set等常用方法

先來，上父類的程式碼：

public class BaseCache : IDisposable
    {
        protected string def_ip = string.Empty;
        protected int def_port = 0;
        protected string def_password = string.Empty;

        public BaseCache()
        {

        }

        public virtual void InitCache(string ip = "", int port = 0, string password = "")
        {

        }

        public virtual bool SetCache<T>(string key, T t, int timeOutMinute = 10) where T : class,new()
        {

            return false;
        }

        public virtual T GetCache<T>(string key) where T : class,new()
        {

            return default(T);
        }

        public virtual bool Remove(string key)
        {

            return false;
        }

        public virtual bool FlushAll()
        {

            return false;
        }

        public virtual bool Any(string key)
        {

            return false;
        }

        public virtual void Dispose(bool isfalse)
        {

            if (isfalse)
            {


            }
        }

        //手動釋放
        public void Dispose()
        {

            this.Dispose(true);
            //不自動釋放
            GC.SuppressFinalize(this);
        }
    }

這裡定義的方法沒有太多的註釋，更多的意思我想看方法名稱就明白了，這個父類主要實現了IDisposable，實現的Dispose()中主要用來釋放資源並且自定義了一個 public virtual void Dispose(bool isfalse)方法，這裡面有一句是GC.SuppressFinalize(this);按照官網介紹的意思是阻塞自動釋放資源，其他的沒有什麼了，繼續看下面的

 

。定義RedisCache快取類，執行Redis的Get，Set方法

首先，咋們分別定義類RedisCache，MemcachedCache（這裡暫未實現對memcache快取的操作），並且繼承BaseCache，重寫Set，Get方法如下程式碼：

/// <summary>
    /// Redis快取
    /// </summary>
    public class RedisCache : BaseCache
    {
        public RedisClient redis = null;

        public RedisCache()
        {

            //這裡去讀取預設配置檔案資料
            def_ip = "172.0.0.1";
            def_port = 6379;
            def_password = "";
        }

        #region Redis快取

        public override void InitCache(string ip = "", int port = 0, string password = "")
        {

            if (redis == null)
            {
                ip = string.IsNullOrEmpty(ip) ? def_ip : ip;
                port = port == 0 ? def_port : port;
                password = string.IsNullOrEmpty(password) ? def_password : password;

                redis = new RedisClient(ip, port, password);
            }
        }

        public override bool SetCache<T>(string key, T t, int timeOutMinute = 10)
        {

            var isfalse = false;

            try
            {
                if (string.IsNullOrEmpty(key)) { return isfalse; }

                InitCache();
                isfalse = redis.Set<T>(key, t, TimeSpan.FromMinutes(timeOutMinute));
            }
            catch (Exception ex)
            {
            }
            finally { this.Dispose(); }
            return isfalse;
        }

        public override T GetCache<T>(string key)
        {
            var t = default(T);
            try
            {
                if (string.IsNullOrEmpty(key)) { return t; }

                InitCache();
                t = redis.Get<T>(key);
            }
            catch (Exception ex)
            {
            }
            finally { this.Dispose(); }
            return t;
        }

        public override bool Remove(string key)
        {
            var isfalse = false;
            try
            {
                if (string.IsNullOrEmpty(key)) { return isfalse; }

                InitCache();
                isfalse = redis.Remove(key);
            }
            catch (Exception ex)
            {
            }
            finally { this.Dispose(); }
            return isfalse;
        }

        public override void Dispose(bool isfalse)
        {

            if (isfalse && redis != null)
            {

                redis.Dispose();
                redis = null;
            }
        }

        #endregion
    }


    /// <summary>
    /// Memcached快取
    /// </summary>
    public class MemcachedCache : BaseCache
    {


    }

這裡，用到的RedisClient類是來自nuget包引用的，這裡nuget包是：

然後，來看下重寫的InitCache方法，這裡面有一些ip，port（埠），password（密碼）引數，這裡直接寫入在cs檔案中沒有從配置檔案讀取，大家可以擴充套件下；這些引數通過RedisClient建構函式傳遞給底層Socket訪問需要的資訊，下面簡單展示下RedisClient幾個的建構函式：

        public RedisClient();
        public RedisClient(RedisEndpoint config);
        public RedisClient(string host);
        public RedisClient(Uri uri);
        public RedisClient(string host, int port);
        public RedisClient(string host, int port, string password = null, long db = 0);

至於Get，Set方法最終都是使用RedisClient物件訪問的，個人覺得需要注意的是Set方法裡面的過期時間引數，目前還沒有試驗這種情況的效果：

?通過這幾種方法設定過期時間後，快到過期時間的時候如果此時有使用這個快取key那麼過期時間是否會往後自動增加過期時間有效期，這裡暫時沒有試驗（這裡是由於前面專案中的.net core框架中的memecache快取都有這種設定，想來redis應該也有吧）

這裡，需要重寫下public override void Dispose(bool isfalse)方法，因為呼叫完RedisClient後需要釋放，我們通過Dispose統一來手動釋放，而不是直接在呼叫的時候使用using()

 

。構造出快取工廠呼叫方法

接下來，咋們需要定義一個快取工廠，因為上面剛才定義了一個RedisCache和MemcachedCache明顯這裡會有多個不同快取的方法呼叫，所用咋們來定義個工廠模式來呼叫對應的快取；這裡的工廠模式沒有使用直接顯示建立new RedisCache(),new MemcachedCache()物件的方法，而是使用了反射的原理，建立對應的快取物件；

先來，定義個列舉，列舉裡面的宣告的名字要和咋們快取類的名稱相同，程式碼如下：

public enum CacheType
    {
        RedisCache,

        MemcachedCache
    }

再來，定義個工廠來CacheRepository(快取工廠)，並且定義方法Current如下程式碼：

public static BaseCache Current(CacheType cacheType = CacheType.RedisCache)
        {
            var nspace = typeof(BaseCache);
            var fullName = nspace.FullName;
            var nowspace = fullName.Substring(0, fullName.LastIndexOf('.') + 1);

            return Assembly.GetExecutingAssembly().CreateInstance(nowspace + cacheType.ToString(), true) as BaseCache;
        }

*：通過傳遞列舉引數，來確定反射CreateInstance()方法需要用到的typeName引數，從而來定義需要訪問的那個快取物件，這裡要注意的是加上了一個名稱空間nowspace，因為快取類可能和工廠類不是同一個名稱空間，但是通常會和快取基類是同名稱空間所以在方法最開始的時候擷取獲取了快取類需要的名稱空間（這裡看自身專案來定吧）；

*：Assembly.GetExecutingAssembly()這個是用來獲取當前應用程式集的路徑，這裡就避免了咋們使用Assembly.Load()方法還需要傳遞程式集的路徑地址了

好了滿上上面要求後，咋們可以在測試頁面呼叫程式碼如：CacheRepository.Current(CacheType.RedisCache).SetCache<MoFlightSearchResponse>(keyData, value)；就如此簡單，咋們使用redis-cli.exe客戶端來看下快取起來的資料：

怎麼樣，您們的是什麼效果呢，下面給出整體程式碼(最後更新時間：2016-09-29)：

#region CacheRepository 快取工廠（預設儲存Session中）

    /// <summary>
    /// 快取列舉
    /// </summary>
    public enum CacheType
    {
        BaseCache,

        RedisCache,

        MemcachedCache
    }

    /// <summary>
    /// 快取工廠（預設儲存Session中）
    /// </summary>
    public class CacheRepository
    {

        /// <summary>
        /// 快取工廠（預設儲存Session中, CacheKey = "SeesionKey"）
        /// </summary>
        /// <param name="cacheType">快取型別</param>
        /// <returns></returns>
        public static BaseCache Current(CacheType cacheType = CacheType.RedisCache)
        {
            var nspace = typeof(BaseCache);
            var fullName = nspace.FullName;
            var nowspace = fullName.Substring(0, fullName.LastIndexOf('.') + 1);

            return Assembly.GetExecutingAssembly().CreateInstance(nowspace + cacheType.ToString(), true) as BaseCache;
        }
    }

    /// <summary>
    /// 快取基類（預設儲存Session中）
    /// </summary>
    public class BaseCache : IDisposable
    {
        protected string def_ip = string.Empty;
        protected int def_port = 0;
        protected string def_password = string.Empty;
        protected string CacheKey = "SeesionKey";

        public BaseCache()
        {

        }

        /// <summary>
        /// 獲取自定義SessionId值
        /// </summary>
        /// <param name="key">key：使用唯一的登陸賬號</param>
        /// <returns>hash值的SessionId</returns>
        public virtual string GetSessionId(string key)
        {
            return Md5Extend.GetSidMd5Hash(key);
        }

        public virtual void InitCache(bool isReadAndWriter = true, string ip = "", int port = 0, string password = "")
        {

        }

        public virtual bool SetCache<T>(string key, T t, int timeOutMinute = 10, bool isSerilize = false) where T : class,new()
        {
            var isfalse = false;

            try
            {
                key = key ?? CacheKey;
                if (t == null) { return isfalse; }

                var session_json = JsonConvert.SerializeObject(t);
                HttpContext.Current.Session.Timeout = timeOutMinute;
                HttpContext.Current.Session.Add(key, session_json);
                isfalse = true;
            }
            catch (Exception ex)
            {

                throw new Exception(ex.Message);
            }
            return isfalse;
        }

        public virtual T GetCache<T>(string key = null, bool isSerilize = false) where T : class,new()
        {
            var t = default(T);

            try
            {

                key = key ?? CacheKey;
                var session = HttpContext.Current.Session[key];
                if (session == null) { return t; }

                t = JsonConvert.DeserializeObject<T>(session.ToString());
            }
            catch (Exception ex)
            {

                throw new Exception(ex.Message);
            }
            return t;
        }

        public virtual bool Remove(string key = null)
        {
            var isfalse = false;

            try
            {
                key = key ?? CacheKey;
                HttpContext.Current.Session.Remove(key);
                isfalse = true;
            }
            catch (Exception ex)
            {

                throw new Exception(ex.Message);
            }
            return isfalse;
        }

        /// <summary>
        /// 增加快取時間
        /// </summary>
        /// <returns></returns>
        public virtual bool AddExpire(string key, int nTimeMinute = 10)
        {
            return true;
        }

        public virtual bool FlushAll()
        {

            return false;
        }

        public virtual bool Any(string key)
        {

            return false;
        }

        public virtual bool SetHashCache<T>(string hashId, string key, T t, int nTimeMinute = 10) where T : class,new()
        {

            return false;
        }

        public virtual List<string> GetHashKeys(string hashId)
        {

            return null;
        }

        public virtual List<string> GetHashValues(string hashId)
        {

            return null;
        }

        public virtual T GetHashValue<T>(string hashId, string key) where T : class,new()
        {
            var t = default(T);
            return t;
        }

        public virtual bool RemoveHashByKey(string hashId, string key)
        {

            return false;
        }


        public virtual void Dispose(bool isfalse)
        {

            if (isfalse)
            {


            }
        }

        //手動釋放
        public void Dispose()
        {

            this.Dispose(true);
            //不自動釋放
            GC.SuppressFinalize(this);
        }
    }

    /// <summary>
    /// Redis快取
    /// </summary>
    public class RedisCache : BaseCache
    {
        public IRedisClient redis = null;

        public RedisCache()
        {

            //這裡去讀取預設配置檔案資料
            def_ip = "127.0.0.1";
            def_port = 6379;
            def_password = "";
        }

        #region Redis快取

        public static object _lockCache = new object();
        public override void InitCache(bool isReadAndWriter = true, string ip = "", int port = 0, string password = "")
        {

            if (redis == null)
            {
                ip = string.IsNullOrEmpty(ip) ? def_ip : ip;
                port = port == 0 ? def_port : port;
                password = string.IsNullOrEmpty(password) ? def_password : password;

                //單個redis服務
                //redis = new RedisClient(ip, port, password);

                //叢集服務 如果密碼，格式如：pwd@ip:port
                var readAndWritePorts = new List<string> { "shenniubuxing3@127.0.0.1:6379" };
                var onlyReadPorts = new List<string> {
                    "shenniubuxing3@127.0.0.1:6378",
                    "shenniubuxing3@127.0.0.1:6377"
                };

                var redisPool = new PooledRedisClientManager(
                    readAndWritePorts,
                    onlyReadPorts,
                    new RedisClientManagerConfig
                    {
                        AutoStart = true,
                        //最大讀取連結
                        MaxReadPoolSize = 20,
                        //最大寫入連結
                        MaxWritePoolSize = 10
                    })
                {
                    //每個連結超時時間
                    ConnectTimeout = 20,
                    //連線池超時時間
                    PoolTimeout = 60
                };

                lock (_lockCache)
                {
                    redis = isReadAndWriter ? redisPool.GetClient() : redisPool.GetReadOnlyClient();
                }
            }
        }

        public override bool AddExpire(string key, int nTimeMinute = 10)
        {
            var isfalse = false;
            try
            {
                if (string.IsNullOrEmpty(key)) { return isfalse; }

                InitCache();
                //isfalse = redis.ExpireEntryIn(key, TimeSpan.FromMinutes(nTimeMinute));
                isfalse = redis.ExpireEntryAt(key, DateTime.Now.AddMinutes(nTimeMinute));
            }
            catch (Exception ex)
            {
            }
            finally { this.Dispose(); }
            return isfalse;
        }

        public override bool SetCache<T>(string key, T t, int timeOutMinute = 10, bool isSerilize = false)
        {

            var isfalse = false;

            try
            {
                if (string.IsNullOrEmpty(key)) { return isfalse; }

                InitCache();
                if (isSerilize)
                {
                    var data = JsonConvert.SerializeObject(t);
                    var bb = System.Text.Encoding.UTF8.GetBytes(data);
                    isfalse = redis.Set<byte[]>(key, bb, TimeSpan.FromMinutes(timeOutMinute));
                }
                else { isfalse = redis.Set<T>(key, t, TimeSpan.FromMinutes(timeOutMinute)); }
            }
            catch (Exception ex)
            {
            }
            finally { this.Dispose(); }
            return isfalse;
        }


        public override T GetCache<T>(string key, bool isSerilize = false)
        {
            var t = default(T);
            try
            {
                if (string.IsNullOrEmpty(key)) { return t; }

                InitCache(false);
                if (isSerilize)
                {

                    var bb = redis.Get<byte[]>(key);
                    if (bb.Length <= 0) { return t; }
                    var data = System.Text.Encoding.UTF8.GetString(bb);
                    t = JsonConvert.DeserializeObject<T>(data);
                }
                else { t = redis.Get<T>(key); }
            }
            catch (Exception ex)
            {
            }
            finally { this.Dispose(); }
            return t;
        }

        public override bool Remove(string key)
        {
            var isfalse = false;
            try
            {
                if (string.IsNullOrEmpty(key)) { return isfalse; }

                InitCache();
                isfalse = redis.Remove(key);
            }
            catch (Exception ex)
            {
            }
            finally { this.Dispose(); }
            return isfalse;
        }

        public override bool SetHashCache<T>(string hashId, string key, T t, int nTimeMinute = 10)
        {

            var isfalse = false;

            try
            {
                if (string.IsNullOrEmpty(hashId) || string.IsNullOrEmpty(key) || t == null) { return isfalse; }

                InitCache();

                var result = JsonConvert.SerializeObject(t);
                if (string.IsNullOrEmpty(result)) { return isfalse; }
                isfalse = redis.SetEntryInHash(hashId, key, result);
                if (isfalse) { AddExpire(key, nTimeMinute); }
            }
            catch (Exception ex)
            {
            }
            finally { this.Dispose(); }
            return isfalse;
        }

        public override List<string> GetHashKeys(string hashId)
        {
            var hashKeys = new List<string>();
            try
            {
                if (string.IsNullOrEmpty(hashId)) { return hashKeys; }

                InitCache();
                hashKeys = redis.GetHashKeys(hashId);

            }
            catch (Exception ex)
            {
            }
            finally { this.Dispose(); }
            return hashKeys;
        }

        public override List<string> GetHashValues(string hashId)
        {
            var hashValues = new List<string>();
            try
            {
                if (string.IsNullOrEmpty(hashId)) { return hashValues; }

                InitCache();
                hashValues = redis.GetHashValues(hashId);
            }
            catch (Exception ex)
            {
            }
            finally { this.Dispose(); }
            return hashValues;
        }

        public override T GetHashValue<T>(string hashId, string key)
        {
            var t = default(T);
            try
            {
                if (string.IsNullOrEmpty(hashId) || string.IsNullOrEmpty(key)) { return t; }

                InitCache();
                var result = redis.GetValueFromHash(hashId, key);
                if (string.IsNullOrEmpty(result)) { return t; }

                t = JsonConvert.DeserializeObject<T>(result);
            }
            catch (Exception ex)
            {
            }
            finally { this.Dispose(); }
            return t;
        }

        public override bool RemoveHashByKey(string hashId, string key)
        {
            var isfalse = false;

            try
            {
                if (string.IsNullOrEmpty(hashId) || string.IsNullOrEmpty(key)) { return isfalse; }

                InitCache();
                isfalse = redis.RemoveEntryFromHash(hashId, key);
            }
            catch (Exception ex)
            {
            }
            finally { this.Dispose(); }
            return isfalse;
        }

        public override void Dispose(bool isfalse)
        {

            if (isfalse && redis != null)
            {

                redis.Dispose();
                redis = null;
            }
        }

        #endregion
    }

    /// <summary>
    /// Memcached快取
    /// </summary>
    public class MemcachedCache : BaseCache
    {


    }

    #endregion

這次分享的Redis快取從搭建到使用希望給您們有幫助，還請多多支援點贊，謝謝。

.2016-08-30號修改最新版本程式碼