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

filters.Add(new XYHMVCAuthorizeAttribute());

config.Filters.Add(new XYHAPIAuthorizeAttribute());

// 有 AllowAnonymous 属性的接口直接开绿灯
   if (actionContext.ActionDescriptor.GetCustomAttributes().Any())
   {
    return;
   }

/// 

 /// 授权认证过滤器
 /// 
 public class XYHAPIAuthFilterAttribute : AuthorizationFilterAttribute
 {
  /// 

  /// 认证授权验证
  /// 
  /// 请求上下文
  public override void OnAuthorization(HttpActionContext actionContext)
  {
   // 有 AllowAnonymous 属性的接口直接开绿灯
   if (actionContext.ActionDescriptor.GetCustomAttributes().Any())
   {
    return;
   }

   // 在请求前做一层拦截，主要验证token的有效性和验签
   HttpRequest httpRequest = HttpContext.Current.Request;

   // 获取apikey
   var apikey = httpRequest.QueryString["apikey"];

   // 首先做IP白名单校验 
   MBaseResult 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 queryParameters = httpRequest.GetAllQueryParameters();

    result = new AuthCheckService().SignCheck(queryParameters, apikey);

    if (result.Code == MResultCodeEnum.successCode)
    {
     // 如果有NoChekokenFilterAttribute 标签 那么直接不做token认证
     if (actionContext.ActionDescriptor.GetCustomAttributes().Any())
     {
      return;
     }

     // 校验token的有效性
     // 获取一个 token
     string token = httpRequest.Headers.GetValues("Token") == null &＃63; 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自定义授权
 /// 认证授权有两个重写方法
 /// 具体的认证逻辑实现：AuthorizeCore 这个里面写具体的认证逻辑，认证成功返回true,反之返回false
 /// 认证失败处理逻辑：HandleUnauthorizedRequest 前一步返回 false时，就会执行到该方法中
 /// 但是，我平时在应用过程中，一般都是在AuthorizeCore根据不同的认证结果，直接做认证后的逻辑处理
 /// 
 public class XYHMVCAuthorizeAttribute : AuthorizeAttribute
 {
  /// 

  /// 认证逻辑
  /// 
  /// 过滤器上下文
  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;
   }
  }
 }

/// 

 /// Action过滤器
 /// 
 public class XYHAPICustomActionFilterAttribute : ActionFilterAttribute
 {
  /// 

  /// Action执行开始
  /// 
  /// 
  public override void OnActionExecuting(HttpActionContext actionContext)
  {

  }

  /// 

  /// action执行以后
  /// 
  /// 
  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 &＃63; 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 action = AddApiRequestLogs;//声明一个委托
    // IAsyncResult ret = action.BeginInvoke(apiRequestLogsM, null, null);

   }
   catch (Exception ex)
   {

   }
  }
 }

 /// 

 /// MVC自定义异常处理机制
 /// 说道异常处理，其实我们脑海中的第一反应，也该是try/cache操作
 /// 但是在实际开发中，很有可能地址错误根本就进入不到try中，又或者没有被try处理到异常
 /// 该类就发挥了作用，能够很好的未经捕获的异常，并做相应的逻辑处理
 /// 自定义异常机制，主要集成HandleErrorAttribute 重写其OnException方法
 /// 
 public class XYHMVCHandleError : HandleErrorAttribute
 {
  /// 

  /// 处理异常
  /// 
  /// 异常上下文
  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 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自定义异常处理机制
 /// 说道异常处理，其实我们脑海中的第一反应，也该是try/cache操作
 /// 但是在实际开发中，很有可能地址错误根本就进入不到try中，又或者没有被try处理到异常
 /// 该类就发挥了作用，能够很好的未经捕获的异常，并做相应的逻辑处理
 /// 自定义异常机制，主要集成ExceptionFilterAttribute 重写其OnException方法
 /// 
 public class XYHAPIHandleError : ExceptionFilterAttribute
 {
  /// 

  /// 处理异常
  /// 
  /// 异常上下文
  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 queryParameters = httpRequest.GetAllQueryParameters();

   // 获取异常对象
   Exception ex = actionExecutedContext.Exception;

   // 异常描述信息
   string exMessage = ex.Message;

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

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

   // 构建统一的内部异常处理机制，相当于对异常做一层统一包装暴露
   MBaseResult result = new MBaseResult()
   {
    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(); // 此处结束响应，就不会走路由系统
  }
 }