利用 IHttpModule 自定义 HTTP 处理模块

最新推荐文章于 2024-05-06 16:40:16 发布

weixin_30682415

最新推荐文章于 2024-05-06 16:40:16 发布

阅读量120

点赞数

文章标签： ui c# json

原文链接：http://www.cnblogs.com/liuning8023/archive/2011/12/01/2271304.html

版权

本文内容

引入
IHttpModule 概述
创建自定义 HTTP 模块的步骤
演示创建自定义 HTTP 模块
HTTP 模块的工作方式
HTTP 模块与 Global.asax 文件
参考资料

引入

本文在 VS 2008 和 IIS 6 环境下概述如何利用 IHttpModule 自定义 HTTP 模块。

当我们在 VS 2008 里新建一个 Web 应用程序项目后，会在 Web.config 文件看到如下一个配置：

<httpModules>

  <add name="ScriptModule" type="System.Web.Handlers.ScriptModule, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35"/>

</httpModules>

我们知道 VS 2008 已经可以开发 Ajax 程序，异步刷新界面，如 ScriptManager 控件、UpdatePanel 控件，那么 System.Web.Handlers.ScriptModule 类就是管理用于 ASP.NET 中 AJAX 功能的 HTTP 模块。

更进一步，看它 C# 声明：

[AspNetHostingPermissionAttribute(SecurityAction.LinkDemand, Level = AspNetHostingPermissionLevel.Minimal)]

[AspNetHostingPermissionAttribute(SecurityAction.InheritanceDemand, Level = AspNetHostingPermissionLevel.Minimal)]

public class ScriptModule : IHttpModule

该类继承了 IHttpModule 接口。代码如下所示。看看它的事件，你多少体会出如若让 Web 应用程序支持 Ajax 功能，发出异步请求，需要做什么，至少能够检查传入和传出的请求。

 
   ﻿// 
   // ScriptModule.cs 
   // 
   // Author: 
   //   Igor Zelmanovich <igorz@mainsoft.com> 
   // 
   // (C) 2007 Mainsoft, Inc.  http://www.mainsoft.com 
   // 
   // 
   // Permission is hereby granted, free of charge, to any person obtaining 
   // a copy of this software and associated documentation files (the 
   // "Software"), to deal in the Software without restriction, including 
   // without limitation the rights to use, copy, modify, merge, publish, 
   // distribute, sublicense, and/or sell copies of the Software, and to 
   // permit persons to whom the Software is furnished to do so, subject to 
   // the following conditions: 
   //  
   // The above copyright notice and this permission notice shall be 
   // included in all copies or substantial portions of the Software. 
   //  
   // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 
   // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 
   // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 
   // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE 
   // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION 
   // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION 
   // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 
   // 
     
   using System; 
   using System.Collections.Generic; 
   using System.Text; 
   using System.Web.UI; 
   using System.Web.Script.Services; 
     
   namespace System.Web.Handlers 
   { 
       public class ScriptModule : IHttpModule 
       { 
           protected virtual void Init (HttpApplication context) { 
               context.PreSendRequestHeaders += new EventHandler (PreSendRequestHeaders); 
               context.PostAcquireRequestState += new EventHandler (PostAcquireRequestState); 
               context.AuthenticateRequest += new EventHandler (AuthenticateRequest); 
           } 
     
           void AuthenticateRequest (object sender, EventArgs e) { 
               // The AuthenticateRequest event is raised after the identity of the current user has been  
               // established. The handler for this event sets the SkipAuthorization property of the HttpContext  
               // for the current request. This property is checked in the authorization module to see  
               // if it has to omit authorization checking for the requested url. Usually an HttpModule  
               // use this property to allow anonymous access to some resources (for example,  
               // the Login Page if we’re using forms authentication). In our scenario,  
               // the ScriptModule sets the SkipAuthorization to true if the requested url is  
               // scriptresource.axd or if the authorization module is enabled and the request is a rest  
               // request to the authorization web service. 
           } 
     
           void PostAcquireRequestState (object sender, EventArgs e) { 
               // The PostAcquireRequestState event is raised after the session data has been obtained.  
               // If the request is for a class that implements System.Web.UI.Page and it is a rest  
               // method call, the WebServiceData class (that was explained in a previous post) is used  
               // to call the requested method from the Page. After the method has been called,  
               // the CompleteRequest method is called, bypassing all pipeline events and executing  
               // the EndRequest method. This allows MS AJAX to be able to call a method on a page  
               // instead of having to create a web service to call a method. 
               HttpApplication app = (HttpApplication) sender; 
               HttpContext context = app.Context; 
               if (context == null) 
                   return; 
                
               HttpRequest request = context.Request; 
               string contentType = request.ContentType; 
               IHttpHandler currentHandler = context.CurrentHandler; 
               if (currentHandler == null) 
                   return; 
   #if TARGET_J2EE 
               if (!(currentHandler is Page) && currentHandler is IServiceProvider) { 
                   pageType = (Type) ((IServiceProvider) currentHandler).GetService (typeof (Type)); 
                   if (pageType == null) 
                       return; 
               } 
   #endif 
               Type pageType = currentHandler.GetType (); 
               if (typeof (Page).IsAssignableFrom (pageType) && !String.IsNullOrEmpty (contentType) && contentType.StartsWith ("application/json", StringComparison.OrdinalIgnoreCase)) { 
                   IHttpHandler h = RestHandler.GetHandler (context, pageType, request.FilePath); 
                   h.ProcessRequest (context); 
                   app.CompleteRequest (); 
               } 
           } 
     
           void PreSendRequestHeaders (object sender, EventArgs e) { 
               HttpApplication app = (HttpApplication) sender; 
               HttpContext context = app.Context; 
               if (context.Request.Headers ["X-MicrosoftAjax"] == "Delta=true") { 
                   Page p = context.CurrentHandler as Page; 
   #if TARGET_J2EE 
                   if (p == null && context.CurrentHandler is IServiceProvider) 
                       p = (Page) ((IServiceProvider) context.CurrentHandler).GetService (typeof (Page)); 
   #endif 
                   if (p == null) 
                       return; 
                   ScriptManager sm = ScriptManager.GetCurrent (p); 
                   if (sm == null) 
                       return; 
                   if (context.Response.StatusCode == 302) { 
                       context.Response.StatusCode = 200; 
                       context.Response.ClearContent (); 
                       if (context.Error == null || sm.AllowCustomErrorsRedirect) 
                           ScriptManager.WriteCallbackRedirect (context.Response.Output, context.Response.RedirectLocation); 
                       else 
                           sm.WriteCallbackException (context.Response.Output, context.Error, false); 
                   } 
                   else if (context.Error != null) { 
                       context.Response.StatusCode = 200; 
                       context.Response.ClearContent (); 
                       sm.WriteCallbackException (context.Response.Output, context.Error, true); 
                   } 
               } 
           } 
     
           protected virtual void Dispose () { 
           } 
     
           #region IHttpModule Members 
     
           void IHttpModule.Dispose () { 
               Dispose (); 
           } 
     
           void IHttpModule.Init (HttpApplication context) { 
               Init (context); 
           } 
     
           #endregion 
       } 
   } 
  

IHttpModule 概述

HTTP 模块是一个在每次针对应用程序发出请求时调用的程序集。HTTP 模块作为 ASP.NET 请求管道的一部分调用，它们能够在整个请求过程中访问生命周期事件。HTTP 模块使您可以检查传入和传出的请求并根据该请求进行操作。

HTTP 模块通常具有以下用途：

安全因为您可以检查传入的请求，所以 HTTP 模块可以在调用请求页、XML Web services 或处理程序之前执行自定义的身份验证或其他安全检查。
统计信息和日志记录因为 HTTP 模块是在每次请求时调用的，所以，您可以将请求统计信息和日志信息收集到一个集中的模块中，而不是收集到各页中。
自定义的页眉或页脚因为您可以修改传出响应，所以可以在每一个页面或 XML Web services 响应中插入内容，如自定义的标头信息。

创建自定义 HTTP 模块的步骤

编写 HTTP 模块的一般过程如下：

创建一个实现 IHttpModule 接口的类。
实现 Init 方法。该方法初始化模块，并创建所需的任何应用程序事件。例如，如果希望为响应附加一些内容，可以创建 EndRequest 事件。如果希望执行自定义身份验证逻辑，可以创建 AuthenticateRequest 事件。
为已创建的事件编写代码。
若模块需要释放，还可以实现 Dispose 方法。
在 Web.config 文件中注册模块。

演示创建自定义 HTTP 模块

将一个字符串追加到响应的开头和末尾。在对其扩展名已分配给 ASP.NET 的文件进行任何请求的过程中，该模块都将自动运行。

新建 Web 项目。
新建名为 HelloWorldModule 的类，该类继承 IHttpModule，如下所示：

 
   using System; 
   using System.Collections.Generic; 
   using System.Linq; 
   using System.Web; 
     
   namespace HttpModuleDemo 
   { 
       public class HelloWorldModule : IHttpModule 
       { 
           public HelloWorldModule() 
           { 
           } 
     
           public String ModuleName 
           { 
               get { return "HelloWorldModule"; } 
           } 
     
           // In the Init function, register for HttpApplication  
           // events by adding your handlers. 
           public void Init(HttpApplication application) 
           { 
               application.BeginRequest += 
                   (new EventHandler(this.Application_BeginRequest)); 
               application.EndRequest += 
                   (new EventHandler(this.Application_EndRequest)); 
           } 
     
           private void Application_BeginRequest(Object source, 
                EventArgs e) 
           { 
               // Create HttpApplication and HttpContext objects to access 
               // request and response properties. 
               HttpApplication application = (HttpApplication)source; 
               HttpContext context = application.Context; 
               string filePath = context.Request.FilePath; 
               string fileExtension = 
                   VirtualPathUtility.GetExtension(filePath); 
               if (fileExtension.Equals(".aspx")) 
               { 
                   context.Response.Write("<h1><font color=red>" + 
                       "HelloWorldModule: Beginning of Request" + 
                       "</font></h1><hr>"); 
               } 
           } 
     
           private void Application_EndRequest(Object source, EventArgs e) 
           { 
               HttpApplication application = (HttpApplication)source; 
               HttpContext context = application.Context; 
               string filePath = context.Request.FilePath; 
               string fileExtension = 
                   VirtualPathUtility.GetExtension(filePath); 
               if (fileExtension.Equals(".aspx")) 
               { 
                   context.Response.Write("<hr><h1><font color=red>" + 
                       "HelloWorldModule: End of Request</font></h1>"); 
               } 
           } 
     
           public void Dispose() { } 
       } 
   } 
  

在 Web.config 文件注册该模块，如下所示：

<httpModules>

  <add name="HelloWorldModule" type="HttpModuleDemo.HelloWorldModule"/>

</httpModules>

新建一个页面，并用浏览器查看该页面，页面会显示如下信息。

HTTP 模块的工作方式

模块必须注册才能从请求管道接收通知。注册 HTTP 模块的最常用方法是在应用程序的 Web.config 文件中进行注册。

当 ASP.NET 创建表示您的应用程序的 HttpApplication 类的实例时，将创建已注册的任何模块的实例。在创建模块时，将调用它的 Init 方法，并且模块会自行初始化。

当这些应用程序事件被引发时，将调用模块中的相应方法。该方法可以执行所需的任何逻辑。如检查身份验证或记录请求信息。在事件处理过程中，模块能访问当前请求的 Context 属性。这使得可以将请求重定向到其他页、修改请求或者执行任何其他请求操作。例如，若模块检查身份验证，则在凭据不正确的情况下，模块可能重定向到登录页或错误页。否则，当模块的事件处理程序完成运行时，ASP.NET 会调用管道中的下一个进程。这可能是另一个模块，也可能是用于该请求的 HTTP 处理程序（如 .aspx 文件）。

HTTP 模块与 Global.asax 文件

之所以把它们放在一起，是因为在某种程度上，它们功能有相似之处。

可以在应用程序的 Global.asax 文件中实现模块的许多功能，这使你可以响应应用程序事件。但是，

模块相对于 Global.asax 文件具有如下优点：模块可以进行封装。创建一次后在其他应用程序中使用。通过将它们添加到全局程序集缓存，并将其注册到 Machine.config 文件中，可以跨应用程序重新使用它们。
使用 Global.asax 文件的好处在于可以处理其他已注册事件，如 Session_Start 和 Session_End。此外，Global.asax 文件还允许您实例化可在整个应用程序中使用的全局对象。

当您必须创建依赖应用程序事件的代码，并且符合以下条件时，都应该使用模块：