开篇叙

本篇将和大家分享一下秒杀商品活动架构，采用的架构方案正如标题名称.NetCore+Jexus代理+Redis，由于精力有限所以这里只设计到商品添加，抢购，订单查询，处理队列抢购订单的功能；有不足或者不够详细的还请见谅，顺手点个推荐也不错；

a. ^_秒杀流程

b. 封装StackExchange.Redis的使用类

c. Ubuntu16.04上使用Jexus搭建代理完成分布式部署

d. NetCore写实时监控队列服务

秒杀架构设计图︿(￣︶￣)︿三幅

1. 一般业务性架构

2. 后端分布式架构

3. 整站分布式

项目工程结构描述

a. 该项目git开源地址： class="cnblogs_code">https://github.com/shenniubuxing3/SeckillPro ，线上效果地址： http://www.lovexins.com:3333/

b. SeckillPro.Web：面向用户的web站点，主要提供商品展示，秒杀抢购，抢购结果，订单列表等功能；

c. SeckillPro.Api：主要处理秒杀活动的请求，然后加入到秒杀队列中，以及订单状态的查询接口；

d. SeckillPro.Server：处理秒杀队列的服务；根据Redis模糊匹配key的方式，开启多个商品秒杀的任务，并处理秒杀请求和改变订单抢购状态；

e. SeckillPro.Com：集成公共的方法；这里面前有操作Redis的list，hash，string的封装类；

SeckillPro.Web商品后台管理

对于商品活动来说，商品维护是必不可少的，由于这里商品维护的信息比较少，并且这里只加入到了RedisDb中，所以就不直接上代码了；一个列表，一个添加仅此而已；这里就不再贴代码了，如果你感兴趣可以去我的git上面看源码： https://github.com/shenniubuxing3/SeckillPro/blob/master/SeckillPro/SeckillPro.Web/Controllers/HomeController.cs 

SeckillPro.Web用户端商品列表+秒杀请求+用户订单列表

商品列表和订单列表没有可以太多说的，一般订单系统都有这两个列表；关键点在于订单秒杀流程中，咋们来简单分析下面向客户秒杀的流程需要注意的事项：

a. 限制秒杀开始时间和结束时间(测试未限制)

b. 未开始活动限制提交按钮不可点(测试未限制)

c. 获取真实剩余库存限制秒杀提交(获取redis中商品hash存储的真实剩余量)

d. 把客户的秒杀请求转移到另外的api集群，以此提高面向客户端的web站点并发承载率(测试项目中我直接指定4545端口的api测试)

这里就不再贴代码了，如果你感兴趣可以去我的git上面看看这部分源码： https://github.com/shenniubuxing3/SeckillPro/blob/master/SeckillPro/SeckillPro.Web/Controllers/HomeController.cs 

.NetCore写处理秒杀活动队列的服务

这个处理队列服务处理流程：模糊匹配Redis中每种商品的队列key-》开启不同商品的处理队列任务-》处理秒杀订单-》更新库存和秒杀订单状态；

a. 模糊匹配Redis中每种商品的队列key：这里采用的是StackExchange.Redis中指定redis原生命令的方法来获取匹配队列key，设计的代码如下：

 1 /// <summary>
 2         /// 模糊匹配redis中的key
 3         /// </summary>
 4         /// <param name="paramArr"></param>
 5         /// <returns></returns>
 6         public async Task<List<string>> MatchKeys(params string[] paramArr)
 7         {
 8             var list = new List<string>();
 9             try
10             {
11                 var result = await this.ExecuteAsync("keys", paramArr);
12 
13                 var valArr = ((RedisValue[])result);
14                 foreach (var item in valArr)
15                 {
16                     list.Add(item);
17                 }
18             }
19             catch (Exception ex) { }
20             return list;
21         }
22 
23         /// <summary>
24         /// 执行redis原生命令
25         /// </summary>
26         /// <param name="cmd"></param>
27         /// <param name="paramArr"></param>
28         /// <returns></returns>
29         public async Task<RedisResult> ExecuteAsync(string cmd, params string[] paramArr)
30         {
31             try
32             {
33                 var db = this.GetDb();
34                 return await db.ExecuteAsync(cmd, paramArr);
35             }
36             catch (Exception ex) { }
37             return default(RedisResult);
38         }

b. 开启不同商品的处理队列任务：通过Task.Factory.StartNew(action,object)方法开启不同商品的处理秒杀订单的任务；

c. 更新库存和秒杀订单状态：由于抢购商品要求库存剩余实时性，所以每处理一个抢购订单，需要对该商品减去相应的库存和修改秒杀订单的状态方便用户查看秒杀结果；

d. 处理队列具体的实现代码可以去git看下，个人觉得还是有用的：https://github.com/shenniubuxing3/SeckillPro/blob/master/SeckillPro/SeckillPro.Server/Program.cs

使用Jexus代理部署分布式站点和接口

这里部署的代理采用的是Jexus代理；作为在linux和unix上部署.net程序实用的工具，真的很感谢jexus作者；首先本篇讲解的部署环境是ubunt16.04x64（至于这么安装jexus可以参考上一篇分享文章），为了更直观的看出来效果我在服务器上拷贝了两份SeckillPro.Web发布的站点，他们代码都是一样的只是分别把_Layout.cshtml试图模板中加入了端口7777和8888，我就用这两个端口来测试jexus的代理效果；

测试方便直接分别在两个复制站点中执行如下终端命令：dotnet SeckillPro.Web.dll http://ip:端口 ；一个监听7777端口一个监听8888；执行命令效果图：

监听7777和8888端口成功后，我们就可以直接在浏览器输入：http://172.16.9.66:7777 访问，正常情况下能够看到如下图示例：

单个站点访问没问题了，下面开始配置jexus代理；只需要在jexus/siteconf的配置文件中（我这里是default配置文件），增加如下设置：

注意reproxy参数：

a. 第一个/表示根目录，一般不变

b. 多个被代理地址使用‘,’隔开；

c. 被代理地址后面也同样需要加/

此时我们配置完后，只需要启动jexus就行了：./jws start （怎么启动可以参考上一篇文章）；当启动jws成功后，我们就能通过配置的80端口，来访问SeckillPro.Web站点了，效果图：

至于代理分发的策略暂不在本章的讨论范围内，如果可以建议去jexus官网了解下；同样对于Seckill.Api我们也可以这样部署，这里部署了个秒杀线上地址，有兴趣的朋友可以点击试试：http://www.lovexins.com:3333/ （注：这里没有使用代理）

封装StackExchange.Redis的使用类StackRedis.cs

其实这个在之前已经分享过了，只不过只有操作string和list的分装；本篇测试涉及到订单查询和商品查询等功能，所以这里我又扩展了对hash的操作方法，可以说更丰富了吧，如果您正打算使用redis或许直接用我这个封装类是个不错的打算；

  1 public class StackRedis : IDisposable
  2     {
  3         #region 配置属性   基于 StackExchange.Redis 封装
  4         //连接串 （注：IP:端口,属性=,属性=)
  5         public string _ConnectionString = "127.0.0.1:6377,password=shenniubuxing3";
  6         //操作的库（注：默认0库）
  7         public int _Db = 0;
  8         #endregion
  9 
 10         #region 管理器对象
 11 
 12         /// <summary>
 13         /// 获取redis操作类对象
 14         /// </summary>
 15         private static StackRedis _StackRedis;
 16         private static object _locker_StackRedis = new object();
 17         public static StackRedis Current
 18         {
 19             get
 20             {
 21                 if (_StackRedis == null)
 22                 {
 23                     lock (_locker_StackRedis)
 24                     {
 25                         _StackRedis = _StackRedis ?? new StackRedis();
 26                         return _StackRedis;
 27                     }
 28                 }
 29 
 30                 return _StackRedis;
 31             }
 32         }
 33 
 34         /// <summary>
 35         /// 获取并发链接管理器对象
 36         /// </summary>
 37         private static ConnectionMultiplexer _redis;
 38         private static object _locker = new object();
 39         public ConnectionMultiplexer Manager
 40         {
 41             get
 42             {
 43                 if (_redis == null)
 44                 {
 45                     lock (_locker)
 46                     {
 47                         _redis = _redis ?? GetManager(this._ConnectionString);
 48                         return _redis;
 49                     }
 50                 }
 51 
 52                 return _redis;
 53             }
 54         }
 55 
 56         /// <summary>
 57         /// 获取链接管理器
 58         /// </summary>
 59         /// <param name="connectionString"></param>
 60         /// <returns></returns>
 61         public ConnectionMultiplexer GetManager(string connectionString)
 62         {
 63             return ConnectionMultiplexer.Connect(connectionString);
 64         }
 65 
 66         /// <summary>
 67         /// 获取操作数据库对象
 68         /// </summary>
 69         /// <returns></returns>
 70         public IDatabase GetDb()
 71         {
 72             return Manager.GetDatabase(_Db);
 73         }
 74         #endregion
 75 
 76         #region 操作方法
 77 
 78         #region string 操作
 79 
 80         /// <summary>
 81         /// 根据Key移除
 82         /// </summary>
 83         /// <param name="key"></param>
 84         /// <returns></returns>
 85         public async Task<bool> Remove(string key)
 86         {
 87             var db = this.GetDb();
 88 
 89             return await db.KeyDeleteAsync(key);
 90         }
 91 
 92         /// <summary>
 93         /// 根据key获取string结果
 94         /// </summary>
 95         /// <param name="key"></param>
 96         /// <returns></returns>
 97         public async Task<string> Get(string key)
 98         {
 99             var db = this.GetDb();
100             return await db.StringGetAsync(key);
101         }
102 
103         /// <summary>
104         /// 根据key获取string中的对象
105         /// </summary>
106         /// <typeparam name="T"></typeparam>
107         /// <param name="key"></param>
108         /// <returns></returns>
109         public async Task<T> Get<T>(string key)
110         {
111             var t = default(T);
112             try
113             {
114                 var _str = await this.Get(key);
115                 if (string.IsNullOrWhiteSpace(_str)) { return t; }
116 
117                 t = JsonConvert.DeserializeObject<T>(_str);
118             }
119             catch (Exception ex) { }
120             return t;
121         }
122 
123         /// <summary>
124         /// 存储string数据
125         /// </summary>
126         /// <param name="key"></param>
127         /// <param name="value"></param>
128         /// <param name="expireMinutes"></param>
129         /// <returns></returns>
130         public async Task<bool> Set(string key, string value, int expireMinutes = 0)
131         {
132             var db = this.GetDb();
133             if (expireMinutes > 0)
134             {
135                 return db.StringSet(key, value, TimeSpan.FromMinutes(expireMinutes));
136             }
137             return await db.StringSetAsync(key, value);
138         }
139 
140         /// <summary>
141         /// 存储对象数据到string
142         /// </summary>
143         /// <typeparam name="T"></typeparam>
144         /// <param name="key"></param>
145         /// <param name="value"></param>
146         /// <param name="expireMinutes"></param>
147         /// <returns></returns>
148         public async Task<bool> Set<T>(string key, T value, int expireMinutes = 0)
149         {
150             try
151             {
152                 var jsonOption = new JsonSerializerSettings()
153                 {
154                     ReferenceLoopHandling = ReferenceLoopHandling.Ignore
155                 };
156                 var _str = JsonConvert.SerializeObject(value, jsonOption);
157                 if (string.IsNullOrWhiteSpace(_str)) { return false; }
158 
159                 return await this.Set(key, _str, expireMinutes);
160             }
161             catch (Exception ex) { }
162             return false;
163         }
164 
165         /// <summary>
166         /// 是否存在key
167         /// </summary>
168         /// <typeparam name="T"></typeparam>
169         /// <param name="key"></param>
170         /// <returns></returns>
171         public async Task<bool> KeyExists(string key)
172         {
173             try
174             {
175                 var db = this.GetDb();
176                 return await db.KeyExistsAsync(key);
177             }
178             catch (Exception ex) { }
179             return false;
180         }
181 
182         #endregion
183 
184         #region hash操作
185 
186         /// <summary>
187         /// 是否存在hash的列
188         /// </summary>
189         /// <param name="key"></param>
190         /// <param name="filedKey"></param>
191         /// <returns></returns>
192         public async Task<bool> HashFieldExists(string key, string filedKey)
193         {
194             try
195             {
196                 if (string.IsNullOrWhiteSpace(key) || string.IsNullOrWhiteSpace(filedKey)) { return false; }
197 
198                 var result = await this.HashFieldsExists(key, new Dictionary<string, bool> { { filedKey, false } });
199                 return result[filedKey];
200             }
201             catch (Exception ex) { }
202             return false;
203         }
204 
205         /// <summary>
206         /// 是否存在hash的列集合
207         /// </summary>
208         /// <param name="key"></param>
209         /// <param name="dics"></param>
210         /// <returns></returns>
211         public async Task<Dictionary<string, bool>> HashFieldsExists(string key, Dictionary<string, bool> dics)
212         {
213             try
214             {
215                 if (dics.Count <= 0) { return dics; }
216 
217                 var db = this.GetDb();
218                 foreach (var fieldKey in dics.Keys)
219                 {
220                     dics[fieldKey] = await db.HashExistsAsync(key, fieldKey);
221                 }
222             }
223             catch (Exception ex) { }
224             return dics;
225         }
226 
227         /// <summary>
228         /// 设置hash
229         /// </summary>
230         /// <typeparam name="T"></typeparam>
231         /// <param name="key"></param>
232         /// <param name="filedKey"></param>
233         /// <param name="t"></param>
234         /// <returns></returns>
235         public async Task<long> SetOrUpdateHashsField<T>(string key, string filedKey, T t, bool isAdd = true)
236         {
237             var result = 0L;
238             try
239             {
240                 return await this.SetOrUpdateHashsFields<T>(key, new Dictionary<string, T> { { filedKey, t } }, isAdd);
241             }
242             catch (Exception ex) { }
243             return result;
244         }
245 
246         /// <summary>
247         /// 设置hash集合，添加和更新操作
248         /// </summary>
249         /// <typeparam name="T"></typeparam>
250         /// <param name="key"></param>
251         /// <param name="dics"></param>
252         /// <returns></returns>
253         public async Task<long> SetOrUpdateHashsFields<T>(string key, Dictionary<string, T> dics, bool isAdd = true)
254         {
255             var result = 0L;
256             try
257             {
258                 var jsonOption = new JsonSerializerSettings()
259                 {
260                     ReferenceLoopHandling = ReferenceLoopHandling.Ignore
261                 };
262                 var db = this.GetDb();
263                 foreach (var fieldKey in dics.Keys)
264                 {
265                     var item = dics[fieldKey];
266                     var _str = JsonConvert.SerializeObject(item, jsonOption);
267                     result += await db.HashSetAsync(key, fieldKey, _str) ? 1 : 0;
268                     if (!isAdd) { result++; }
269                 }
270                 return result;
271             }
272             catch (Exception ex) { }
273             return result;
274         }
275 
276         /// <summary>
277         /// 移除hash的列
278         /// </summary>
279         /// <param name="key"></param>
280         /// <param name="filedKey"></param>
281         /// <returns></returns>
282         public async Task<bool> RemoveHashField(string key, string filedKey)
283         {
284             try
285             {
286                 if (string.IsNullOrWhiteSpace(key) || string.IsNullOrWhiteSpace(filedKey)) { return false; }
287 
288                 var result = await this.RemoveHashFields(key, new Dictionary<string, bool> { { filedKey, false } });
289                 return result[filedKey];
290             }
291             catch (Exception ex) { }
292             return false;
293         }
294 
295         /// <summary>
296         /// 异常hash的列集合
297         /// </summary>
298         /// <param name="key"></param>
299         /// <param name="dics"></param>
300         /// <returns></returns>
301         public async Task<Dictionary<string, bool>> RemoveHashFields(string key, Dictionary<string, bool> dics)
302         {
303 
304             try
305             {
306                 var jsonOption = new JsonSerializerSettings()
307                 {
308                     ReferenceLoopHandling = ReferenceLoopHandling.Ignore
309                 };
310                 var db = this.GetDb();
311                 foreach (var fieldKey in dics.Keys)
312                 {
313                     dics[fieldKey] = await db.HashDeleteAsync(key, fieldKey);
314                 }
315                 return dics;
316             }
317             catch (Exception ex) { }
318             return dics;
319         }
320 
321         /// <summary>
322         /// 设置hash
323         /// </summary>
324         /// <typeparam name="T"></typeparam>
325         /// <param name="key"></param>
326         /// <param name="filedKey"></param>
327         /// <param name="t"></param>
328         /// <returns></returns>
329         public async Task<T> GetHashField<T>(string key, string filedKey)
330         {
331             var t = default(T);
332             try
333             {
334                 var dics = await this.GetHashFields<T>(key, new Dictionary<string, T> { { filedKey, t } });
335                 return dics[filedKey];
336             }
337             catch (Exception ex) { }
338             return t;
339         }
340 
341         /// <summary>
342         /// 获取hash的列值集合
343         /// </summary>
344         /// <typeparam name="T"></typeparam>
345         /// <param name="key"></param>
346         /// <param name="dics"></param>
347         /// <returns></returns>
348         public async Task<Dictionary<string, T>> GetHashFields<T>(string key, Dictionary<string, T> dics)
349         {
350             try
351             {
352                 var db = this.GetDb();
353                 foreach (var fieldKey in dics.Keys)
354                 {
355                     var str = await db.HashGetAsync(key, fieldKey);
356                     if (string.IsNullOrWhiteSpace(str)) { continue; }
357 
358                     dics[fieldKey] = JsonConvert.DeserializeObject<T>(str);
359                 }
360                 return dics;
361             }
362             catch (Exception ex) { }
363             return dics;
364         }
365 
366         /// <summary>
367         /// 获取hash的key的所有列的值
368         /// </summary>
369         /// <typeparam name="T"></typeparam>
370         /// <param name="key"></param>
371         /// <returns></returns>
372         public async Task<Dictionary<string, T>> GetHashs<T>(string key)
373         {
374             var dic = new Dictionary<string, T>();
375             try
376             {
377                 var db = this.GetDb();
378 
379                 var hashFiles = await db.HashGetAllAsync(key);
380                 foreach (var field in hashFiles)
381                 {
382                     dic[field.Name] = JsonConvert.DeserializeObject<T>(field.Value);
383                 }
384                 return dic;
385             }
386             catch (Exception ex) { }
387             return dic;
388         }
389 
390         /// <summary>
391         /// 获取hash的Key的所有列的值的list集合
392         /// </summary>
393         /// <typeparam name="T"></typeparam>
394         /// <param name="key"></param>
395         /// <returns></returns>
396         public async Task<List<T>> GetHashsToList<T>(string key)
397         {
398             var list = new List<T>();
399             try
400             {
401                 var db = this.GetDb();
402 
403                 var hashFiles = await db.HashGetAllAsync(key);
404                 foreach (var field in hashFiles)
405                 {
406                     var item = JsonConvert.DeserializeObject<T>(field.Value);
407                     if (item == null) { continue; }
408                     list.Add(item);
409                 }
410             }
411             catch (Exception ex) { }
412             return list;
413         }
414 
415         #endregion
416 
417         #region List操作（注：可以当做队列使用）
418 
419         /// <summary>
420         /// list长度
421         /// </summary>
422         /// <typeparam name="T"></typeparam>
423         /// <param name="key"></param>
424         /// <returns></returns>
425         public async Task<long> GetListLen<T>(string key)
426         {
427             try
428             {
429                 var db = this.GetDb();
430                 return await db.ListLengthAsync(key);
431             }
432             catch (Exception ex) { }
433             return 0;
434         }
435 
436         /// <summary>
437         /// 获取List数据
438         /// </summary>
439         /// <typeparam name="T"></typeparam>
440         /// <param name="key"></param>
441         /// <returns></returns>
442         public async Task<List<T>> GetList<T>(string key)
443         {
444             var t = new List<T>();
445             try
446             {
447                 var db = this.GetDb();
448                 var _values = await db.ListRangeAsync(key);
449                 foreach (var item in _values)
450                 {
451                     if (string.IsNullOrWhiteSpace(item)) { continue; }
452                     t.Add(JsonConvert.DeserializeObject<T>(item));
453                 }
454             }
455             catch (Exception ex) { }
456             return t;
457         }
458 
459         /// <summary>
460         /// 获取队列出口数据并移除
461         /// </summary>
462         /// <typeparam name="T"></typeparam>
463         /// <param name="key"></param>
464         /// <returns></returns>
465         public async Task<T> GetListAndPop<T>(string key)
466         {
467             var t = default(T);
468             try
469             {
470                 var db = this.GetDb();
471                 var _str = await db.ListRightPopAsync(key);
472                 if (string.IsNullOrWhiteSpace(_str)) { return t; }
473                 t = JsonConvert.DeserializeObject<T>(_str);
474             }
475             catch (Exception ex) { }
476             return t;
477         }
478 
479         /// <summary>
480         /// 集合对象添加到list左边
481         /// </summary>
482         /// <typeparam name="T"></typeparam>
483         /// <param name="key"></param>
484         /// <param name="values"></param>
485         /// <returns></returns>
486         public async Task<long> SetLists<T>(string key, List<T> values)
487         {
488             var result = 0L;
489             try
490             {
491                 var jsonOption = new JsonSerializerSettings()
492                 {
493                     ReferenceLoopHandling = ReferenceLoopHandling.Ignore
494                 };
495                 var db = this.GetDb();
496                 foreach (var item in values)
497                 {
498                     var _str = JsonConvert.SerializeObject(item, jsonOption);
499                     result += await db.ListLeftPushAsync(key, _str);
500                 }
501                 return result;
502             }
503             catch (Exception ex) { }
504             return result;
505         }
506 
507         /// <summary>
508         /// 单个对象添加到list左边
509         /// </summary>
510         /// <typeparam name="T"></typeparam>
511         /// <param name="key"></param>
512         /// <param name="value"></param>
513         /// <returns></returns>
514         public async Task<long> SetList<T>(string key, T value)
515         {
516             var result = 0L;
517             try
518             {
519                 result = await this.SetLists(key, new List<T> { value });
520             }
521             catch (Exception ex) { }
522             return result;
523         }
524 
525 
526         #endregion
527 
528         #region 额外扩展
529 
530         public async Task<List<string>> MatchKeys(params string[] paramArr)
531         {
532             var list = new List<string>();
533             try
534             {
535                 var result = await this.ExecuteAsync("keys", paramArr);
536 
537                 var valArr = ((RedisValue[])result);
538                 foreach (var item in valArr)
539                 {
540                     list.Add(item);
541                 }
542             }
543             catch (Exception ex) { }
544             return list;
545         }
546 
547         /// <summary>
548         /// 执行redis原生命令
549         /// </summary>
550         /// <param name="cmd"></param>
551         /// <param name="paramArr"></param>
552         /// <returns></returns>
553         public async Task<RedisResult> ExecuteAsync(string cmd, params string[] paramArr)
554         {
555             try
556             {
557                 var db = this.GetDb();
558                 return await db.ExecuteAsync(cmd, paramArr);
559             }
560             catch (Exception ex) { }
561             return default(RedisResult);
562         }
563 
564         /// <summary>
565         /// 手动回收管理器对象
566         /// </summary>
567         public void Dispose()
568         {
569             this.Dispose(_redis);
570         }
571 
572         public void Dispose(ConnectionMultiplexer con)
573         {
574             if (con != null)
575             {
576                 con.Close();
577                 con.Dispose();
578             }
579         }
580 
581         #endregion
582 
583         #endregion
584     }