redis+memoryCache 现实内存缓存解决redis缓存存取大对象较慢的问题

Redis 作为内存数据库，拥有非常高的性能，单个实例的 QPS 能够达到 10W 左右。
Redis 在写入数据时，需要为新的数据分配内存，当从 Redis 中删除数据时，它会释放对应的内存空间。
如果一个 Key 写入的数据非常大，Redis 在分配内存时也会比较耗时。同样的，当删除这个 Key 的数据时，释放内存也会耗时比较久。
你需要检查你的业务代码，是否存在写入大 Key 的情况，需要评估写入数据量的大小，业务层应该避免一个 Key 存入过大的数据量。
那么有没有什么办法可以扫描现在 Redis 中是否存在大 Key 的数据吗？

Redis 也提供了扫描大 Key 的方法：

1. redis-cli -h $host -p $port --bigkeys -i 0.01

项目上遇到过 存了几千条数据（5M以上）到redis 导致 从redis获取就花费了 近两秒

这里主要是针对微服务，因为微服务同一个程序可能有多个实例，此时 通过 redis 同步缓存memoryCache的key，删除了redis里面的key就可以使所有实现的缓存失效，无需同步删除所有实例的缓存（如果担心缓存时间过长，造成内存泄漏可以加一个定时任务 隔一段时间清理下redis上不存在的key）

具体实现如下(java原理一样)：

1. using System;
2. using System.Collections.Concurrent;
3. using System.Collections.Generic;
4. using System.Threading;
5. using Microsoft.Extensions.Caching.Memory;
6. using Microsoft.Extensions.DependencyInjection;
7. using Service.Common.Autofac.Attributes;
8. using Service.Common.helpers;
9. using Utils.Common.utils;
11. namespace Service.Common.Services
12. {
13. /// <summary>
14. /// 内存缓存 主要是缓存部分大对象 不要所有的缓存都是用这个缓存
15. /// 不能依赖这个缓存 如果缓存查询不到还是要从数据库查询
16. /// 每个服务都会缓存一份
17. /// </summary>
18. [Service(lifetime = ServiceLifetime.Singleton)]
19. public class CacheService
20. {
21. //前缀
22. private static String redisKeyPrefix = "CacheServiceKey_";
24. //内存缓存
25. private IMemoryCache memoryCache;
27. //redis服务
28. private RedisService redisService;
30. /// <summary>
31. /// 构造方法
32. /// </summary>
33. /// <param name="memoryCache"></param>
34. /// <param name="redisService"></param>
35. public CacheService(IMemoryCache memoryCache, RedisService redisService)
36. {
37. this.memoryCache = memoryCache;
38. this.redisService = redisService;
39. }
40. /// <summary>
41. /// 获取对象
42. /// </summary>
43. /// <typeparam name="T"></typeparam>
44. /// <param name="key"></param>
45. /// <returns></returns>
46. public T Get<T>(string key)
47. {
48. if (String.IsNullOrWhiteSpace(key))
49. {
50. return default(T);
51. }
53. key = $"{redisKeyPrefix}{key}";
55. Object result;
56. if (redisService.Exists(key) && memoryCache.TryGetValue(key, out result))
57. {
58. return (T)result;
59. }
60. return default(T);
61. }
63. /// <summary>
64. /// 设置缓存
65. /// </summary>
66. /// <param name="key"></param>
67. /// <param name="value"></param>
68. /// <param name="expireMinutes"></param>
69. public bool Set(string key, Object value, int expireMinutes = 1440)
70. {
71. TimeSpan timeSpan = TimeSpan.FromMinutes(expireMinutes);
72. return Set(key, value, timeSpan);
73. }
75. /// <summary>
76. /// 设置缓存
77. /// </summary>
78. /// <param name="key"></param>
79. /// <param name="value"></param>
80. /// <param name="timeSpan"></param>
81. public bool Set(string key, object value, TimeSpan timeSpan)
82. {
83. if (String.IsNullOrWhiteSpace(key) || value == null)
84. {
85. return false;
86. }
87. key = $"{redisKeyPrefix}{key}";
88. memoryCache.Set(key, value, timeSpan);
89. redisService.Set(key, "1", timeSpan);
90. return true;
91. }
94. /// <summary>
95. /// 判断在缓存中是否存在该key的缓存数据
96. /// </summary>
97. /// <param name="key"></param>
98. /// <returns></returns>
99. public bool Exists(string key)
100. {
101. key = $"{redisKeyPrefix}{key}";
102. return redisService.Exists(key) && memoryCache.TryGetValue(key, out _);
103. }
105. /// <summary>
106. /// 移除指定key的缓存
107. /// </summary>
108. /// <param name="key"></param>
109. /// <returns></returns>
110. public bool Remove(string key)
111. {
112. if (String.IsNullOrWhiteSpace(key))
113. {
114. return true;
115. }
116. key = $"{redisKeyPrefix}{key}";
117. redisService.Remove(key);
118. memoryCache.Remove(key);
119. return true;
120. }
121. }
122. }