.NetCore+Redis模拟秒杀商品活动(分析)

最新推荐文章于 2024-07-05 03:19:09 发布
最新推荐文章于 2024-07-05 03:19:09 发布
阅读量4.5k 收藏 16
点赞数
分类专栏： 分布式开发技术 文章标签： redis
原文链接：https://blog.csdn.net/WuLex
版权

主页

这里写图片描述

HomeController

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc;
using SeckillPro.Com.Tool;
using SeckillPro.Com.Model.CrmModel;
using SeckillPro.Com.Model;
using SeckillPro.Com.Common;
using System.Net.Http;
using SeckillPro.Com.Model.ApiModel;
using Newtonsoft.Json;

namespace SeckillPro.Web.Controllers
{
    public class HomeController : Controller
    {
        //redis引用
        private StackRedis _redis = StackRedis.Current;

        /// <summary>
        /// 用户抢购商品列表
        /// </summary>
        /// <returns></returns>
        public async Task<IActionResult> Index()
        {
            #region  使用ip模拟登录账号
            var token = "Sid_" + HttpContext.Connection.RemoteIpAddress.ToString();
            var sessionData = await _redis.Get<MoUserInfo>(token);
            if (sessionData == null || sessionData.UserId <= 0)
            {
                //用户基本信息
                var moUser = new MoUserInfo();
                moUser.UserId = await DataKeyHelper.Current.GetKeyId(EnumHelper.EmDataKey.UserId);
                moUser.NickName = token;
                //redis存储session，默认30分钟失效
                var isLogin = await _redis.Set<MoUserInfo>(token, moUser, 30);
                if (isLogin)
                {
                    ViewData["MoUser"] = moUser;
                    //加入cookie
                    Response.Cookies.Append(EnumHelper.EmDataKey.SessionKey.ToString(), token, new Microsoft.AspNetCore.Http.CookieOptions
                    {
                        Expires = DateTime.Now.AddMinutes(30),
                        HttpOnly = true
                    });
                }
            }
            else
            {
                ViewData["MoUser"] = sessionData;
                //已经是登陆状态，需要重新设置失效时间
                var isLogin = await _redis.Set<MoUserInfo>(token, sessionData, 30);
                Response.Cookies.Append(EnumHelper.EmDataKey.SessionKey.ToString(), token, new Microsoft.AspNetCore.Http.CookieOptions
                {
                    Expires = DateTime.Now.AddMinutes(30),
                    HttpOnly = true
                });
            }
            #endregion

            //商品列表
            var shoppings = await _redis.GetHashsToList<MoShopping>(EnumHelper.EmDataKey.ShoppingHash.ToString());
            Response.Headers.Add("PageCache-Time", $"{60 * 2}");  //2分钟
            return View(shoppings);
        }

        [HttpGet]
        public async Task<IActionResult> Qiang(int? id)
        {
            if (id == null) { return BadRequest(); }

            var shop = await _redis.GetHashField<MoShopping>(EnumHelper.EmDataKey.ShoppingHash.ToString(), id.ToString());
            if (shop == null) { return NotFound(); }
            return View(shop);
        }

        [HttpPost]
        public async Task<IActionResult> Qiang(MoKaiQiang qiang)
        {

            #region 基础验证
            if (qiang == null || qiang.ShopId <= 0) { return RedirectToAction("Error", new { msg = "操作太快，请稍后重试。" }); }

            if (!Request.Cookies.TryGetValue(EnumHelper.EmDataKey.SessionKey.ToString(), out string token))
            {
                return RedirectToAction("Error", new { msg = "请先去登录。" });
            }
            var sessionData = await _redis.Get<MoUserInfo>(token);
            if (sessionData == null || sessionData.UserId <= 0) { return RedirectToAction("Error", new { msg = "请先去登录！" }); }

            var shop = await _redis.GetHashField<MoShopping>(EnumHelper.EmDataKey.ShoppingHash.ToString(), qiang.ShopId.ToString());
            if (shop == null) { return NotFound(); }
            else if (shop.MaxNum <= 0)
            {
                return RedirectToAction("Error", new { msg = $"你太慢了，商品：{shop.Name}，已经被抢完了！" });
            }
            else if (shop.MaxNum < qiang.Num)
            {
                return RedirectToAction("Error", new { msg = $"库存不足，商品：{shop.Name}，只剩{shop.MaxNum}了！" });
            }
            else if (shop.MaxGouNum < qiang.Num)
            {
                return RedirectToAction("Error", new { msg = $"一个账号每次最多只能抢购【{shop.Name}】{shop.MaxGouNum}件。" });
            }

            #endregion

            #region 请求抢购商品的分布式接口
            var rq = new MoQiangGouRq();
            rq.Num = qiang.Num;
            rq.ShoppingId = qiang.ShopId;
            rq.MemberRq = new MoMemberRq
            {
                Ip = HttpContext.Connection.RemoteIpAddress.ToString(),  //用户Ip
                RqSource = (int)EnumHelper.EmRqSource.Web,
                Token = token
            };
            var strRq = JsonConvert.SerializeObject(rq);
            var content = new StringContent(strRq, System.Text.Encoding.UTF8, "application/json");

            //基础接口地址
            //string apiBaseUrl = $"http://{HttpContext.Connection.LocalIpAddress}:4545";
            string apiBaseUrl = $"http://localhost:4545";
            var qiangApiUrl = $"{apiBaseUrl}/api/order/SubmitQiangGouOrder";
            var strRp = await HttpTool.HttpPostAsync(qiangApiUrl, content, 30);
            if (string.IsNullOrWhiteSpace(strRp))
            {
                return RedirectToAction("Error", new { msg = $"抢单超时，请查看你的订单列表是否抢单成功。" });
            }
            var rp = JsonConvert.DeserializeObject<MoQiangGouRp>(strRp);
            if (rp == null)
            {
                return RedirectToAction("Error", new { msg = $"抢单超时，请查看你的订单列表是否抢单成功。" });
            }
            else if (rp.RpStatus != 1)
            {
                return Error(rp.RpMsg);
            }
            #endregion

            return RedirectToAction("QiangResult", new { id = rp.OrderId });
        }

        /// <summary>
        /// 抢购结果
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [HttpGet]
        public async Task<IActionResult> QiangResult(long? id)
        {
            if (id == null) { return BadRequest(); }
            if (!Request.Cookies.TryGetValue(EnumHelper.EmDataKey.SessionKey.ToString(), out string token))
            {
                return RedirectToAction("Error", new { msg = $"请先去登录" });
            }

            var rq = new MoOrderDetailRq();
            rq.OrderId = Convert.ToInt64(id);
            rq.MemberRq = new MoMemberRq { Token = token };

            var strRq = JsonConvert.SerializeObject(rq);
            var content = new StringContent(strRq, System.Text.Encoding.UTF8, "application/json");

            //基础接口地址
            //string apiBaseUrl = $"http://{HttpContext.Connection.LocalIpAddress}:4545";
            string apiBaseUrl = $"http://localhost:4545";
            
            var qiangApiUrl = $"{apiBaseUrl}/api/order/GetOrderDetail";
            var strRp = await HttpTool.HttpPostAsync(qiangApiUrl, content, 30);
            if (string.IsNullOrWhiteSpace(strRp))
            {
                return RedirectToAction("Error", new { msg = "查询失败，请稍后重试。" });
            }
            var rp = JsonConvert.DeserializeObject<MoOrderDetailRp>(strRp);
            if (rp == null) { return RedirectToAction("Error", new { msg = $"查询失败，请稍后重试！" }); }
            else if (rp.RpStatus != 1)
            {
                return RedirectToAction("Error", new { msg = rp.RpMsg });
            }
            return View(rp);
        }

        /// <summary>
        /// 订单列表
        /// </summary>
        /// <returns></returns>
        public async Task<IActionResult> OrderList()
        {
            if (!Request.Cookies.TryGetValue(EnumHelper.EmDataKey.SessionKey.ToString(), out string token))
            {
                return RedirectToAction("Error", new { msg = "请先去登录。" });
            }
            var sessionData = await _redis.Get<MoUserInfo>(token);
            if (sessionData == null || sessionData.UserId <= 0) { return RedirectToAction("Error", new { msg = "请先去登录！" }); }

            var orderList = await _redis.GetHashsToList<MoOrderInfo>($"User_{sessionData.UserId}");
            return View(orderList);
        }

        #region 商品后台管理
        /// <summary>
        /// 商品后台管理列表（后台人员设置）
        /// </summary>
        /// <returns></returns>
        public async Task<IActionResult> ShoppingManage()
        {
            //获取原有商品
            var shoppings = await _redis.GetHashsToList<MoShopping>(EnumHelper.EmDataKey.ShoppingHash.ToString());
            return View(shoppings);
        }

        #region 添加商品
        [HttpGet]
        public IActionResult ShoppingAdd()
        {
            return View();
        }
        [HttpPost]
        public async Task<IActionResult> ShoppingAdd(MoShopping shopping)
        {

            //加入商品列表
            shopping.Id = await DataKeyHelper.Current.GetKeyId(EnumHelper.EmDataKey.ShoppingId);
            shopping.MaxNum = shopping.MaxNum < 0 ? 0 : shopping.MaxNum;
            shopping.MaxGouNum = shopping.MaxGouNum <= 0 ? 1 : shopping.MaxGouNum;
            shopping.Url = string.IsNullOrWhiteSpace(shopping.Url) ? "https://ss1.bdstatic.com/70cFvXSh_Q1YnxGkpoWK1HF6hhy/it/u=112998166,256272819&fm=117&gp=0.jpg" : shopping.Url;
            var result = await _redis.SetOrUpdateHashsField<MoShopping>(EnumHelper.EmDataKey.ShoppingHash.ToString(), shopping.Id.ToString(), shopping);
            if (result > 0) { return RedirectToAction("ShoppingManage"); }
            return View(shopping);
        }
        #endregion

        #endregion

        public IActionResult About()
        {
            ViewData["Message"] = "Your application description page.";

            return View();
        }

        public IActionResult Contact()
        {
            ViewData["Message"] = "Your contact page.";

            return View();
        }

        public IActionResult Error(string msg = "怎么就迷路了呢。")
        {
            ViewData["msg"] = msg;
            return View();
        }
    }

    public class MoKaiQiang
    {
        public long ShopId { get; set; }
        public int Num { get; set; }
    }
}

redis里的商品
这里写图片描述

redis里的订单
这里写图片描述

redis里的用户
这里写图片描述

订单列表

这里写图片描述

请求API的响应
这里写图片描述

OrderController

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json;
using SeckillPro.Com.Model.ApiModel;
using SeckillPro.Com.Tool;
using SeckillPro.Com.Model.CrmModel;
using SeckillPro.Com.Model;
using SeckillPro.Com.Common;
using System.IO;

namespace SeckillPro.Api.Controllers
{
    [Route("api/[controller]/[action]")]
    public class OrderController : Controller
    {
        //redis引用
        private StackRedis _redis = StackRedis.Current;

        // GET api/values
        [HttpGet]
        public IEnumerable<string> Get()
        {
            return new string[] { "value1", "value2" };
        }

        // GET api/values/5
        [HttpGet("{id}")]
        public string Get(int id)
        {
            return "value";
        }

        /// <summary>
        /// 抢单
        /// </summary>
        /// <returns></returns>
        [HttpPost]
        public async Task<MoQiangGouRp> SubmitQiangGouOrder()
        {
            var rp = new MoQiangGouRp { RpMsg = EnumHelper.EmOrderStatus.抢购失败.ToString() };
            try
            {
                var strRq = string.Empty;
                using (var stream = Request.Body)
                {
                    using (var reader = new StreamReader(stream))
                    {
                        strRq = await reader.ReadToEndAsync();
                    }
                }
                if (string.IsNullOrWhiteSpace(strRq)) { return rp; }

                var rq = JsonConvert.DeserializeObject<MoQiangGouRq>(strRq);
                if (rq.ShoppingId <= 0 || rq.MemberRq == null) { return rp; }

                #region 验证

                //登录验证
                if (string.IsNullOrWhiteSpace(rq.MemberRq.Token))
                {
                    rp.RpMsg = $"未登录，请登录后重试。";
                    return rp;
                }
                var sessionData = await _redis.Get<MoUserInfo>(rq.MemberRq.Token);
                if (sessionData == null)
                {
                    rp.RpMsg = $"登录失效，请重新登录！";
                    return rp;
                }

                //库存验证
                var shopsKey = EnumHelper.EmDataKey.ShoppingHash.ToString();
                var shop = await _redis.GetHashField<MoShopping>(shopsKey, rq.ShoppingId.ToString());
                if (shop == null) { return rp; }
                else if (shop.MaxNum <= 0)
                {
                    rp.RpMsg = $"你太慢了，商品：{shop.Name}，已经被抢完了！";
                    return rp;
                }
                else if (shop.MaxNum < rq.Num)
                {
                    rp.RpMsg = $"库存不足，商品：{shop.Name}，只剩{shop.MaxNum}了！";
                    return rp;
                }
                else if (shop.MaxGouNum < rq.Num)
                {
                    rp.RpMsg = $"一个账号每次最多只能抢购【{shop.Name}】{shop.MaxGouNum}件。";
                    return rp;
                }
                #endregion

                #region 加入订单list中

                var orderInfo = new MoOrderInfo();
                orderInfo.OrderId = await DataKeyHelper.Current.GetKeyId(EnumHelper.EmDataKey.OrderId);
                orderInfo.OrderStatus = (int)EnumHelper.EmOrderStatus.排队抢购中;
                orderInfo.CreatTime = DateTime.Now;
                orderInfo.Num = rq.Num;
                orderInfo.ShoppingId = rq.ShoppingId;
                orderInfo.UserId = sessionData.UserId;
                orderInfo.MoShopping = shop;
                //记录所有订单

                //记录会员名下的订单
                var isAddOrder = await _redis.SetOrUpdateHashsField<MoOrderInfo>($"User_{orderInfo.UserId}", orderInfo.OrderId.ToString(), orderInfo);
                if (isAddOrder <= 0)
                {
                    return rp;
                }
                rp.OrderId = orderInfo.OrderId;
                rp.OrderStatus = orderInfo.OrderStatus;
                rp.CreatTime = orderInfo.CreatTime;
                rp.RpStatus = 1;
                rp.RpMsg = EnumHelper.EmOrderStatus.排队抢购中.ToString();
                #endregion

                #region 各种验证无误后，加入抢购队列，并返回抢购中...

                var isAddQiangQueue = await _redis.SetList<MoOrderInfo>($"{EnumHelper.EmDataKey.QiangOrderEqueue.ToString()}_{orderInfo.ShoppingId}", orderInfo);

                #endregion
            }
            catch (Exception ex)
            {
                rp.RpMsg = "抢购活动正在高峰期，请稍后重试";
            }
            return rp;
        }

        [HttpPost]
        public async Task<MoOrderDetailRp> GetOrderDetail()
        {
            var rp = new MoOrderDetailRp();
            try
            {
                //获取请求参数
                var strRq = string.Empty;
                using (var stream = Request.Body)
                {
                    using (var reader = new StreamReader(stream))
                    {
                        strRq = await reader.ReadToEndAsync();
                    }
                }
                if (string.IsNullOrWhiteSpace(strRq)) { return rp; }

                var rq = JsonConvert.DeserializeObject<MoOrderDetailRq>(strRq);

                #region 验证

                #region 登录验证
                if (rq.MemberRq == null || string.IsNullOrWhiteSpace(rq.MemberRq.Token))
                {
                    rp.RpMsg = $"未登录，请登录后重试。";
                    return rp;
                }
                var sessionData = await _redis.Get<MoUserInfo>(rq.MemberRq.Token);
                if (sessionData == null)
                {
                    rp.RpMsg = $"登录失效，请重新登录！";
                    return rp;
                }
                #endregion

                if (rq.OrderId <= 0)
                {
                    rp.RpMsg = $"参数不正确！";
                    return rp;
                }
                #endregion

                var orderDetail = await _redis.GetHashField<MoOrderInfo>($"User_{sessionData.UserId}", rq.OrderId.ToString());
                if (orderDetail == null)
                {
                    rp.RpMsg = $"订单查询失败，无此订单！";
                    return rp;
                }

                rp.OrderId = orderDetail.OrderId;
                rp.Num = orderDetail.Num;
                rp.OrderStatus = orderDetail.OrderStatus;
                rp.PayOutTime = orderDetail.PayOutTime;
                rp.CreatTime = orderDetail.CreatTime;
                rp.ShoppingId = orderDetail.ShoppingId;

                var shop = await _redis.GetHashField<MoShopping>(EnumHelper.EmDataKey.ShoppingHash.ToString(), rp.ShoppingId.ToString());
                if (shop == null)
                {
                    rp.RpMsg = $"订单查询失败，请稍后重试！";
                    return rp;
                }
                rp.MoShopping = shop;
                rp.RpStatus = 1;
                rp.RpMsg = "订单查询成功";
            }
            catch (Exception ex)
            {
                rp.RpMsg = "查询超时，请稍后重试";
            }
            return rp;
        }
    }
}

控制台程序，监控订单队列
这里写图片描述

Program

using SeckillPro.Com.Model;
using SeckillPro.Com.Model.CrmModel;
using SeckillPro.Com.Tool;
using System;
using System.Text;
using System.Threading.Tasks;
using System.Linq;
using System.Diagnostics;
using System.Collections.Generic;

namespace SeckillPro.Server
{
    class Program
    {
        //redis引用
        private static StackRedis _redis = StackRedis.Current;
        //控制重复任务
        private static Dictionary<long, long> _dicTask = new Dictionary<long, long>();
        static void Main(string[] args)
        {
            Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
            Console.OutputEncoding = Encoding.GetEncoding("GB2312");

            try
            {
                Console.WriteLine("是否开启处理抢购队列（Y）：");
                Console.ReadLine();
                Console.WriteLine($"开启抢购任务监控中...");
                var shopsKey = EnumHelper.EmDataKey.ShoppingHash.ToString();
                while (true)
                {
                    //匹配出QiangOrderEqueue_xxx格式的抢单队列keys
                    var matchKey = $"{EnumHelper.EmDataKey.QiangOrderEqueue.ToString()}_*";
                    var matches = _redis.MatchKeys(matchKey).Result;
                    var matchLen = matches.Count;
                    if (matchLen <= 0) { continue; }

                    //根据key获取对应的商品，并加载对应的商品抢单任务处理
                    foreach (var item in matches)
                    {
                        var itemArr = item.Split('_');
                        if (itemArr.Length <= 1) { continue; }
                        var shopId = itemArr[1];
                        var shop = _redis.GetHashField<MoShopping>(shopsKey, shopId).Result;
                        if (shop == null || _dicTask.ContainsKey(shop.Id)) { continue; }

                        //加入排重任务dic
                        _dicTask.Add(shop.Id, shop.Id);

                        Task.Factory.StartNew(async b =>
                        {
                            var equeueShop = b as MoShopping;
                            var equeueKey = $"{EnumHelper.EmDataKey.QiangOrderEqueue.ToString()}_{equeueShop.Id}";
                            var sbTaskLog = new StringBuilder(string.Empty);
                            try
                            {
                                sbTaskLog.AppendFormat("商品【{0}-{1}】，开启抢购队列处理；", equeueShop.Name, equeueShop.Id);
                                Console.WriteLine(sbTaskLog);

                                //监控队列key是否存在
                                while (await _redis.KeyExists(equeueKey))
                                {
                                    //获取队列
                                    var qiangOrder = await _redis.GetListAndPop<MoOrderInfo>(equeueKey);
                                    if (qiangOrder == null) { continue; }

                                    //获取真实剩余库存
                                    var equShop = await _redis.GetHashField<MoShopping>(shopsKey, equeueShop.Id.ToString());
                                    if (equShop == null) { continue; }

                                    var sbLog = new StringBuilder(string.Empty);
                                    Stopwatch watch = new Stopwatch();
                                    watch.Start();
                                    try
                                    {
                                        #region 逻辑处理库存

                                        sbLog.AppendFormat("用户：{0}抢购商品【{1}-{4}】当前库存：{2}件，抢购数：{3}件，",
                                                                    qiangOrder.UserId,
                                                                    equShop.Name,
                                                                    equShop.MaxNum,
                                                                    qiangOrder.Num,
                                                                    equShop.Id);
                                        if (equShop.MaxNum <= 0)
                                        {
                                            //无库存，直接抢购失败
                                            qiangOrder.OrderStatus = (int)EnumHelper.EmOrderStatus.抢购失败;
                                        }
                                        else if (equShop.MaxNum < qiangOrder.Num)
                                        {
                                            //剩余库存小于抢购数量
                                            qiangOrder.OrderStatus = (int)EnumHelper.EmOrderStatus.抢购失败;
                                        }
                                        else if (equShop.MaxGouNum < qiangOrder.Num)
                                        {
                                            //最大允许抢购数量小于抢购申请数量
                                            qiangOrder.OrderStatus = (int)EnumHelper.EmOrderStatus.抢购失败;
                                        }
                                        else
                                        {
                                            //库存充足
                                            equShop.MaxNum = equShop.MaxNum - qiangOrder.Num;
                                            //扣除当前抢购数量后，更新库存
                                            var isOk = await _redis.SetOrUpdateHashsField<MoShopping>(shopsKey, equShop.Id.ToString(), equShop, false) > 0;
                                            if (!isOk)
                                            {
                                                qiangOrder.OrderStatus = (int)EnumHelper.EmOrderStatus.抢购失败;
                                            }
                                            else
                                            {
                                                qiangOrder.OrderStatus = (int)EnumHelper.EmOrderStatus.抢购成功;
                                            }
                                        }
                                        #endregion
                                    }
                                    catch (Exception ex)
                                    {
                                        sbLog.AppendFormat("异常信息：{0},", ex.Message);
                                    }
                                    finally
                                    {
                                        sbLog.AppendFormat("库存剩余：{0}件，抢购订单状态：{1}，",
                                            equeueShop.MaxNum,
                                            Enum.GetName(typeof(EnumHelper.EmOrderStatus), qiangOrder.OrderStatus));

                                        //更新当前订单抢购状态
                                        var isQiangOrder = await _redis.SetOrUpdateHashsField<MoOrderInfo>($"User_{qiangOrder.UserId}", qiangOrder.OrderId.ToString(), qiangOrder, false);
                                        watch.Stop();
                                        sbLog.AppendFormat("更新订单状态：{0}；处理总耗时：{1}ms。", isQiangOrder > 0, watch.ElapsedMilliseconds);
                                        Console.WriteLine(sbLog);
                                    }
                                }
                            }
                            catch (Exception ex)
                            {
                                sbTaskLog.AppendFormat("异常信息：{0}；", ex.Message);
                            }
                            finally
                            {
                                //任务结束时去掉排重任务dic记录
                                if (_dicTask.ContainsKey(equeueShop.Id)) { _dicTask.Remove(equeueShop.Id); }

                                sbTaskLog.Append("处理抢购订单队列结束。");
                                Console.WriteLine(sbTaskLog);
                            }
                        }, shop);
                        //Console.WriteLine($"商品【{shop.Name}-{shop.Id}】开启处理订单队列任务;");
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine("全局异常信息：" + ex.Message);
            }
            Console.WriteLine("温馨提示：按住任意键即可退出！");
            Console.ReadLine();
        }
    }
}

抢购成功
这里写图片描述

下载示例

.NET跨平台
关注
  • 0
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
.net core + redis 实用类库
11-06
封装了redis各种类： 1.redis连接 2.redis锁 3.各种构造方法 反正就是很实用 //在Redis中存储常用的5种数据类型：String,Hash,List,SetSorted set //这种方式要引用ServiceStack，ServiceStack.Interfaces，ServiceStack.ServiceInterface三个dll
秒杀活动，模拟，netcore开发，架构：mvc+webapi+console+redis
05-15
秒杀活动，模拟，netcore开发，架构：mvc+webapi+console+redis
NetCore/Net8下使用Redis的分布式锁实现秒杀功能
JuCheap
10-18 1009
使用Redis分布式锁在NET8中实现一个简单的商品秒杀功能
Redis基础之【3.Net Core对接Redis实现简单秒杀功能】
qq_33101689的博客
09-10 1657
Redis基础之【3.Net Core对接Redis实现简单秒杀功能】 一. 简单秒杀 二. 总结
netcore使用redis
最新发布
weixin_33560311的博客
07-05 18
使用NetCore和Redis实现流程 流程图 #render_6_2978899912-svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}#render_6_2978899912-svg .error-ico...
ASP.NET Core与Redis搭建一个简易分布式缓存
weixin_48967543的博客
03-17 409
​本文主要介绍了缓存的概念，以及如何在服务器内存中存储内容。今天的目标是利用IDistributedCache来做一些分布式缓存，这样我们就可以横向扩展我们的web应用程序。 在本教程中，我将使用Redis作为缓存。Redis是一个可靠的快速内存缓存，可以存储多种类型的对象。Redis正在被Twitter, Github, Instagram, Stackoverflow等巨头使用。 你可以在https://github.com/sahan91/DistributedCacheAspNetCoreRedi.
关于.net高并发商品秒杀方案（Redis+队列）
qq_34867171的博客
03-12 1936
四、Redis+队列：思路和服务器缓存+队列基本相同，使用Redis做缓存替代服务器缓存，Redis可以直接使用.net code进行管理也可安装RedisDesktopManager。 业务流程：接口触发-> 通过Redis获取库存和新增随机订单号->利用后台任务进行查询数据->新增订单\扣除库存 功能分析： Redis是单线程的,利用api自身的原子性，去除lock锁。Redis6.0支持多线程不在此次的讨论范围 数据可以持久化解决服务器异常容易导致缓存里的信息丢失 压力测试： 线
秒杀抢购SeckillPro(dotnetcore2.1+redis)
06-13
基于dotnetcore2.1跨平台抢购系统，包含web端、API、server端（处理抢购队列），可实现高并发抢购队列
asp.netCore+vue +SignalR
12-08
**ASP.NET Core + Vue + SignalR：实现实时通信的现代Web应用开发** 在现代Web应用开发中，实时通信已经成为不可或缺的功能，它使得用户能够实时接收到服务器端的数据更新，无需频繁刷新页面。...
.netcore秒杀活动，模拟
11-02
标题中的".netcore秒杀活动，模拟"指出我们要探讨的是使用.NET Core框架构建的一个秒杀系统，这是一种在短时间内处理大量用户请求的高并发场景。在电商或其他促销活动中，秒杀功能常常被用来吸引用户，因此系统的...
.NetCore+Consul+Ocelot服务网关和服务注册与发现
05-11
《.NetCore+Consul+Ocelot：构建服务网关和服务注册与发现的实践指南》 在微服务架构中，服务网关和服务注册与发现是至关重要的组件。本示例项目".NetCore+Consul+Ocelot服务网关和服务注册与发现"为我们提供了一种...
毕业设计：基于asp.netCore+EFCore+mysql+layui的CRM系统.zip
10-11
【标题】：“毕业设计：基于asp.netCore+EFCore+mysql+layui的CRM系统” 【描述】：“计算机毕设源码”通常是指学生在完成计算机科学或相关专业学业时，进行的一项综合性的项目，旨在应用所学理论知识解决实际问题...
.netcore + sqlSugar
11-14
《.NET Core与SqlSugar：数据库操作的高效组合》 在现代软件开发中，数据库管理是不可或缺的一部分。本文将深入探讨如何使用.NET Core框架结合SqlSugar库，进行高效的数据库操作，包括增、删、改、查等基本功能。...
.NetCore Redis使用及帮助类
你要明白，任何问题都不是孤立存在的，一定有人曾经遇到过，并且已经有更好的解决办法了，只是我还不知道。我不应该在黑暗中独自前行，去重新发明轮子，也许我的顿悟，只是别人的基本功！我应该要站在巨人的肩膀上，学习更成熟的经验和方法，然后再来解决这个问题
04-06 4866
上一篇讲解了Redis的搭建及ServiceStack.Redis 与 StackExchange.Reids的区别https://blog.csdn.net/qq_39569480/article/details/105249607 这篇文章遗我们来说下 StackExchange.Redis的使用及帮助类 首先在windows上安装redis 在上边连接中有教程 1.创建net co...
(更新时间)2021年6月3日 商城高并发秒杀系统(.NET Core版) 28-性能优化-Redis分布式缓存使用
热门推荐
时光隧道
06-03 5万+
一：相关依赖包 CSRedisCore 二：代码封装 /// <summary> /// ServiceCollection Redis扩展 /// </summary> public static class RedisServiceCollectionExtensions { /// <summary> /// 注册分布式Redis缓存 /// </summary> /// <typeparam name="con
秒杀抢购案例，基于 Redis 实现
一个热爱编程的大学僧
05-20 3901
第一个线程在操作后，数据库中的version变成了2，但是他自己满足version=1 ，所以没有问题，此时线程2执行，线程2 最后也需要加上条件version =1 ，但是现在由于线程1已经操作过了，vsersion 的值已经变为了 2；，那么假设在服务器A的tomcat内部，有两个线程，这两个线程由于使用的是同一份代码，那么他们的锁对象是同一个，是可以实现互斥的，但是如果现在是服务器B的tomcat内部，又有两个线程，但是他们的锁对象写的虽然和服务器A一样，但是锁对象却不是同一个，所以。
.NetCore使用Redis，StackExchange.Redis队列，发布与订阅，分布式锁的简单使用
kaixincheng2009的专栏
08-25 2185
https://www.cnblogs.com/Fengge518/p/13556182.html环境：之前一直是使用serverStack.Redis的客服端，今天来使用一下Stack...
【redis】Redis中的队列list实现秒杀活动抢购
天涯共明月的博客
10-26 1409
Redis中的队列list实现秒杀活动抢购 目录Redis中的队列list实现秒杀活动抢购1. 引入redis客户端maven依赖2. 定义抢购商品实体类3. 定义模拟用户抢购线程类4. 实现秒杀抢购活动主类5. 秒杀抢购活动结果 redis中的数据结构list中 rpush | lpop | lpush | rpop 实现队列的先进先出的特性 lpush：左边入队列，存入秒杀活动的商品 rpop：右边出队列，获取抢到的商品 1. 引入redis客户端maven依赖 <!-- java
使用netcore 3.1实现简单的商品秒杀活动(一)
Jonny的博客
03-03 1340
文章目录1、说明2、接口3、模拟器 1、说明 该项目用于简单的模拟尝试，后期完善实际的秒杀活动，将逻辑做到更深更密。 2、接口 接口也只是简单简单的在内存中插入商品，实际要考虑写入Redis [Route("api/[controller]/[action]")] [ApiController] public class OrderController : ControllerB...
.netcore redis出现连接不够用的情况
04-26
出现连接不够用的情况通常是由于Redis连接池中的连接数量不足而造成的。这时可以考虑调整连接池的配置，增加连接池的最大连接数，例如通过配置maxpoolsize参数实现。同时，也要注意在使用完Redis连接后及时释放连接...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值