使用ActionFilterAttribute 记录 WebApi Action 请求和返回结果记录

在asp.net mvc 中 webapi 和 mvc 处理消息是两个不同的管道，Asp.net mvc 和 webapi 为我们提供的 ActionFilterAttribute 拦截器，通过 重写 OnActionExecutingAsync，来 拦截action的请求消息，当执行OnActionExecutingAsync完成以后才真正进入请求的action中，action运行完后又把控制权给了 OnActionExecutedAsync ，这个管道机制可以使我们用它来轻松实现 权限认证、日志记录 ，跨域以及很多需要对全局或者部分请求做手脚的的功能。

大概的流程如下

通过ActionFilterAttribute ，就能拦截action 处理的所有内容，包括请求提交的参数以及返回值。由于asp.net MVC 与webapi  是两个完全独立的管道:

• MVC由System.Web.Mvc.ActionFilterAttribute 来做action请求的拦截。
• webapi 由 System.Web.Http.Filters.ActionFilterAttribute 来处理。

因此拦截action请求是完全不相干的两个通道，于此同时，当我们需要注册全局的ActionFilterAttribute  这两个也是分开注册的：

MVC 直接在System.Web.Mvc.GlobalFilterCollection  这个全局管道里面注册 ActionFilter ，位置在App_Start目录>FilterConfig 类>RegisterGlobalFilters 方法 使用参数filters ， filters.Add(new YourMvcAttribute()) 添加你的mvc ActionFilterAttribute  。

wepi API 在System.Web.Http.Filters 中注册， 在项目的App_Start 目录>WebApiConfig类中>Register 方法中加入使用 config参数,  config.Filters.Add(new YourWebApiAttribute()); 添加你的 webapi ActionFilterAttribute 

 

这样就可以注册你的 ActionFilterAttribute   成为全局的Filter，系统中请求经过Action 之前或之后 都会被你的ActionFilter 拦下来做处理然后在转交下去。

好了道理已经讲完了，现在开始我自己要实现的 日志记录功能，

需求是记录所有访问webapi action的（请求地址、内容、访问用户、提交的参数、返回的结果、以及一些客户端的信息）

由于MVC 框架 提倡契约编程，在你自定义的Attribute 时，需要遵守契约规范， 【YourFilterName】+Attribute ，所以我的filter名字为 OperateTrackAttribute 

  1 using System;
  2 using System.Collections.Generic;
  3 using System.IO;
  4 using System.Linq;
  5 using System.Text;
  6 using System.Threading;
  7 using System.Threading.Tasks;
  8 using System.Web;
  9 using System.Web.Http.Controllers;
 10 using System.Web.Http.Filters;
 11 using WebApiTrackLog.Models;
 12
 13 
 14 namespace WebApiTrackLog.WebApiAttributes
 15 {
 16     public class OperateTrackAttribute : ActionFilterAttribute
 17     {
 18         /// <summary>
 19         /// 自定义参数
 20         /// </summary>
 21         public string msg { get; set; }
 22         public OperateTrackAttribute()
 23         {
 24 
 25         }
 26 
 27 
 28         /// <summary>
 29         /// 初始化时填入类的说明
 30         /// </summary>
 31         /// <param name="message"></param>
 32         public OperateTrackAttribute(string message)
 33         {
 34             msg = message;
 35         }
 36 
 37 
 38         private static readonly string key = "enterTime";
 39         public override Task OnActionExecutingAsync(HttpActionContext actionContext, CancellationToken cancellationToken)
 40         {
 41             if (SkipLogging(actionContext))//是否该类标记为NoLog
 42             {
 43                 return base.OnActionExecutingAsync(actionContext, cancellationToken);
 44 
 45             }
 46             //记录进入请求的时间
 47             actionContext.Request.Properties[key] = DateTime.Now.ToBinary();
 48 
 49             return base.OnActionExecutingAsync(actionContext, cancellationToken);
 50         }
 51         /// <summary>
 52         /// 在请求执行完后 记录请求的数据以及返回数据
 53         /// </summary>
 54         /// <param name="actionExecutedContext"></param>
 55         /// <param name="cancellationToken"></param>
 56         /// <returns></returns>
 57         public override Task OnActionExecutedAsync(HttpActionExecutedContext actionExecutedContext, CancellationToken cancellationToken)
 58         {
 59             object beginTime = null;
 60             if (actionExecutedContext.Request.Properties.TryGetValue(key, out beginTime))
 61             {
 62                 DateTime time = DateTime.FromBinary(Convert.ToInt64(beginTime));
 63                 HttpRequest request = HttpContext.Current.Request;
 64                 string token = request.Headers["token"];
 65 
 66                 WepApiActionLog apiActionLog = new WepApiActionLog
 67                 {
 68                     Id = Guid.NewGuid(),
 69                     //获取action名称
 70                     actionName = actionExecutedContext.ActionContext.ActionDescriptor.ActionName,
 71                     //获取Controller 名称
 72                     controllerName = actionExecutedContext.ActionContext.ActionDescriptor.ControllerDescriptor.ControllerName,
 73                     //获取action开始执行的时间
 74                     enterTime = time,
 75                     //获取执行action的耗时
 76                     costTime = (DateTime.Now - time).TotalMilliseconds,
 77                     navigator = request.UserAgent,
 78                     token = token,
 79                     //获取用户token
 80                     userId = getUserByToken(token),
 81                     //获取访问的ip
 82                     ip = request.UserHostAddress,
 83                     userHostName = request.UserHostName,
 84                     urlReferrer = request.UrlReferrer != null ? request.UrlReferrer.AbsoluteUri : "",
 85                     browser = request.Browser.Browser + " - " + request.Browser.Version + " - " + request.Browser.Type,
 86                     //获取request提交的参数
 87                     paramaters = GetRequestValues(actionExecutedContext), 88                     //获取response响应的结果
 89                     executeResult = GetResponseValues(actionExecutedContext),
 90                     comments = msg,
 91                     RequestUri = request.Url.AbsoluteUri
 92                 };
 93                 using (TrackLogEntities context = new TrackLogEntities())
 94                 {
 95                     context.WepApiActionLogs.Add(apiActionLog);
 96                     context.SaveChanges();
 97                 }
 98             }
 99             return base.OnActionExecutedAsync(actionExecutedContext, cancellationToken);
100 
101         }
102         /// <summary>
103         /// 获取当前登录用户的id
104         /// </summary>
105         /// <param name="token"></param>
106         /// <returns></returns>
107         public static int getUserByToken(string token)
108         {
109             UserInfo user = null;
110             // TokenManager.getUserByToken(token, out user);
111             return user == null ? 0 : user.user_id;
112         }
113         /// <summary>
114         /// 读取request 的提交内容
115         /// </summary>
116         /// <param name="actionExecutedContext"></param>
117         /// <returns></returns>
118         public string GetRequestValues(HttpActionExecutedContext actionExecutedContext)
119         {
120 
121             Stream stream = actionExecutedContext.Request.Content.ReadAsStreamAsync().Result;
122             Encoding encoding = Encoding.UTF8;
123             /*
124                 这个StreamReader不能关闭，也不能dispose， 关了就傻逼了
125                 因为你关掉后，后面的管道  或拦截器就没办法读取了
126             */
127             var reader = new StreamReader(stream, encoding);
128             string result = reader.ReadToEnd();
129             /*
130             这里也要注意：   stream.Position = 0;
131             当你读取完之后必须把stream的位置设为开始
132             因为request和response读取完以后Position到最后一个位置，交给下一个方法处理的时候就会读不到内容了。
133             */
134             stream.Position = 0;
135             return result;
136         }
137 
138         /// <summary>
139         /// 读取action返回的result
140         /// </summary>
141         /// <param name="actionExecutedContext"></param>
142         /// <returns></returns>
143         public string GetResponseValues(HttpActionExecutedContext actionExecutedContext)
144         {
145             Stream stream = actionExecutedContext.Response.Content.ReadAsStreamAsync().Result;
146             Encoding encoding = Encoding.UTF8;
147             /*
148             这个StreamReader不能关闭，也不能dispose， 关了就傻逼了
149             因为你关掉后，后面的管道  或拦截器就没办法读取了
150             */
151             var reader = new StreamReader(stream, encoding);
152             string result = reader.ReadToEnd();
153             /*
154             这里也要注意：   stream.Position = 0; 
155             当你读取完之后必须把stream的位置设为开始
156             因为request和response读取完以后Position到最后一个位置，交给下一个方法处理的时候就会读不到内容了。
157             */
158             stream.Position = 0;
159             return result;
160         }
161         /// <summary>
162         /// 判断类和方法头上的特性是否要进行Action拦截
163         /// </summary>
164         /// <param name="actionContext"></param>
165         /// <returns></returns>
166         private static bool SkipLogging(HttpActionContext actionContext)
167         {
168             return actionContext.ActionDescriptor.GetCustomAttributes<NoLogAttribute>().Any() || actionContext.ActionDescriptor.ControllerDescriptor.GetCustomAttributes<NoLogAttribute>().Any();
169         }
170 
171     }
172 
173 }

如果将webapi 的 OperateTrackAttribute 注册为webapi全局的 ActionFilter 那么我们如果有不想过滤的action 时，可以通过 检查方法或类顶部特性  来对那些不需要接受拦击的 Controller 和action 顶部添加一个这样的特性来区分开，并通过在filter中检查是被拦截的action或controller 否包含此特性标记，不包含时拦截。

下面是这个类的写法，一个空的类 继承Attribute，并在类顶部写出该Attribute 使用的范围

    [AttributeUsage(AttributeTargets.Method | AttributeTargets.Class, Inherited = true)]
    public class NoLogAttribute : Attribute
    {
    }

这样我们的拦截就更灵活了，无论是添加了整个个Controller 的拦截还是全局拦截，只需要在不拦截的 controller 或action头部加上[NoLog] 

例如

 

    /// <summary>
    /// 记录该类中的Action内容
    /// </summary>
    [OperateTrack]
    public class TestApiLogController : ApiController
    {
        [HttpPost]
        public object Login(UserInfo user)
        {
            var result = new { data = user, status = true };
            return result;
        }
        /// <summary>
        /// 该类不参与记录
        /// </summary>
        /// <param name="name"></param>
        /// <returns></returns>
        [NoLog]
        public string DontLogMe(string name)
        {

            return name;
        }
    }

 

或者

/// <summary>
    /// 该Controller 下的所有action 都不会被全局的OperateTrack Filter 拦截
    /// </summary>
    [NoLog]
    public class UserManagerController : ApiController
    {
        public List<string> GetUsers() {
            return new List<string>() { "tomers","jack"};
        }
        public  string GiveUserSomeMoney(int money)
        {
            return money+"";
        }
    }

我们来测试一下： 提交到/api/TestApiLog/Login  整个action 被标记为拦截

再看看记录的结果，结果已经记录了

这样整个记录用户访问记录的拦截器就到此为止了。

需要demo在github中下载：https://github.com/shan333chao/WebApiTrackLogs