Asp.net mvc 网站之速度优化 -- Memcache

前一章说了一下使用页面缓存的问题，这次说一下数据缓存,我们使用的是Memcache作为数据缓存。

下面弱弱地引用一下百度百科关于Memcache的定义:

Memcache是一个高性能的分布式的内存对象缓存系统，通过在内存里维护一个统一的巨大的hash表，它能够用来存储各种格式的数据，包括图像、视频、文件以及数据库检索的结果等。Memcache是danga的一个项目，最早是LiveJournal 服务的，最初为了加速 LiveJournal 访问速度而开发的，后来被很多大型的网站采用。

1.Memcache服务器端的安装与启动

1. 下载memcache,我们使用的版本是1.2.5。
2. 使用命令行方式安装memcached-1.2.5.exe:  memcached-1.2.5.exe -d install
3. 启动memcached: memcached-1.2.5.exe -d start
4. 确认Windows 服务中memcached服务已经安装成功：
5. 需要注意的是memcached服务是使用的11211端口，如果开启了防火墙，需要将11211添加到例外中。



2.网站中配置BeITMemcached

1. 下载BeITMemcached_source_2010_08_04.zip, 并编译出BeITMemcached的DLL文件添加到项目的解决方案中:
2. 配置Web.Config

<!– 第三方的组件配置–>

<configSections>

<section name=”beitmemcached” type=”System.Configuration.NameValueSectionHandler” />

</configSections>

<beitmemcached>

<add key=”MemcachedConfig” value=”localhost” />

</beitmemcached>

我们目前的访问量还不是很大，因此将Memcached与网站部署在一台机器上，使用的是localhost.  如果网站和Memcache部署在不同机  器，这里的value 就应该是memcached所在机器的IP,请再次确认11211端口可以访问。

 

3. Memcache在业务代码中的设计

前面把配置都弄完了，现在需要说一下Memcache在业务代码中的设计了。我们使用的是Controller->Service->Model的模式，切入点就在Service层。

首先构造一个接口ICachePolicy：

 1 public interface ICachePolicy    {
 2 
 3 void Add<T>(string key, T value);
 4 
 5 void Add<T>(string key, T value, DateTime dt);
 6 
 7 T Get<T>(string key);
 8 
 9 void Add(string key, object value);
10 
11 void Add(string key, object value, DateTime dt);
12 
13 object Get(string key);
14 
15 void Delete(string key);
16 
17 }

 

 

接着实现MemcachedCachePolicy实现ICachePlolicy:

  1 public class MemcachedCachePolicy : ICachePolicy

 

 2     {
 3         private static readonly ILog Logger = LogManager.GetCurrentClassLogger();
 4 
 5         private readonly MemcachedClient _cache;
 6 
 7         public MemcachedCachePolicy()
 8         {
 9             _cache = MemcachedClient.GetInstance("MemcachedConfig");
10             
11             _cache.MaxPoolSize = 10000;
12         }
13 
14         public void Add<T>(string key, T value)
15         {
16             if (_cache.Set(key, value))
17             {
18                 Logger.Debug("Set _cache for key successed, key[" + key + "]");
19             }
20             else
21             {
22                 Logger.Debug("Set _cache for key failed");
23             }
24         }
25 
26         public void Add<T>(string key, T value, DateTime dt)
27         {
28             _cache.Set(key, value, dt);
29         }
30 
31         public T Get<T>(string key)
32         {
33             try
34             {
35                 return (T)_cache.Get(key);
36             }
37             catch (Exception e)
38             {
39                 Logger.Debug("Get _cache for key failed, key[" + key + "]", e);
40                 _cache.Delete(key);
41                 return default(T);
42             }
43         }
44 
45         public void Add(string key, object value)
46         {
47             _cache.Set(key, value);
48         }
49 
50         public void Add(string key, object value, DateTime dt)
51         {
52             _cache.Set(key, value, dt);
53         }
54 
55         public object Get(string key)
56         {
57             return _cache.Get(key);
58         }
59 
60         public void Delete(string key)
61         {
62             _cache.Delete(key);
63         }
64     }

 

 

最后构造一个BaseCacheService，让BussinessService都继承BaseCacheService, 比如什么ProductService, ShopService等等。对外可见的是BaseCacheService,  而MemcachePolicy对于其他代码来说就是透明的了。

 

 1 public abstract class BaseCacheService
 2     {
 3         protected readonly ICachePolicy _cachePolicy;
 4 
 5         protected BaseCacheService()
 6         {
 7 
 8         }
 9 
10         protected BaseCacheService(ICachePolicy cachePolicy)
11         {
12             _cachePolicy = cachePolicy;
13         }
14         
15         protected T GetCache<T>(string key) where T: class
16         {
17             return _cachePolicy.Get<T>(key);
18         }
19 
20         protected void Add<T>(string key, T items)
21         {
22             _cachePolicy.Add(key, items);
23         }
24 
25         protected T GetOrAdd<T>(string key, T loadedItems) where T : class
26         {
27             var items = _cachePolicy.Get<T>(key);
28            
29             if (items == null)
30             {
31                 _cachePolicy.Add(key, loadedItems);
32                 return loadedItems;
33             }
34 
35             return items;
36         }
37 
38         protected T GetOrAdd<T>(string key, Func<T> howToGet) where T : class
39         {
40             var items = _cachePolicy.Get<T>(key);
41 
42             
43             if (items == null)
44             {
45                 var loadedItems = howToGet();
46                 _cachePolicy.Add(key, loadedItems);
47                 return loadedItems;
48             }
49 
50             var type = items.GetType();
51             if (type == typeof(int) && items.Equals(0))
52             {
53                 var loadedItems = howToGet();
54                 _cachePolicy.Add(key, loadedItems);
55                 return loadedItems;
56             }
57 
58             return items;
59         }
60 
61         protected T GetOrAdd<T>(string key, Func<T> howToGet, DateTime dt) where T : class
62         {
63             var items = _cachePolicy.Get<T>(key);
64             if (items == null)
65             {
66                 var loadedItems = howToGet();
67                 _cachePolicy.Add(key, loadedItems, dt);
68                 return loadedItems;
69             }
70 
71             var type = items.GetType();
72             if (type == typeof(int) && items.Equals(0))
73             {
74                 var loadedItems = howToGet();
75                 _cachePolicy.Add(key, loadedItems, dt);
76                 return loadedItems;
77             }
78             return items;
79         }
80     }