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
    {

    }

        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);
        }

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