聊一聊Asp.net过滤器Filter那一些事

最近在整理优化.net代码时，发现几个很不友好的处理现象：登录判断、权限认证、日志记录、异常处理等通用操作，在项目中的action中到处都是。在代码优化上，这一点是很重要着力点。这时.net中的过滤器、拦截器（filter）就派上用场了。现在根据这几天的实际工作，对其做了一个简单的梳理，分享出来，以供大家参考交流，如有写的不妥之处，多多指出，多多交流。

概述：

.net中的filter中主要包括以下4大类：authorize（授权），actionfilter（自定义），handleerror（错误处理）。

过滤器	类名	实现接口	描述
授权	authorizeattribute	iauthorizationfilter	此类型（或过滤器）用于限制进入控制器或控制器的某个行为方法，比如：登录、权限、访问控制等等
异常	handleerrorattribute	iexceptionfilter	用于指定一个行为，这个被指定的行为处理某个行为方法或某个控制器里面抛出的异常，比如：全局异常统一处理。
自定义	actionfilterattribute	iactionfilter和iresultfilter	用于进入行为之前或之后的处理或返回结果的之前或之后的处理，比如：用户请求日志详情日志记录

authorizeattribute：认证授权

认证授权主要是对所有action的访问第一入口认证，对用户的访问做第一道监管过滤拦截闸口。

实现方式：需要自定义一个类，继承authorizeattribute并重写onauthorization，在onauthorization中能够获取到用户请求的所有request信息，其实我们做的所有认证拦截操作，其所有数据支撑都是来自request中。

具体验证流程设计：

ip白名单：这个主要针对的是api做ip限制，只有指定ip才可访问，非指定ip直接返回

请求频率控制：这个主要是控制用户的访问频率，主要是针对api做，超出请求频率直接返回。

登录认证：登录认证一般我们采用的是通过在请求的header中传递token的方式来进行验证，这样即使用与一般的mvc登录认证，也使用与api接口的auth认证，并且也不依赖于用户前端js设置等。

授权认证：授权认证就简单了，主要是验证该用户是否具有该权限，如果不具有，直接做下相应的返回处理。

mvc和api异同：

　　命名空间：mvc：system.web.http.filters；api：system.web.mvc

　　注入方式：在注入方式上，主要包括：全局->控制器controller->行为action

　　全局注册：针对所有系统的所有aciton都使用

　　controller：只针对该controller下的action起作用

　　action：只针对该action起作用

其中全局注册，针对mvc和api还有一些差异：

　　mvc在 filterconfig.cs中注入

filters.add(new xyhmvcauthorizeattribute());

     api 在 webapiconfig.cs 中注入

config.filters.add(new xyhapiauthorizeattribute());

 　注意事项：在实际使用中，针对认证授权，我们一般都是添加全局认证，但是，有的action又不需要做认证，比如本来的登录action等等，那么该如何排除呢？其实也很简单，我们只需要在自定定义一个attribute集成attribute，或者系统的allowanonymousattribute，在不需要验证的action中只需要注册上对于的attribute,并在验证前做一个过滤即可，比如：

// 有 allowanonymous 属性的接口直接开绿灯
   if (actioncontext.actiondescriptor.getcustomattributes<allowanonymousattribute>().any())
   {
    return;
   }

api authfilterattribute实例代码

/// <summary>
 /// 授权认证过滤器
 /// </summary>
 public class xyhapiauthfilterattribute : authorizationfilterattribute
 {
  /// <summary>
  /// 认证授权验证
  /// </summary>
  /// <param name="actioncontext">请求上下文</param>
  public override void onauthorization(httpactioncontext actioncontext)
  {
   // 有 allowanonymous 属性的接口直接开绿灯
   if (actioncontext.actiondescriptor.getcustomattributes<allowanonymousattribute>().any())
   {
    return;
   }

   // 在请求前做一层拦截，主要验证token的有效性和验签
   httprequest httprequest = httpcontext.current.request;

   // 获取apikey
   var apikey = httprequest.querystring["apikey"];

   // 首先做ip白名单校验 
   mbaseresult<string> result = new authcheckservice().checkipwhitelist(filterattributehelp.getipaddress(actioncontext.request), apikey);

   // 检验时间搓
   string timestamp = httprequest.querystring["timestamp"];
   if (result.code == mresultcodeenum.successcode)
   {
    // 检验时间搓 
    result = new authcheckservice().checktimestamp(timestamp);
   }

   if (result.code == mresultcodeenum.successcode)
   {
    // 做请求频率验证 
    string acitonname = actioncontext.actiondescriptor.actionname;
    string controllername = actioncontext.actiondescriptor.controllerdescriptor.controllername;
    result = new authcheckservice().checkrequestfrequency(apikey, $"api/{controllername.tolower()}/{acitonname.tolower()}");
   }

   if (result.code == mresultcodeenum.successcode)
   {
    // 签名校验

    // 获取全部的请求参数
    dictionary<string, string> queryparameters = httprequest.getallqueryparameters();

    result = new authcheckservice().signcheck(queryparameters, apikey);

    if (result.code == mresultcodeenum.successcode)
    {
     // 如果有nochekokenfilterattribute 标签 那么直接不做token认证
     if (actioncontext.actiondescriptor.getcustomattributes<xyhapinochekokenfilterattribute>().any())
     {
      return;
     }

     // 校验token的有效性
     // 获取一个 token
     string token = httprequest.headers.getvalues("token") == null ? string.empty :
      httprequest.headers.getvalues("token")[0];

     result = new authcheckservice().checktoken(token, apikey, httprequest.filepath);
    }
   }

   // 输出
   if (result.code != mresultcodeenum.successcode)
   {
    // 一定要实例化一个response,是否最终还是会执行action中的代码
    actioncontext.response = new httpresponsemessage(httpstatuscode.ok);
    //需要自己指定输出内容和类型
    httpcontext.current.response.contenttype = "text/html;charset=utf-8";
    httpcontext.current.response.write(jsonconvert.serializeobject(result));
    httpcontext.current.response.end(); // 此处结束响应，就不会走路由系统
   }
  }
 }

 mvc authfilterattribute实例代码

/// <summary>
 /// mvc自定义授权
 /// 认证授权有两个重写方法
 /// 具体的认证逻辑实现：authorizecore 这个里面写具体的认证逻辑，认证成功返回true,反之返回false
 /// 认证失败处理逻辑：handleunauthorizedrequest 前一步返回 false时，就会执行到该方法中
 /// 但是，我平时在应用过程中，一般都是在authorizecore根据不同的认证结果，直接做认证后的逻辑处理
 /// </summary>
 public class xyhmvcauthorizeattribute : authorizeattribute
 {
  /// <summary>
  /// 认证逻辑
  /// </summary>
  /// <param name="filtercontext">过滤器上下文</param>
  public override void onauthorization(authorizationcontext filtercontext)
  {

   // 此处主要写认证授权的相关验证逻辑
   // 该部分的验证一般包括两个部分
   // 登录权限校验
   // --我们的一般处理方式是，通过header中传递一个token来进行逻辑验证
   // --当然不同的系统在设计上也不尽相同，有的也会采用session等方式来验证
   // --所以最终还是根据其项目本身的实际情况来进行对应的逻辑操作

   // 具体的页面权限校验
   // --该部分的验证是具体的到页面权限验证
   // --我看有得小伙伴没有做到这一个程度,直接将这一步放在前端js来验证，这样不是很安全，但是可以拦住小白用户
   // --当然有的系统根本就没有做权限控制，那就更不需要这一个逻辑了。
   // --所以最终还是根据其项目本身的实际情况来进行对应的逻辑操作

   // 现在用一个粗暴的方式来简单模拟实现过，用系统当前时间段秒厨艺3，取余数
   // 当余数为0：认证授权通过
   //   1:代表为登录，调整至登录页面
   //   2:代表无访问权限，调整至无权限提示页面

   // 当然，在这也还可以做一些ip白名单，ip黑名单验证 请求频率验证等等

   // 说到这而，还有一点需要注意，如果我们选择的是全局注册该过滤器，那么如果有的页面根本不需要权限认证，比如登录页面，那么我们可以给不需要权限的认证的控制器或者action添加一个特殊的注解 allowanonymous ，来排除

   // 获取request的几个关键信息
   httprequest httprequest = httpcontext.current.request;
   string acitonname = filtercontext.actiondescriptor.actionname;
   string controllername = filtercontext.actiondescriptor.controllerdescriptor.controllername;

   // 注意：如果认证不通过，需要设置filtercontext.result的值，否则还是会执行action中的逻辑

   filtercontext.result = null;
   int thissecond = system.datetime.now.second;
   switch (thissecond % 3)
   {
    case 0:
     // 认证授权通过
     break;
    case 1:
     // 代表为登录，调整至登录页面
     // 只有设置了result才会终结操作
     filtercontext.result = new redirectresult("/html/login.html");
     break;
    case 2:
     // 代表无访问权限，调整至无权限提示页面
     filtercontext.result = new redirectresult("/html/noauth.html");
     break;
   }
  }
 }

actionfilter：自定义过滤器

自定义过滤器，主要是监控action请求前后，处理结果返回前后的事件。其中api只有请求前后的两个方法。

重新方法	方法功能描述	使用于
onactionexecuting	一个请求在进入到aciton逻辑前执行	mvc、api
onactionexecuted	一个请求aciton逻辑执行后执行	mvc、api
onresultexecuting	对应的view视图渲染前执行	mvc
onresultexecuted	对应的view视图渲染后执行	mvc

在这几个方法中，我们一般主要用来记录交互日志，记录每一个步骤的耗时情况，以便后续系统优化使用。具体的使用，根据自身的业务场景使用。

其中mvc和api的异同点，和上面说的认证授权的异同类似，不在详细说明。

下面的一个实例代码：

api定义过滤器实例demo代码

/// <summary>
 /// action过滤器
 /// </summary>
 public class xyhapicustomactionfilterattribute : actionfilterattribute
 {
  /// <summary>
  /// action执行开始
  /// </summary>
  /// <param name="actioncontext"></param>
  public override void onactionexecuting(httpactioncontext actioncontext)
  {

  }

  /// <summary>
  /// action执行以后
  /// </summary>
  /// <param name="actioncontext"></param>
  public override void onactionexecuted(httpactionexecutedcontext actioncontext)
  {
   try
   {
    // 构建一个日志数据模型
    mapirequestlogs apirequestlogsm = new mapirequestlogs();

    // api名称
    apirequestlogsm.api = actioncontext.request.requesturi.absolutepath;

    // apikey
    apirequestlogsm.api_key = httpcontext.current.request.querystring["apikey"];

    // ip地址
    apirequestlogsm.ip = filterattributehelp.getipaddress(actioncontext.request);

    // 获取token
    string token = httpcontext.current.request.headers.getvalues("token") == null ? string.empty :
        httpcontext.current.request.headers.getvalues("token")[0];
    apirequestlogsm.token = token;

    // url
    apirequestlogsm.url = actioncontext.request.requesturi.absoluteuri;

    // 返回信息
    var objectcontent = actioncontext.response.content as objectcontent;
    var returnvalue = objectcontent.value;
    apirequestlogsm.response_infor = returnvalue.tostring();

    // 由于数据库中最大只能存储4000字符串，所以对返回值做一个截取
    if (!string.isnullorempty(apirequestlogsm.response_infor) &&
     apirequestlogsm.response_infor.length > 4000)
    {
     apirequestlogsm.response_infor = apirequestlogsm.response_infor.substring(0, 2000);
    }

    // 请求参数
    apirequestlogsm.request_infor = actioncontext.request.requesturi.query;

    // 定义一个异步委托 ,异步记录日志
    // func<mapirequestlogs, string> action = addapirequestlogs;//声明一个委托
    // iasyncresult ret = action.begininvoke(apirequestlogsm, null, null);

   }
   catch (exception ex)
   {

   }
  }
 }

handleerror：错误处理

异常处理对于我们来说很常用，很好的利用异常处理，可以很好的避免全篇的try/catch。异常处理箱单很简单，值需要自定义集成：exceptionfilterattribute，并自定义实现：onexception方法即可。

在onexception我们可以根据自身需要，做一些相应的逻辑处理，比如记录异常日志，便于后续问题分析跟进。

onexception还有一个很重要的处理，那就是对异常结果的统一包装，返回一个很友好的结果给用户，避免把一些不必要的信息返回给用户。比如：针对mvc，那么跟进不同异常，统一调整至友好的提示页面等等；针对api，那么我们可以一个统一的返回几个封装，便于用户统一处理结果。

mvc 的异常处理实例代码：

 /// <summary>
 /// mvc自定义异常处理机制
 /// 说道异常处理，其实我们脑海中的第一反应，也该是try/cache操作
 /// 但是在实际开发中，很有可能地址错误根本就进入不到try中，又或者没有被try处理到异常
 /// 该类就发挥了作用，能够很好的未经捕获的异常，并做相应的逻辑处理
 /// 自定义异常机制，主要集成handleerrorattribute 重写其onexception方法
 /// </summary>
 public class xyhmvchandleerror : handleerrorattribute
 {
  /// <summary>
  /// 处理异常
  /// </summary>
  /// <param name="filtercontext">异常上下文</param>
  public override void onexception(exceptioncontext filtercontext)
  {
   // 我们在平时的项目中，异常处理一般有两个作用
   // 1:记录异常的详细日志，便于事后分析日志
   // 2:对异常的统一友好处理，比如根据异常类型重定向到友好提示页面

   // 在这里面既能获取到未经处理的异常信息，也能获取到请求信息
   // 在此可以根据实际项目需要做相应的逻辑处理
   // 下面简单的列举了几个关键信息获取方式

   // 控制器名称 注意，这样获取出来的是一个文件的全路径 
   string contropath = filtercontext.controller.tostring();

   // 访问目录的相对路径
   string filepath = filtercontext.httpcontext.request.filepath;

   // url完整地址
   string url = (filtercontext.httpcontext.request.url.absoluteuri).exurldecode();

   // 请求方式 post get
   string httpmethod = filtercontext.httpcontext.request.httpmethod;

   // 请求ip地址
   string ip = filtercontext.httpcontext.request.getipaddress();

   // 获取全部的请求参数
   httprequest httprequest = httpcontext.current.request;
   dictionary<string, string> queryparameters = httprequest.getallqueryparameters();

   // 获取异常对象
   exception ex = filtercontext.exception;

   // 异常描述信息
   string exmessage = ex.message;

   // 异常堆栈信息
   string stacktrace = ex.stacktrace;

   // 根据实际情况记录日志（文本日志、数据库日志，建议具体步骤采用异步方式来完成）


   filtercontext.exceptionhandled = true;

   // 模拟根据不同的做对应的逻辑处理
   int statuscode = filtercontext.httpcontext.response.statuscode;

   if (statuscode>=400 && statuscode<500)
   {
    filtercontext.result = new redirectresult("/html/404.html");
   }
   else 
   {
    filtercontext.result = new redirectresult("/html/500.html");
   }
  }
 }

api 的异常处理实例代码：

 /// <summary>
 /// api自定义异常处理机制
 /// 说道异常处理，其实我们脑海中的第一反应，也该是try/cache操作
 /// 但是在实际开发中，很有可能地址错误根本就进入不到try中，又或者没有被try处理到异常
 /// 该类就发挥了作用，能够很好的未经捕获的异常，并做相应的逻辑处理
 /// 自定义异常机制，主要集成exceptionfilterattribute 重写其onexception方法
 /// </summary>
 public class xyhapihandleerror : exceptionfilterattribute
 {
  /// <summary>
  /// 处理异常
  /// </summary>
  /// <param name="actionexecutedcontext">异常上下文</param>
  public override void onexception(httpactionexecutedcontext actionexecutedcontext)
  {
   // 我们在平时的项目中，异常处理一般有两个作用
   // 1:记录异常的详细日志，便于事后分析日志
   // 2:对异常的统一友好处理，比如根据异常类型重定向到友好提示页面

   // 在这里面既能获取到未经处理的异常信息，也能获取到请求信息
   // 在此可以根据实际项目需要做相应的逻辑处理
   // 下面简单的列举了几个关键信息获取方式

   // action名称 
   string actionname = actionexecutedcontext.actioncontext.actiondescriptor.actionname;

   // 控制器名称 
   string controllername =actionexecutedcontext.actioncontext.controllercontext.controllerdescriptor.controllername;

   // url完整地址
   string url = (actionexecutedcontext.request.requesturi.absoluteuri).exurldecode();

   // 请求方式 post get
   string httpmethod = actionexecutedcontext.request.method.method;

   // 请求ip地址
   string ip = actionexecutedcontext.request.getipaddress();

   // 获取全部的请求参数
   httprequest httprequest = httpcontext.current.request;
   dictionary<string, string> queryparameters = httprequest.getallqueryparameters();

   // 获取异常对象
   exception ex = actionexecutedcontext.exception;

   // 异常描述信息
   string exmessage = ex.message;

   // 异常堆栈信息
   string stacktrace = ex.stacktrace;

   // 根据实际情况记录日志（文本日志、数据库日志，建议具体步骤采用异步方式来完成）
   // 自己的记录日志落地逻辑略 ......

   // 构建统一的内部异常处理机制，相当于对异常做一层统一包装暴露
   mbaseresult<string> result = new mbaseresult<string>()
   {
    code = mresultcodeenum.systemerrorcode,
    message = mresultcodeenum.systemerror
   };

   actionexecutedcontext.response = new httpresponsemessage(httpstatuscode.ok);
   //需要自己指定输出内容和类型
   httpcontext.current.response.contenttype = "text/html;charset=utf-8";
   httpcontext.current.response.write(jsonconvert.serializeobject(result));
   httpcontext.current.response.end(); // 此处结束响应，就不会走路由系统
  }
 }

总结

.net过滤器，我个人的一句话理解就是：对action的各个阶段进行统一的监控处理等操作。.net过滤器中，其中每一个种过滤器的执行先后顺序为：authorize（授权）-->actionfilter（自定义）-->handleerror（错误处理）

好了，就先聊到这而，如果什么地方说的不对之处，多多指点和多多包涵。我自己写了一个练习demo，里面会有每一种情况的处理说明。有兴趣的可以取下载下来看一看，谢谢。

demo在github地址为：https://github.com/xuyuanhong0902/xyh.filtertest.git

到此这篇关于聊一聊asp.net过滤器filter那一些事的文章就介绍到这了,更多相关asp.net过滤器filter内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！