一步步實現一個基本的緩存模塊

一步步實現一個基本的緩存模塊

注意后續代碼及改進見后后文及github，文章上的並沒有更新。

    1. 前言
    2.  請求級別緩存
    2.1 多線程
    3.  進程級別緩存
    3.1 分區與計數
    3.2 可空緩存值
    3.3 封裝與集成
    4.  小結

1. 前言

• 面向讀者：初、中級用戶；
• 涉及知識：HttpContext、HttpRuime.Cache、DictionaryEntry、Unit Test等；
• 文章目的：這里的內容不會涉及 Memcached、Redies 等進程外緩存的使用，只針對包含WEB應用的常見場景，實現一個具有線程安全、分區、過期特性的緩存模塊，略微提及DI等內容。
• jusfr 原創，轉載請注明來自博客園。

2.  請求級別緩存

如果需要線程安全地存取數據，System.Collections.Concurrent 命名空間下的像 ConcurrentDictionary 等實現是首選；更復雜的特性像過期策略、文件依賴等就需要其他實現了。ASP.NET中的HttpContext.Current.Items 常常被用作自定義數據容器，注入工具像Unity、Autofac 等便借助自定義 HttpModule 將容器掛接在 HttpContext.Current 上以進行生命周期管理。

基本接口 ICacheProvider，請求級別的緩存從它定義，考慮到請求級別緩存的運用場景有限，故只定義有限特性；

    public interface ICacheProvider {
        Boolean TryGet<T>(String key, out T value);
        T GetOrCreate<T>(String key, Func<T> function);
        T GetOrCreate<T>(String key, Func<String, T> factory);
        void Overwrite<T>(String key, T value);
        void Expire(String key);
    }

HttpContext.Current.Items 從 IDictionary 定義，存儲 Object-Object 鍵值對，出於便利與直觀，ICacheProvider 只接受String類型緩存鍵，故HttpContextCacheProvider內部使用 BuildCacheKey(String key) 方法生成真正緩存鍵以避免鍵值重復；

同時 HashTable 可以存儲空引用作為緩存值，故 TryGet() 方法先進行 Contains() 判斷存在與否，再進行類型判斷，避免緩存鍵重復使用；  

public class HttpContextCacheProvider : ICacheProvider {
        protected virtual String BuildCacheKey(String key) {
            return String.Concat("HttpContextCacheProvider_", key);
        }

        public Boolean TryGet<T>(String key, out T value) {
            key = BuildCacheKey(key);
            Boolean exist = false;
            if (HttpContext.Current.Items.Contains(key)) {
                exist = true;
                Object entry = HttpContext.Current.Items[key];
                if (entry != null && !(entry is T)) {
                    throw new InvalidOperationException(String.Format("緩存項`[{0}]`類型錯誤, {1} or {2} ?",
                        key, entry.GetType().FullName, typeof(T).FullName));
                }
                value = (T)entry;
            }
            else {
                value = default(T);
            }
            return exist;
        }

        public T GetOrCreate<T>(String key, Func<T> function) {
            T value;
            if (TryGet(key, out value)) {
                return value;
            }
            value = function();
            Overwrite(key, value);
            return value;
        }

        public T GetOrCreate<T>(String key, Func<String, T> factory) {
            T value;
            if (TryGet(key, out value)) {
                return value;
            }
            value = factory(key);
            Overwrite(key, value);
            return value;
        }

        public void Overwrite<T>(String key, T value) {
            key = BuildCacheKey(key);
            HttpContext.Current.Items[key] = value;
        }

        public void Expire(String key) {
            key = BuildCacheKey(key);
            HttpContext.Current.Items.Remove(key);
        }
    }

這里使用了 Func<T> 委托的運用，合並查詢、判斷和添加緩存項的操作以簡化接口調用；如果用戶期望不同類型緩存值可以存儲到相同的 key 上，則需要重新定義 BuildCacheKey() 方法將緩存值類型作為參數參與生成緩存鍵，此時 Expire() 方法則同樣需要了。測試用例：

[TestClass]
    public class HttpContextCacheProviderTest {
        [TestInitialize]
        public void Initialize() {
            HttpContext.Current = new HttpContext(new HttpRequest(null, "http://localhost", null), new HttpResponse(null));
        }

        [TestMethod]
        public void NullValue() {
            var key = "key-null";
            HttpContext.Current.Items.Add(key, null);
            Assert.IsTrue(HttpContext.Current.Items.Contains(key));
            Assert.IsNull(HttpContext.Current.Items[key]);
        }

        [TestMethod]
        public void ValueType() {
            var key = "key-guid";
            ICacheProvider cache = new HttpContextCacheProvider();
            var id1 = Guid.NewGuid();
            var id2 = cache.GetOrCreate(key, () => id1);
            Assert.AreEqual(id1, id2);

            cache.Expire(key);
            Guid id3;
            var exist = cache.TryGet(key, out id3);
            Assert.IsFalse(exist);
            Assert.AreNotEqual(id1, id3);
            Assert.AreEqual(id3, Guid.Empty);
        }
    }

引用類型測試用例忽略。

2.1 多線程

異步等情況下，HttpContext.Current並非無處不在，故異步等情況下 HttpContextCacheProvider 的使用可能拋出空引用異常，需要被處理，對此園友有過思考 ，這里貼上A大的方案 ，有需求的讀者請按圖索驥。

3.  進程級別緩存

HttpRuntime.Cache 定義在 System.Web.dll 中，System.Web 命名空間下，實際上是可以使用在非 Asp.Net 應用里的；另外 HttpContext 對象包含一個 Cache 屬性，它們的關系可以閱讀 HttpContext.Cache 和 HttpRuntime.Cache；

HttpRuntime.Cache 為 System.Web.Caching.Cache 類型，支持滑動/絕對時間過期策略、支持緩存優先級、緩存更新/過期回調、基於文件的緩存依賴項等，功能十分強大，這里借用少數特性來實現進程級別緩存，更多文檔請自行檢索。

從 ICacheProvider 定義 IHttpRuntimeCacheProvider，添加相對過期與絕對過期、添加批量的緩存過期接口 ExpireAll()；

    public interface IHttpRuntimeCacheProvider : ICacheProvider {
        T GetOrCreate<T>(String key, Func<T> function, TimeSpan slidingExpiration);
        T GetOrCreate<T>(String key, Func<T> function, DateTime absoluteExpiration);
        void Overwrite<T>(String key, T value, TimeSpan slidingExpiration);
        void Overwrite<T>(String key, T value, DateTime absoluteExpiration);
        void ExpireAll();
    }

System.Web.Caching.Cache 只繼承 IEnumerable，內部使用 DictionaryEntry 存儲Object-Object 鍵值對，但 HttpRuntime.Cache 只授受字符串類型緩存鍵及非空緩存值，關於空引用緩存值的問題，我們在3.2中討論；

故 TryGet() 與 HttpContextCacheProvider.TryGet() 具有顯著差異，前者需要拿出值來進行非空判斷，后者則是使用 IDictionary.Contains() 方法；

除了 TryGet() 方法與過期過期參數外的差異外，接口實現與 HttpContextCacheProvider 類似；

    public class HttpRuntimeCacheProvider : IHttpRuntimeCacheProvider {
        private static readonly Object _sync = new Object();

        protected virtual String BuildCacheKey(String key) {
            return String.Concat("HttpRuntimeCacheProvider_", key);
        }

        public Boolean TryGet<T>(String key, out T value) {
            key = BuildCacheKey(key);
            Boolean exist = false;
            Object entry = HttpRuntime.Cache.Get(key);
            if (entry != null) {
                exist = true;
                if (!(entry is T)) {
                    throw new InvalidOperationException(String.Format("緩存項[{0}]類型錯誤, {1} or {2} ?",
                        key, entry.GetType().FullName, typeof(T).FullName));
                }
                value = (T)entry;
            }
            else {
                value = default(T);
            }
            return exist;
        }

        public T GetOrCreate<T>(String key, Func<String, T> factory) {
            T result;
            if (TryGet<T>(key, out result)) {
                return result;
            }
            result = factory(key);
            Overwrite(key, result);
            return result;
        }

        public T GetOrCreate<T>(String key, Func<T> function) {
            T result;
            if (TryGet<T>(key, out result)) {
                return result;
            }
            result = function();
            Overwrite(key, result);
            return result;
        }


        public T GetOrCreate<T>(String key, Func<T> function, TimeSpan slidingExpiration) {
            T result;
            if (TryGet<T>(key, out result)) {
                return result;
            }
            result = function();
            Overwrite(key, result, slidingExpiration);
            return result;
        }

        public T GetOrCreate<T>(String key, Func<T> function, DateTime absoluteExpiration) {
            T result;
            if (TryGet<T>(key, out result)) {
                return result;
            }
            result = function();
            Overwrite(key, result, absoluteExpiration);
            return result;
        }

        public void Overwrite<T>(String key, T value) {
            HttpRuntime.Cache.Insert(BuildCacheKey(key), value);
        }

        //slidingExpiration 時間內無訪問則過期
        public void Overwrite<T>(String key, T value, TimeSpan slidingExpiration) {
            HttpRuntime.Cache.Insert(BuildCacheKey(key), value, null,
                Cache.NoAbsoluteExpiration, slidingExpiration);
        }

        //absoluteExpiration 絕對時間過期
        public void Overwrite<T>(String key, T value, DateTime absoluteExpiration) {
            HttpRuntime.Cache.Insert(BuildCacheKey(key), value, null,
                absoluteExpiration, Cache.NoSlidingExpiration);
        }

        public void Expire(String key) {
            HttpRuntime.Cache.Remove(BuildCacheKey(key));
        }

        public void ExpireAll() {
            lock (_sync) {
                var entries = HttpRuntime.Cache.OfType<DictionaryEntry>()
                    .Where(entry => (entry.Key is String) && ((String)entry.Key).StartsWith("HttpRuntimeCacheProvider_"));
                foreach (var entry in entries) {
                    HttpRuntime.Cache.Remove((String)entry.Key);
                }
            }
        }
    }

測試用例與 HttpContextCacheProviderTest 類似，這里貼出緩存過期的測試：  

public class HttpRuntimeCacheProviderTest {
        [TestMethod]
        public void GetOrCreateWithAbsoluteExpirationTest() {
            var key = Guid.NewGuid().ToString();
            var val = Guid.NewGuid();

            IHttpRuntimeCacheProvider cacheProvider = new HttpRuntimeCacheProvider();
            var result = cacheProvider.GetOrCreate<Guid>(key, () => val, DateTime.UtcNow.AddSeconds(2D));
            Assert.AreEqual(result, val);

            var exist = cacheProvider.TryGet<Guid>(key, out val);
            Assert.IsTrue(exist);
            Assert.AreEqual(result, val);

            Thread.Sleep(2000);
            exist = cacheProvider.TryGet<Guid>(key, out val);
            Assert.IsFalse(exist);
            Assert.AreEqual(val, Guid.Empty);
        }

        [TestMethod]
        public void ExpireAllTest() {
            var key = Guid.NewGuid().ToString();
            var val = Guid.NewGuid();

            IHttpRuntimeCacheProvider cacheProvider = new HttpRuntimeCacheProvider();
            var result = cacheProvider.GetOrCreate<Guid>(key, () => val);
            Assert.AreEqual(result, val);

            cacheProvider.ExpireAll();
            Guid val2;
            var exist = cacheProvider.TryGet<Guid>(key, out val2);
            Assert.IsFalse(exist);
            Assert.AreEqual(val2, Guid.Empty);
        }
    }

3.1 分區與計數

緩存分區是常見需求，緩存用戶A、用戶B的認證信息可以拿用戶標識作為緩存鍵，但每個用戶分別有一整套包含授權的其他數據時，為創建以用戶分區的緩存應該是更好的選擇；
常規的想法是為緩存添加類似 `Region` 或 `Partition`的參數，個人覺得這不是很好的實踐，因為接口被修改，同時過多的參數非常讓人困惑；

讀者可能對前文中 BuildCacheKey() 方法被 protected virtual 修飾覺得很奇怪，是的，個人覺得定義新的接口，配合從緩存Key的生成算法作文章來分區貌似比較巧妙，也迎合依賴注冊被被廣泛使用的現狀；

分區的進程級別緩存定義，只需多出一個屬性：

    public interface IHttpRuntimeRegionCacheProvider : IHttpRuntimeCacheProvider {
        String Region { get; }
    }

分區的緩存實現，先為 IHttpRuntimeCacheProvider 添加計數，然后重構HttpRuntimeCacheProvider，提取出過濾算法，接着重寫 BuildCacheKey() 方法的實現，使不同分區的生成不同的緩存鍵，緩存項操作方法無須修改；  

public interface IHttpRuntimeCacheProvider : ICacheProvider {
        ...
        Int32 Count { get; }
    }

     public class HttpRuntimeCacheProvider : IHttpRuntimeCacheProvider {
        ...
        protected virtual Boolean Hit(DictionaryEntry entry) {
            return (entry.Key is String) && ((String)entry.Key).StartsWith("HttpRuntimeCacheProvider_");
        }

        public void ExpireAll() {
            lock (_sync) {
                var entries = HttpRuntime.Cache.OfType<DictionaryEntry>().Where(Hit);
                foreach (var entry in entries) {
                    HttpRuntime.Cache.Remove((String)entry.Key);
                }
            }
        }

        public Int32 Count {
            get {
                lock (_sync) {
                    return HttpRuntime.Cache.OfType<DictionaryEntry>().Where(Hit).Count();
                }
            }
        }
    }

    public class HttpRuntimeRegionCacheProvider : HttpRuntimeCacheProvider, IHttpRuntimeRegionCacheProvider {
        private String _prefix;
        public virtual String Region { get; private set; }

        private String GetPrifix() {
            if (_prefix == null) {
                _prefix = String.Concat("HttpRuntimeRegionCacheProvider_", Region, "_");
            }
            return _prefix;
        }

        public HttpRuntimeRegionCacheProvider(String region)  {
            Region = region;
        }

        protected override String BuildCacheKey(String key) {
            //Region 為空將被當作  String.Empty 處理
            return String.Concat(GetPrifix(), base.BuildCacheKey(key));
        }

        protected override Boolean Hit(DictionaryEntry entry) {
            return (entry.Key is String) && ((String)entry.Key).StartsWith(GetPrifix());
        }
    }

測試用例示例了兩個分區緩存對相同 key 的操作： 

 [TestClass]
    public class HttpRuntimeRegionCacheProviderTest {
        [TestMethod]
        public void ValueType() {
            var key = "key-guid";
            IHttpRuntimeCacheProvider cache1 = new HttpRuntimeRegionCacheProvider("Region1");
            var id1 = cache1.GetOrCreate(key, Guid.NewGuid);

            IHttpRuntimeCacheProvider cache2 = new HttpRuntimeRegionCacheProvider("Region2");
            var id2 = cache2.GetOrCreate(key, Guid.NewGuid);
            Assert.AreNotEqual(id1, id2);

            cache1.ExpireAll();
            Assert.AreEqual(cache1.Count, 0);
            Assert.AreEqual(cache2.Count, 1);
        }
    }

至此一個基本的緩存模塊已經完成；

3.2 可空緩存值

前文提及過，HttpRuntime.Cache 不授受空引用作為緩存值，與 HttpContext.Current.Items表現不同，另一方面實際需求中，空值作為字典的值仍然是有意義，此處給出一個支持空緩存值的實現；

HttpRuntime.Cache 斷然是不能把 null 存入的，查看 HttpRuntimeCacheProvider.TryGet() 方法，可知 HttpRuntime.Cache.Get() 獲取的總是 Object 類型，思路可以這樣展開：

1) 添加緩存時進行判斷，如果非空，常規處理，否則把用一個特定的自定義對象存入；
2) 取出緩存時進行判斷，如果為特定的自定義對象，返回 null；

為 HttpRuntimeCacheProvider 的構造函數添加可選參數，TryGet() 加入 null 判斷邏輯；添加方法 BuildCacheEntry()，替換空的緩存值為 _nullEntry，其他方法不變；  

public class HttpRuntimeCacheProvider : IHttpRuntimeCacheProvider {
        private static readonly Object _sync = new Object();
        private static readonly Object _nullEntry = new Object();
        private Boolean _supportNull;

        public HttpRuntimeCacheProvider(Boolean supportNull = false) {
            _supportNull = supportNull;
        }

        protected virtual String BuildCacheKey(String key) {
            return String.Concat("HttpRuntimeCacheProvider_", key);
        }

        protected virtual Object BuildCacheEntry<T>(T value) {
            Object entry = value;
            if (value == null) {
                if (_supportNull) {
                    entry = _nullEntry;
                }
                else {
                    throw new InvalidOperationException(String.Format("Null cache item not supported, try ctor with paramter 'supportNull = true' "));
                }
            }
            return entry;
        }

        public Boolean TryGet<T>(String key, out T value) {
            Object entry = HttpRuntime.Cache.Get(BuildCacheKey(key));
            Boolean exist = false;
            if (entry != null) {
                exist = true;
                if (!(entry is T)) {
                    if (_supportNull && !(entry == _nullEntry)) {
                        throw new InvalidOperationException(String.Format("緩存項`[{0}]`類型錯誤, {1} or {2} ?",
                            key, entry.GetType().FullName, typeof(T).FullName));
                    }
                    value = (T)((Object)null);
                }
                else {
                    value = (T)entry;
                }
            }
            else {
                value = default(T);
            }
            return exist;
        }

        public T GetOrCreate<T>(String key, Func<String, T> factory) {
            T value;
            if (TryGet<T>(key, out value)) {
                return value;
            }
            value = factory(key);
            Overwrite(key, value);
            return value;
        }

        public T GetOrCreate<T>(String key, Func<T> function) {
            T value;
            if (TryGet<T>(key, out value)) {
                return value;
            }
            value = function();
            Overwrite(key, value);
            return value;
        }

        public T GetOrCreate<T>(String key, Func<T> function, TimeSpan slidingExpiration) {
            T value;
            if (TryGet<T>(key, out value)) {
                return value;
            }
            value = function();
            Overwrite(key, value, slidingExpiration);
            return value;
        }

        public T GetOrCreate<T>(String key, Func<T> function, DateTime absoluteExpiration) {
            T value;
            if (TryGet<T>(key, out value)) {
                return value;
            }
            value = function();
            Overwrite(key, value, absoluteExpiration);
            return value;
        }

        public void Overwrite<T>(String key, T value) {
            HttpRuntime.Cache.Insert(BuildCacheKey(key), BuildCacheEntry<T>(value));
        }

        //slidingExpiration 時間內無訪問則過期
        public void Overwrite<T>(String key, T value, TimeSpan slidingExpiration) {
            HttpRuntime.Cache.Insert(BuildCacheKey(key), BuildCacheEntry<T>(value), null,
                Cache.NoAbsoluteExpiration, slidingExpiration);
        }

        //absoluteExpiration 時過期
        public void Overwrite<T>(String key, T value, DateTime absoluteExpiration) {
            HttpRuntime.Cache.Insert(BuildCacheKey(key), BuildCacheEntry<T>(value), null,
                absoluteExpiration, Cache.NoSlidingExpiration);
        }

        public void Expire(String key) {
            HttpRuntime.Cache.Remove(BuildCacheKey(key));
        }

        protected virtual Boolean Hit(DictionaryEntry entry) {
            return (entry.Key is String) && ((String)entry.Key).StartsWith("HttpRuntimeCacheProvider_");
        }

        public void ExpireAll() {
            lock (_sync) {
                var entries = HttpRuntime.Cache.OfType<DictionaryEntry>().Where(Hit);
                foreach (var entry in entries) {
                    HttpRuntime.Cache.Remove((String)entry.Key);
                }
            }
        }

        public Int32 Count {
            get {
                lock (_sync) {
                    return HttpRuntime.Cache.OfType<DictionaryEntry>().Where(Hit).Count();
                }
            }
        }
    }

然后是分區緩存需要修改構造函數：

    public HttpRuntimeRegionCacheProvider(String region)
            : base(false) {
            Region = region;
        }

        public HttpRuntimeRegionCacheProvider(String region, Boolean supportNull)
            : base(supportNull) {
            Region = region;
        }
        ...
    }

測試用例： 

 [TestClass]
    public class HttpRuntimeCacheProviderTest {    
        [TestMethod]
        public void NullCacheErrorTest() {
            var key = "key-null";
            Person person = null;
            IHttpRuntimeCacheProvider cacheProvider = new HttpRuntimeCacheProvider(false);
            try {
                cacheProvider.GetOrCreate<Person>(key, () => person); //error
                Assert.Fail();
            }
            catch (Exception ex) {
                Assert.IsTrue(ex is InvalidOperationException);
            }

            Person person2;
            var exist = cacheProvider.TryGet(key, out person2);
            Assert.IsFalse(exist);
            Assert.AreEqual(person2, null);
        }

        [TestMethod]
        public void NullableCacheTest() {
            var key = "key-nullable";
            Person person = null;
            IHttpRuntimeCacheProvider cacheProvider = new HttpRuntimeCacheProvider(true);
            cacheProvider.GetOrCreate<Person>(key, () => person);
            Person person2;
            var exist = cacheProvider.TryGet(key, out person2);
            Assert.IsTrue(exist);
            Assert.AreEqual(person2, null);
        }

        class Person {
            public Int32 Id { get; set; }
            public String Name { get; set; }
        }
    }

3.3 封裝與集成

多數情況下我們不需要暴露實現和手動創建上文所提各種 CacheProvider，實踐中它們被 internal 修飾，再配合工廠類使用：  

public static class CacheProviderFacotry {
        public static ICacheProvider GetHttpContextCache() {
            return new HttpContextCacheProvider();
        }

        public static IHttpRuntimeCacheProvider GetHttpRuntimeCache(Boolean supportNull = false) {
            return new HttpRuntimeCacheProvider(supportNull);
        }

        public static IHttpRuntimeRegionCacheProvider GetHttpRuntimeRegionCache(String region, Boolean supportNull = false) {
            return new HttpRuntimeRegionCacheProvider(region, supportNull);
        }

        public static IHttpRuntimeRegionCacheProvider Region(this IHttpRuntimeCacheProvider runtimeCacheProvider, String region, Boolean supportNull = false) {
            return GetHttpRuntimeRegionCache(region, supportNull);
        }
    }

然后在依賴注入中的聲明如下，這里是 Autofac 下的組件注冊：     

 ...
            //請求級別緩存, 使用 HttpContext.Current.Items 作為容器
            builder.Register(ctx => CacheProviderFacotry.GetHttpContextCache()).As<ICacheProvider>().InstancePerLifetimeScope();
            //進程級別緩存, 使用 HttpRuntime.Cache 作為容器
            builder.RegisterInstance(CacheProviderFacotry.GetHttpRuntimeCache()).As<IRuntimeCacheProvider>().ExternallyOwned();
            //進程級別且隔離的緩存, 若出於key算法唯一考慮而希望加入上下文件信息, 則仍然需要 CacheModule 類的實現
            builder.Register(ctx => CacheProviderFacotry.GetHttpRuntimeRegionCache(/*... 分區依據 ...*/))
                .As<IRuntimeRegionCacheProvider>().InstancePerLifetimeScope();
        ...

4. 小結

本文簡單探討了一個具有線程安全、分區、過期特性緩存模塊的實現過程，只使用了HttpRuntime.Cache的有限特性，有更多需求的同學可以自行擴展；見解有限，謬誤之處還請園友指正。

園友Jusfr 原創，轉載請注明來自博客園  。

注意后續代碼及改進見后后文及github，文章上的並沒有更新。