通过spring.net中的spring.caching CacheResult实现memcached缓存

通过spring.net中的spring.caching CacheResult实现memcached缓存
1.SpringMemcachedCache.cs
2.APP.config
3.Program.cs
4.Common

待解决问题：CacheResult，CacheResultItems有什么区别？？？？

SpringMemcachedCache.cs   memcached的实现， 继承了Spring.Caching.AbstractCache， memcached的实现用了Enyim.Caching

using System;
using Spring.Caching;
using System.Web;
using System.Collections;
using System.Web.Caching;
using Enyim.Caching;
using Enyim.Caching.Memcached;

namespace Demo.Common
{
    /// <summary>
    /// An <see cref="ICache"/> implementation backed by ASP.NET Cache (see <see cref="HttpRuntime.Cache"/>).
    /// </summary>
    /// <remarks>
    /// <para>
    /// Because ASP.NET Cache uses strings as cache keys, you need to ensure
    /// that the key object type has properly implemented <b>ToString</b> method.
    /// </para>
    /// <para>
    /// Despite the shared underlying <see cref="HttpRuntime.Cache"/>, it is possible to use more than
    /// one instance of <see cref="AspNetCache"/> without interfering each other.
    /// </para>
    /// </remarks>
    /// <author>Aleksandar Seovic</author>
    /// <author>Erich Eichinger</author>
    public class SpringMemcachedCache : AbstractCache
    {
        #region Fields

        // logger instance for this class
        private static MemcachedClient memcachedClient = null;
        private static object initLock = new object();

        #endregion

        private MemcachedClient MemcachedClient
        {
            get
            {
                if (memcachedClient == null)
                {
                    lock (initLock)
                    {
                        if (memcachedClient == null)
                        {
                            memcachedClient = new MemcachedClient();
                        }
                    }
                }

                return memcachedClient;
            }
        }

        /// <summary>
        /// Retrieves an item from the cache.
        /// </summary>
        /// <param name="key">
        /// Item key.
        /// </param>
        /// <returns>
        /// Item for the specified <paramref name="key"/>, or <c>null</c>.
        /// </returns>
        public override object Get(object key)
        {
            object result = key == null ? null : MemcachedClient.Get(GenerateKey(key));
            return result;
        }

        /// <summary>
        /// Removes an item from the cache.
        /// </summary>
        /// <param name="key">
        /// Item key.
        /// </param>
        public override void Remove(object key)
        {
            if (key != null)
            {
                MemcachedClient.Remove(GenerateKey(key));
            }
        }

        /// <summary>
        /// Inserts an item into the cache.
        /// </summary>
        /// <param name="key">
        /// Item key.
        /// </param>
        /// <param name="value">
        /// Item value.
        /// </param>
        /// <param name="timeToLive">
        /// Item's time-to-live (TTL).
        /// </param>
        protected override void DoInsert(object key, object value, TimeSpan timeToLive)
        {
            MemcachedClient.Store(StoreMode.Set, GenerateKey(key), value, timeToLive);
        }

        /// <summary>
        /// Generate a key to be used for the underlying <see cref="Cache"/> implementation.
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public string GenerateKey(object key)
        {
            return key.ToString();
        }

        public override ICollection Keys
        {
            get { throw new NotSupportedException(); }
        }
    }
}

APP.config  配置enyim.com， memcache， spring.net

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <configSections>
    <sectionGroup name="enyim.com">
      <section name="memcached" type="Enyim.Caching.Configuration.MemcachedClientSection, Enyim.Caching"/>
      <!-- log -->
      <section name="log" type="Enyim.Caching.Configuration.LoggerSection, Enyim.Caching" />
    </sectionGroup>

    <sectionGroup name="spring">
      <section name="context" type="Spring.Context.Support.ContextHandler, Spring.Core"/>
      <section name="objects" type="Spring.Context.Support.DefaultSectionHandler, Spring.Core" />
    </sectionGroup>
  </configSections>
  
  <enyim.com>
    <memcached>
      <servers>
        <add address="127.0.0.1" port="11211"/>
      </servers>
      <socketPool minPoolSize="10" maxPoolSize="100" connectionTimeout="00:00:10" deadTimeout="00:02:00"/>
    </memcached>
  </enyim.com>

  <spring>
    <context>
      <resource uri="config://spring/objects" />
    </context>
    <objects xmlns="http://www.springframework.net"  >
      <object id="CacheAspect" type="Spring.Aspects.Cache.CacheAspect, Spring.Aop"/>
      <object id="autoBOProxyCreator" type="Spring.Aop.Framework.AutoProxy.ObjectNameAutoProxyCreator, Spring.Aop">
        <property name="ObjectNames">
          <list>
            <value>*BO</value>
          </list>
        </property>
        <property name="InterceptorNames">
          <list>
            <value>CacheAspect</value>
          </list>
        </property>
      </object>

      <object id="cachedTestBO" type="Demo.App.CachedTestBO, Demo.App"></object>
      
      <object id="MemCachedCache" type="Demo.Common.SpringMemcachedCache, Demo.Common">
        <property name="TimeToLive" value="00:05:00"/>
      </object>

      <object id="MemCachedCache-Short" type="Demo.Common.SpringMemcachedCache, Demo.Common">
          <property name="TimeToLive" value="00:05:00"/>
      </object>

      <object id="MemCachedCache-Long" type="Demo.Common.SpringMemcachedCache, Demo.Common">
          <property name="TimeToLive" value="00:30:00"/>
      </object>

    </objects>
  </spring>
  

</configuration>

App Program.cs       测试效果

1.要从spring中进入的才会调用， 直接实例化进入不会调用

2.CacheName - "SpringCache" 对应spring配置中的id="SpringCache"节点，是实现cache的类

3.Key="'prefix.key.'+#cacheId" 传人cachedId=1对应生成以后的key为 prefix.key.1
复杂点的Key组合见下面

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using Demo.Common;
using Spring.Caching;
using Spring.Context;
using Spring.Context.Support;


namespace Demo.App
{
    class Program
    {
        private static void Main(string[] args)
        {
            //通过spring.net来调用函数
            IApplicationContext ctx = ContextRegistry.GetContext();

            IDictionary testDictionary = ctx.GetObjectsOfType(typeof(ITestBO));
            foreach (DictionaryEntry entry in testDictionary)
            {
                string name = (string)entry.Key;
                ITestBO service = (ITestBO)entry.Value;
                Console.WriteLine(name + " intercept: ");
　　　　　　　　　　
                 //第一次运行函数并保存到memcached
                Console.WriteLine("nowTime:" + DateTime.Now.ToString("T") 
                    + " testTime:" +service.TestMethod(1, new object[]{"one", "two"}));

                Console.WriteLine();

                Thread.Sleep(5);   //休眠5秒以便第二次调用查看是否有保存到memcached

                //第二次运行从memcached中读取数据
                Console.WriteLine("nowTime:" + DateTime.Now.ToString("T")
                    + " testTime:" + service.TestMethod(1, new object[] { "one", "two" }));

                Console.WriteLine();

            }

            //手动实例化，不会从memcached中读取数据，因为没有运行到CacheResult中去
            ITestBO test = new CachedTestBO();
            test.TestMethod(2);

            Console.ReadLine();
        }
    }


    public interface ITestBO
    {
        string TestMethod(int cacheId, params object[] elements);
    }

    public class CachedTestBO : ITestBO
    {
        //生成的key类似HK-MainSubAccountMap-1    
        [CacheResult(CacheName = SpringCache.NormalCache,
            Key = SpringCache.SpringCacheCountryPrefix
            +"+'" + SpringCacheKey.MainSubAccountMap + "'"
            + "+'-' + #cacheId")]
        public string TestMethod(int cacheId, params object[] elements)
        {
            return  DateTime.Now.ToString("T");
        }
    }

}

Common类

namespace Demo.Common
{
    public static class ApplicationVariables
    {
        private static string countryCode;
        public static string CountryCode
        {
            get
            {
                if (countryCode == null)
                {
                    countryCode = "HK";
                }
                return countryCode;
            }
        }
    }

    public static class SpringCache
    {
        public const string SpringCacheCountryPrefix = @"T(Demo.Common.ApplicationVariables).CountryCode + '-'";
        public const string NormalCache = "MemCachedCache";

        public const string AspnetCache = "AspnetCache";
    }

    public static class SpringCacheKey
    {
        public const string MainSubAccountMap = "MainSubAccountMap";

        public const string BOSetting = "BOSetting";
    }
}