Owin Katana 的底層源碼分析

時間 2020-05-16

標籤 owin katana 底層源碼分析简体版

原文原文鏈接

最近看了一下開源項目asp.net katana，感受公開的接口很是的簡潔優雅，channel 9 說是受到node.js的啓發設計的，Katana是一個比較老的項目，如今已經整合到asp.net core中。node

從github克隆下來的項目,這個博客專門是從代碼角度去理解katana項目，因此本篇隨筆針對已經對OWIN有所瞭解的人，若是隻是入門的話能夠跑一下MSDN的源碼再來閱讀本篇文章。git

代碼結構如上，簡單分析一下各個文件夾的含義，這對於理解katana項目的總體結構有一個大的輪廓。github

　　.build文件夾顧名思義就是編譯的文件夾，在沒使用vs的時候你能夠單擊build.cmd 去編譯這個項目，十分的方便。web

　　.Nuget就是包管理工具的配置文件，這個咱們能夠忽略。同理.Prerelease。api

　　Development是本次的研究重點，當你打開這個文件夾的時候你會發現一個類庫Microsoft.Owin的類庫，這個是OWIN組件的經典實現。服務器

　　FunctionTests是單元測試的類庫app

　　Hosting 是server的抽象層，OWIN 將服務器進行抽象化，Hosting 就是可以管理Server的一層，像WebApp就能開啓一個httplister服務，詳細稍後再講。框架

　　Middleware是一些中間件的實現，在katana已經將管道模型虛擬化成中間件asp.net

　　Performance 和Sandbox 是微軟的一些測試工具異步

　　Security 是微軟已經寫好的驗證中間件，其中包括JWT和Oauth的驗證方式

　　Server 就是服務器的實現

　　Owin.Analysis是我本人建的web程序用來debug

上面已經介紹了各個文件夾所對應的功能，相必大部分人都是一臉矇蔽，可是不用擔憂，下面就來看看具體的代碼，固然是從最小的例子出發。點擊 getting started with owin and katan 你就能跳到MSDN獲得最小的例子。裏面的一系列操做就爲了添加下面的一個類和幾個reference.如今咱們看一下這個類。

 1 using Microsoft.Owin;
 2 
 3 [assembly: OwinStartup(typeof(Owin.Analysis.Startup))]
 4 namespace Owin.Analysis
 5 {
 6     public class Startup
 7     {
 8         public void Configuration(IAppBuilder app)
 9         {
10             app.Run(context =>
11             {
12                 context.Response.ContentType = "text/plain";
13                 return context.Response.WriteAsync("Hello World");
14             });
15         }
16     }
17 }

看起來這個代碼十分的優雅，添加幾個reference和一個類就讓請求到達Hello World。咱們先分析這個類，首先程序集特性OwinStartupAtribute將當前類保存在元數據中。而後寫了一個Configuration方法，獲取一個IAppBuilder 參數調用Run方法，Run方法傳遞一個委託進去，咱們的處理邏輯就在這一個委託裏。

這裏面咱們分析一下核心接口IAppBuilder的經典實現者AppBuilder，IAppBuilder的接口以下，

using System;
using System.Collections.Generic;

namespace Owin
{
    public interface IAppBuilder
    {
        IDictionary<string, object> Properties { get; }//請求的參數

        object Build(Type returnType);//中間件連接
        IAppBuilder New();//建立一個新的對象
        IAppBuilder Use(object middleware, params object[] args);//註冊中間件
    }
}

好的咱們來分析一下AppBuilder中間件的註冊實現。在app.Run 打完break point你就能夠進入app.use方法，首先在AppBuilderUseExtensions這個類裏對use的入口寫了一大堆擴展方法。app.Run就是其中的一個，當你用app.Run註冊中間件的時候是沒有下一個中間件的引用的。

        public static void Run(this IAppBuilder app, Func<IOwinContext, Task> handler)
        {
            if (app == null)
            {
                throw new ArgumentNullException("app");
            }
            if (handler == null)
            {
                throw new ArgumentNullException("handler");
            }

            app.Use<UseHandlerMiddleware>(handler);
        }

在經典的實現中，參數middleware會有兩種狀況，一種是delegate，一種是type,若是是type類型，則他的構造方法接受next爲參數，而且裏面有一個公開的Invoke方法。若是是委託，當前委託做爲參數傳遞到next中。

 public IAppBuilder Use(object middleware, params object[] args)
        {
            _middleware.Add(ToMiddlewareFactory(middleware, args));
            return this;
        }

下面的代碼是ToMiddlewareFactory的實現，在第9行和第27行分別判斷了中間件對象是委託類型仍是type類型，因爲本題例子是type對象，咱們分析一下ToConstructorMiddlewareFactory方法。

 1 private static Tuple<Type, Delegate, object[]> ToMiddlewareFactory(object middlewareObject, object[] args)
 2         {
 3             if (middlewareObject == null)
 4             {
 5                 throw new ArgumentNullException("middlewareObject");
 6             }
 7 
 8             var middlewareDelegate = middlewareObject as Delegate;
 9             if (middlewareDelegate != null)
10             {
11                 return Tuple.Create(GetParameterType(middlewareDelegate), middlewareDelegate, args);
12             }
13 
14             Tuple<Type, Delegate, object[]> factory = ToInstanceMiddlewareFactory(middlewareObject, args);
15             if (factory != null)
16             {
17                 return factory;
18             }
19 
20             factory = ToGeneratorMiddlewareFactory(middlewareObject, args);
21             if (factory != null)
22             {
23                 return factory;
24             }
25 
26             if (middlewareObject is Type)
27             {
28                 return ToConstructorMiddlewareFactory(middlewareObject, args, ref middlewareDelegate);
29             }
30 
31             throw new NotSupportedException(string.Format(CultureInfo.CurrentCulture,
32                 Resources.Exception_MiddlewareNotSupported, middlewareObject.GetType().FullName));
33         }

在第5行獲取type類型的全部構造方法，第8行獲取構造方法的全部參數，在第14行有個trick,用zip方法判斷參數類型是否和構造方法類型是一致的。若是是一致的則繼續往下走，在第22行和第23行利用委託將構造方法建立成lambda表達式，而後生成元祖，第一個是next的類型，第二個是type的構造方法，第三個是type構造方法所需的參數。而後將元祖加入到AppBuild所維護的中間件對象。

 1  
 2         private static Tuple<Type, Delegate, object[]> ToConstructorMiddlewareFactory(object middlewareObject, object[] args, ref Delegate middlewareDelegate)
 3         {
 4             var middlewareType = middlewareObject as Type;
 5             ConstructorInfo[] constructors = middlewareType.GetConstructors();
 6             foreach (var constructor in constructors)
 7             {
 8                 ParameterInfo[] parameters = constructor.GetParameters();
 9                 Type[] parameterTypes = parameters.Select(p => p.ParameterType).ToArray();
10                 if (parameterTypes.Length != args.Length + 1)
11                 {
12                     continue;
13                 }
14                 if (!parameterTypes
15                     .Skip(1)
16                     .Zip(args, TestArgForParameter)
17                     .All(x => x))
18                 {
19                     continue;
20                 }
21 
22                 ParameterExpression[] parameterExpressions = parameters.Select(p => Expression.Parameter(p.ParameterType, p.Name)).ToArray();
23                 NewExpression callConstructor = Expression.New(constructor, parameterExpressions);
24                 middlewareDelegate = Expression.Lambda(callConstructor, parameterExpressions).Compile();
25                 return Tuple.Create(parameters[0].ParameterType, middlewareDelegate, args);
26             }
27 
28             throw new MissingMethodException(string.Format(CultureInfo.CurrentCulture,
29                 Resources.Exception_NoConstructorFound, middlewareType.FullName, args.Length + 1));
30         }

這個時候咱們已經將中間件註冊到AppBuilder對象了。註冊完中間件的對象咱們還須要作一件事就是將這些中間件chained together,這些實現就是Build 方法中，而Build方法BuildInternal方法，這個時候會產生一個entry point供調用。

如今咱們重點看一下這個build方法。

    public object Build(Type returnType)
        {
            return BuildInternal(returnType);
        }

Build方法調用私有的BuildInternal的方法。

private object BuildInternal(Type signature)
        {
            object app;
            if (!_properties.TryGetValue(Constants.BuilderDefaultApp, out app))
            {
                app = NotFound;
            }

            foreach (var middleware in _middleware.Reverse())
          {
                Type neededSignature = middleware.Item1;
                Delegate middlewareDelegate = middleware.Item2;
                object[] middlewareArgs = middleware.Item3;

                app = Convert(neededSignature, app);
                object[] invokeParameters = new[] { app }.Concat(middlewareArgs).ToArray();
                app = middlewareDelegate.DynamicInvoke(invokeParameters);
                app = Convert(neededSignature, app);
            }

            return Convert(signature, app);
        }

咱們能夠看到它是怎樣將中間件chained together的，在咱們以前註冊的時候實際上middleware元祖會保存三個信息，第一個type就是構造函數的第一個類型，第二個委託是useHandlerMiddleware的構造方法，第三個是構造方法的參數（除了第一個），Reverse的方法會將中間件逆序，這樣保證調用的順序就是你註冊的順序，後面的是chain的邏輯，app的變量實際上就是下一個中間件構造函數的next，當獲得第一個中間件的時候，裏面的next會保存第二個中間件的處理邏輯，一樣第二個next就是第三個...，這樣chained together獲得的就是第一個中間件的邏輯，因此大家在用app.Use的方法就會有一個參數next，而且須要手動調用一下。

獲得這些以後須要的就是要將中間件註冊到application管道事件呢。由於asp.net的是一個大的切面框架。

 public void Initialize(HttpApplication application)
        {
            for (IntegratedPipelineBlueprintStage stage = _blueprint.FirstStage; stage != null; stage = stage.NextStage)
            {
                var segment = new IntegratedPipelineContextStage(this, stage);
                switch (stage.Name)
                {
                    case Constants.StageAuthenticate:
                        application.AddOnAuthenticateRequestAsync(segment.BeginEvent, segment.EndEvent);
                        break;
                    case Constants.StagePostAuthenticate:
                        application.AddOnPostAuthenticateRequestAsync(segment.BeginEvent, segment.EndEvent);
                        break;
                    case Constants.StageAuthorize:
                        application.AddOnAuthorizeRequestAsync(segment.BeginEvent, segment.EndEvent);
                        break;
                    case Constants.StagePostAuthorize:
                        application.AddOnPostAuthorizeRequestAsync(segment.BeginEvent, segment.EndEvent);
                        break;
                    case Constants.StageResolveCache:
                        application.AddOnResolveRequestCacheAsync(segment.BeginEvent, segment.EndEvent);
                        break;
                    case Constants.StagePostResolveCache:
                        application.AddOnPostResolveRequestCacheAsync(segment.BeginEvent, segment.EndEvent);
                        break;
                    case Constants.StageMapHandler:
                        application.AddOnMapRequestHandlerAsync(segment.BeginEvent, segment.EndEvent);
                        break;
                    case Constants.StagePostMapHandler:
                        application.AddOnPostMapRequestHandlerAsync(segment.BeginEvent, segment.EndEvent);
                        break;
                    case Constants.StageAcquireState:
                        application.AddOnAcquireRequestStateAsync(segment.BeginEvent, segment.EndEvent);
                        break;
                    case Constants.StagePostAcquireState:
                        application.AddOnPostAcquireRequestStateAsync(segment.BeginEvent, segment.EndEvent);
                        break;
                    case Constants.StagePreHandlerExecute:
                        application.AddOnPreRequestHandlerExecuteAsync(segment.BeginEvent, segment.EndEvent);
                        break;
                    default:
                        throw new NotSupportedException(
                            string.Format(CultureInfo.InvariantCulture, Resources.Exception_UnsupportedPipelineStage, stage.Name));
                }
            }
            // application.PreSendRequestHeaders += PreSendRequestHeaders; // Null refs for async un-buffered requests with bodies.
            application.AddOnEndRequestAsync(BeginFinalWork, EndFinalWork);
        }

這裏面有一個概念就是IntegratedPipelineBlueprintStage，這個是一個鏈表結構，每一個對應的就是管道事件，每一個stage都有entry point，這樣方便咱們在不一樣的管道事件中運行中間件，在BeginEvent裏咱們獲得stage 的entry point，而後異步調用獲得結果。entry point 就是咱們上例build獲得的結果。

  private async Task RunApp(AppFunc entryPoint, IDictionary<string, object> environment, TaskCompletionSource<object> tcs, StageAsyncResult result)
        {
            try
            {
                await entryPoint(environment);
                tcs.TrySetResult(null);
                result.TryComplete();
            }
            catch (Exception ex)
            {
                // Flow the exception back through the OWIN pipeline.
                tcs.TrySetException(ex);
                result.TryComplete();
            }
        }

而後咱們分析一下怎麼在不一樣的管道中註冊事件。在MSDN的文檔描述的。

app.UseStageMarker(PipelineStage.Authenticate)

這個api會建立一個IntegratedPipelineBlueprintStage，上文說這是一個鏈表結構，之間用next屬性鏈接。在不一樣的stage中會有entry point，而後在上面的例子中註冊到不一樣的管道中去調用。下圖是api的代碼。

  public static IAppBuilder UseStageMarker(this IAppBuilder app, string stageName)
        {
            if (app == null)
            {
                throw new ArgumentNullException("app");
            }

            object obj;
            if (app.Properties.TryGetValue(IntegratedPipelineStageMarker, out obj))
            {
                var addMarker = (Action<IAppBuilder, string>)obj;
                addMarker(app, stageName);
            }
            return app;
        }