ASP.NET Core - 缓存之分布式缓存

婀娜婀娜

分布式缓存是由多个应用服务器共享的缓存，通常作为访问它的应用服务器的外部服务进行维护。 分布式缓存可以提高 ASP.NET Core 应用的性能和可伸缩性，尤其是当应用由云服务或服务器场托管时。
与其他将缓存数据存储在单个应用服务器上的缓存方案相比，分布式缓存具有多个优势。
当分发缓存数据时，数据：

• 在多个服务器的请求之间保持一致（一致性）。
  
• 在进行服务器重启和应用部署后仍然有效。
  
• 不使用本地内存。
  

1. 分布式缓存的使用

.NET Core 框架下对于分布式缓存的使用是基于 IDistributedCache 接口的，通过它进行抽象，统一了分布式缓存的使用方式，它对缓存数据的存取都是基于 byte[] 的。
IDistributedCache 接口提供以下方法来处理分布式缓存实现中的项：

• Get、GetAsync：如果在缓存中找到，则接受字符串键并以 byte[] 数组的形式检索缓存项。
  
• Set、SetAsync：使用字符串键将项（作为 byte[] 数组）添加到缓存。
  
• Refresh、RefreshAsync：根据键刷新缓存中的项，重置其可调到期超时（如果有）。
  
• Remove、RemoveAsync：根据字符串键删除缓存项。
  

使用的时候只需要将其通过容器注入到相应的类中即可。
2. 分布式缓存的接入

分布式缓存是基于特定的缓存应用实现的，需要依赖特定的第三方应用，在接入特定的分布式缓存应用时，需要应用对于的 Nuget 包，微软官方提供了基于 SqlServer 、Redis 实现分布式缓存的 Nuget 包，还推荐了基于 Ncache 的方案，除此之外还有像 Memcache 之类的方案，微软虽然没有提供相应的 Nuget 包，但是社区也有相关开源的项目。
这里只讲 .NET Core 下两种分布式缓存的接入和使用，一种是分布式内存缓存，一种是使用得比较广泛的 Redis。其他的在 .NET Core 框架下的使用是差不多的，仅仅只是接入的时候有点区别。当然，Redis 除了作为分布式缓存来使用，还有其他更加丰富的一些功能，后续也会找时间进行一些介绍。
2.1 基于内存的分布式缓存

分布式内存缓存 (AddDistributedMemoryCache) 是框架提供的 IDistributedCache 实现，用于将项存储在内存中，它就在 Microsoft.Extensions.Caching.Memory Nuget 包中。 分布式内存缓存不是真正的分布式缓存。 缓存项由应用实例存储在运行该应用的服务器上。
分布式内存缓存是一个有用的实现：

• 在开发和测试场景中。
  
• 当在生产环境中使用单个服务器并且内存消耗不重要时。 实现分布式内存缓存会抽象缓存的数据存储。 如果需要多个节点或容错，它允许在未来实现真正的分布式缓存解决方案。
  

当应用在 Program.cs 的开发环境中运行时，我们可以通过以下方式使用分布式缓存，以下示例代码基于 .NET 控制台程序：

1. using Microsoft.Extensions.DependencyInjection;
2. using Microsoft.Extensions.Hosting;
4. var host = Host.CreateDefaultBuilder(args)
5.         .ConfigureServices(services =>
6.         {
7.                 services.AddDistributedMemoryCache();
8.         })
9.         .Build();
11. host.Run();

复制代码

之后还是和内存缓存差不多的例子，演示一下缓存的存取、删除、刷新。

1. public interface IDistributedCacheService
2. {
3.         Task PrintDateTimeNow();
4. }
5. public class DistributedCacheService : IDistributedCacheService
6. {
7.         public const string CacheKey = nameof(DistributedCacheService);
8.         private readonly IDistributedCache _distributedCache;
9.         public DistributedCacheService(IDistributedCache distributedCache)
10.         {
11.                 _distributedCache = distributedCache;
12.         }
14.         public async Task FreshAsync()
15.         {
16.                 await _distributedCache.RefreshAsync(CacheKey);
17.         }
19.         public async Task PrintDateTimeNowAsync()
20.         {
21.                 var time = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
22.                 var cacheValue = await _distributedCache.GetAsync(CacheKey);
23.                 if(cacheValue == null)
24.                 {
25.                         // 分布式缓存对于缓存值的存取都是基于 byte[]，所以各种对象必须先序列化为字符串，之后转换为 byte[] 数组
26.                         cacheValue = Encoding.UTF8.GetBytes(time);
27.                         var distributedCacheEntryOption = new DistributedCacheEntryOptions()
28.                         {
29.                                 //AbsoluteExpiration = DateTimeOffset.Now.AddSeconds(20),
30.                                 AbsoluteExpirationRelativeToNow = TimeSpan.FromSeconds(20),
31.                                 SlidingExpiration = TimeSpan.FromSeconds(3)
32.                         };
33.                         // 存在基于字符串的存取扩展方法，内部其实也是通过 Encoding.UTF8 进行了编码
34.                         // await _distributedCache.SetStringAsync(CacheKey, time, distributedCacheEntryOption);
35.                         await _distributedCache.SetAsync(CacheKey, cacheValue, distributedCacheEntryOption);
36.                 }
37.                 time = Encoding.UTF8.GetString(cacheValue);
38.                 Console.WriteLine("缓存时间：" + time);
39.                 Console.WriteLine("当前时间：" + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
40.         }
42.         public async Task RemoveAsync()
43.         {
44.                 await _distributedCache.RemoveAsync(CacheKey);
45.         }
46. }

复制代码

之后，在入口文件添加以下代码，查看控制台结果是否与预想的一致：

1. using DistributedCacheSample;
2. using Microsoft.Extensions.DependencyInjection;
3. using Microsoft.Extensions.Hosting;
5. var host = Host.CreateDefaultBuilder(args)
6.         .ConfigureServices(services =>
7.         {
8.                 services.AddDistributedMemoryCache();
9.                 services.AddTransient<IDistributedCacheService, DistributedCacheService>();
10.         })
11.         .Build();
13. var distributedCache = host.Services.GetRequiredService<IDistributedCacheService>();
14. // 第一次调用，设置缓存
15. Console.WriteLine("第一次调用，设置缓存");
16. await distributedCache.PrintDateTimeNowAsync();
17. await Task.Delay(TimeSpan.FromSeconds(1));
18. // 未过滑动时间，数据不变
19. Console.WriteLine("未过滑动时间，数据不变");
20. await distributedCache.PrintDateTimeNowAsync();
21. await Task.Delay(TimeSpan.FromSeconds(3));
22. // 已过滑动时间，数据改变
23. Console.WriteLine("已过滑动时间，数据改变");
24. await distributedCache.PrintDateTimeNowAsync();
25. await Task.Delay(TimeSpan.FromSeconds(1));
26. // 未过滑动时间，手动刷新过期时间
27. Console.WriteLine("未过滑动时间，手动刷新过期时间");
28. await distributedCache.FreshAsync();
29. await Task.Delay(TimeSpan.FromSeconds(2));
30. // 距离上一次调用此方法，已过滑动时间，但由于手动刷新过过期时间，过期时间重新计算，数据不变
31. Console.WriteLine("距离上一次调用此方法，已过滑动时间，但由于手动刷新过过期时间，过期时间重新计算，数据不变");
32. await distributedCache.PrintDateTimeNowAsync();
33. await Task.Delay(TimeSpan.FromSeconds(2));
34. // 移除缓存
35. Console.WriteLine("移除缓存");
36. await distributedCache.RemoveAsync();
37. // 原有的缓存已移除，调用此方法是重新设置缓存，数据改变
38. Console.WriteLine("原有的缓存已移除，调用此方法是重新设置缓存，数据改变");
39. await distributedCache.PrintDateTimeNowAsync();
41. host.Run();

复制代码

结果和预想的是一致的。
2.2 基于 Redis 的分布式缓存

Redis 是一种开源的基于内存的非关系型数据存储，通常用作分布式缓存。在 .NET Core 框架中使用 Redis 实现分布式缓存，需要引用 Microsoft.Extensions.Caching.StackExchangeRedis Nuget 包，包中通过  AddStackExchangeRedisCache 添加 RedisCache 实例来配置缓存实现，该类基于 Redis 实现了 IDistributedCache 接口。
(1) 安装 Redis
这里我在云服务器上通过 Docker 快速安装了 Redis ，映射容器内 Redis 默认端口 6379 到主机端口 6379，并且设置了访问密码为 123456 。

1. docker run -d --name redis -p 6379:6379 redis --requirepass "123456"

复制代码

(2) 应用添加依赖包，并且通过配置服务依赖关系

1. Install-Package Microsoft.Extensions.Caching.StackExchangeRedis

复制代码

或者通过 VS 的 Nuget 包管理工具进行安装
依赖关系配置如下：

1. var host = Host.CreateDefaultBuilder(args)
2.         .ConfigureServices(services =>
3.         {
4.                 // services.AddDistributedMemoryCache();
5.                 services.AddStackExchangeRedisCache(opyions =>
6.                 {
7.                         opyions.Configuration = "xxx.xxx.xxx.xxx:6379,password=123456";
8.                 });
9.         })
10.         .Build();

复制代码

这里只需要将原来的分布式内存缓存服务的配置切换为分布式 Redis 缓存的配置即可，其他的什么都不用改，就可以从内存缓存切换到 Redis 分布式缓存了。所以我们在日常工作的应用搭建中推荐使用基于分布式缓存方案，前期或者开发环境中可以使用基于内存的分布式缓存，后面项目的性能要求高了，可以很方便地切换到真正的分布式缓存，只需改动一行代码。
之后基于前面的例子运行应用，可以看到输出的结果是一样的。

而在 Redis 上也可以看得到我们缓存上去的数据。

这里还有一个要注意的点，理论上使用分布式缓存是能够增强应用的性能和体验性的，但是像 Redis 这样的分布式缓存一般情况下是和应用部署在不同的服务器，每一次缓存的获取会存在一定的网络传输消耗，当缓存的数据量比较大，而且缓存存取频繁的时候，也会有很大的性能消耗。之前在项目中就遇到过这样的问题，由于一个查询功能需要实时进行计算，计算中需要进行循环，而计算依赖于基础数据，这部分的数据是使用缓存的，当初直接使用 Redis 缓存性能并不理想。当然可以说这种方式是有问题的，但是当时由于业务需要，封装的计算方法中需要在应用启动的时候由外部初始化基础数据，为基础数据能够根据前端改动而刷新，所以用了缓存的方式。
下面是一个示例进行内存缓存和 Redis 缓存的对比：
这里利用 BenchmarkDotNet 进行性能测试，需要先对原有的代码进行一下改造，这里调整了一下构造函数，自行实例化相关缓存的对象，之后有三个方法，分别使用 Redis 缓存、内存缓存、内存缓存结合 Redis 缓存，每个方法中模拟业务中的1000次循环，循环中缓存数据进行存取。
点击查看性能测试代码

1. [SimpleJob(RuntimeMoniker.Net60)]
2. public class DistributedCacheService : IDistributedCacheService
3. {
4.         public const string CacheKey = nameof(DistributedCacheService);
5.         private readonly IDistributedCache _distributedCache;
6.         private readonly IDistributedCache _distributedMemoryCache;
7.         private readonly IMemoryCache _memoryCache;
9.         [Params(1000)]
10.         public int N;
12.         public DistributedCacheService()
13.         {
14.                 _distributedCache = new RedisCache(Options.Create(new RedisCacheOptions()
15.                 {
16.                         Configuration = "1.12.64.68:6379,password=123456"
17.                 }));
18.                 _distributedMemoryCache = new MemoryDistributedCache(Options.Create(new MemoryDistributedCacheOptions()));
19.                 _memoryCache = new MemoryCache(Options.Create(new MemoryCacheOptions()));
20.         }
22.         public async Task FreshAsync()
23.         {
24.                 await _distributedCache.RefreshAsync(CacheKey);
25.         }
27.         public async Task PrintDateTimeNowAsync()
28.         {
29.                 var time = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
30.                 var cacheValue = await _distributedCache.GetAsync(CacheKey);
31.                 if (cacheValue == null)
32.                 {
33.                         // 分布式缓存对于缓存值的存取都是基于 byte[]，所以各种对象必须先序列化为字符串，之后转换为 byte[] 数组
34.                         cacheValue = Encoding.UTF8.GetBytes(time);
35.                         var distributedCacheEntryOption = new DistributedCacheEntryOptions()
36.                         {
37.                                 //AbsoluteExpiration = DateTimeOffset.Now.AddSeconds(10),
38.                                 AbsoluteExpirationRelativeToNow = TimeSpan.FromSeconds(20),
39.                                 SlidingExpiration = TimeSpan.FromSeconds(3)
40.                         };
41.                         // 存在基于字符串的存取扩展方法，内部其实也是通过 Encoding.UTF8 进行了编码
42.                         // await _distributedCache.SetStringAsync(CacheKey, time, distributedCacheEntryOption);
43.                         await _distributedCache.SetAsync(CacheKey, cacheValue, distributedCacheEntryOption);
44.                 }
45.                 time = Encoding.UTF8.GetString(cacheValue);
46.                 Console.WriteLine("缓存时间：" + time);
47.                 Console.WriteLine("当前时间：" + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
48.         }
50.         [Benchmark]
51.         public async Task PrintDateTimeNowWithRedisAsync()
52.         {
53.                 for(var i =0; i< N; i++)
54.                 {
55.                         var time = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
56.                         var cacheValue = await _distributedCache.GetAsync(CacheKey);
57.                         if (cacheValue == null)
58.                         {
59.                                 // 分布式缓存对于缓存值的存取都是基于 byte[]，所以各种对象必须先序列化为字符串，之后转换为 byte[] 数组
60.                                 cacheValue = Encoding.UTF8.GetBytes(time);
61.                                 var distributedCacheEntryOption = new DistributedCacheEntryOptions()
62.                                 {
63.                                         //AbsoluteExpiration = DateTimeOffset.Now.AddSeconds(10),
64.                                         AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(10),
65.                                         SlidingExpiration = TimeSpan.FromMinutes(5)
66.                                 };
67.                                 // 存在基于字符串的存取扩展方法，内部其实也是通过 Encoding.UTF8 进行了编码
68.                                 // await _distributedCache.SetStringAsync(CacheKey, time, distributedCacheEntryOption);
69.                                 await _distributedCache.SetAsync(CacheKey, cacheValue, distributedCacheEntryOption);
70.                         }
71.                         time = Encoding.UTF8.GetString(cacheValue);
72.                 }
73.         }
74.         [Benchmark]
75.         public async Task PrintDateTimeWithMemoryAsync()
76.         {
77.                 for (var i = 0; i < N; i++)
78.                 {
79.                         var time = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
80.                         var cacheValue = await _distributedMemoryCache.GetAsync(CacheKey);
81.                         if (cacheValue == null)
82.                         {
83.                                 // 分布式缓存对于缓存值的存取都是基于 byte[]，所以各种对象必须先序列化为字符串，之后转换为 byte[] 数组
84.                                 cacheValue = Encoding.UTF8.GetBytes(time);
85.                                 var distributedCacheEntryOption = new DistributedCacheEntryOptions()
86.                                 {
87.                                         //AbsoluteExpiration = DateTimeOffset.Now.AddSeconds(10),
88.                                         AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(10),
89.                                         SlidingExpiration = TimeSpan.FromMinutes(5)
90.                                 };
91.                                 // 存在基于字符串的存取扩展方法，内部其实也是通过 Encoding.UTF8 进行了编码
92.                                 // await _distributedCache.SetStringAsync(CacheKey, time, distributedCacheEntryOption);
93.                                 await _distributedMemoryCache.SetAsync(CacheKey, cacheValue, distributedCacheEntryOption);
94.                         }
95.                         time = Encoding.UTF8.GetString(cacheValue);
96.                 }
97.         }
99.         [Benchmark]
100.         public async Task PrintDateTimeWithMemoryAndRedisAsync()
101.         {
102.                 for (var i = 0; i < N; i++)
103.                 {
104.                         var cacheValue = await _memoryCache.GetOrCreateAsync(CacheKey, async cacheEntry =>
105.                         {
106.                                 var time = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
107.                                 var redisCacheValue = await _distributedCache.GetAsync(CacheKey);
108.                                 if (redisCacheValue == null)
109.                                 {
110.                                         // 分布式缓存对于缓存值的存取都是基于 byte[]，所以各种对象必须先序列化为字符串，之后转换为 byte[] 数组
111.                                         redisCacheValue = Encoding.UTF8.GetBytes(time);
112.                                         var distributedCacheEntryOption = new DistributedCacheEntryOptions()
113.                                         {
114.                                                 //AbsoluteExpiration = DateTimeOffset.Now.AddSeconds(10),
115.                                                 AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(10),
116.                                                 SlidingExpiration = TimeSpan.FromMinutes(5)
117.                                         };
118.                                         // 存在基于字符串的存取扩展方法，内部其实也是通过 Encoding.UTF8 进行了编码
119.                                         // await _distributedCache.SetStringAsync(CacheKey, time, distributedCacheEntryOption);
120.                                         await _distributedCache.SetAsync(CacheKey, redisCacheValue, distributedCacheEntryOption);
121.                                 }
122.                                 time = Encoding.UTF8.GetString(redisCacheValue);
123.                                 cacheEntry.SlidingExpiration = TimeSpan.FromSeconds(20);
124.                                 return time;
125.                         });
126.                 }
127.         }
129.         public async Task RemoveAsync()
130.         {
131.                 await _distributedCache.RemoveAsync(CacheKey);
132.         }
133. }

复制代码

Program.cs 文件中只保留以下代码：

1. Summary summary = BenchmarkRunner.Run<DistributedCacheService>();
2. Console.ReadLine();

复制代码

测试结果如下：

可以看到这种情况下使用 Redis 缓存性能是惨不忍睹的，但是另外两种方式就不一样了。
我们在业务中的缓存最终就是第三种方法的方式，结合内存缓存和 Redis 缓存，根本的思路就是在使用时将数据临时保存在本地，减少网络传输的消耗，并且根据实际业务情况控制内存缓存的超时时间以保持数据的一致性。


参考文章：
ASP.NET Core 中的分布式缓存


ASP.NET Core 系列：
目录：ASP.NET Core 系列总结
上一篇：ASP.NET Core - 缓存之内存缓存(下)

来源:https://www.cnblogs.com/wewant/archive/2023/04/19/17114119.html
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！