绑定完请刷新页面
取消
刷新
登录 | 注册

分享好友

×
取消 复制
基于STSdb和fastJson的磁盘/内存缓存
2022-04-14 15:45:54

更新

1. 增加了对批量处理的支持，写操作速度提升5倍，读操作提升100倍

2. 增加了对并发的支持

需求

业务系统用的是数据库，数据量大，部分只读或相对稳定业务查询复杂，每次页面加载都要花耗不少时间(不讨论异步)，觉得可以做一下高速缓存，譬如用nosql那种key/value快速存取结果

目的

这里不是要做一个大家都适用的磁盘/内存缓存库，这个做法，部分是展示STSdb的用法，部分是提供一个简单易用的解决方案。

磁盘/内存

为什么不用memcached或者AppFabric Cache这样的现成解决方案呢？因为业务要缓存的内存或大或小，小的几KB，大的几MB，如果用户一多，势必对内存有过度的需求。所以选择做一个基于磁盘的。

当然，这个解决方案是支持内存缓存的。构造的时候传递空字符串便可。

STSdb是什么

再来说明一下STSdb是什么：STSdb是C#写的开源嵌入式数据库和虚拟文件系统，支持实时索引，性能是同类产品的几倍到几十倍，访问官方网站。

我之前介绍过：STSdb，强纯C#开源NoSQL和虚拟文件系统 和 STSdb，强纯C#开源NoSQL和虚拟文件系统 4.0 RC2 支持C/S架构 ，大家可以先看看。

实现

存取

因为是基于磁盘，所以需要使用到高效的Key/Value存取方案，碰巧我们有STSdb :)

序列化

因为要求简便快速，用的是fastJson。

代码

代码比较简单，花了2个小时写的，很多情况没考虑，譬如磁盘空间不足、过期空间回收等，这些留给大家做家庭作业吧。另外，为了发布方便，STSdb和fastJson的代码都合并到一个项目里。

CahceEngine.cs

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using STSdb4.Database;
  6. using fastJSON;
  7. using System.IO;
  8.  
  9. namespace Com.SuperCache.Engine
  10. {
  11.     public class CacheEngine
  12.     {
  13.         private const string KeyExpiration = "Expiration";
  14.         private string dataPath;
  15.         private static IStorageEngine memoryInstance = null;
  16.         private static object syncRoot = new object();
  17.         private bool isMemory = false;
  18.  
  19.         public CacheEngine(string DataPath)
  20.         {
  21.             dataPath = DataPath;
  22.             if (!dataPath.EndsWith(Path.DirectorySeparatorChar.ToString()))
  23.                 dataPath += Path.DirectorySeparatorChar;
  24.  
  25.             isMemory = string.IsNullOrEmpty(DataPath);
  26.         }
  27.  
  28.         public void Add<K>(string Category, K Key, object Data)
  29.         {
  30.             Add(Category, Key, Data, null);
  31.         }
  32.  
  33.         private IStorageEngine Engine
  34.         {
  35.             get
  36.             {
  37.                 if (isMemory)
  38.                 {
  39.                     lock (syncRoot)
  40.                     {
  41.                         if (memoryInstance == null)
  42.                             memoryInstance = STSdb.FromMemory();
  43.                     }
  44.                     return memoryInstance;
  45.                 }
  46.                 else
  47.                     return STSdb.FromFile(GetFile(false), GetFile(true));
  48.             }
  49.         }
  50.  
  51.         private string GetExpirationTable(string Category)
  52.         {
  53.             return KeyExpiration + "_" + Category;
  54.         }
  55.  
  56.         public void Add<K, V>(string Category, IEnumerable<KeyValuePair<K, V>> Items, DateTime? ExpirationDate)
  57.         {
  58.             lock (syncRoot)
  59.             {
  60.                 var engine = Engine;
  61.                 var table = engine.OpenXIndex<K, string>(Category);
  62.                 Items.ForEach(i =>
  63.                     {
  64.                         var key = i.Key;
  65.                         var data = i.Value;
  66.                         //will only serialize object other than string
  67.                         var result = typeof(V) == typeof(string) ? data as string : JSON.Instance.ToJSON(data);
  68.                         table[key] = result;
  69.                         table.Flush();
  70.  
  71.                         //specify expiration
  72.                         var expiration = engine.OpenXIndex<K, DateTime>(GetExpirationTable(Category));
  73.                         //default 30 mins to expire from now
  74.                         var expirationDate = ExpirationDate == null || ExpirationDate <= DateTime.Now ? DateTime.Now.AddMinutes(30) : (DateTime)ExpirationDate;
  75.                         expiration[key] = expirationDate;
  76.                         expiration.Flush();
  77.                     });
  78.                 engine.Commit();
  79.  
  80.                 //only dispose disk-based engine
  81.                 if (!isMemory)
  82.                     engine.Dispose();
  83.             }
  84.         }
  85.  
  86.         public void Add<K>(string Category, K Key, object Data, DateTime? ExpirationDate)
  87.         {
  88.             Add<K, object>(Category, new List<KeyValuePair<K, object>> { new KeyValuePair<K, object>(Key, Data) }, ExpirationDate);
  89.         }
  90.  
  91.         private string GetFile(bool IsData)
  92.         {
  93.             if (!Directory.Exists(dataPath))
  94.                 Directory.CreateDirectory(dataPath);
  95.             return dataPath + "SuperCache." + (IsData ? "dat" : "sys");
  96.         }
  97.  
  98.         public List<KeyValuePair<K, V>> Get<K, V>(string Category, IEnumerable<K> Keys)
  99.         {
  100.             var result = new List<KeyValuePair<K, V>>();
  101.             lock (syncRoot)
  102.             {
  103.                 var engine = Engine;
  104.                 var table = engine.OpenXIndex<K, string>(Category);
  105.                 var expiration = engine.OpenXIndex<K, DateTime>(GetExpirationTable(Category));
  106.                 var isCommitRequired = false;
  107.  
  108.                 Keys.ForEach(key =>
  109.                     {
  110.                         string buffer;
  111.                         V value;
  112.                         if (table.TryGet(key, out buffer))
  113.                         {
  114.                             //will only deserialize object other than string
  115.                             value = typeof(V) == typeof(string) ? (V)(object)buffer : JSON.Instance.ToObject<V>(buffer);
  116.                             DateTime expirationDate;
  117.                             //get expiration date
  118.                             if (expiration.TryGet(key, out expirationDate))
  119.                             {
  120.                                 //expired
  121.                                 if (expirationDate < DateTime.Now)
  122.                                 {
  123.                                     value = default(V);
  124.                                     table.Delete(key);
  125.                                     table.Flush();
  126.                                     expiration.Delete(key);
  127.                                     expiration.Flush();
  128.                                     isCommitRequired = true;
  129.                                 }
  130.                             }
  131.                         }
  132.                         else
  133.                             value = default(V);
  134.  
  135.                         result.Add(new KeyValuePair<K, V>(key, value));
  136.                     });
  137.  
  138.                 //only need to commit write actions
  139.                 if (isCommitRequired)
  140.                     engine.Commit();
  141.  
  142.                 //only dispose disk-based engine
  143.                 if (!isMemory)
  144.                     engine.Dispose();
  145.             }
  146.             return result;
  147.         }
  148.  
  149.         public V Get<K, V>(string Category, K Key)
  150.         {
  151.             var buffer = Get<K, V>(Category, new K[] { Key });
  152.             var result = buffer.FirstOrDefault();
  153.             return result.Value;
  154.         }
  155.     }
  156. }

新建

构造CacheEngine需要传递缓存保存到哪个文件夹。

基于内存

如果你不喜欢基于磁盘的缓存，可以使用基于内存，构造函数传递空字符串便可。

增加/更新

同一个方法：Add。用户可以指定类型（Category），譬如User，Employee等。键（Key）支持泛型，值（Data）是object。有一个overload是过期日期（ExpirationDate），默认当前时间30分钟后

获取

Get方法需要指定类型（Category）和键（Key）。

例子

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Threading;
  6. using System.Threading.Tasks;
  7. using System.Diagnostics;
  8. using Com.SuperCache.Engine;
  9.  
  10. namespace Com.SuperCache.Test
  11. {
  12.     public class Foo
  13.     {
  14.         public string Name { get; set; }
  15.         public int Age { get; set; }
  16.         public double? Some { get; set; }
  17.         public DateTime? Birthday { get; set; }
  18.     }
  19.  
  20.     class Program
  21.     {
  22.         static void Main(string[] args)
  23.         {
  24.             //TestAddGet();
  25.  
  26.             //Thread.Sleep(4000);
  27.             //TestExpiration();
  28.  
  29.             TestPerformance();
  30.  
  31.             //TestConcurrent();
  32.  
  33.             Console.Read();
  34.         }
  35.  
  36.         private static void TestConcurrent()
  37.         {
  38.             var w = new Stopwatch();
  39.             w.Start();
  40.             Parallel.For(1, 3, (a) =>
  41.                 {
  42.                     var employees = Enumerable.Range((a - 1) * 1000, a * 1000).Select(i => new KeyValuePair<int, string>(i, "Wilson " + i + " Chen"));
  43.                     var engine = new CacheEngine(@"..\..\data");
  44.                     engine.Add<int, string>("Employee", employees, DateTime.Now.AddMinutes(1));
  45.                 });
  46.             w.Stop();
  47.             Console.WriteLine("add:" + w.Elapsed);
  48.  
  49.             var engine2 = new CacheEngine(@"..\..\data");
  50.             var o = engine2.Get<int, string>("Employee", 1005);
  51.             Console.WriteLine(o);
  52.         }
  53.  
  54.         private static void TestPerformance()
  55.         {
  56.             var engine = new CacheEngine(@"..\..\data");
  57.             var w = new Stopwatch();
  58.  
  59.             w.Start();
  60.             var employees = Enumerable.Range(, 1000).Select(i => new KeyValuePair<int, string>(i, "Wilson " + i + " Chen"));
  61.             engine.Add<int, string>("Employee", employees, DateTime.Now.AddMinutes(1));
  62.             w.Stop();
  63.             Console.WriteLine("add:" + w.Elapsed);
  64.  
  65.             /*w.Restart();
  66.             employees.ForEach(key =>
  67.                 {
  68.                     var o1 = engine.Get<int, string>("Employee", key.Key);
  69.                 });
  70.             w.Stop();
  71.             Console.WriteLine("individual get:" + w.Elapsed);*/
  72.  
  73.             w.Restart();
  74.             var keys = employees.Select(i => i.Key);
  75.             var o = engine.Get<int, string>("Employee", keys);
  76.             w.Stop();
  77.             Debug.Assert(o.Count == keys.Count());
  78.             Console.WriteLine("get:" + w.Elapsed);
  79.         }
  80.  
  81.         private static void TestExpiration()
  82.         {
  83.             var engine = new CacheEngine(@"..\..\data");
  84.             var o = engine.Get<string, Foo>("User", "wchen");
  85.             Console.WriteLine(o != null ? o.Name : "wchen does not exist or expired");
  86.         }
  87.  
  88.         private static void TestAddGet()
  89.         {
  90.             var engine = new CacheEngine(@"..\..\data");
  91.             var f = new Foo { Name = "Wilson Chen", Age = 30, Birthday = DateTime.Now, Some = 123.456 };
  92.             engine.Add("User", "wchen", f, DateTime.Now.AddSeconds(5));
  93.  
  94.             var o = engine.Get<string, Foo>("User", "wchen");
  95.             Console.WriteLine(o.Name);
  96.  
  97.             var o4 = engine.Get<string, Foo>("User", "foo");
  98.             Console.WriteLine(o4 != null ? o4.Name : "foo does not exist");
  99.  
  100.             var o3 = engine.Get<string, string>("PlainText", "A");
  101.             Console.WriteLine(o3 ?? "A does not exist");
  102.         }
  103.     }
  104. }

说明

项目中引用了System.Management是因为STSdb支持内存数据库，需要判断大物理内存。如果不喜欢，大家可以移除引用，并且去掉STSdb4.Database.STSdb.FromMemory方法便可。

上一篇：Springboot启动过程中的五大扩展点
下一篇：stsdb开发指南
分享好友

分享这个小栈给你的朋友们，一起进步吧。

STSdb
创建时间：2022-04-14 10:53:57
STSdb
展开
订阅须知

• 所有用户可根据关注领域订阅专区或所有专区

• 付费订阅：虚拟交易，一经交易不退款；若特殊情况，可3日内客服咨询

• 专区发布评论属默认订阅所评论专区（除付费小栈外）

技术专家

查看更多
  • LCR_
    专家
戳我，来吐槽～

北京盛拓优讯信息技术有限公司. 版权所有  京ICP备16024965号-8  北京市公安局海淀分局网监中心备案编号：11010802021510  未成年人举报专区

违法不良信息举报电话:18101376593   广播电视节目制作经营许可证(京) 字第1234号 中国互联网协会会员