TinyFrame升级之五：全局缓存的设计及实现

在任何框架中，缓存都是不可或缺的一部分，本框架亦然。在这个框架中，我们的缓存分为两部分：内存缓存和单次请求缓存。简单说来，就是一个使用微软提供的MemoryCache做扩展，并提供全局唯一实例；另一个使用微软提供的HttpContextBase做扩展，用户每发送一次请求，HttpContextBase都会被关联创建。先来看下接口约束：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace TinyFrame.Framework.Caching
{
    public interface ICacheManager
    {
        //根据key获取缓存对象
        T Get<T>(string key);

        //设置缓存对象
        void Set(string key, object data, int cacheTime);

        //查询key是否被缓存
        bool IsSet(string key);

        //从缓存移除
        void Remove(string key);

        //缓存移除匹配
        void RemoveByPattern(string pattern);

        //清空所有缓存
        void Clear();
    }
}

 

方法不多，但是包含了缓存的增删查。其中Get泛型方法可以通过Key返回缓存对象；Set方法可以添加缓存；IsSet方法可以检测缓存是否存在；Remove方法可以清除已有的单个缓存；RemoveByPattern可以通过正则匹配清除缓存；Clear方法则清除全部缓存。

首先是MemoryCacheManager的实现：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.Caching;
using System.Text.RegularExpressions;

namespace TinyFrame.Framework.Caching
{
    public class MemoryCacheManager:ICacheManager
    {
        protected ObjectCache Cache
        {
            get { return MemoryCache.Default; }
        }

        public T Get<T>(string key)
        {
            return (T)Cache[key];
        }

        public void Set(string key, object data, int cacheTime)
        {
            if (data == null)
                return;
            var policy = new CacheItemPolicy();
            policy.AbsoluteExpiration = DateTime.Now + TimeSpan.FromMinutes(cacheTime);
            Cache.Add(new CacheItem(key,data),policy);

        }

        public bool IsSet(string key)
        {
            return Cache.Contains(key);
        }

        public void Remove(string key)
        {
            Cache.Remove(key);
        }

        public void RemoveByPattern(string pattern)
        {
            var regex = new Regex(pattern, RegexOptions.Singleline
                                            | RegexOptions.Compiled
                                            | RegexOptions.IgnoreCase);
            var keysToRemove = new List<string>();
            foreach (var item in Cache)
                if (regex.IsMatch(item.Key))
                    keysToRemove.Add(item.Key);

            foreach (string key in keysToRemove)
            {
                Remove(key);
            }
        }

        public void Clear()
        {
            foreach (var item in Cache)
            {
                Remove(item.Key);
            }
        }
    }
}

 

然后是PerRequestCacheManager的实现：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Web;
using System.Collections;
using System.Text.RegularExpressions;

namespace TinyFrame.Framework.Caching
{
    public class PerRequestCacheManager : ICacheManager
    {
        public PerRequestCacheManager(HttpContextBase context)
        {
            this.context = context;
        }

        private readonly HttpContextBase context;

        protected virtual IDictionary GetItems()
        {
            if (context != null)
                return context.Items;

            return null;
        }

        public T Get<T>(string key)
        {
            var items = GetItems();
            if (items == null)
                return default(T);

            return (T)items[key];
        }

        public void Set(string key, object data, int cacheTime)
        {
            var items = GetItems();
            if (items == null)
                return;

            if (data != null)
            {
                if (items.Contains(key))
                    items[key] = data;
                else
                    items.Add(key, data);
            }
        }

        public bool IsSet(string key)
        {
            var items = GetItems();
            if (items == null)
                return false;

            return items[key] != null;
        }

        public void Remove(string key)
        {
            var items = GetItems();
            if (items == null)
                return;

            items.Remove(key);
        }

        public void RemoveByPattern(string pattern)
        {
            var items = GetItems();
            if (items == null)
                return;

            var enumerator = items.GetEnumerator();
            var regex = new Regex(pattern, RegexOptions.Singleline
                                          | RegexOptions.Compiled
                                          | RegexOptions.IgnoreCase);
            var keysToRemove = new List<string>();
            while (enumerator.MoveNext())
            {
                if (regex.IsMatch(enumerator.Key.ToString()))
                {
                    keysToRemove.Add(enumerator.Key.ToString());
                }
            }

            foreach (string key in keysToRemove)
            {
                items.Remove(key);
            }
        }

        public void Clear()
        {
            var items = GetItems();
            if (items == null)
                return;

            var enumerator = items.GetEnumerator();
            var keysToRemove = new List<string>();
            while (enumerator.MoveNext())
            {
                keysToRemove.Add(enumerator.Key.ToString());
            }

            foreach (string key in keysToRemove)
            {
                items.Remove(key);
            }
        }
    }
}

 

二者的实现方式差不多。这里我就不做过多的解释了。

如果想使用的话，直接在Autofac容器中注册一下就行了。在这次演示中，我们使用MemoryCacheManager来做缓存容器。

这里我以一个分页为例:

string BookPaggerKey = "Books-{0}-{1}-{2}-{3}";
        //分页查询
        public IList<Book> GetBooksPagger(int pageCount
                                        , int currentIndex
                                        , out int totalCount
                                        , string propertyName=""
                                        , string propertyValue=""
                                        )
        {
            IQueryable<Book> bookList = null;
            int skipRows = 0;
            if (currentIndex > 0) skipRows = currentIndex * pageCount;

            if (!string.IsNullOrEmpty(propertyName))
                bookList = GetBooksByConstruct(propertyName, propertyValue);
            else
                bookList = bookRepository.GetMany(m => m.ID >= 0);
            totalCount = bookList.Count();

            //return bookList.OrderBy(p => p.ID).Skip(skipRows).Take(pageCount).ToList();
            string key = string.Format(BookPaggerKey, pageCount, currentIndex, propertyName, propertyValue);

            return cacheManager.Get(key, () => bookList.OrderBy(p => p.ID).Skip(skipRows).Take(pageCount).ToList());
        }

第1行：定义了一个Cache的Key，用于标识保存ID

第23行：利用get方法检查缓存容器，如果缓存中数据不存在，则将查询数据添加到缓存；否则直接从缓存中拿出数据来。

我们来看看效果：

首先打开页面，我们换换页，目的是让页面被缓存住：

然后我们打开SQL的SQL Server Profile来进行追踪，现在，我们点击页面的刷新按钮，看看测试效果 ：

当我们连续刷新页面好几次，但是并未见到有新的分页查询被追踪到，说明我们的数据被缓存住了。

最后我们加个断点调试一下缓存对象，可以找到被缓存的数据：