一步一步asp.net_緩存管理

緩存是性能優化一個非常重要的模塊,幾乎計算機哪里都會用到緩存,我們的網站緩存也是非常重要的一塊,緩存給網站帶來太大的性能提高,在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="width: 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);
    }

這樣我們一個簡單的完整的緩存模塊就設計完了,可以發現,這樣我們的緩存管理就容易得多了.

 

設計需要思考,程序員更需要思考,深入去學習軟件思想,架構,而不僅僅停留在簡單

的工作,軟件的復雜在於做大,軟件的擴大,讓軟件的復雜度成指數級增長,所以更需

要架構,深層次的去研究軟件理論,軟件精華!

 

整個項目也快接近尾聲了!下一個模塊就是刪除模塊的設計!然后總結總個項目!

呵呵!慢慢准備開始學習asp.net MVC!