中小型网站的缓存策略

最新推荐文章于 2018-05-23 12:08:35 发布

小飞鹤

最新推荐文章于 2018-05-23 12:08:35 发布

阅读量994

点赞数

分类专栏：网站架构 Java技术栈架构

Java技术栈架构同时被 2 个专栏收录

28 篇文章 65 订阅

订阅专栏

网站架构

25 篇文章 3 订阅

订阅专栏

在上一篇文章《大型网站系统架构分析》中，介绍了大型网站的系统架构，其中缓存环境非常重要，大型网站往往使用Squid前端缓存服务器群，memcache分布式缓存，负载均衡，CDN等来提升性能。但中小型网站使用这些大家伙就有杀鸡用牛刀的感觉，但毋庸置疑，缓存是需要的，开发者开发程序的时候若没有并发思维，一味注重业务逻辑，往往导致并发用户可能在差不多相同的时间请求相同的数据，网站再请求数据库，如果使用缓存，对这种相同的请求，或者不变的数据，可以缓存起来，直接从内存读取，可以大大提升并发访问的性能，减少数据库访问次数。因为数据库往往是最容易出现瓶颈的地方，而通过使用恰当的缓存技术可以非常有效地减轻数据库的负载。

根据我的经验，中小型网站可以采用这样的缓存策略：

如果是单台服务器可以直接缓存在内存，怕内存不够就合理利用ASP.NET所提供的缓存机制，有现成的干嘛不用呢？缓存存在XML文件中也是一种备选方案，但首先速度没有内存的来的快，其次是写入并发写入XML的时候会锁住文件。可以选用现成的微软Cache application block来实现。
有多台的服务器的话可以考虑memcached，或者其他类似的东西，或者另加一个数据库作为缓存库也行啊。当然有钱的可以用内存数据库。

但不是所有数据都可以缓存的：

对于恒定不变的数据，系统启动后放入缓存就不过期不更新了。
对于偶尔改变的数据，缓存过期时间可以稍微长一些，比如15分钟。
对于经常改变的数据，但访问量极大的热点数据，可以缓存很短的时间，例如30秒，或60秒。（微软有一种数据库数据改变自动同步缓存的SqlDependency功能，有兴趣的读者可以关注）

如此，便可最大程度的利用缓存，从而可以有效提高系统性能，并明显减轻数据库和网络负载。

你也可以统计并发访问最高的页面和DB访问的频率，把网页静态化，或缓存该些热点，淘汰不热的(缓存替换算法)，即使缓存30秒，或60秒也是很大的性能提升，因为他们的并发访问量很大，导致数据库的压力也很大。

代码参考：使用策略模式和单例模式的单机内存缓存：(可以扩展到其他的缓存策略，例如memcache等)

ICacheStrategy.cs

 
using System; 
using System.Text; 
   
namespace Sample.Caching 
{ 
/// <summary> 
/// 缓存策略接口 
/// </summary> 
public interface ICacheStrategy 
{ 
void AddObject(string objId, object o); 
 
void AddObjectWithTimeout(string objId, object o, int timeoutSec); 
 
void AddObjectWithFileChange(string objId, object o, string[] files); 
 
void AddObjectWithDepend(string objId, object o, string[] dependKey); 
   
void RemoveObject(string objId); 
   
object RetrieveObject(string objId); 
   
int TimeOut { set;get;} 
} 
} 
 

DefaultCacheStrategy.cs

 
using System; 
using System.Web; 
using System.Collections; 
using System.Web.Caching; 
   
namespace Sample.Caching 
{ 
/// <summary> 
/// 默认的缓存策略，实现了缓存策略接口 
/// </summary> 
public class DefaultCacheStrategy : ICacheStrategy 
{ 
private static readonly DefaultCacheStrategy instance = new DefaultCacheStrategy(); 
   
protected static volatile System.Web.Caching.Cache webCache = System.Web.HttpRuntime.Cache; 
   
protected int _timeOut = 1; //默认缓存一分钟，也可以单独设置对象的超时时间 
   
private static object syncObj = new object(); 
   
/// <summary> 
/// Initializes the <see cref="DefaultCacheStrategy"/> class. 
/// </summary> 
static DefaultCacheStrategy() 
{ 
//lock (syncObj) 
//{ 
// //System.Web.HttpContext context = System.Web.HttpContext.Current; 
// //if(context != null) 
// // webCache = context.Cache; 
// //else 
// webCache = System.Web.HttpRuntime.Cache; 
//}  
} 
   
   
public int TimeOut 
{ 
set { _timeOut = value > 0 ? value : 6000; } 
get { return _timeOut > 0 ? _timeOut : 6000; } 
} 
   
 
public static System.Web.Caching.Cache GetWebCacheObj 
{ 
get { return webCache; } 
} 
   
public void AddObject(string objId, object o) 
{ 
   
if (objId == null || objId.Length == 0 || o == null) 
{ 
return; 
} 
   
CacheItemRemovedCallback callBack = new CacheItemRemovedCallback(onRemove); 
   
if (TimeOut == 6000) 
{ 
webCache.Insert(objId, o, null, DateTime.MaxValue, TimeSpan.Zero, System.Web.Caching.CacheItemPriority.High, callBack); 
} 
else 
{ 
webCache.Insert(objId, o, null, DateTime.Now.AddMinutes(TimeOut), System.Web.Caching.Cache.NoSlidingExpiration, System.Web.Caching.CacheItemPriority.High, callBack); 
} 
} 
   
public void AddObjectWith(string objId, object o) 
{ 
if (objId == null || objId.Length == 0 || o == null) 
{ 
return; 
} 
   
CacheItemRemovedCallback callBack = new CacheItemRemovedCallback(onRemove); 
   
webCache.Insert(objId, o, null, System.DateTime.Now.AddHours(TimeOut), System.Web.Caching.Cache.NoSlidingExpiration, System.Web.Caching.CacheItemPriority.High, callBack); 
} 
   
 
public void AddObjectWithTimeout(string objId, object o, int timeoutSec) 
{ 
if (objId == null || objId.Length == 0 || o == null || timeoutSec <= 0) 
{ 
return; 
} 
   
CacheItemRemovedCallback callBack = new CacheItemRemovedCallback(onRemove); 
   
webCache.Insert(objId, o, null, System.DateTime.Now.AddSeconds(timeoutSec), System.Web.Caching.Cache.NoSlidingExpiration, System.Web.Caching.CacheItemPriority.High, callBack); 
} 
   
public void AddObjectWithFileChange(string objId, object o, string[] files) 
{ 
if (objId == null || objId.Length == 0 || o == null) 
{ 
return; 
} 
   
CacheItemRemovedCallback callBack = new CacheItemRemovedCallback(onRemove); 
   
CacheDependency dep = new CacheDependency(files, DateTime.Now); 
   
webCache.Insert(objId, o, dep, System.DateTime.Now.AddHours(TimeOut), System.Web.Caching.Cache.NoSlidingExpiration, System.Web.Caching.CacheItemPriority.High, callBack); 
} 
   
 
public void AddObjectWithDepend(string objId, object o, string[] dependKey) 
{ 
if (objId == null || objId.Length == 0 || o == null) 
{ 
return; 
} 
   
CacheItemRemovedCallback callBack = new CacheItemRemovedCallback(onRemove); 
   
CacheDependency dep = new CacheDependency(null, dependKey, DateTime.Now); 
   
webCache.Insert(objId, o, dep, System.DateTime.Now.AddMinutes(TimeOut), System.Web.Caching.Cache.NoSlidingExpiration, System.Web.Caching.CacheItemPriority.High, callBack); 
} 
   
public void onRemove(string key, object val, CacheItemRemovedReason reason) 
{ 
switch (reason) 
{ 
case CacheItemRemovedReason.DependencyChanged: 
break; 
case CacheItemRemovedReason.Expired: 
{ 
//CacheItemRemovedCallback callBack = new CacheItemRemovedCallback(this.onRemove); 
   
//webCache.Insert(key, val, null, System.DateTime.Now.AddMinutes(TimeOut), 
// System.Web.Caching.Cache.NoSlidingExpiration, 
// System.Web.Caching.CacheItemPriority.High, 
// callBack); 
break; 
} 
case CacheItemRemovedReason.Removed: 
{ 
break; 
} 
case CacheItemRemovedReason.Underused: 
{ 
break; 
} 
default: break; 
} 
   
//TODO: write log here 
} 
   
 
public void RemoveObject(string objId) 
{ 
//objectTable.Remove(objId); 
if (objId == null || objId.Length == 0) 
{ 
return; 
} 
webCache.Remove(objId); 
} 
   
   
public object RetrieveObject(string objId) 
{ 
//return objectTable[objId]; 
   
if (objId == null || objId.Length == 0) 
{ 
return null; 
} 
   
return webCache.Get(objId); 
} 
   
} 
} 
 

CachingManager.cs

 
using System; 
using System.Collections.Generic; 
using System.Text; 
   
namespace Sample.Caching 
{ 
/// <summary> 
/// The caching manager 
/// </summary> 
public class CachingManager 
{ 
private static ICacheStrategy cs; 
private static volatile CachingManager instance = null; 
private static object lockHelper = new object(); 
 
//private static System.Timers.Timer cacheConfigTimer = new System.Timers.Timer(15000);//Interval in ms 
   
 
private CachingManager() 
{ 
cs = new DefaultCacheStrategy(); 
   
Set timer 
//cacheConfigTimer.AutoReset = true; 
//cacheConfigTimer.Enabled = true; 
//cacheConfigTimer.Elapsed += new System.Timers.ElapsedEventHandler(Timer_Elapsed); 
//cacheConfigTimer.Start(); 
} 
   
 
private static void Timer_Elapsed(object sender, System.Timers.ElapsedEventArgs e) 
{ 
//TODO: 
} 
   
 
public static CachingManager GetCachingService() 
{ 
if (instance == null) 
{ 
lock (lockHelper) 
{ 
if (instance == null) 
{ 
instance = new CachingManager(); 
} 
} 
} 
   
return instance; 
} 
   
 
public virtual void AddObject(string key, object o) 
{ 
if (String.IsNullOrEmpty(key) || o == null) return; 
   
lock (lockHelper) 
{ 
if (cs.TimeOut <= 0) return; 
   
cs.AddObject(key, o); 
} 
} 
   
 
public virtual void AddObject(string key, object o, int timeout) 
{ 
if (String.IsNullOrEmpty(key) || o == null) return; 
   
lock (lockHelper) 
{ 
if (cs.TimeOut <= 0) return; 
   
cs.AddObjectWithTimeout(key, o, timeout); 
} 
} 
   
 
public virtual object RetrieveObject(string objectId) 
{ 
return cs.RetrieveObject(objectId); 
} 
   
 
public virtual void RemoveObject(string key) 
{ 
lock (lockHelper) 
{ 
cs.RemoveObject(key); 
} 
} 
   
 
public void LoadCacheStrategy(ICacheStrategy ics) 
{ 
lock (lockHelper) 
{ 
cs = ics; 
} 
} 
   
 
public void LoadDefaultCacheStrategy() 
{ 
lock (lockHelper) 
{ 
cs = new DefaultCacheStrategy(); 
} 
} 
} 
} 
 

调用：

 
CachingManager cm = CachingManager.GetCachingService(); 
cm.LoadDefaultCacheStrategy(); 
//从缓存获取 
IList list = cm.RetrieveObject("mykey") as IList; 
if (list == null) 
{ 
list = DAL.GetData(); //从数据库查询 
cm.AddObject("mykey", list, 2 * 60); //缓存2分钟 
} 
return list; 
 