8.2 ASP.NET-Pipeline und Anwendungslebenszyklus
Abschnitt 8.1 stellt die Systemarchitektur von IIS und den Gesamtprozess der HTTP-Anfrageverarbeitung vor. Daraus können wir erkennen, dass jede ASP.NET-Website einer Webanwendung entspricht, die auf HTTP-Anfragen reagieren und Benutzern die erforderlichen Informationen bereitstellen kann. Wie genau reagiert eine ASP.NET-Anwendung auf HTTP-Anfragen? Welche spezifischen Verarbeitungsvorgänge sind enthalten? Dies betrifft den Lebenszyklus von ASP.NET-Anwendungen.
8.2.1 ASP.NET-Anwendungslebenszyklus*
In diesem Abschnitt wird IIS 6 als Beispiel verwendet, um Schritt für Schritt den Prozess der Verarbeitung von HTTP-Anforderungen durch ASP.NET-Anwendungen vorzustellen. Der Prozess von IIS 7 weist im Vergleich zu IIS 6 einige geringfügige Änderungen auf, ist jedoch im Allgemeinen konsistent.
1 Der Browser gibt eine HTTP-Anfrage aus, um auf eine ASP.NET-Webseite zuzugreifen.
Gehen Sie davon aus, dass es sich bei dieser Anfrage um die erste Anfrage an die ASP.NET-Anwendung handelt, zu der diese Webseite gehört.
Wenn diese Anfrage den Webserver erreicht, ist HTTP.SYS für den Empfang verantwortlich. Gemäß der URL dieser Anfrage leitet HTTP.SYS sie an den Anwendungspool weiter, der dieser ASP.NET-Anwendung entspricht, und an den Anwendungspool, der in dieser Anwendung ausgeführt wird Pool-Worker-Prozesse sind für die Bearbeitung von Anfragen verantwortlich[1].
Nachdem der Arbeitsprozess diese Anfrage erhalten hat, lädt er eine ISAPI-Erweiterung „aspnet_isapi.dll“, die für die Verarbeitung von ASP.NET-Seiten bestimmt ist, und übergibt die HTTP-Anfrage an sie.
Nachdem der Arbeitsprozess aspnet_isapi.dll geladen hat, ist aspnet_isapi.dll für das Laden der laufenden Umgebung der ASP.NET-Anwendung verantwortlich – CLR [2].
Der Arbeitsprozess arbeitet in einer nicht verwalteten Umgebung (bezogen auf das Windows-Betriebssystem selbst), während die Objekte in .NET in einer verwalteten Umgebung (bezogen auf die CLR) als Brücke für die Kommunikation zwischen den beiden arbeiten Empfangene Anforderungen (aus einer nicht verwalteten Umgebung) werden zur Verarbeitung an das entsprechende .NET-Objekt (in einer verwalteten Umgebung) weitergeleitet.
2 Erstellen Sie das ApplicationManager-Objekt und die Anwendungsdomäne
Nachdem die CLR geladen wurde, ist die ApplicationManager-Klasse für die Erstellung einer Anwendungsdomäne verantwortlich. Jede ASP.NET-Anwendung wird in ihrer eigenen Anwendungsdomäne ausgeführt und durch eine eindeutige Anwendungskennung identifiziert.
Jede Anwendungsdomäne entspricht einer Instanz der ApplicationManager-Klasse, die für die Verwaltung von ASP.NET-Anwendungen verantwortlich ist, die in der Domäne ausgeführt werden (z. B. Starten und Stoppen einer ASP.NET-Anwendung, Erstellen von Objekten in einer bestimmten ASP.NET-Anwendung usw.). .
3 Erstellen Sie ein HostingEnvironment-Objekt
Beim Erstellen einer Anwendungsdomäne für eine ASP.NET-Anwendung wird ein HostingEnvironment-Objekt erstellt, das einige Verwaltungsinformationen für die ASP.NET-Anwendung bereitstellt (z. B. die Identität der ASP.NET-Anwendung, das entsprechende virtuelle Verzeichnis und das physische Verzeichnis). und bietet einige zusätzliche Funktionen (z. B. die Registrierung eines Objekts in der Anwendungsdomäne, die Nachahmung eines bestimmten Benutzers usw.).
4 Erstellen Sie ASP.NET Core-Objekte für jede Anfrage
Beim Erstellen der Anwendungsdomäne wird ein ISAPIRuntime-Objekt erstellt und dessen ProcessRequest()-Methode automatisch aufgerufen. Bei dieser Methode erstellt das ISAPIRuntime-Objekt ein HttpWorkerRequest-Objekt basierend auf der eingehenden HTTP-Anforderung. Dieses Objekt verpackt verschiedene Informationen der HTTP-Anforderung auf objektorientierte Weise (d. h. die ursprünglichen HTTP-Anforderungsinformationen werden als HttpWorkerRequest-Objekt gekapselt). Rufen Sie dann die StartProcessing()-Methode des ISAPIRuntime-Objekts auf, um den gesamten HTTP-Anforderungsverarbeitungsprozess zu starten (dies ist die „HTTP-Pipeline: HTTP-Pipeline“). Zu Beginn dieses Verarbeitungsprozesses wird ein Objekt vom Typ HttpRuntime erstellt Das zuvor erstellte HttpWorkerRequest-Objekt wird als verwendet. Die Methodenparameter werden an die ProcessRequest()-Methode dieses HttpRuntime-Objekts übergeben.
In der ProcessRequest()-Methode der HttpRuntime-Klasse werden einige sehr wichtige Arbeiten ausgeführt, von denen die folgenden am engsten mit Web-Software-Ingenieuren verwandt sind:
Die ProcessRequest()-Methode der HttpRuntime-Klasse erstellt ein HttpContext-Objekt basierend auf den HTTP-Anforderungsinformationen, die im HttpWorkerRequest-Objekt bereitgestellt werden.
Das HttpContext-Objekt ist wichtig, da dieses Objekt zwei weitere Objekte enthält, die in der ASP.NET-Programmierung sehr häufig vorkommen: HttpResponse und HttpRequest.
Die Informationen im HttpRequest-Objekt stammen aus der ursprünglichen HTTP-Anfrage. Das URL-Attribut stellt beispielsweise die URL in den ursprünglichen HTTP-Anfrageinformationen dar.
Das HttpResponse-Objekt verfügt über einige Eigenschaften und Methoden zum Generieren von Informationen, die an den Browser zurückgegeben werden.
Die Page-Klasse stellt entsprechende Eigenschaften zum Verweisen auf diese beiden Objekte bereit, sodass Sie die Eigenschaften „Requset“ und „Response“ direkt verwenden können, um auf diese beiden Objekte auf der ASP.NET-Webseite zuzugreifen. Zum Beispiel:
öffentliche Teilklasse _Default: System.Web.UI.Page
{
protected void Page_Load(object sender, EventArgs e)
{
Antwort .Write(Request .Url);
}
}
Die Context-Eigenschaft der Page-Klasse verweist auf das HttpContext-Objekt, sodass der obige Code auch in der folgenden Form umgeschrieben werden kann:
öffentliche Teilklasse _Default: System.Web.UI.Page
{
protected void Page_Load(object sender, EventArgs e)
{
this.Context.Response .Write(this.Context.Request .Url);
}
}
Bezüglich der drei Objekte HttpContext, HttpResponse und HttpRequest müssen Sie folgende Punkte beherrschen:
l Das HttpContext-Objekt enthält zwei Objekte, HttpResponse und HttpRequest. Sie können HTTP-Anforderungsinformationen vom HttpRequest-Objekt erhalten, und der an den Browser auszugebende Inhalt kann durch Aufrufen der HttpResponse-Methode erreicht werden.
l Für jede HTTP-Anfrage erstellt ASP.NET ein HttpContext-Objekt, auf das während der gesamten HTTP-Verarbeitung zugegriffen werden kann.
5 Weisen Sie ein HttpApplication-Objekt zu, um die Anforderung zu verarbeiten
Neben der Erstellung des HttpContext-Objekts erledigt die ProcessRequest()-Methode der HttpRuntime-Klasse auch eine weitere sehr wichtige Aufgabe: Sie beantragt die Zuweisung eines HttpApplication-Objekts zu einer Instanz der HttpApplicationFactory-Klasse [3], um jeden Schritt in der gesamten HTTP-Anforderungsverarbeitung zu verwalten Pipeline-Art von Veranstaltung.
Das HttpApplicationFactory-Objekt ist für die Verwaltung eines HttpApplication-Objektpools verantwortlich [4]. Wenn eine HTTP-Anfrage eingeht und ein HttpApplication-Objekt im Pool verfügbar ist, wird dieses Objekt direkt zur Verarbeitung der HTTP-Anfrage zugewiesen erstellt.
6 Das HttpApplication-Objekt startet die HTTP-Pipeline
Das HttpApplication-Objekt ist für den Aufbau der gesamten „HTTP-Anforderungsverarbeitungspipeline“ verantwortlich. Die „HTTP-Anforderungsverarbeitungspipeline“ kann mit der „Produktionspipeline“ in einer modernen Fabrik verglichen werden. Das im vorherigen Schritt erstellte HttpContext-Objekt ist das „Produkt“, das von dieser Produktionspipeline verarbeitet werden soll. Wenn es durch verschiedene Teile der „Produktionspipeline“ fließt, wird es spezifisch verarbeitet.
Wie laufen diese spezifischen „Prozesse und Behandlungen“ ab?
Einfach ausgedrückt: Wenn das HttpContext-Objekt verschiedene Teile der „Produktionspipeline“ durchläuft, löst das HttpApplication-Objekt eine Reihe von Ereignissen aus [5]. Eine bestimmte Komponente – das HTTP-Modul (HTTP-Modul) – kann auf diese Ereignisse reagieren. In diesem Ereignisantwortcode kann das HttpContext-Objekt „verarbeitet und verarbeitet“ werden. In diesem Sinne kann das HTTP-Modul als „Produktionspipeline“ betrachtet werden. ”Arbeiter in. Das HTTP-Modul ist eigentlich der zuvor eingeführte „ISAPI-Filter“.
Das HTTP-Modulobjekt wird in der InitModules()-Methode [6] des HttpApplication-Objekts erstellt. Wir schreiben im Allgemeinen Code in die Init()-Methode [7] des HTTP-Modulobjekts, damit es auf bestimmte von der HttpApplication ausgelöste Ereignisse reagieren kann Objekt.
ASP.NET bietet einige vordefinierte HTTP-Module, um auf bestimmte Ereignisse zu reagieren. Web-Softwareentwickler können auch eigene HTTP-Module schreiben und diese in die „HTTP-Anforderungsverarbeitungspipeline“ einfügen [8].
In der Mitte der Pipeline (nach der Verarbeitung verwandter Ereignisse) wird das HttpContext-Objekt vom letzten Page-Objekt empfangen (aus diesem Grund kann auf das HttpContext-Objekt in der ASP.NET-Seite über die von der Page-Klasse definierte Context-Eigenschaft zugegriffen werden).
Jede aufgerufene ASP.NET-Seite wird in eine „von der Page-Klasse abgeleitete Seitenklasse“ konvertiert.
Hinweis: Die Page-Klasse implementiert die IHttpHandler-Schnittstelle, die eine ProcessRequest()-Methode definiert.
Nachdem die ASP.NET-Seitenklasse generiert wurde, wird sie automatisch in eine Assembly kompiliert und dann wird ihre ProcessRequest()-Methode automatisch aufgerufen (da die Page-Klasse die IHttpHandler-Schnittstelle implementiert, muss sie über diese Methode verfügen). Bei dieser Methode wird der vom Web-Softwareentwickler geschriebene Code ausgeführt (sofern vorhanden). Das Ausführungsergebnis der ProcessRequest()-Methode wird erneut vom HttpContext-Objekt übertragen, die Steuerung wird zurück an die „HTTP-Anforderungsverarbeitungspipeline“ übertragen und das HttpApplication-Objekt löst weiterhin nachfolgende Ereignisse aus. Wenn zu diesem Zeitpunkt bestimmte HTTP-Module vorhanden sind, die auf diese Ereignisse reagieren, werden sie automatisch aufgerufen.
Das HttpContext-Objekt bringt das endgültige Verarbeitungsergebnis an das Ende der „HTTP-Anforderungsverarbeitungspipeline“, und seine Informationen werden herausgenommen und unter Verwendung von aspnet_isapi.dll als Brücke erneut an den Arbeitsprozess übertragen. Der Worker-Prozess übergibt dann die Verarbeitungsergebnisse der HTTP-Anfrage an HTTP.SYS, das für die Rückgabe der Ergebnisse an den Browser verantwortlich ist.
Gemäß der vorherigen Einführung kann die gesamte HTTP-Pipeline in drei Abschnitte unterteilt werden: Vorverarbeitungsphase, Verarbeitungsphase und Nachverarbeitungsphase (Abbildung 8 – 14).
Abbildung 8 – 14 Drei Stufen der HTTP-Pipeline
Wie in Abbildung 8 ‑14 dargestellt, sind die Vorverarbeitungs- und Nachverarbeitungsphasen der HTTP-Pipeline hauptsächlich von mehreren HTTP-Modulen beteiligt und werden durch Ereignisse gesteuert. Die in diesen beiden Phasen durchgeführte Arbeit dient hauptsächlich der Ausführung verschiedener Attribute des HttpContext-Objekts.
Die Verarbeitung von HTTP-Anfragen wird schließlich in der „Verarbeitungsphase“ durch ein Objekt abgeschlossen, das die IHttpHandler-Schnittstelle implementiert. Jede von ASP.NET-Webseiten generierte Seitenklasse implementiert diese Schnittstelle. Das PageHandlerFactory-Objekt [9] ist für die Erstellung eines geeigneten HTTP-Anfrageverarbeitungsobjekts verantwortlich.
Es ist ersichtlich, dass das Objekt, das die IHttpHandler-Schnittstelle implementiert, für die Verarbeitung von HTTP-Anfragen verantwortlich ist, weshalb es als „Handler (Handler)“ bezeichnet wird.
Neben den gängigsten ASP.NET-Webseiten können Web-Softwareentwickler auch eigene Objekte erstellen, die die IHttpHandler-Schnittstelle implementieren, und diese in die HTTP-Pipeline einfügen, um HTTP-Anfragen zu verarbeiten.
Wenn die HTTP-Anfrage verarbeitet wird, werden die zugehörigen Objekte freigegeben, aber die erstellte Anwendungsdomäne, HttpApplication und andere Objekte bleiben bestehen und können auf die nächste HTTP-Anfrage antworten.
7 Zusammenfassung des ASP.NET-Anwendungslebenszyklus
In diesem Abschnitt wird der Lebenszyklus von ASP.NET-Anwendungen vorgestellt. Dies ist ein recht komplexer Prozess. Mit der folgenden gängigen Analogie ist es möglicherweise einfacher, ihn zu verstehen.
l „HTTP-Anforderungsverarbeitungspipeline“ ist ein „Produktionsfließband“ in einer modernen Fabrik, und das HttpContext-Objekt ist das Produkt, das auf diesem Fließband verarbeitet werden soll.
l Das HttpHandler-Objekt (HTTP-Handler) ist der Kern der gesamten „Produktproduktionslinie“, die für den Zusammenbau des Produkts in Form verantwortlich ist.
l HttpModule (HTTP-Modul) entspricht Hilfsarbeitern an der „Produktionslinie“. Sie führen „Vorverarbeitung“ (Vorbereitung für die Produktmontage) und „Nachbearbeitung“ (Vorbereitung für die Produktlieferung, z. B. Etikettierung) durch das Produkt (HttpContext-Objekt) ).
l Das HttpApplication-Objekt ist der „Anführer“ der gesamten „Produktionslinie“. Er ist dafür verantwortlich, Arbeiter der „Produktionslinie“ zuzuweisen (alle registrierten HttpModules zu initialisieren und zu laden) und dann eine Reihe von Ereignissen auszulösen (genannt „ASP“). NET-Anwendungsereignisse" "), ist ein bestimmtes HttpModule für die Reaktion auf bestimmte Ereignisse verantwortlich.
-------------------------------------------------- ----------------------------------
[1] Wenn der Arbeitsprozess nicht vorhanden ist, erstellt das IIS-Überwachungsprogramm WAS einen, andernfalls wird der vorhandene Arbeitsprozess wiederverwendet.
[2] Im integrierten IIS 7-Modus ist dieser Schritt nicht erforderlich, da die CLR vorinstalliert ist.
[3] „Instanz einer Klasse“ und „Objekt einer Klasse“ haben die gleiche Bedeutung und beziehen sich beide auf Objekte, die mithilfe von Klassen als Vorlagen erstellt wurden.
[4] Der Objektpool (Objektpool) ist eine gängige Objektorganisationsmethode in objektorientierten Softwaresystemen. Er kann als Objektcontainer betrachtet werden. Der Objektpool enthält mehrere im Voraus erstellte Objekte. Wenn die Außenwelt ein Objekt benötigt, kann sie ein fertiges Objekt direkt aus dem Pool entnehmen und verwenden, wodurch der Leistungsverlust durch häufige Objekterstellung vermieden wird.
[5] HttpApplication definiert eine ganze Reihe von Ereignissen. Eine vollständige Liste der Ereignisse finden Sie im MSDN.
[6] Diese Methode wird automatisch aufgerufen, wenn das HttpApplication-Objekt abgerufen wird.
[7] Alle HTTP-Module müssen die IHttpModule-Schnittstelle implementieren, und die Init()-Methode wird durch diese Schnittstelle definiert.
[8] Benutzerdefinierte HTTP-Module können dem HTTP-Anforderungsverarbeitungsablauf hinzugefügt werden, indem spezifische Inhalte in Web.Config eingefügt werden.
[9] Dies ist ein weiterer Kern des ASP.NET-Technologie-Frameworks