[.Net Core] 基于.netcore middleware 机制, 实现模块化开发框架

一. 背景:

　　在开发过程中，我们有时候想要独立出一块业务模块，进行模块化开发。但是微软自带的dotnet core mvc 框架秉承了传统 dotnet framework mvc 框架，再UI 层面层面，难以进行业务区分，这就回导致整个项目想当庞大。在这种背景下，我开始思考，能不能使用模块化开发方案进，从而降低单个项目的业务复杂度。 

二. 搜集:

　　在以往的开发过程中，我所了解到的模块化开发框架有 微软的 Orchard CMS 框架，最近这款框架也支持了.net core 版本。以及业界鼎鼎大名的Abp .net 框架，这款框架现在也支持了.net core 版本。

       Orchard CMS

　　优势：Orchard CMS 功能完善，支持热插拔
       劣势：学习成本较高，难以将单独的模块式开发功能拿到自己的项目中来。

　　Abp .Net

　　优势：功能完善，原生支持模块化开发

       劣势：引入模块化开发需要引入成套的Apb .Net 框架，难以与现有项目进行结合。

       通过搜集现有的框架，发现已有的框架引太过庞大，难以直接应用到现有项目中。在这个基础上，我们开始思考能不能通过dotnet core 现有的middleware功能来实现以个模块化开发框架。

三. 思路

       要自定义Request Middleware 首先要处理的就是路由问题。我们的方法是，单独维护一个Module 内部的路由表，然后在Module 定义时将路由表保存起来，然后当请求到达时去查询路由表，然后执行对应的方法。

　　注：值得注意的是，我们这里的路由表支持参数路由。

　　1. 路由表

　　路由表的设计需要注意以下几点：

　　a)  路由的添加

　　b) 路由表通过依赖注入设定为单例模式

　　c) 路由的解析，需要区别 get post , ... 等不同类型，需要支持参数表达式  /path/{id} 这样的方式

　　在这里的路由表设计，以及定义路由表的方式参考了nodejs express 的写法，在定Module方法的时候同时将路由添加到路由表：

　　a) 路由的添加：

　　首先我们要解决的是路由添加的问题，我参考了nodejs express的定义方法通过以下代码完成路由的添加：

　　

 public class InstanceBDModule : OryxWebModule
    {
        public InstanceBDModule()
        {
            Get("/user/info", async ctx =>
            {
            });
        }
    }

　　注：Get 在这里为快捷方法，Get方法的含义是 通过get 请求 /user/info 这个路由并执行，在内部通过处理将路由值处理为 /user/info_get 并保存在路由表，同时还要将Get请求的处理方法委托进行保存。通过这种方式我们可以处理get,post ,websocket 等类型的请求。
　　

 public void Request(string route, string method, Func<OryxWebContext, Task> func)
        {
            RouteTable.Add(route + "_" + method, new RouteTableItem
            {
                Func = func,
                Path = route,
                Method = method
            });
        }

    b) 路由表类的定义： 

public class RouteTable:Dictionary<string, RouteTableItem>
    {
        
    }

   c) 路由的解析：

 public static IApplicationBuilder UseOryxWeb(this IApplicationBuilder applicationBuilder)
        {
           
            //通过applicationBuilder.Use 完成中间件处理
            return applicationBuilder.Use(async (ctx, next) =>
            {
                var routeTable = ctx.RequestServices.GetService<RouteTable>();

                var serverRouteTable = ctx;10                 //匹配路由表中的值，支持参数匹配
                var targetRoute = matchRoute(ctx, routeTable);
                //如果为websocket 请求，则单独处理websocket
                if (targetRoute.Method == "ws" && ctx.WebSockets.IsWebSocketRequest)
                {
                    //非关键代码，在此注释
                }

                if (targetRoute != null)
                {
                    var routeTableItem = targetRoute;
                    var func = routeTableItem.Func;
                    if (func != null && ctx.Request.Method.ToLower() == routeTableItem.Method)
                    {
                        //包装HttpContext , 然后交由路由表中保存的委托方法处理
                        var webContext = new OryxWebContext(ctx);
                        webContext.RouteValue(targetRoute.RouteValue);
                        using (webContext.HttpContext.RequestServices.CreateScope())
                        {
                            webContext.Body = await webContext.HttpContext.Request.Body.GetString();
                            if (webContext.Body.IsTrue())
                            {
                                webContext.JsonObj = JObject.Parse(webContext.Body);
                            } 
                            await func(webContext);
                        }
                    }
                    else
                    {
                        await next();
                    }
                }
                else
                {
                    await next();
                }
            });
        }

　　至此，我们完成了路由的请求、解析并处理的过程。处理过程中我们用到了MatchRoute 方法来解析路由模板中的参数，这个方法采用了 Microsoft.AspNetCore.Routing.Template.TemplateParser.Parse  的方法来解析路由模板，通过TemplateMatcher 来获取模板路由中的值，对此方法的使用我会在另一片文章中单独介绍。具体的使用方法，大家可以查看完整的源代码来学习。

2. 处理器

　　完成了路由表的设计，还要有配套的处理器设计（类似mvc中的action 的设计）。

　　Request请求：在以往的开发过程中，我很羡慕其他阵营中框架帮忙处理好请求内容，我们直接使用即可。但是dotnet core mvc在处理的时候经常会遇到一些莫名其妙的问题，主要是由于前段content-type配置与后端 不匹配导致了发送过来的body没有数据，调试起来很头疼。所以在设计处理器框架这部分，我直接将请求的数据进行预处理，将常见的一些数据 例如json, querystring 进行处理，然后将数据通过内置的body方法传递给处理器。

　　Response相应：dotnetcore mvc 内置了Razor engine ，他本身很不错，但是cshtml 是预编译的，而我想使用的是动态处理的模板引擎，这样可以实时修改模板内容，实时更改页面。尝试了很多方式，razor engine 单独使用并不理想，所以在此框架内部我选择使用了scriban 模板引擎（dotnet liquid 也是一款非常不错的模板引擎，并且由于使用广泛，还可以兼容nodejs php使用同一种模板语法的模板引擎 ）

　　

　　在这里我们最终将Request和Response包装成OryxWebContext，代码如下：

　　Request 包含： get post websocket 处理

　　Reponse包含： Ajax WriteString RenderTemplate Send(websocket)方法

　　

public class OryxWebContext
    {
        public HttpContext HttpContext { get; }

        public WebSocket WebSocket { get; set; }

        public Dictionary<string, string> ParamDictionary { get; }

        public string Body { get; set; }

        public dynamic JsonObj { get; set; }

        public T Json<T>()
        {
            var setting = new JsonSerializerSettings();
            return JsonConvert.DeserializeObject<T>(Body, setting);
        }

        public async Task Send(string content)
        {
            var buffer = new byte[1024 * 4];
            var arrByte = new ArraySegment<byte>(Encoding.UTF8.GetBytes(content));
            await WebSocket.SendAsync(arrByte, WebSocketMessageType.Text, true, CancellationToken.None);
        }

        public Stream Stream { get; set; }

        public OryxWebContext(HttpContext httpContext)
        {
            HttpContext = httpContext;
            ParamDictionary = new Dictionary<string, string>();
            HttpContext.Request.Query.ToList().ForEach(item =>
            {
                ParamDictionary.Add(item.Key, item.Value);
            });
        }

        public async Task Write(string content)
        {
            await HttpContext.Response.WriteAsync(content);
        }
        public async Task Write(Stream stream)
        {
            HttpContext.Response.ContentType = "application/octet-stream";
            await stream.CopyToAsync(HttpContext.Response.Body);
        }

        public async Task Ajax(object jsonObj)
        {
            HttpContext.Response.ContentType = "application/json";
            var jsonSetting = new JsonSerializerSettings();
            jsonSetting.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
            var jsonStr = JsonConvert.SerializeObject(jsonObj, jsonSetting);
            await HttpContext.Response.WriteAsync(jsonStr);
        }

        public async Task Render(string tempPath, object dataObj)
        {
            var tmpStr = ReadTemplateStr(tempPath);

            TemplateContext ctx = new TemplateContext();
            ctx.TemplateLoader = new OryxTemplateLoader(@"OryxWebShared");

            var scriptObject = new ScriptObject();
            scriptObject.Import(dataObj);
            ctx.PushGlobal(scriptObject);

            var template = Template.Parse(tmpStr);
            var result = await template.RenderAsync(ctx);
            HttpContext.Response.ContentType = "text/html";
            await HttpContext.Response.WriteAsync(result);
        }

        public async Task Render(string tempPath)
        {
            var tmpStr = ReadTemplateStr(tempPath);
            TemplateContext ctx = new TemplateContext();
            ctx.TemplateLoader = new OryxTemplateLoader(@"OryxWebShared");
             
            var baseDir = AppContext.BaseDirectory;
            var dir = baseDir + Path.GetDirectoryName(tempPath);
             
            //var ll = ctx.TemplateLoader.GetPath(ctx, callerSpan, "index.html");

            var template = Template.Parse(tmpStr, dir,
                lexerOptions: new LexerOptions()
                {
                    EnableIncludeImplicitString = true
                ,
                    Mode = ScriptMode.Default
                });

            var result = await template.RenderAsync(ctx);
            //var eva = Template.Evaluate(tmpStr, ctx); 

            HttpContext.Response.ContentType = "text/html";
            await HttpContext.Response.WriteAsync(result);
        }

        public async Task RenderWithLayout(string tmepPath, string LayoutPath)
        {
            TemplateContext ctxsub = new TemplateContext();
            //获得子页面
            var subTemplate = GetTemplate(tmepPath, ctxsub);
            var tempResult = subTemplate.RenderAsync();

            //将父页面作为参数传入Layout
            TemplateContext ctxLayout = new TemplateContext();
            var scriptObject = new ScriptObject();
            scriptObject.Import(new { renderbody = tempResult });
            ctxLayout.PushGlobal(scriptObject);
            var layoutTemplate = GetTemplate(LayoutPath, ctxLayout);
            var result = await layoutTemplate.RenderAsync(ctxLayout);

            HttpContext.Response.ContentType = "text/html";
            await HttpContext.Response.WriteAsync(result);
        }

        public Template GetTemplate(string tempPath, TemplateContext ctx)
        {
            var tmpStr = ReadTemplateStr(tempPath);
            ctx.TemplateLoader = new OryxTemplateLoader(@"OryxWebShared");

            var callerSpan = new SourceSpan();
            var baseDir = AppContext.BaseDirectory;
            var dir = baseDir + Path.GetDirectoryName(tempPath);

            callerSpan.FileName = dir + "\index.html";

            //var ll = ctx.TemplateLoader.GetPath(ctx, callerSpan, "index.html");

            var template = Template.Parse(tmpStr, dir,
                lexerOptions: new LexerOptions()
                {
                    EnableIncludeImplicitString = true
                ,
                    Mode = ScriptMode.Default
                });
            return template;
        }

        private string ReadTemplateStr(string path)
        {
            var absolutePath = MapPath(path);
            return File.ReadAllText(absolutePath);
        }

        private string MapPath(string path)
        {
            return Path.Combine(AppDomain.CurrentDomain.BaseDirectory, path.TrimStart('/').Replace("/", "\"));
        }

        public void RouteValue(RouteValueDictionary routeValue)
        {
            if (routeValue != null)
            {
                routeValue.ToList().ForEach(item =>
                {
                    ParamDictionary.Add(item.Key, item.Value.ToString());
                });
            }
        }

        public string this[string key]
        {
            get
            {
                if (!ParamDictionary.ContainsKey(key))
                {
                    return string.Empty;
                }
                return ParamDictionary[key];
            }
        }

        public T Service<T>()
        {
            return HttpContext.RequestServices.GetService<T>();
        }
    }

3. Startup

  dotnet core startup 类主要有两个入口，一个用来管理类依赖注入的ConfigureServices ，一个用来配置请求Middleware 的Configure 方法。我们主要通过自定义处理 Request Middleare 来完成我们的请求处理，同时通过依赖注入将宿主的类实例引入到我们的模块中使用，Startup.cs :

public class Startup
    {
        public Startup(IConfiguration configuration)
        {
            Configuration = configuration;
        }

        public IConfiguration Configuration { get; }

        // This method gets called by the runtime. Use this method to add services to the container.
        public void ConfigureServices(IServiceCollection services)
        { 
            services.AddOryxWeb<SNSModule>();
        }

        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app, IWebHostEnvironment env, IServiceProvider serviceProvider)
        {
            app.UseOryxWeb();
        }
    }

 完整的代码地址：https://github.com/OryxLib/Oryx.FastAdmin/tree/master/Libs/Oryx.Web.Core