asp.net_缓存管理

转自：http://www.cnblogs.com/mysweet/archive/2012/06/05/2536372.html

缓存是性能优化一个非常重要的模块,几乎计算机哪里都会用到缓存,我们的网站缓存也是非常重要的一块,缓存给网站带来太大的性能提高,在asp.net中的Cache,同样有各种缓存依赖,文件缓存依赖,数据库缓存依赖等等,我们的缓存管理就成了一个很重要的问题,当我们的网站小的时候,我们采用asp.net内置的Cache就可以了,但是如果我们的网站进一步扩展,单独分布式缓存服务器的时候,我们采用Memcached的时候,我们又不得不大量去修改我们的代码,这就是我之前写死缓存的问题,如下图:

这里配置缓存,如果,现在把asp.net缓存改为Memcached的时候,我们就坑爹了!

因此,很多人就开始抱怨了,改改改!

做网站就是改改改!

呵呵!

这就是一个非常重要的问题,程序员的工作似乎都在开发,修改代码中进行,而往往总是抱怨似乎没什么技术含量,天天做重复性的工作!

这就是oo的开始,这时候就需要慢慢开始学习软件工程和面向对象,

以前的层次,学习这些东西,一般也就是停留在理论层面上,软件工程,面向对象,总被人强调有用,但是总说不出为什么有用!

一旦一个软件,网站做大,就难得多得多,考虑的东西也深得多得多!这就是软件更需要大局观,需要考虑全局,考虑复用,考虑架构!

软件理论,很多人感觉很虚很虚,我刚开始也是这么感觉的,但是一旦你熟练了程序员的工作,写代码写CRUD写多了就容易出现瓶颈,感觉似乎软件都是增删改查和复杂的业务,各种技术浅尝则止,感觉无非如此,无非如此,还不如去学硬件方面的,呵呵!

而这却离软件的思想越离越远,于是乎,出现了大量的精通asp.net,精通asp.net mvc,精通wpf,Silverlight,精通一大堆的人,无非也就是能写点增删改查,这也能叫做精通..........能不能自己写框架,写架构?看博客园那些技术牛人的代码就是一种享受,他们的代码,几乎隔一段时间都会发现技术的演变,重构.这就是造诣!

于是更多的人开始不淡定,我敬佩博客园那么多专研同一种技术动不动就是好多年的牛人.

话题扯远了!

最近看了基本关于这方面的书,感触挺深的!

我们的缓存这时候更应该抽象出来,形成一种组件,以适应日后分布式缓存,而且也方便调用.

在DBO数据库连接类设计中,曾经采用工厂模式的方式以适应多种数据库的设计,

我们的缓存也可以设计成复用设计,支持多种缓存模式,

这时候,看了一下.net应用架构设计原则,模式与实践,

感觉那种缓存模式蛮好的,我也尝试着做了部分修改.

ICacheStorage就是通用缓存接口,

   1:  using System;

   2:  using System.Collections.Generic;

   3:  using System.Linq;

   4:  using System.Text;

   5:   

   6:  namespace CacheStorage

   7:  {

   8:      /// <summary>

   9:      /// 缓存接口

  10:      /// </summary>

  11:     public interface ICacheStorage

  12:      {

  13:          #region 缓存操作

  14:          /// <summary>

  15:          /// 添加缓存

  16:          /// </summary>

  17:          /// <param name="key"></param>

  18:          /// <param name="value"></param>

  19:          void Insert(string key, object value);

  20:          /// <summary>

  21:          /// 添加缓存(默认滑动时间为20分钟)

  22:          /// </summary>

  23:          /// <param name="key">key</param>

  24:          /// <param name="value">value</param>

  25:          /// <param name="expiration">绝对过期时间</param>

  26:          void Insert(string key, object value, DateTime expiration);

  27:          /// <summary>

  28:          /// 添加缓存

  29:          /// </summary>

  30:          /// <param name="key">key</param>

  31:          /// <param name="value">value</param>

  32:          /// <param name="expiration">过期时间</param>

  33:          void Insert(string key, object value, TimeSpan expiration);

  34:          /// <summary>

  35:          /// 获得key对应的value

  36:          /// </summary>

  37:          /// <param name="key"></param>

  38:          /// <returns></returns>

  39:          object Get(string key);

  40:          /// <summary>

  41:          /// 根据key删除缓存

  42:          /// </summary>

  43:          /// <param name="key"></param>

  44:          void Remove(string key);

  45:          /// <summary>

  46:          /// 缓存是否存在key的value

  47:          /// </summary>

  48:          /// <param name="key">key</param>

  49:          /// <returns></returns>

  50:          bool Exist(string key);

  51:          /// <summary>

  52:          /// 获取所有的缓存key

  53:          /// </summary>

  54:          /// <returns></returns>

  55:          List<string> GetCacheKeys();

  56:          /// <summary>

  57:          /// 清空缓存

  58:          /// </summary>

  59:          void Flush();

  60:          

  61:          #endregion

  62:      }

  63:    

  64:  }

默认的asp.net缓存

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Web;
using System.Web.Caching;
using System.Collections;
namespace CacheStorage
{
    /// <summary>
    /// 默认的asp.net中Cache
    /// </summary>
     class DefaultCacheAdapter : ICacheStorage
    {
        /// <summary>
        /// 当前请求上下文
        /// </summary>
        private static HttpContext context = null;
        /// <summary>
        /// 构造函数
        /// </summary>
        static DefaultCacheAdapter()
        {
            context = HttpContext.Current;
        }
        #region ICacheStorage 成员
        /// <summary>
        /// 添加缓存
        /// </summary>
        /// <param name="key">key</param>
        /// <param name="value">value</param>
        public void Insert(string key, object value)
        {
            context.Cache.Insert(key, value);
        }
        /// <summary>
        /// 添加缓存(默认滑动时间为20分钟)
        /// </summary>
        /// <param name="key">key</param>
        /// <param name="value">value</param>
        /// <param name="expiration">绝对过期时间</param>
        public void Insert(string key, object value, DateTime expiration)
        {
            context.Cache.Insert(key, value, null, expiration, TimeSpan.FromMinutes(20), CacheItemPriority.Normal, null);
        }
        /// <summary>
        /// 添加缓存
        /// </summary>
        /// <param name="key">key</param>
        /// <param name="value">value</param>
        /// <param name="expiration">过期时间</param>
        public void Insert(string key, object value, TimeSpan expiration)
        {
            context.Cache.Insert(key, value, null, DateTime.MaxValue, expiration, CacheItemPriority.Normal, null);

        }
        /// <summary>
        /// 获取当前缓存中key的值
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public object Get(string key)
        {
            return context.Cache[key];

        }
        /// <summary>
        /// 删除当前key的value值
        /// </summary>
        /// <param name="key"></param>
        public void Remove(string key)
        {
            if (Exist(key))
                context.Cache.Remove(key);
        }
        /// <summary>
        /// 缓存是否存在key的value
        /// </summary>
        /// <param name="key">key</param>
        /// <returns></returns>
        public bool Exist(string key)
        {
            if (context.Cache[key] == null)
                return false;
            else
                return true;
        }
        /// <summary>
        /// 获取所有的缓存key
        /// </summary>
        /// <returns></returns>
        public List<string> GetCacheKeys()
        {
            List<string> keys = new List<string>();
            IDictionaryEnumerator ide = context.Cache.GetEnumerator();
            while (ide.MoveNext())
            {
                keys.Add(ide.Key.ToString());
            }
            return keys;
        }
        /// <summary>
        /// 清空缓存
        /// </summary>
        public void Flush()
        {
            foreach (string s in GetCacheKeys())
            {
                Remove(s);
            }
        }
        #endregion
    }
}

分布式Memcached

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Enyim.Caching;
using Enyim.Caching.Memcached;

namespace CacheStorage
{
    /// <summary>
    /// 分布式Memcached缓存
    /// </summary>
    class MemcachedCache : ICacheStorage
    {
        /// <summary>
        /// 分布式缓存客户端Cache
        /// </summary>
        private MemcachedClient Cache;
        public MemcachedCache()
        {
            Cache = new MemcachedClient();
            List<string> keys = new List<string>();
            Cache.Store(StoreMode.Add, "keys", keys);
        }
        #region ICacheStorage 成员
        /// <summary>
        /// 插入缓存
        /// </summary>
        /// <param name="key">key</param>
        /// <param name="value">value</param>
        public void Insert(string key, object value)
        {
            Cache.Store(StoreMode.Set, key, value);

        }
        /// <summary>
        /// 插入缓存
        /// </summary>
        /// <param name="key">key</param>
        /// <param name="value">value</param>
        /// <param name="expiration">绝对过期时间</param>
        public void Insert(string key, object value, DateTime expiration)
        {
            Cache.Store(StoreMode.Set, key, value, expiration);
            Updatekeys(key);
        }
        /// <summary>
        /// 插入缓存
        /// </summary>
        /// <param name="key">key</param>
        /// <param name="value">value</param>
        /// <param name="expiration">过期时间</param>
        public void Insert(string key, object value, TimeSpan expiration)
        {
            Cache.Store(StoreMode.Set, key, value, expiration);
            Updatekeys(key);
        }
        /// <summary>
        /// 根据key获取value
        /// </summary>
        /// <param name="key">key</param>
        /// <returns></returns>
        public object Get(string key)
        {
            return Cache.Get(key);
        }
        /// <summary>
        /// 删除key的缓存的值
        /// </summary>
        /// <param name="key">key</param>
        public void Remove(string key)
        {
            if (Exist(key))
                Cache.Remove(key);
        }
        /// <summary>
        /// 检验key是否存在
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public bool Exist(string key)
        {
            if (Cache.Get(key) != null)
                return true;
            else return false;
        }
        /// <summary>
        /// 获取所有的key
        /// </summary>
        /// <returns></returns>
        public List<string> GetCacheKeys()
        {
            return Cache.Get("keys") as List<string>;

        }
        /// <summary>
        /// 清空缓存
        /// </summary>
        public void Flush()
        {
            foreach (string s in GetCacheKeys())
            {
                Remove(s);
            }
        }
        /// <summary>
        /// 更新key
        /// </summary>
        /// <param name="key">key</param>
        private void Updatekeys(string key)
        {
            List<string> keys = new List<string>();
            //读取本地keys
            if (Cache.Get("keys") != null)
                keys = Cache.Get("keys") as List<string>;
            //如果keys中不存在
            if (!keys.Contains(key.ToLower()))
                keys.Add(key);
            Cache.Store(StoreMode.Set, "keys", keys);
        }
        #endregion
    }
}

缓存工厂,用来创建缓存

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

namespace CacheStorage
{

    /// <summary>
    /// 缓存工厂
    /// </summary>
    public class CacheFactory
    {
        /// <summary>
        /// 缓存类别
        /// </summary>
        public enum CacheType
        {
            //默认缓存
            DefaultCache = 0,
            /// <summary>
            /// 分布式Memcached缓存
            /// </summary>
            MemcachedCache = 1
        }
        /// <summary>
        /// 初始化
        /// </summary>
        /// <returns></returns>
        public static ICacheStorage CreateCacheFactory()
        {
           string Cache=ConfigurationManager.AppSettings["CacheType"];
           if (CacheType.MemcachedCache.ToString ()== Cache)
           {
               return new MemcachedCache();
           }
           else
               return new DefaultCacheAdapter();
        }
    }
}
在webconfig中配置缓存类别,
然后在客户端,配置缓存

客户端调用就见得多了,

然后,我们的后台需要一个管理缓存的模块,

可以动态配置,内容页的缓存时间,等等

   1:  <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

   2:   

   3:  <html xmlns="http://www.w3.org/1999/xhtml">

   4:  <head>

   5:      <title>缓存管理</title>

   6:       <meta http-equiv="content-type" content="text/html; charset=UTF-8" />

   7:      <link href="../css/demo.css" rel="stylesheet" type="text/css" />

   8:   

   9:      <script src="../scripts/jquery-1.6.2.min.js" type="text/javascript"></script>

  10:   

  11:      <script src="../scripts/miniui/miniui.js" type="text/javascript"></script>

  12:   

  13:      <link href="../scripts/miniui/themes/default/miniui.css" rel="stylesheet" type="text/css" />

  14:      <link href="../scripts/miniui/themes/icons.css" rel="stylesheet" type="text/css" />

  15:  </head>

  16:  <body>

  17:    <div class="mini-toolbar">

  18:          <h1>

  19:              缓存管理</h1>

  20:      </div>

  21:      <div id="datagrid1" class="mini-datagrid" style=" 100%; height: 400px;" allowresize="true"

  22:          url="Data/UrlInfo.ashx?method=SearchCacheInfo" idfield="Id" multiselect="false">

  23:          <div property="columns">

  24:              <div type="checkcolumn">

  25:              </div>

  26:              <div id="deal" name="action" width="100" headeralign="center" align="center" renderer="onActionRenderer"

  27:                  cellstyle="padding:0;">

  28:                  操作

  29:              </div>

  30:              <div field="Name" width="100" headeralign="center" allowsort="true">

  31:                  缓存标识</div>

  32:              <div field="Day" width="100"> <input  class="mini-spinner"  property="editor" value="0"  minValue="1" maxValue="365" />

  33:                  天</div>

  34:              <div field="Hour" width="100">小时

  35:                  <input  class="mini-spinner"  property="editor"  minValue="1" maxValue="365" /></div>

  36:              <div field="Title" width="100">

  37:                  缓存名称</div>

  38:          </div>

  39:      </div>

  40:   

  41:      <script type="text/javascript">

  42:          mini.parse();

  43:   

  44:          var grid = mini.get("datagrid1");

  45:        //  grid.load();

  46:          grid.sortBy("Name", "desc");

  47:   

  48:          grid.set({ footerStyle: "padding-right:10px;" });

  49:    function onActionRenderer(e) {

  50:              var grid = e.sender;

  51:              var record = e.record;

  52:              var uid = record._uid;

  53:              var rowIndex = e.rowIndex;

  54:   

  55:              var s = ' <a class="Edit_Button" href="javascript:editRow(\'' + uid + '\')">编辑</a>';

  56:   

  57:              if (grid.isEditingRow(record)) {

  58:                  s = '<a class="Update_Button" href="javascript:updateRow(\'' + uid + '\')">更新</a>'

  59:                      + '<a class="Cancel_Button" href="javascript:cancelRow(\'' + uid + '\')">取消</a>'

  60:              }

  61:              return s;

  62:          }

  63:            function editRow(row_uid) {

  64:              var row = grid.getRowByUID(row_uid);

  65:              if (row) {

  66:                  grid.cancelEdit();

  67:                  grid.beginEditRow(row);

  68:              }

  69:          }

  70:          function cancelRow(row_uid) {            

  71:              grid.reload();

  72:          }

  73:          function updateRow(row_uid) {

  74:              var row = grid.getRowByUID(row_uid);

  75:              var rowData = grid.getEditRowData(row);

  76:              grid.loading("保存中，请稍后......");

  77:              var json=mini.encode(rowData);

  78:              $.ajax({

  79:                  url: "Data/UrlInfo.ashx?method=UpdateCacheInfo",

  80:                  data: {CacheInfo:json },

  81:                  success: function (text) {

  82:                      grid.reload();

  83:                  

  84:                  },

  85:                  error: function (jqXHR, textStatus, errorThrown) {

  86:                      alert(jqXHR.responseText);

  87:                  }

  88:              });

  89:   

  90:          }

  91:    

  92:        

  93:   

  94:   

  95:      </script>

  96:   

  97:  </body>

  98:  </html>

后台处理:

  /// <summary>
    /// 更新缓存信息
    /// </summary>
    /// <param name="context"></param>
    public void UpdateCacheInfo(HttpContext context)
    {
        string CacheInfo = context.Request["CacheInfo"];
      CacheInfo=CacheInfo.Trim(new char[] { '[', ']' });
      JObject o = JObject.Parse(CacheInfo);
    string Id=(string)o.SelectToken("Id");
    int Day = (int)o.SelectToken("Day");
    int Hour = (int)o.SelectToken("Hour");
    context.Response.Write(new CacheManage().UpdateCacheInfo(Id, Day, Hour));
    }
    /// <summary>
    ///  查询缓存信息
    /// </summary>
    /// <param name="context"></param>
    public void SearchCacheInfo(HttpContext context)
    {
        //查询条件
       // string key = context.Request["key"];
        //分页
        int pageIndex = Convert.ToInt32(context.Request["pageIndex"]);
        int pageSize = Convert.ToInt32(context.Request["pageSize"]);
        ////字段排序
        //String sortField = context.Request["sortField"];
        //String sortOrder = context.Request["sortOrder"];
        //JSON 序列化
        string json = new CacheManage().GetCacheAllInfoForMiniUIJson(pageIndex,pageSize);
        context.Response.Write(json);
    }

这样我们一个简单的完整的缓存模块就设计完了,可以发现,这样我们的缓存管理就容易得多了.

设计需要思考,程序员更需要思考,深入去学习软件思想,架构,而不仅仅停留在简单

的工作,软件的复杂在于做大,软件的扩大,让软件的复杂度成指数级增长,所以更需

要架构,深层次的去研究软件理论,软件精华!