ASP.NET MVC5 频率控制Filter

最新推荐文章于 2024-06-03 17:41:07 发布
最新推荐文章于 2024-06-03 17:41:07 发布
阅读量2.3k 收藏 2
点赞数 1
分类专栏： ASP.NET MVC4|MVC5 文章标签： asp.net filter mvc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/WuLex/article/details/77744204
版权

类库项目类图:

这里写图片描述

核心类:

ThrottlingFilter.cs

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Net;
using System.Text;
using System.Threading.Tasks;
using System.Web;
using System.Web.Mvc;
using System.Web.Routing;

namespace MvcThrottle
{
    public class ThrottlingFilter : ActionFilterAttribute, IActionFilter
    {
        /// <summary>
        ///创建一个新的实例<see cref="ThrottlingHandler"/> 类.
        /// 默认情况下，<see cref="QuotaExceededResponseCode"/> 属性设置为429（太多请求）.
        /// </summary>
        public ThrottlingFilter()
        {
            QuotaExceededResponseCode = (HttpStatusCode)429;
            Repository = new CacheRepository();
            IpAddressParser = new IpAddressParser();
        }

        /// <summary>
        /// 频率速率限制策略
        /// </summary>
        public ThrottlePolicy Policy { get; set; }

        /// <summary>
        ///频率指标存储
        /// </summary>
        public IThrottleRepository Repository { get; set; }

        /// <summary>
        ///记录阻塞的请求
        /// </summary>
        public IThrottleLogger Logger { get; set; }

        /// <summary>
        ///如果没有指定，默认值为：HTTP请求超出配额！每{1}最多允许{0}
        /// </summary>
        public string QuotaExceededMessage { get; set; }

        /// <summary>
        /// 获取或设置值作为HTTP状态代码返回，因为由于限制策略拒绝请求。 默认值为429（太多请求）。
        /// </summary>
        public HttpStatusCode QuotaExceededResponseCode { get; set; }

        public IIpAddressParser IpAddressParser { get; set; }

        public override void OnActionExecuting(ActionExecutingContext filterContext)
        {
            EnableThrottlingAttribute attrPolicy = null;
            var applyThrottling = ApplyThrottling(filterContext, out attrPolicy);

            if (Policy != null && applyThrottling)
            {
                var identity = SetIdentity(filterContext.HttpContext.Request);

                if (!IsWhitelisted(identity))
                {
                    TimeSpan timeSpan = TimeSpan.FromSeconds(1);

                    var rates = Policy.Rates.AsEnumerable();
                    if (Policy.StackBlockedRequests)
                    {
                        //所有请求（包括拒绝的请求）将按照以下顺序进行堆叠：天，时，分，秒,如果客户端遇到小时限制，则分钟和秒计数器将会过期并最终从缓存中擦除
                        rates = Policy.Rates.Reverse();
                    }

                    //应用策略
                    //最后应用IP规则，并覆盖您可能定义的任何客户端规则
                    foreach (var rate in rates)
                    {
                        var rateLimitPeriod = rate.Key;
                        var rateLimit = rate.Value;

                        switch (rateLimitPeriod)
                        {
                            case RateLimitPeriod.Second:
                                timeSpan = TimeSpan.FromSeconds(1);
                                break;
                            case RateLimitPeriod.Minute:
                                timeSpan = TimeSpan.FromMinutes(1);
                                break;
                            case RateLimitPeriod.Hour:
                                timeSpan = TimeSpan.FromHours(1);
                                break;
                            case RateLimitPeriod.Day:
                                timeSpan = TimeSpan.FromDays(1);
                                break;
                            case RateLimitPeriod.Week:
                                timeSpan = TimeSpan.FromDays(7);
                                break;
                        }

                        //增量计数器
                        string requestId;
                        var throttleCounter = ProcessRequest(identity, timeSpan, rateLimitPeriod, out requestId);

                        if (throttleCounter.Timestamp + timeSpan < DateTime.UtcNow)
                            continue;

                        //应用EnableThrottlingAttribute策略
                        var attrLimit = attrPolicy.GetLimit(rateLimitPeriod);
                        if (attrLimit > 0)
                        {
                            rateLimit = attrLimit;
                        }

                        //应用终点速率限制
                        if (Policy.EndpointRules != null)
                        {
                            var rules = Policy.EndpointRules.Where(x => identity.Endpoint.IndexOf(x.Key, 0, StringComparison.InvariantCultureIgnoreCase) != -1).ToList();
                            if (rules.Any())
                            {
                                //从所有应用规则获得下限
                                var customRate = (from r in rules let rateValue = r.Value.GetLimit(rateLimitPeriod) select rateValue).Min();

                                if (customRate > 0)
                                {
                                    rateLimit = customRate;
                                }
                            }
                        }


                        //应用自定义速率限制会覆盖客户端端点限制
                        if (Policy.ClientRules != null && Policy.ClientRules.Keys.Contains(identity.ClientKey))
                        {
                            var limit = Policy.ClientRules[identity.ClientKey].GetLimit(rateLimitPeriod);
                            if (limit > 0) rateLimit = limit;
                        }

                        //应用user agent的自定义速率限制
                        if (Policy.UserAgentRules != null && !string.IsNullOrEmpty(identity.UserAgent))
                        {
                            var rules = Policy.UserAgentRules.Where(x => identity.UserAgent.IndexOf(x.Key, 0, StringComparison.InvariantCultureIgnoreCase) != -1).ToList();
                            if (rules.Any())
                            {

                                //从所有应用规则获得下限
                                var customRate = (from r in rules let rateValue = r.Value.GetLimit(rateLimitPeriod) select rateValue).Min();
                                rateLimit = customRate;
                            }
                        }

                        //执行最大限度的IP 速率限制
                        string ipRule = null;
                        if (Policy.IpRules != null && IpAddressParser.ContainsIp(Policy.IpRules.Keys.ToList(), identity.ClientIp, out ipRule))
                        {
                            var limit = Policy.IpRules[ipRule].GetLimit(rateLimitPeriod);
                            if (limit > 0) rateLimit = limit;
                        }

                        //检查是否达到限制
                        if (rateLimit > 0 && throttleCounter.TotalRequests > rateLimit)
                        {
                            //日志记录阻塞请求
                            if (Logger != null) Logger.Log(ComputeLogEntry(requestId, identity, throttleCounter, rateLimitPeriod.ToString(), rateLimit, filterContext.HttpContext.Request));

                            //跳出执行并返回409
                            var message = string.IsNullOrEmpty(QuotaExceededMessage) ?
                                "HTTP请求配额超出！每{1}最多允许{0}次" : QuotaExceededMessage;

                            //添加状态代码，并在x秒后重试以进行响应
                            filterContext.HttpContext.Response.StatusCode = (int)QuotaExceededResponseCode;
                            filterContext.HttpContext.Response.Headers.Set("Retry-After", RetryAfterFrom(throttleCounter.Timestamp, rateLimitPeriod));

                            filterContext.Result = QuotaExceededResult(
                                filterContext.RequestContext,
                                string.Format(message, rateLimit, rateLimitPeriod),
                                QuotaExceededResponseCode,
                                requestId);

                            return;
                        }
                    }
                }
            }

            base.OnActionExecuting(filterContext);
        }

        protected virtual RequestIdentity SetIdentity(HttpRequestBase request)
        {
            var entry = new RequestIdentity();
            entry.ClientIp = IpAddressParser.GetClientIp(request).ToString();

            entry.ClientKey = request.IsAuthenticated ? "auth" : "anon";

            var rd = request.RequestContext.RouteData;
            string currentAction = rd.GetRequiredString("action");
            string currentController = rd.GetRequiredString("controller");

            switch (Policy.EndpointType)
            {
                case EndpointThrottlingType.AbsolutePath:
                    entry.Endpoint = request.Url.AbsolutePath;
                    break;
                case EndpointThrottlingType.PathAndQuery:
                    entry.Endpoint = request.Url.PathAndQuery;
                    break;
                case EndpointThrottlingType.ControllerAndAction:
                    entry.Endpoint = currentController + "/" + currentAction;
                    break;
                case EndpointThrottlingType.Controller:
                    entry.Endpoint = currentController;
                    break;
                default:
                    break;
            }

            //不区分路由大小写
            entry.Endpoint = entry.Endpoint.ToLowerInvariant();

            entry.UserAgent = request.UserAgent;

            return entry;
        }

        static readonly object _processLocker = new object();
        private ThrottleCounter ProcessRequest(RequestIdentity requestIdentity, TimeSpan timeSpan, RateLimitPeriod period, out string id)
        {
            var throttleCounter = new ThrottleCounter()
            {
                Timestamp = DateTime.UtcNow,
                TotalRequests = 1
            };

            id = ComputeThrottleKey(requestIdentity, period);

            //串行读写
            lock (_processLocker)
            {
                var entry = Repository.FirstOrDefault(id);
                if (entry.HasValue)
                {
                    //条目尚未过期
                    if (entry.Value.Timestamp + timeSpan >= DateTime.UtcNow)
                    {
                        //递增请求计数
                        var totalRequests = entry.Value.TotalRequests + 1;

                        //深拷贝
                        throttleCounter = new ThrottleCounter
                        {
                            Timestamp = entry.Value.Timestamp,
                            TotalRequests = totalRequests
                        };

                    }
                }

                //存储: id (string) - timestamp (datetime) - total (long)
                Repository.Save(id, throttleCounter, timeSpan);
            }

            return throttleCounter;
        }

        protected virtual string ComputeThrottleKey(RequestIdentity requestIdentity, RateLimitPeriod period)
        {
            var keyValues = new List<string>()
                {
                    "throttle"
                };

            if (Policy.IpThrottling)
                keyValues.Add(requestIdentity.ClientIp);

            if (Policy.ClientThrottling)
                keyValues.Add(requestIdentity.ClientKey);

            if (Policy.EndpointThrottling)
                keyValues.Add(requestIdentity.Endpoint);

            if (Policy.UserAgentThrottling)
                keyValues.Add(requestIdentity.UserAgent);

            keyValues.Add(period.ToString());

            var id = string.Join("_", keyValues);
            var idBytes = Encoding.UTF8.GetBytes(id);
            var hashBytes = new System.Security.Cryptography.SHA1Managed().ComputeHash(idBytes);
            var hex = BitConverter.ToString(hashBytes).Replace("-", "");
            return hex;
        }

        private string RetryAfterFrom(DateTime timestamp, RateLimitPeriod period)
        {
            var secondsPast = Convert.ToInt32((DateTime.UtcNow - timestamp).TotalSeconds);
            var retryAfter = 1;
            switch (period)
            {
                case RateLimitPeriod.Minute:
                    retryAfter = 60;
                    break;
                case RateLimitPeriod.Hour:
                    retryAfter = 60 * 60;
                    break;
                case RateLimitPeriod.Day:
                    retryAfter = 60 * 60 * 24;
                    break;
                case RateLimitPeriod.Week:
                    retryAfter = 60 * 60 * 24 * 7;
                    break;
            }
            retryAfter = retryAfter > 1 ? retryAfter - secondsPast : 1;
            return retryAfter.ToString(CultureInfo.InvariantCulture);
        }

        private bool IsWhitelisted(RequestIdentity requestIdentity)
        {
            if (Policy.IpThrottling)
                if (Policy.IpWhitelist != null && IpAddressParser.ContainsIp(Policy.IpWhitelist, requestIdentity.ClientIp))
                    return true;

            if (Policy.ClientThrottling)
                if (Policy.ClientWhitelist != null && Policy.ClientWhitelist.Contains(requestIdentity.ClientKey))
                    return true;

            if (Policy.EndpointThrottling)
                if (Policy.EndpointWhitelist != null && 
                    Policy.EndpointWhitelist.Any(x => requestIdentity.Endpoint.IndexOf(x, 0, StringComparison.InvariantCultureIgnoreCase) != -1))
                    return true;

            if (Policy.UserAgentThrottling && requestIdentity.UserAgent != null)
                if (Policy.UserAgentWhitelist != null && 
                    Policy.UserAgentWhitelist.Any(x => requestIdentity.UserAgent.IndexOf(x, 0, StringComparison.InvariantCultureIgnoreCase) != -1))
                    return true;

            return false;
        }

        private bool ApplyThrottling(ActionExecutingContext filterContext, out EnableThrottlingAttribute attr)
        {
            var applyThrottling = false;
            attr = null;

            if (filterContext.ActionDescriptor.ControllerDescriptor.IsDefined(typeof(EnableThrottlingAttribute), true))
            {
                attr = (EnableThrottlingAttribute)filterContext.ActionDescriptor.ControllerDescriptor.GetCustomAttributes(typeof(EnableThrottlingAttribute), true).First();
                applyThrottling = true;
            }

            //在类上 禁用属性
            if (filterContext.ActionDescriptor.ControllerDescriptor.IsDefined(typeof(DisableThrottlingAttribute), true))
            {
                applyThrottling = false;
            }

            if (filterContext.ActionDescriptor.IsDefined(typeof(EnableThrottlingAttribute), true))
            {
                attr = (EnableThrottlingAttribute)filterContext.ActionDescriptor.GetCustomAttributes(typeof(EnableThrottlingAttribute), true).First();
                applyThrottling = true;
            }

            //显式禁用
            if (filterContext.ActionDescriptor.IsDefined(typeof(DisableThrottlingAttribute), true))
            {
                applyThrottling = false;
            }

            return applyThrottling;
        }

        protected virtual ActionResult QuotaExceededResult(RequestContext filterContext, string message, HttpStatusCode responseCode, string requestId)
        {
            return new HttpStatusCodeResult(responseCode, message);
        }

        private ThrottleLogEntry ComputeLogEntry(string requestId, RequestIdentity identity, ThrottleCounter throttleCounter, string rateLimitPeriod, long rateLimit, HttpRequestBase request)
        {
            return new ThrottleLogEntry
            {
                ClientIp = identity.ClientIp,
                ClientKey = identity.ClientKey,
                Endpoint = identity.Endpoint,
                UserAgent = identity.UserAgent,
                LogDate = DateTime.UtcNow,
                RateLimit = rateLimit,
                RateLimitPeriod = rateLimitPeriod,
                RequestId = requestId,
                StartPeriod = throttleCounter.Timestamp,
                TotalRequests = throttleCounter.TotalRequests,
                Request = request
            };
        }
    }
}

Mvc项目

BaseController.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;

namespace Demo.Controllers
{
    [EnableThrottling]
    public class BaseController : Controller
    {

    }
}

BlogController.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;

namespace Demo.Controllers
{
    [DisableThrottling]
    public class BlogController : BaseController
    {
        public ActionResult Index()
        {
            ViewBag.Message = "博客没有限制.";

            return View();
        }

        [EnableThrottling(PerSecond = 2, PerMinute = 5)]
        public ActionResult Search()
        {
            ViewBag.Message = "搜索被限制.";

            return View();
        }
    }
}

HomeController.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;

namespace Demo.Controllers
{
    public class HomeController : BaseController
    {
        public ActionResult Index()
        {
            return View();
        }

        [EnableThrottling(PerSecond = 2, PerMinute = 5)]
        public ActionResult About()
        {
            ViewBag.Message = "你的应用描述页.";

            return View();
        }

        [DisableThrottling]
        public ActionResult Contact()
        {
            ViewBag.Message = "你的联系页.";

            return View();
        }
    }
}

Helpers文件夹:

MvcThrottleCustomFilter.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;
using System.Web.Routing;

namespace Demo.Helpers
{
    public class MvcThrottleCustomFilter : ThrottlingFilter
    {
        protected override ActionResult QuotaExceededResult(RequestContext filterContext, string message, System.Net.HttpStatusCode responseCode, string requestId)
        {
            var rateLimitedView = new ViewResult
            {
                ViewName = "RateLimited"
            };
            rateLimitedView.ViewData["Message"] = message;

            return rateLimitedView;
        }
    }
}

NginxIpAddressParser.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

namespace Demo.Helpers
{
    public class NginxIpAddressParser : IpAddressParser
    {
        public override string GetClientIp(HttpRequestBase request)
        {
            var ipAddress = request.UserHostAddress;

            //从反向代理获取客户端IP
            //如果客户端使用了代理服务器，则利用HTTP_X_FORWARDED_FOR找到客户端IP地址
            var xForwardedFor = request.ServerVariables["HTTP_X_FORWARDED_FOR"];
            if (!string.IsNullOrEmpty(xForwardedFor))
            {
                // 搜索公共IP地址
                var publicForwardingIps = xForwardedFor.Split(',').Where(ip => !IsPrivateIpAddress(ip)).ToList();

                // 如果发现任何公共IP，则使用NGINX时返回第一个IP地址，否则返回用户主机地址
                return publicForwardingIps.Any() ? publicForwardingIps.First().Trim() : ipAddress;
            }

            return ipAddress;
        }
    }
}

FilterConfig.cs

using MvcThrottle.Demo.Helpers;
using System.Collections.Generic;
using System.Web;
using System.Web.Mvc;

namespace Demo
{
    public class FilterConfig
    {
        public static void RegisterGlobalFilters(GlobalFilterCollection filters)
        {
            filters.Add(new HandleErrorAttribute());

            var throttleFilter = new MvcThrottleCustomFilter
            {
                Policy = new MvcThrottle.ThrottlePolicy(perSecond: 2, perMinute: 10, perHour: 60 * 10, perDay: 600 * 10)
                {
                    //IPs范围
                    IpThrottling = true,
                    IpRules = new Dictionary<string, MvcThrottle.RateLimits>
                    { 
                        { "::1/10", new MvcThrottle.RateLimits { PerHour = 15 } },
                        { "192.168.2.1", new MvcThrottle.RateLimits { PerMinute = 30, PerHour = 30*60, PerDay = 30*60*24 } }
                    },
                    IpWhitelist = new List<string> 
                    {
                        //localhost
                        // "::1",
                        "127.0.0.1",
                        //局域网
                        "192.168.0.0 - 192.168.255.255",
                        //Googlebot 谷歌的网页抓取机器人，类似于中国的Baiduspider（百度蜘蛛）
                        //更新自 http://iplists.com/nw/google.txt                    
                        "64.68.1 - 64.68.255",
                        "64.68.0.1 - 64.68.255.255",
                        "64.233.0.1 - 64.233.255.255",
                        "66.249.1 - 66.249.255",
                        "66.249.0.1 - 66.249.255.255",                        
                        "209.85.0.1 - 209.85.255.255",
                        "209.185.1 - 209.185.255",
                        "216.239.1 - 216.239.255",
                        "216.239.0.1 - 216.239.255.255",
                        //Bingbot                 
                        "65.54.0.1 - 65.54.255.255",
                        "68.54.1 - 68.55.255",
                        "131.107.0.1 - 131.107.255.255",
                        "157.55.0.1 - 157.55.255.255",
                        "202.96.0.1 - 202.96.255.255",
                        "204.95.0.1 - 204.95.255.255",
                        "207.68.1 - 207.68.255",
                        "207.68.0.1 - 207.68.255.255",
                        "219.142.0.1 - 219.142.255.255",
                        //Yahoo - 更新自http://user-agent-string.info/list-of-ua/bot-detail?bot=Yahoo!
                        "67.195.0.1 - 67.195.255.255",
                        "72.30.0.1 - 72.30.255.255",
                        "74.6.0.1 - 74.6.255.255",
                        "98.137.0.1 - 98.137.255.255",
                        //Yandex - 更新自 http://user-agent-string.info/list-of-ua/bot-detail?bot=YandexBot
                        //Yandex在俄罗斯本地搜索引擎的市场份额已远超俄罗斯Google
                        "100.43.0.1 - 100.43.255.255",
                        "178.154.0.1 - 178.154.255.255",
                        "199.21.0.1 - 199.21.255.255",
                        "37.140.0.1 - 37.140.255.255",
                        "5.255.0.1 - 5.255.255.255",
                        "77.88.0.1 - 77.88.255.255",
                        "87.250.0.1 - 87.250.255.255",
                        "93.158.0.1 - 93.158.255.255",
                        "95.108.0.1 - 95.108.255.255",
                    },

                    //客户端范围
                    ClientThrottling = true,
                    //白名单认证客户端
                    ClientWhitelist = new List<string> { "auth" },

                    //请求路径范围
                    EndpointThrottling = true,
                    EndpointType = EndpointThrottlingType.AbsolutePath,
                    EndpointRules = new Dictionary<string, RateLimits>
                    { 
                        { "home/", new RateLimits { PerHour = 90 } },
                        { "Home/about", new RateLimits { PerHour = 30 } }
                    },

                    //用户代理范围
                    UserAgentThrottling = true,
                    UserAgentWhitelist = new List<string>
                    {
                        "Googlebot",
                        "Mediapartners-Google",
                        "AdsBot-Google",
                        "Bingbot",
                        "YandexBot",
                        "DuckDuckBot"
                    },
                    UserAgentRules = new Dictionary<string, RateLimits>
                    {
                        {"Facebot", new RateLimits { PerMinute = 1 }},
                        {"Sogou", new RateLimits { PerHour = 1 } }
                    }

                },
                IpAddressParser = new NginxIpAddressParser(),
                Logger = new MvcThrottleCustomLogger()
            };

            filters.Add(throttleFilter);
        }
    }
}

Blog视图文件夹

Index.cshtml

@{
    ViewBag.Title = "Index";
}
<h2>@ViewBag.Title.</h2>
<h3>@ViewBag.Message</h3>

<p>但 @Html.ActionLink("search", "Search") 是被限制了.</p>

<p>使用此区域提供其他信息.</p>

Search.cshtml

@{
    ViewBag.Title = "Search";
}
<h2>@ViewBag.Title.</h2>
<h3>@ViewBag.Message</h3>

<p>但 @Html.ActionLink("blog", "Index") 没有限制.</p>

<p>使用此区域提供其他信息.</p>

Home视图文件夹

Index.cshtml

@{
    ViewBag.Title = "Home Page";
}

<div class="jumbotron">
    <h1>ASP.NET MVC频率筛选器</h1>
    <p class="lead">重新加载这个页面几次看到MvcThrottle在action.</p>
    <p><a href="@Url.Action("Index","Home")" class="btn btn-primary btn-large">Reload &raquo;</a></p>
</div>

运行结果

这里写图片描述

如果在1秒内按F5刷新浏览器首页超过2次
这里写图片描述

如果在1分钟内按F5刷新浏览器首页超过10次
这里写图片描述

如果在1分小时内按F5刷新浏览器首页超过15次
这里写图片描述

Blog视图Index页没被限制
这里写图片描述

Blog视图Search页被限制
这里写图片描述

风神.NET跨平台
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
mvc控制ip访问次数的demo
08-22
这是一个可以控制同一ip在特定时间里访问某一页面次数的demo，可以限制每秒每分钟每小时每天的次数，防止一般的攻击
ASP.NET MVC5
06-22
5. **过滤器**：过滤器是ASP.NET MVC5中的一种可重用组件，可以应用于控制器或动作，用于执行如授权、日志记录、异常处理等任务。 6. **Bundling和Minification**：这些功能用于合并和压缩CSS和JavaScript文件，...
filter全局控制重复提交
天道酬勤
01-24 235
采用filter来全局控制重复提交   filter拦截需要控制重复提交的页面 filter中获取该页面的所有参数值 将参数值字符串进行计算hash值存入session，或者数据库中，保存最近一次操作的hash值   获取session中最近的hash值和本次获取参数值计算所得的hash值对比，，相同则为重复提交，不同则放行   @Override public void do...
速率限制中间件AspNetCoreRateLimit
最新发布
A_nanda的博客
06-03 996
如果客户端每秒发出 3 个请求，并且您设置了每秒 个呼叫的限制，则其他限制（如每分钟或每天计数器）将仅记录第一个呼叫，即未被阻止的呼叫。如果设置为 ，则限制将应用于每个端点，如 中所示。例如，如果设置为每秒 5 次调用的限制，则客户端可以每秒调用 5 次，但也可以调用 5 次。当您的 Kestrel 服务器位于反向代理后面时，用于提取客户端 IP，如果您的代理使用不同的标头，则使用此选项进行设置。在常规规则中搜索匹配项，如果匹配的常规规则具有 IP 规则中不存在的已定义时间段，则也会使用此常规规则。
ASP.NET MVC5（热访问控制） 控制同一用户IP一段时间内对控制器的访问次数
Denny辉的博客
07-09 1168
有时候，当用户请求一个Controller下的Action，我们希望，在单位时间间隔内，比如每秒，每分钟，每小时，每天，每星期，限制同一个IP地址对某个Action的请求次数。如何做呢？ stefanprodan的MvcThrottle能很好地解决这个问题，以及其它类型的IP限制问题。在这里：https://github.com/stefanprodan/MvcThrottle 把项目从GitH...
【.NET】WebApiThrottle限流框架(14)——用ThrottlingFilter、EnableThrottlingAttribute特性配置限制频率
u013938578的博客
10-06 1367
EnableThrottling与ThrottlingHandler是一个二选一的策略配置方案，二者会做同样的事情，但ThrottlingHandler可以通过EnableThrottlingAttribute特性指定某个webapi的controllers和actions去自定义频率限制。需要注意的是，在webapi请求管道中，ThrottlingHandler是在controller前面执行，...
WebApi接口访问频率控制的实现
a422821906的博客
04-19 674
关于限流的文章，博客园内还是有挺多的。本文做了一个基于Filter限流的例子，算是对WebApiThrottle使用的一个具体的实例。 实现方法： 1、使用Nuget，对WebAPI项目添加WebApiThrottle的引用 2、进行注册，一般是在WebApiConfig的Register方法里添加，代码如下： 1 config.Filters.Add(ne...
ASP.NET MVC5 编程实战.pdf
10-30
ASP.NET MVC5 是微软开发的一款用于构建Web应用程序的框架，它结合了模型-视图-控制器（MVC）设计模式、ASP.NET Web Forms组件以及Web API功能，为开发者提供了更灵活、可测试的Web开发解决方案。这本书《ASP.NET ...
ASP.NET MVC5 入门 之登录验证
07-31
ASP.NET MVC5 是微软开发的一款用于构建动态网站的框架，它结合了模型-视图-控制器（MVC）设计模式，使开发者能够更高效地构建可维护和测试的Web应用程序。在本入门教程中，我们将重点探讨如何在ASP.NET MVC5中实现...
ASP.NET MVC项目源代码设计资料
06-08
5. **依赖注入（Dependency Injection, DI）**：ASP.NET MVC支持DI，这是一种设计模式，用于减少代码间的耦合。通过DI，可以在运行时动态地将依赖项注入到控制器和其他组件，提高代码的可测试性和可维护性。 6. **...
asp.net mvc5源码下载.rar
01-03
ASP.NET MVC5是一个开源的Web应用程序框架，由微软开发，用于构建动态、数据驱动的Web应用。这个框架基于模型-视图-控制器（MVC）设计模式，它为开发者提供了强大的设计工具，使得构建可测试、可维护的Web应用变得...
在ASP.NET MVC下限制同一个IP地址单位时间间隔内的请求次数
weixin_34088838的博客
01-08 881
有时候，当用户请求一个Controller下的Action，我们希望，在单位时间间隔内，比如每秒，每分钟，每小时，每天，每星期，限制同一个IP地址对某个Action的请求次数。如何做呢？   stefanprodan的MvcThrottle能很好地解决这个问题，以及其它类型的IP限制问题。在这里：https://github.com/stefanprodan/MvcThrottle 把项目从G...
asp.netcore web api访问限制AspNetCoreRateLimit
飞鸟慕鱼的博客
04-30 3164
网上很多介绍都是一样的，如下。可以先看这个 https://www.jianshu.com/p/7c52ab7eb73f 本人想自定义返回信息，需要重写IpRateLimitMiddleware.ReturnQuotaExceededResponse 从github上下载了源码https://github.com/stefanprodan/AspNetCoreRateLimit 在M...
.Net Core 限流控制-AspNetCoreRateLimit
dotNET跨平台
04-21 1274
简介AspNetCoreRateLimit是ASP.NET核心速率限制框架，能够对WebApi，Mvc中控制限流，AspNetCoreRateLimit包包含IpRateLimit中间件和ClientRateLimit中间件，每个中间件都可以为不同的场景设置多个限，该框架的作者是stefanprodan，项目nuget地址是https://github.com/stefa...
.net mvc、api等入参限制特性
Panda的专栏
09-04 994
一、Required 　　　　必填选项，当提交的表单缺少该值就引发验证错误。 二、StringLength 　　　　指定允许的长度 　　　　指定最大长度： 　　[StringLength(20)]　　//最大长度不超过20个字符 　　　　指定最短于最长限制： 　　[StringLength(20,MinimumLength=3)]　　//最大长度不超过20个字符，最短不能低于3个字符...
WebApiThrottle限流框架使用手册
weixin_34050519的博客
07-21 230
阅读目录： 介绍 基于IP全局限流 基于IP的端点限流 基于IP和客户端key的端点限流 IP和客户端key的白名单 IP和客户端key自定义限制频率 端点自定义限制频率 关于被拒请求的计数器 在web.config或app.config中定义限制策略 获取API的客户端key 存储限流的数据 运行期间更新限制频率 限流的请求日志 用ThrottlingFilter...
前后端分离开发 使用throttle 限制api的访问速率
pzl_pzl的博客
07-18 1287
根据官网 的做法 REST_FRAMEWORK = { 'DEFAULT_AUTHENTICATION_CLASSES': ( 'rest_framework.authentication.BasicAuthentication', 'rest_framework.authentication.SessionAuthentication', ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值