Core篇——初探Core的Http请求管道&&Middleware

目录：

1、Core 处理HTTP请求流程

2、中间件（Middleware）&&处理流程

3、创建自定义中间件&&模拟Core的请求管道

Core 处理HTTP请求流程

Http请求来到之后，会先由WebServer（ 例如IIS，Nginx） 拿到然后丢给Kestrel WebServer，再有Kestrel 将Http请求封装为HttpContext后传入给.net core 请求管道(RequestDelegate)。HttpContext经过一系列middleware后返回response给WebServer。

中间件（Middleware）&&处理流程

　　微软官方文档给出的解释是这样的：中间件是加载在应用程序管道中以处理和相应请求的组件。其中每个组件都可以 选择是否可以将请求传递给管道中下一个组件；可以在调用管道的下一个组件之前或之后执行。下面是官方文档给出的一张图。

　　也就是说一个http请求的处理过程为，经过中间件1的处理逻辑（这个时候可以在中间件1中对httpcontext做一些处理，例如写入一段内容）,调用next()方法，进入到中间件2中，重复以上步骤。最终，所有中间件的处理逻辑的输出结果都会叠加到HttpResponse中去。

　　.net core 中有三种方式调用中间件。在StartUp的Configure方法中，分别可以调用app.Use()，app.Run()，app.Map() 来调用中间件。接下来让我们来看下：

　　app.Use方法有两个重载形式：

第一个方法接收一个中间件，第二个方法接收一个上下文和一个中间件。让我们来分别调用下：

             app.Use(next =>
             {
                 return context =>
                 {
                     context.Response.WriteAsync("this is middleware1 start...  ");
                     return next(context);
                 };
             });
             app.Use(async (context, next) =>
             {
                 await context.Response.WriteAsync("this is middleware2 start...   ");
                 await next();
             });

　　app.Run方法会终止管道，返回HttpResponse。在我们Configure方法中，默认最后一个方法就是app.Run 输出一句HelloWorld ，如下图

　　Use和Run都比较简单，不再详细介绍了。来看一眼程序运行结果：

　　app.Map 方法用来构建分支管线，它会启用一个新的ApplicationBuilder。Map根据请求的路径来匹配分支管线。Map方法也可以根据不同的PathString来匹配多个分支管线或嵌套匹配。

            app.Map("/task", build =>
            {
                build.Run(async (context) =>
                {
                    await context.Response.WriteAsync("this is middleware3 For Map start...  ");
                });
            });

             app.Map("/map", build =>
             {
                 build.Map("/mapTest2", MapHandleTest2);
                 build.Run(async (context) =>
                 {
                     await context.Response.WriteAsync("this is middleware3 For Map start...  ");
                 });
             });
             app.Map("/mapTest1", MapHandleTest1);

         private void MapHandleTest1(IApplicationBuilder applicationBuilder)
         {
             applicationBuilder.Run(async context =>
             {
                 await context.Response.WriteAsync("this is middleware3HandleTest1 For Map start...  ");
             });
         }
         private void MapHandleTest2(IApplicationBuilder applicationBuilder)
         {
             applicationBuilder.Run(async context =>
             {
                 await context.Response.WriteAsync("this is middleware3HandleTest2 For Map start...  ");
             });
         }

　　Map还有个特殊的方法，MapWhen， 它接收一个Func<HttpContext, bool>的参数，可以根据Http请求上下文做一些逻辑判断。然后继续执行管道

             app.MapWhen(context => context.Request.Query.ContainsKey("branch"),
                 build =>
                     build.Run(async context =>
                     {
                         var branchVer = context.Request.Query["branch"];
                         await context.Response.WriteAsync($"Branch used = {branchVer}");
                     })
                 );

，这里再贴张.net core 自带的中间件

　　

创建自定义中间件&&模拟Core的请求管道

　　管道的实现机制由ApplicationBuilder 和 RequestDelegate 组成。RequestDelegate是Middleware的核心，Use方法会将RequestDelegate加入到ApplicationBuilder 中去，最后执行Build方法，把所有RequestDelegate reverse之后挨个执行一遍。

　　接下来编写一个自定义的Middleware。

    public class RequestTestMiddleware
    {
        private readonly RequestDelegate _next;     //中间件核心RequestDelegate，_next 表示执行下一个中间件。
        public RequestTestMiddleware(RequestDelegate next)
        {
            _next = next;
        }
        public Task Invoke(HttpContext context)
        {
            context.Response.WriteAsync("hello this is my RequestTestMiddleware");
            return _next(context);                 //覆盖delegate 的Inboke方法，将http上下文传入下一个中间件
        }
    }

    public static class RequestTestMiddlewareExtensions
    {
        public static IApplicationBuilder UseRequestTest(this IApplicationBuilder builder)      //使用扩展方法使我们的中间件对外开放。
        {
            return builder.UseMiddleware<RequestTestMiddleware>();  //将我们中间件加入到IApplicationBuilder中去。
        }
    }
　　//在StartUp 中使用我们的自定义中间件。
    app.UseRequestTest();

Http请求管道的模拟构建

     /// <summary>
     /// 拿到请求上下文，返回一个委托
     /// </summary>
     /// <param name="contex"></param>
     /// <returns></returns>
     public delegate Task RequestDelegate(Context contex);
     /// <summary>
     /// 模拟http请求上下文
     /// </summary>
     public class Context
     {

     }

RequestDelegate和Context

         public static IList<Func<RequestDelegate, RequestDelegate>> _list = new
             List<Func<RequestDelegate, RequestDelegate>>();
         static void Main(string[] args)
         {
             Use(next =>                                 //加入中间件1
             {
                 return context =>
                 {
                     Console.WriteLine("this is use middleware1");
                     return next.Invoke(context);
                 };
             });
             Use(next =>                               //加入中间件2
             {
                 return context =>
                 {
                     Console.WriteLine("this is use middleware2");
                     return next.Invoke(context);
                 };
             });
             RequestDelegate end = context =>
             {
                 Console.WriteLine("this is end...");        //管道
                 return Task.CompletedTask;
             };
             _list.Reverse();
             foreach (var middleware in _list)
             {
                 end = middleware.Invoke(end);
             }
             end.Invoke(new Context());              //实例化一个上下文实例
             Console.ReadLine();
         }
         /// <summary>
         /// 将middleware 加入到list(applicationbuilder)中
         /// </summary>
         public static void Use(Func<RequestDelegate, RequestDelegate> iMiddleware)
         {
             _list.Add(iMiddleware);
         }

Use middleware和管道执行

Jesse博客学习笔记。传送门=》 http://video.jessetalk.cn/