应用框架的设计与实现——.NET平台(5 缓存服务.源码分析)

缓存服务的功能：缓存服务可提高对象的重用性，减少读取数据库、计算等操作步骤；为此付出的代价是对象使用前的判断和对象存储内存空间的开销。

作者对缓存服务的设计特点：基于XmlDocument 对象，对象存储的名称信息可包含模块名、用户名、自定名，存储名有自描述性，易于理解；对象的获取和删除可基于某个组某个模块全部获取全部删除。

缓存服务对象 Cache：




/**//// <summary>


/// SAF.Cache is an object caching service that


/// present the cached object in an hierarchical structure.


/// It uses a pluggable object storage mechnism or cache strategy


/// to storage the objects.


/// </summary>


public class Cache




...{


private XmlElement objectXmlMap ;


private static SAF.Cache.ICacheStrategy cs;


private static Cache cache;


private XmlDocument rootXml = new XmlDocument();








/**//// <summary>


/// Private construtor, required for singleton design pattern.


/// </summary>


private Cache()




...{


//retrieve setting from configuration file


ConfigurationManager cm = (ConfigurationManager)ConfigurationSettings.GetConfig("Framework");


// 读取配置文件信息，建立缓存对象存储对象


cs = (ICacheStrategy)cm.CacheConfig.GetCacheStrategy();


//create an Xml used as a map between xml expression and object cached in the


//physical storage.


objectXmlMap = rootXml.CreateElement("Cache");


//build the internal xml document.


rootXml.AppendChild(objectXmlMap);




}






/**//// <summary>


/// Singlton method used to return the instance of Cache class


/// </summary>


/// <returns></returns>


public static Cache GetSAFCacheService()




...{


if (cache == null)




...{


cache = new Cache();


}


return cache;


}






/**//// <summary>


/// Add the object to the underlying storage and Xml mapping document


/// </summary>


/// <param name="xpath">the hierarchical location of the object in Xml document </param>


/// <param name="o">the object to be cached</param>


public virtual void AddObject(string xpath, object o)




...{


//clear up the xpath expression


string newXpath = PrepareXpath(xpath);


int separator = newXpath.LastIndexOf("/");


//find the group name


string group = newXpath.Substring(0,separator );


//find the item name


string element = newXpath.Substring(separator + 1);




XmlNode groupNode = objectXmlMap.SelectSingleNode(group);


//determin if group is already exist?, if not, create one.


if (groupNode == null)




...{


lock(this)




...{


//build the xml tree


groupNode = CreateNode(group);


}


}


//get a unique key to identity of object, it is used to map


//between xml and object key used in the cache strategy


string objectId = System.Guid.NewGuid().ToString();


//create an new element and new attribute for this perticular object


XmlElement objectElement = objectXmlMap.OwnerDocument.CreateElement(element);


XmlAttribute objectAttribute =objectXmlMap.OwnerDocument.CreateAttribute("objectId");


objectAttribute.Value = objectId;


objectElement.Attributes.Append(objectAttribute);


//Add the object element to the Xml document


groupNode.AppendChild(objectElement);




//add the object to the underlying storage through cache strategy


cs.AddObject(objectId,o);


}






/**//// <summary>


/// Retrieve the cached object using its hierarchical location


/// </summary>


/// <param name="xpath">hierarchical location of the object in xml document</param>


/// <returns>cached object </returns>


public virtual object RetrieveObject(string xpath)




...{


object o = null;


XmlNode node =objectXmlMap.SelectSingleNode(PrepareXpath(xpath));


//if the hierarchical location existed in the xml, retrieve the object


//otherwise, return the object as null


if ( node != null)




...{


string objectId = node.Attributes["objectId"].Value;


//retrieve the object through cache strategy


o = cs.RetrieveObject(objectId);


}


return o;




}






/**//// <summary>


/// Remove the object from the storage and clear the Xml assocated with


/// the object


/// </summary>


/// <param name="xpath">hierarchical locatioin of the object</param>


public virtual void RemoveObject(string xpath)




...{


XmlNode result = objectXmlMap.SelectSingleNode(PrepareXpath(xpath));


//check if the xpath refers to a group(container) or


//actual element for cached object


if (result.HasChildNodes)




...{


//remove all the cached object in the hastable


//and remove all the child nodes


XmlNodeList objects = result.SelectNodes("*[@objectId]");


string objectId ="";


foreach (XmlNode node in objects)




...{


objectId = node.Attributes["objectId"].Value;


node.ParentNode.RemoveChild(node);


//use cache strategy to remove the objects from the


//underlying storage


cs.RemoveObject(objectId);




}




}


else




...{


//just remove the element node and the object associate with it


string objectId = result.Attributes["objectId"].Value;


result.ParentNode.RemoveChild(result);


cs.RemoveObject(objectId);


}


}






/**//// <summary>


/// Retrive a list of object under a hierarchical location


/// </summary>


/// <param name="xpath">hierarchical location</param>


/// <returns>an array of objects</returns>


public virtual object[] RetrieveObjectList(string xpath)




...{


XmlNode group = objectXmlMap.SelectSingleNode(PrepareXpath(xpath));


XmlNodeList results = group.SelectNodes(PrepareXpath(xpath) + "/*[@objectId]");


ArrayList objects = new ArrayList();


string objectId= null;


//loop through each node and link the object in object[]


//to objects stored via cache strategy


foreach (XmlNode result in results)




...{


objectId = result.Attributes["objectId"].Value;


objects.Add(cs.RetrieveObject(objectId));


}


//convert the ArrayList to object[]


return (object[])objects.ToArray(typeof(System.Object));


}








/**//// <summary>


/// CreateNode is responsible for creating the xml tree that is


/// specificed in the hierarchical location of the object.


/// </summary>


/// <param name="xpath">hierarchical location</param>


/// <returns></returns>


private XmlNode CreateNode(string xpath)




...{


string[] xpathArray = xpath.Split('/');


string root = "";


XmlNode parentNode = (XmlNode)objectXmlMap;


//loop through the array of levels and create the corresponding node for each level


//skip the root node.


for (int i = 1; i < xpathArray.Length; i ++)




...{


XmlNode node = objectXmlMap.SelectSingleNode(root + "/" + xpathArray[i]);


// if the current location doesn't exist, build one


//otherwise set the current locaiton to the it child location


if (node == null)




...{


XmlElement newElement= objectXmlMap.OwnerDocument.CreateElement(xpathArray[i]);


parentNode.AppendChild(newElement);


}


//set the new location to one level lower


root = root + "/" + xpathArray[i];


parentNode = objectXmlMap.SelectSingleNode(root);


}


return parentNode;


}






/**//// <summary>


/// clean up the xpath so that extra '/' is removed


/// </summary>


/// <param name="xpath">hierarchical location</param>


/// <returns></returns>


private string PrepareXpath(string xpath)




...{


string[] xpathArray = xpath.Split('/');


xpath ="/Cache";


foreach (string s in xpathArray)




...{


if (s != "")




...{


xpath = xpath + "/" + s ;


}


}


return xpath;


}


}

存储缓存对象的对象的接口：




/**//// <summary>


/// the interface for cache strategy.


/// each class that is pluggable to the SAF.Cache must


/// implement this interface.


/// </summary>


public interface ICacheStrategy




...{


void AddObject(string objId, object o);


void RemoveObject(string objId);


object RetrieveObject(string objId);


}

缓存服务对象的实现依赖配置文件配置项Framework/SAF.Cache/CacheStrategy：


<configuration>


<configSections>


<section name="Framework" type="SAF.Configuration.ConfigurationHandler,SAF.Configuration" />


<section name="Application" type="SAF.Configuration.ConfigurationHandler,SAF.Configuration" />


</configSections>




<Framework type="SAF.Configuration.ConfigurationManager,SAF.Configuration">


<SAF.Cache>


<CacheStrategy type = "SAF.Cache.DefaultCacheStrategy,SAF.Cache"/>


</SAF.Cache>


</Framework>


</configuration>

ICacheStrategy 缓存接口的实现 DefaultCacheStrategy ；
缓存对象可自定，自定缓存类需实现 1.继承自ICacheStrategy ；2.配置文件中写明；
使用Hashtable 作为存储缓存对象的数据结构：




/**//// <summary>


/// the sample cache strategy implementation which


/// shows how you create an pluggable component for SAF.Cache


/// to customize the way object is cahced and retrieved.


/// </summary>


public class DefaultCacheStrategy : ICacheStrategy




...{


private Hashtable objectTable;






/**//// <summary>


/// constructor to instantiate the internal hashtable.


/// </summary>


public DefaultCacheStrategy()




...{


objectTable = new Hashtable();


}






/**//// <summary>


/// Add an object to the underlying storage


/// </summary>


/// <param name="objId">key for the object</param>


/// <param name="o">object</param>


public void AddObject(string objId, object o)




...{


objectTable.Add(objId,o);


}




/**//// <summary>


/// Remove an object from the underlying storage


/// </summary>


/// <param name="objId">key for the object</param>


public void RemoveObject(string objId)




...{


objectTable.Remove(objId);


}




/**//// <summary>


/// Retrieve an object from the underlying storage


/// </summary>


/// <param name="objId">key for the object</param>


/// <returns>object</returns>


public object RetrieveObject(string objId)




...{


return objectTable[objId];


}


}

使用缓存服务的代码 Class1：


using System;


using SAF.Cache;


using SAF.Configuration;


using System.Configuration;




namespace TestConsole




...{




/**//// <summary>


/// The demo shows how to use the SAF.Cache service


/// to add, remove and retrieve objects from the cache


/// </summary>


class Class1




...{




[STAThread]


static void Main(string[] args)




...{


// 获取缓存服务对象


Cache cache = SAF.Cache.Cache.GetSAFCacheService();




// 缓存服务内存入一些对象


cache.AddObject("/WebApplication/Users/Xin", "customer xin");


cache.AddObject("/WebApplication/Users/Mike", "customer mike");


cache.AddObject("/WebApplication/Users/Steve", "customer steve");


cache.AddObject("/WebApplication/GlobalData", "1/1/2003");




// 获取同一组的缓存对象


object[] objects = cache.RetrieveObjectList("/WebApplication/Users");


foreach (object o in objects)




...{


Console.WriteLine("Customer in cache: {0}", o.ToString());


}




// 获取一个缓存对象


string time =(string) cache.RetrieveObject("/WebApplication/GlobalData");


string name = (string) cache.RetrieveObject("/WebApplication/Users/Xin");




// 移除一个缓存对象


cache.RemoveObject("/WebApplication/GlobalData");




// 移除同一组的所有缓存对象


cache.RemoveObject("/WebApplication/Users");




Console.WriteLine("Press Enter to finish");


Console.ReadLine();


}


}


}