如何改写WebApi部分默认规则

为什么要改

最近公司在推广SOA框架，第一次正经接触这种技术（之前也有但还是忽略掉吧），感觉挺好，就想自己也折腾一下，实现一个简单的SOA框架

用过mvc进行开发，印象之中WebApi和Mvc好像是一样的，带着这样的预设开始玩WebApi，然后被虐得找不到着北。

被虐的原因，是Mvc和WebApi在细节上差别还是有点大，例如：

  1. 在Mvc中，一个Controller中的所有公共方法一般情况下可以响应POST方法，而WebApi中不行
  2. 在Mvc中，一个Action方法中的参数即可来自Url，也可以来自Form，而WebApi中不是这样，具体的规则好像是除非你在参数中加了[FromBody]，否则这个参数永远也无法从Form中获取

这是这两种技术我知道的最大的差别，其他的没发现或者说是没注意，也有可能这些差别是因为我不会用，毕竟接触WebApi时间不长。如果我有些地方说错了，请指正。

就这两个不同点，我查了很多资料，也没有办法解决，第一个还好，加个特性就行了，第二个的话好像就算加了[FromBody]也还是不行，感觉就是一堆限制。接着，既然这么多让我不爽的地方，那我就来改造它吧。

改造的目标，有以下几个：

  1. 不再限制控制器必须以Controller结尾，其实这个并不是必须，只是被限制着确实不太舒服
  2. 所有方法可以响应所有的请求方法，如果存在方法名相同的方法，那么才需要特性来区分
  3. Action中的参数优先从Url中获取，再从Body中获取，从Body中获取的时候，优先假设Body中的数据是表单参数，若不是则将Body中的数据当作json或xml数据进行获取

定下了目标之后，感觉微软为什么要这样设计WebApi呢，或许它有它的道理。

目标好定，做起来真是头大，一开始想参考公司的SOA框架的实现，但因为我用了OWIN技术来进行宿主，而看了公司的框架好像不是用的这个，总之就是看了半天没看懂应该从哪个地方开始，反而是越看越糊，毕竟不是完全一样的技术，所以还是自己弄吧。

OK，废话了这么多，进入正题吧。首先来一个链接，没了这个文章我就不可能改造成功：http://www.cnblogs.com/beginor/archive/2012/03/22/2411496.html

OWIN宿主

其实这个网上很多，我主要是为了贴代码，不然的话下面几小节写不下去

  1. [assembly: OwinStartup(typeof(Startup))]//这句是在IIS宿主的时候使用的，作用是.Net会查找Startup类来启动整个服务
  2. namespace Xinchen.SOA.Server
  3. {
  4.     public class Startup
  5.     {
  6.         public void Configuration(IAppBuilder appBuilder)
  7.         {
  8.             HttpConfiguration config = new HttpConfiguration();
  9.             config.Routes.MapHttpRoute(
  10.                 name: "DefaultApi",
  11.                 routeTemplate: "{controller}/{action}"
  12.             );
  13.             config.Services.Add(typeof(ValueProviderFactory), new MyValueProviderFactory());//自定义参数查找，实现第三个目标
  14.             config.Services.Replace(typeof(IHttpControllerSelector), new ControllerSelector(config));//自定义控制器查找，实现第一个目标
  15.             config.Services.Replace(typeof(IHttpActionSelector), new HttpActionSelector());//自定义Action查找，实现第二个目标
  16.             appBuilder.UseWebApi(config);
  17.         }
  18.     }
  19. }

省略了部分不太重要的代码，Services.Add和Replace从字面就能明白是什么意思，但我没有试过是否必须要像上面那样写才行

对控制器的限制

  1. public class ControllerSelector : IHttpControllerSelector
  2. {
  3.     HttpConfiguration _config;
  4.     IDictionary<string, HttpControllerDescriptor> _desriptors = new Dictionary<string, HttpControllerDescriptor>(StringComparer.OrdinalIgnoreCase);
  5.     public ControllerSelector(HttpConfiguration config)
  6.     {
  7.         _config = config;
  8.     }
  9.  
  10.     void InitControllers()
  11.     {
  12.         if (_desriptors.Count <= 0)
  13.         {
  14.             lock (_desriptors)
  15.             {
  16.                 if (_desriptors.Count <= 0)
  17.                 {
  18.                     var assemblies = AppDomain.CurrentDomain.GetAssemblies().Where(x => !x.GlobalAssemblyCache && !x.IsDynamic);
  19.                     var controllerTypes = new List<Type>();
  20.                     foreach (var ass in assemblies)
  21.                     {
  22.                         controllerTypes.AddRange(ass.GetExportedTypes().Where(x => typeof(ApiController).IsAssignableFrom(x)));
  23.                     }
  24.                     var descriptors = new Dictionary<string, HttpControllerDescriptor>();
  25.                     foreach (var controllerType in controllerTypes)
  26.                     {
  27.                         var descriptor = new HttpControllerDescriptor(_config, controllerType.Name, controllerType);
  28.                         _desriptors.Add(descriptor.ControllerName, descriptor);
  29.                     }
  30.                 }
  31.             }
  32.         }
  33.     }
  34.  
  35.     public IDictionary<string, HttpControllerDescriptor> GetControllerMapping()
  36.     {
  37.         InitControllers();
  38.         return _desriptors;
  39.     }
  40.  
  41.     public System.Web.Http.Controllers.HttpControllerDescriptor SelectController(System.Net.Http.HttpRequestMessage request)
  42.     {
  43.         InitControllers();
  44.         var routeData = request.GetRouteData();
  45.         var controllerName = Convert.ToString(routeData.Values.Get("controller"));
  46.         if (string.IsNullOrWhiteSpace(controllerName))
  47.         {
  48.             throw new ArgumentException(string.Format("没有在路由信息中找到controller"));
  49.         }
  50.  
  51.         return _desriptors.Get(controllerName);
  52.     }
  53.  
  54. }

这个其实比较简单，测试中WebApi好像没调用GetControllerMapping方法，直接调用了SelectController方法，最后一个方法中有两个Get方法调用，Get只是把从字典获取值的TryGetValue功能给封装了一下，InitControllers方法是从当前所有的程序集中找继承了ApiController的类，找到之后缓存起来。这段代码整体比较简单。

对Action的限制

  1. public class HttpActionSelector : IHttpActionSelector
  2.     {
  3.         public ILookup<string, HttpActionDescriptor> GetActionMapping(HttpControllerDescriptor controllerDescriptor)
  4.         {
  5.             var methods = controllerDescriptor.ControllerType.GetMethods();
  6.             var result = new List<HttpActionDescriptor>();
  7.             foreach (var method in methods)
  8.             {
  9.                 var descriptor = new ReflectedHttpActionDescriptor(controllerDescriptor, method);
  10.                 result.Add(descriptor);
  11.             }
  12.             return result.ToLookup(x => x.ActionName);
  13.         }
  14.  
  15.         public HttpActionDescriptor SelectAction(HttpControllerContext controllerContext)
  16.         {
  17.             var actionDescriptor = new ReflectedHttpActionDescriptor();
  18.             var routeData = controllerContext.RouteData;
  19.             object action = string.Empty;
  20.             if (!routeData.Values.TryGetValue("action", out action))
  21.             {
  22.                 throw new HttpResponseException(controllerContext.Request.CreateErrorResponse(System.Net.HttpStatusCode.NotFound, "在路由中未找到action"));
  23.             }
  24.             string actionName = action.ToString().ToLower();
  25.             var methods = controllerContext.ControllerDescriptor.ControllerType.GetMethods().Where(x => x.Name.ToLower() == actionName);
  26.             var count = methods.Count();
  27.             MethodInfo method = null;
  28.             switch (count)
  29.             {
  30.                 case 0:
  31.                     throw new HttpResponseException(controllerContext.Request.CreateErrorResponse(System.Net.HttpStatusCode.NotFound, "在控制器" + controllerContext.ControllerDescriptor.ControllerName + "中未找到名为" + actionName + "的方法"));
  32.                 case 1:
  33.                     method = methods.FirstOrDefault();
  34.                     break;
  35.                 default:
  36.                     var httpMethod = controllerContext.Request.Method;
  37.                     var filterdMethods = methods.Where(x =>
  38.                         {
  39.                             var verb = x.GetCustomAttribute<AcceptVerbsAttribute>();
  40.                             if (verb == null)
  41.                             {
  42.                                 throw new HttpResponseException(controllerContext.Request.CreateErrorResponse(System.Net.HttpStatusCode.NotFound, "在控制器" + controllerContext.ControllerDescriptor.ControllerName + "中找到多个名为" + actionName + "的方法，请考虑为这些方法加上AcceptVerbsAttribute特性"));
  43.                             }
  44.                             return verb.HttpMethods.Contains(httpMethod);
  45.                         });
  46.                     if (filterdMethods.Count() > 1)
  47.                     {
  48.                         throw new HttpResponseException(controllerContext.Request.CreateErrorResponse(System.Net.HttpStatusCode.NotFound, "在控制器" + controllerContext.ControllerDescriptor.ControllerName + "中找到多个名为" + actionName + "的方法，并且这些方法的AcceptVerbsAttribute都含有" + httpMethod.ToString() + "，发生重复"));
  49.                     }
  50.                     else if (filterdMethods.Count() <= 0)
  51.                     {
  52.                         throw new HttpResponseException(controllerContext.Request.CreateErrorResponse(System.Net.HttpStatusCode.NotFound, "在控制器" + controllerContext.ControllerDescriptor.ControllerName + "中找到多个名为" + actionName + "的方法，但没有方法被配置为可以响应" + httpMethod.ToString() + "请求"));
  53.                     }
  54.                     method = filterdMethods.FirstOrDefault();
  55.                     break;
  56.             }
  57.             return new ReflectedHttpActionDescriptor(controllerContext.ControllerDescriptor, method);
  58.         }
  59.     }

GetActionMapping方法很简单，从控制器类型中找到所有的Action方法并返回

SelectAction方法相对复杂，其实就是第二个目标的逻辑，代码看起来比较多其实并有很难的地方。

对Action的参数的限制

这一块比较难，我试了很久才成功，而且还有坑

  1. public class ActionValueBinder : DefaultActionValueBinder
  2.     {
  3.         protected override HttpParameterBinding GetParameterBinding(HttpParameterDescriptor parameter)
  4.         {
  5.             ParameterBindingAttribute parameterBinderAttribute = parameter.ParameterBinderAttribute;
  6.             if (parameterBinderAttribute == null)
  7.             {
  8.                 ParameterBindingRulesCollection parameterBindingRules = parameter.Configuration.ParameterBindingRules;
  9.                 if (parameterBindingRules != null)
  10.                 {
  11.                     HttpParameterBinding binding = parameterBindingRules.LookupBinding(parameter);
  12.                     if (binding != null)
  13.                     {
  14.                         return binding;
  15.                     }
  16.                 }
  17.                 if (TypeHelper.IsValueType(parameter.ParameterType))
  18.                 {
  19.                     return parameter.BindWithAttribute(new ValueProviderAttribute(typeof(MyValueProviderFactory)));
  20.                 }
  21.                 parameterBinderAttribute = new FromBodyAttribute();
  22.             }
  23.             return parameterBinderAttribute.GetBinding(parameter);
  24.         }
  25.     }

这个类其实就是把.Net的默认实现给改了一点点，也就是从第17行到第20行，现在的判断逻辑是如果参数的类型为基础类型的话，则从Url或Form表单中获取，而这个逻辑是写在MyValueProviderFactory中的，ValueProviderAttribute是.Net自带的。其他并没有改动，怕是也改不动吧，因为一时间看不懂这些代码是什么意思。

  1. public class MyValueProviderFactory : ValueProviderFactory
  2.     {
  3.         public override IValueProvider GetValueProvider(System.Web.Http.Controllers.HttpActionContext actionContext)
  4.         {
  5.             return new ValueProvider(actionContext);
  6.         }
  7.     }

这个很简单，略过。

  1. public class ValueProvider : IValueProvider
  2.     {
  3.         private IEnumerable<KeyValuePair<string, string>> _queryParameters;
  4.         private HttpContent _httpContent;
  5.         private HttpActionContext _context;
  6.  
  7.         public ValueProvider(HttpActionContext context)
  8.         {
  9.             _context = context;
  10.             _httpContent = context.Request.Content;
  11.             _queryParameters = context.Request.GetQueryNameValuePairs();
  12.         }
  13.         public bool ContainsPrefix(string prefix)
  14.         {
  15.             return _queryParameters.Any(x => x.Key == prefix);
  16.         }
  17.  
  18.         NameValueCollection _formDatas = (NameValueCollection)CallContext.LogicalGetData("$formDatas");
  19.  
  20.         public ValueProviderResult GetValue(string key)
  21.         {
  22.             var value = _queryParameters.FirstOrDefault(x => x.Key == key).Value;
  23.             if (string.IsNullOrWhiteSpace(value))
  24.             {
  25.                 if (_formDatas == null)
  26.                 {
  27.                     if (_httpContent.IsFormData())
  28.                     {
  29.                         if (_formDatas == null)
  30.                         {
  31.                             _formDatas = _httpContent.ReadAsFormDataAsync().Result;
  32.                             CallContext.LogicalSetData("$formDatas", _formDatas);
  33.                         }
  34.                     }
  35.                     else
  36.                     {
  37.                         throw new HttpResponseException(_context.Request.CreateErrorResponse(System.Net.HttpStatusCode.NotFound, string.Format("未在URL中找到名为{0}的参数，此时必须传入表单参数或json或xml参数", key)));
  38.                     }
  39.                 }
  40.                 value = _formDatas[key];
  41.                 if (string.IsNullOrWhiteSpace(value))
  42.                 {
  43.                     throw new HttpResponseException(_context.Request.CreateErrorResponse(System.Net.HttpStatusCode.NotFound, string.Format("未在URL中找到名为{0}的参数，也未在表单中找到该参数", key)));
  44.                 }
  45.             }
  46.             return new ValueProviderResult(value, value, CultureInfo.InvariantCulture);
  47.         }
  48.     }

核心是GetValue方法，首先从查询字符串中取值，若没有则判断是否有缓存，若没有的话再一次判断Body中是否表单参数，是的话就直接读取。这个地方其实一开始并没有想用缓存，但如果不用的话就会出现一个问题，如果一个Action有多个参数，那么就挂了。

原因在于：

  1. WebApi在查找参数时，如果这个Action有N个参数，那么WebApi会调用ActionValueBinder的GetParameterBinding方法N次
  2. GetParameterBinding方法在被调用这N次的时候每次都会执行parameter.BindWithAttribute(new ValueProviderAttribute(typeof(MyValueProviderFactory)));
  3. BindWithAttribute方法每次都会实例化一个MyValueProviderFactory对象（是WebApi实例化的）并调用GetValueProvider方法
  4. 大家可以看到GetValueProvider每次都new了一个ValueProvider，但这个我是可以控制的，但我发现除非我弄成全局缓存，否则是没用的，因为MyValueProviderFactory对象每次都会重新实例化。如果弄成全局缓存，那么就会影响其他的Api调用
  5. 然后ValueProvider又调用GetValue方法，然后就开始坑爹了
  6. 因为第一次GetValue的时候就会读取Body流中的表单数据，读取之后其实Body流就不能再读了，再读就成空了，所以就变成了有N个参数，就会调用N次GetValue方法，但其实从第二次调用的时候就已经不能读了，所以才用了这个缓存。

接下来的逻辑其实都简单了。

时间： 2024-10-28 11:37:17

如何改写WebApi部分默认规则的相关文章

iptables默认规则

iptables默认规则 *filter :INPUT ACCEPT [0:0] :FORWARD ACCEPT [0:0] :OUTPUT ACCEPT [34:4104] -A INPUT -m state --state RELATED,ESTABLISHED -j ACCEPT # 允许我发出去的数据包入站 -A INPUT -p icmp -j ACCEPT # 允许ICMP协议 -A INPUT -i lo -j ACCEPT # 允许回环网卡 -A INPUT -p tcp -m

openstack neutron-修改新创建安全组的默认规则

neutron 创建安全组会有两条默认的出口规则 Direction Ether Type IP Protocol Port Range Remote IP Prefix Remote Security Group Actions Egress IPv6 Any Any ::/0 - Delete Rule Egress IPv4 Any Any 0.0.0.0/0 - 遇到的需求要修改它, 找了数据库,配置文件后,在源代码中找到了他 位置 neutron/db/securitygroups_d

iptables_默认规则

:INPUT ACCEPT [0:0] :FORWARD ACCEPT [0:0] :OUTPUT ACCEPT [0:0] -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT -A INPUT -p icmp -j ACCEPT -A INPUT -i lo -j ACCEPT -A INPUT -m state --state NEW -m tcp -p tcp --dport 22 -j ACCEPT -A INPUT -j RE

WebAPI的路由规则

1.自定义路由 public static class WebApiConfig { public static void Register(HttpConfiguration config) { // Web API 路由 config.MapHttpAttributeRoutes(); //1.默认路由 config.Routes.MapHttpRoute( name: "DefaultApi", routeTemplate: "api/{controller}/{id}

C#进阶系列——WebApi 路由机制剖析：你准备好了吗？

前言:从MVC到WebApi,路由机制一直是伴随着这些技术的一个重要组成部分. 它可以很简单:如果你仅仅只需要会用一些简单的路由,如/Home/Index,那么你只需要配置一个默认路由就能简单搞定: 它可以很神秘:你的url可以千变万化,看到一些看似“无厘头”的url,感觉很难理解它如何找到匹配的action,例如/api/user/1/detail,这样一个url可以让你纠结半天. 它可以很晦涩:当面试官提问“请简单分析下MVC路由机制的原理”,你可能事先就准备好了答案,然后噼里啪啦一顿(型如

ABP中动态WebAPI原理解析

ABP中动态WebAPI原理解析 动态WebAPI应该算是ABP中最Magic的功能之一了吧.开发人员无须定义继承自ApiController的类,只须重用Application Service中的类就可以对外提供WebAPI的功能,这应该算是对DRY的最佳诠释了. 如下图所示,一行代码就为所有实现了IApplicationService的类型,自动创建对应的动态WebAPI. 这么Magic的功能是如何实现的呢? 本文为你揭开其Magic的外表.你会发现,实现如此Magic的功能,最关键的代码

mvc中的webapi

MVC中 webapi的使用 和 在其他网站中如何来调用(MVC) 1.webapi的路由规则注册在App_Start\WebApiConfig.cs文件中 2.webapi控制器继承父类 apiController 3.调用webapi的方式:   get请求http://localhost/api/home/1 则默认请求 Home控制器下的Get方法将1作为get()方法的参数   Post请求http://localhost/api/home/1 则默认请求 Home控制器下的Post方

C#进阶系列——WebApi 跨域问题解决方案：CORS

from:http://www.cnblogs.com/landeanfen/p/5177176.html 阅读目录 一.跨域问题的由来 二.跨域问题解决原理 三.跨域问题解决细节 1.场景描述 2.场景测试 四.总结 正文 前言:上篇总结了下WebApi的接口测试工具的使用,这篇接着来看看WebAPI的另一个常见问题:跨域问题.本篇主要从实例的角度分享下CORS解决跨域问题一些细节. WebApi系列文章 C#进阶系列--WebApi接口测试工具:WebApiTestClient C#进阶系列

iptables命令、规则、参数详解

表    (table)包含4个表:4个表的优先级由高到低:raw-->mangle-->nat-->filterraw---RAW表只使用在PREROUTING链和OUTPUT链上,因为优先级最高,从而可以对收到的数据包在连接跟踪前进行处理.一但用户使用了RAW表,在某个链上,RAW表处理完后,将跳过NAT表和ip_conntrack处理,即不再做地址转换和数据包的链接跟踪处理了.filter---这个规则表是预设规则表,拥有 INPUT.FORWARD 和 OUTPUT 三个规则链,