1.背景
昨天看了关于一篇 api 限流的文章，ASP.NET Core WebApi接口限流，作者给出了demo，写的很好，但是我看了一遍，api限流用actionfilterattribute，觉得很奇怪，难道说每次都是用的同一个filter。思考一番觉得自己还是写个demo验证以下，顺便看看源码是如何实现的，
2.demo
public class MyActionfilterAttribute:ActionFilterAttribute
{
private int a;
public MyActionfilterAttribute()
{
a = 50;
}
public override Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
{
Console.WriteLine($"begin");
++a;
Console.WriteLine(a.ToString()) ;
Console.WriteLine("end");
return base.OnActionExecutionAsync(context, next);
}
}
调试连续点击多次 出现如下结果，果然是同一个filter。看来确实是可以用actionfilter进行请求限制。
3.源码探究
感觉到奇怪的我转手就去看源码了，不对首先先搜一下有没有相关的文章，找到了一篇https://www.cnblogs.com/xiaoxiaotank/p/15622083.html 详细介绍了filters。点赞。
我的上一篇文章探究了以下controller在什么时侯被构建的，同时什么使用调用filter过滤器管道，其中就有如何获取filter，所以接着继续薅就是了。
ControllerActionInvokerCache
public (ControllerActionInvokerCacheEntry cacheEntry, IFilterMetadata[] filters) GetCachedResult(ControllerContext controllerContext)
{
// We don't care about thread safety here
if (cacheEntry is null)
{
var filterFactoryResult = FilterFactory.GetAllFilters(_filterProviders, controllerContext);
filters = filterFactoryResult.Filters;
//省略若干代码
}
else
{
// Filter instances from statically defined filter descriptors + from filter providers
filters = FilterFactory.CreateUncachedFilters(_filterProviders, controllerContext, cacheEntry.CachedFilters);
}
return (cacheEntry, filters);
}
逻辑比较简单，如果没有缓存那么就获取所有的filters，如果有缓存那么就创建没有缓存的filters。
FilterFactory
public static FilterFactoryResult GetAllFilters(
IFilterProvider[] filterProviders,
ActionContext actionContext)
{
var actionDescriptor = actionContext.ActionDescriptor;
var staticFilterItems = new FilterItem[actionDescriptor.FilterDescriptors.Count];
var orderedFilters = actionDescriptor.FilterDescriptors
.OrderBy(
filter => filter,
FilterDescriptorOrderComparer.Comparer)
.ToList();
for (var i = 0; i < orderedFilters.Count; i++)
{
staticFilterItems[i] = new FilterItem(orderedFilters[i]);
}
var allFilterItems = new List<FilterItem>(staticFilterItems);
// 由filter factory 决定哪个filter可以被缓存
// Execute the filter factory to determine which static filters can be cached.
var filters = CreateUncachedFiltersCore(filterProviders, actionContext, allFilterItems);
// Cache the filter items based on the following criteria
// 1. Are created statically (ex: via filter attributes, added to global filter list etc.) 2. Are re-usable
//缓存filter基于以下几点 : 首先静态生成 其次能够被重复使用
var allFiltersAreReusable = true;
for (var i = 0; i < staticFilterItems.Length; i++)
{
var item = staticFilterItems[i];
if (!item.IsReusable)
{
item.Filter = null;
allFiltersAreReusable = false;
}
}
if (allFiltersAreReusable && filterProviders.Length == 1 && filterProviders[0] is DefaultFilterProvider defaultFilterProvider)
{
// If we know we can safely cache all filters and only the default filter provider is registered, we can probably re-use filters between requests.
//如果我们知道我们能够安全的缓存这些filters,然后只有默认的filter providerb被注册，那么我们大 概可以在请求中重复使用这些过滤器
actionDescriptor.CachedReusableFilters = filters;
}
return new FilterFactoryResult(staticFilterItems, filters);
}
看到官方的注释确实我们是重复使用这些 filter的，应该是为了提高提高效率
主要的逻辑是 filterprovider来创建filter,然后我们拿到filter，有个属性为 IsReuable决定了我们是否可以重用这个filter
FilterFactory
private static IFilterMetadata[] CreateUncachedFiltersCore(
IFilterProvider[] filterProviders,
ActionContext actionContext,
List<FilterItem> filterItems)
{
// Execute providers
var context = new FilterProviderContext(actionContext, filterItems);
for (var i = 0; i < filterProviders.Length; i++)
{
filterProviders[i].OnProvidersExecuting(context);
}
for (var i = filterProviders.Length - 1; i >= 0; i--)
{
filterProviders[i].OnProvidersExecuted(context);
}
// Extract filter instances from statically defined filters and filter providers
//删除一些代码
var filters = new IFilterMetadata[count];
var filterIndex = 0;
for (int i = 0; i < filterItems.Count; i++)
{
var filter = filterItems[i].Filter;
if (filter != null)
{
filters[filterIndex++] = filter;
}
}
return filters;
}
进去看看 onprovidersexecuting方法 看就怎么产生的filters,默认的实现是
DefaultFilterProvider
public void OnProvidersExecuting(FilterProviderContext context)
{
if (context.ActionContext.ActionDescriptor.FilterDescriptors != null)
{
var results = context.Results;
// Perf: Avoid allocating enumerator and read interface .Count once rather than per iteration
var resultsCount = results.Count;
for (var i = 0; i < resultsCount; i++)
{
ProvideFilter(context, results[i]);
}
}
}
public void ProvideFilter(FilterProviderContext context, FilterItem filterItem)
{
if (filterItem.Filter != null) {return;}
var filter = filterItem.Descriptor.Filter;
if (filter is not IFilterFactory filterFactory) //标记的filter不是IFilterFactory类型
{
filterItem.Filter = filter;
filterItem.IsReusable = true; //那么可以重复使用
}
else
{
var services = context.ActionContext.HttpContext.RequestServices;
filterItem.Filter = filterFactory.CreateInstance(services);//创建实例
filterItem.IsReusable = filterFactory.IsReusable;
ApplyFilterToContainer(filterItem.Filter, filterFactory);
}
}
上面的注释就是创建filter的主要逻辑了，如果是静态构造那么可用重复使用，然后IFilterFactory主要有两种类型，一种是ServiceFilterAttribute，要求该过滤器和构造函数参数要在DI容器中注册，另一种是TypeFilterAttribute，部分参数自己提供，部分参数ioc提供。这两种filter.IsReusable=false.
看看如果有缓存那么是如何创建filters
FilterFactory
public static IFilterMetadata[] CreateUncachedFilters(
IFilterProvider[] filterProviders,
ActionContext actionContext,
FilterItem[] cachedFilterItems)
{
//删除一些代码
if (actionContext.ActionDescriptor.CachedReusableFilters is { } cached)
{
return cached; //如果都是可以缓存的filter直接返回
}
//深拷贝一份数据
// Deep copy the cached filter items as filter providers could modify them
var filterItems = new List<FilterItem>(cachedFilterItems.Length);
for (var i = 0; i < cachedFilterItems.Length; i++)
{
var filterItem = cachedFilterItems[i];
filterItems.Add(
new FilterItem(filterItem.Descriptor)
{
Filter = filterItem.Filter,
IsReusable = filterItem.IsReusable
});
}
return CreateUncachedFiltersCore(filterProviders, actionContext, filterItems);
}
深度拷贝了一份数据，但是filterItem.Filter没有拷贝进来，复制的是filterItem.Descriptor属性所以再调用CreateUncachedFiltersCore的时候我们可以复用静态构造的filter,但是其他的就要重新构造一份了。
4.总结
1.静态构造的filter会复用，其他的会重新构造
2.翻了一遍源码，写bug更有心得了。