细说 HttpHandler 的映射过程

在ASP.NET编程模型中，一个来自客户端的请求要经过一个称为管线的处理过程。在整个处理请求中，相对于其它对象来说，HttpHandler的处理算得上是整个过程的核心部分。由于HttpHandler的重要地位，我前面已经有二篇博客对它过一些使用上的介绍。【用Asp.net写自己的服务框架】中谈到了它的一般使用方法。【细说ASP.NET的各种异步操作】又详细地介绍了异步HttpHandler的使用方式。

今天的博客将着重介绍HttpHandler的配置，创建以及重用过程，还将涉及HttpHandlerFactory的内容。

回顾HttpHandler

HttpHandler其实是一类统称：泛指实现了IHttpHandler接口的一些类型，这些类型有一个共同的功能，那就是可以用来处理HTTP请求。 IHttpHandler的接口定义如下：

// 定义 ASP.NET 为使用自定义 HTTP 处理程序同步处理 HTTP Web 请求而实现的协定。
public interface IHttpHandler
{
    // 获取一个值，该值指示其他请求是否可以使用 System.Web.IHttpHandler 实例。
    //
    // 返回结果:
    //     如果 System.Web.IHttpHandler 实例可再次使用，则为 true；否则为 false。
    bool IsReusable { get; }

    // 通过实现 System.Web.IHttpHandler 接口的自定义 HttpHandler 启用 HTTP Web 请求的处理。
    void ProcessRequest(HttpContext context);
}

有关HttpHandler的各类用法，可参考我的博客【用Asp.net写自己的服务框架】，本文将不再重复说明了。它还有一个异步版本：

// 摘要:
//     定义 HTTP 异步处理程序对象必须实现的协定。
public interface IHttpAsyncHandler : IHttpHandler
{
    // 摘要:
    //     启动对 HTTP 处理程序的异步调用。
    //
    // 参数:
    //   context:
    //     一个 System.Web.HttpContext 对象，该对象提供对用于向 HTTP 请求提供服务的内部服务器对象（如 Request、Response、Session
    //     和 Server）的引用。
    //
    //   extraData:
    //     处理该请求所需的所有额外数据。
    //
    //   cb:
    //     异步方法调用完成时要调用的 System.AsyncCallback。如果 cb 为 null，则不调用委托。
    //
    // 返回结果:
    //     包含有关进程状态信息的 System.IAsyncResult。
    IAsyncResult BeginProcessRequest(HttpContext context, AsyncCallback cb, object extraData);
    //
    // 摘要:
    //     进程结束时提供异步处理 End 方法。
    //
    // 参数:
    //   result:
    //     包含有关进程状态信息的 System.IAsyncResult。
    void EndProcessRequest(IAsyncResult result);
}

IHttpAsyncHandler接口的二个方法该如何使用，可参考我的博客【细说ASP.NET的各种异步操作】，本文也将不再重复讲解。

如果我们创建了一个自定义的HttpHandler，那么为了能让它处理某些HTTP请求，我们还需将它注册到web.config中，就像下面这样：


<httpHandlers>
    <add path="*.fish" verb="*" validate="true" type="MySimpleServiceFramework.AjaxServiceHandler"/>
</httpHandlers>

虽然我以前的博客中也曾多次涉及到HttpHandler，但感觉还是没有把它完整地说清楚，今天的博客将继续以前的话题，因为我认为HttpHandler实在是太重要了。

HttpHandler的映射过程

在博客【用Asp.net写自己的服务框架】中，我从MSDN中摘选了一些ASP.NET管线事件，在这些事件中，第10个事件【根据所请求资源的文件扩展名（在应用程序的配置文件中映射），选择实现 IHttpHandler 的类，对请求进行处理】就是本文要介绍的重点事件。这个事件也是HttpHandler创建的地方。

由于IIS6,7在管线事件触发机制上的有一定的差别，本文将以ASP.NET 2.0以及IIS6的运行方式来介绍这个过程， IIS7的集成模式下只是触发机制不同，但事件的绝大部分是一样的。管线事件由HttpApplication控制，由MapHandlerExecutionStep负责封装这个事件的执行过程：

internal class MapHandlerExecutionStep : HttpApplication.IExecutionStep
{
    private HttpApplication _application;

    void HttpApplication.IExecutionStep.Execute()
    {
        HttpContext context = this._application.Context;
        HttpRequest request = context.Request;

        //我删除了一些与本文无关的调用代码

        context.Handler = this._application.MapHttpHandler(
                context, request.RequestType, request.FilePathObject, request.PhysicalPathInternal, false);
    }

Execute()最终调用了MapHttpHandler()方法，这个映射过程是由HttpApplication实现的。
MapHttpHandler方法的实现如下：注意代码中我加入的注释。


/// <summary>
/// 根据虚拟路径映射到具体的HttpHandler对象
/// </summary>
/// <param name="context">HttpContext的实例</param>
/// <param name="requestType">GET, POST ...</param>
/// <param name="path">一个虚拟路径映射的字符串: /abc.aspx</param>
/// <param name="pathTranslated">要请求的物理文件的路径</param>
/// <param name="useAppConfig"></param>
/// <returns>具体的HttpHandler对象</returns>
internal IHttpHandler MapHttpHandler(HttpContext context, string requestType, 
                                    VirtualPath path, string pathTranslated, bool useAppConfig)
{
    // 说明：这段代码是我精简后的代码。为了便于理解，我去掉了一些与请求无关的代码行。

    IHttpHandler handler = (context.ServerExecuteDepth == 0) ? context.RemapHandlerInstance : null;

    //用于将当前线程的运行帐号切换为web.config指定的帐号
    using( new ApplicationImpersonationContext() ) {

        // 如果之前调用过context.RemapHandler()，则直接返回那个HttpHandler
        // 把这个判断放在这里似乎没有意义，应该放在using前面，那样岂不是更快吗？【fish li个人意见】
        if( handler != null )
            return handler;

        // 到 <httpHandlers> 配置中查找一个能与requestType以及path匹配的配置项
        HttpHandlerAction mapping = this.GetHandlerMapping(context, requestType, path, useAppConfig);
        if( mapping == null ) 
            throw new HttpException("Http_handler_not_found_for_request_type");

        // 获取IHttpHandlerFactory对象，这是比较重要的调用。
        IHttpHandlerFactory factory = this.GetFactory(mapping);

        // 尝试转换成IHttpHandlerFactory2对象。设计二个IHttpHandlerFactory的原因与参数的可见类型有关。
        IHttpHandlerFactory2 factory2 = factory as IHttpHandlerFactory2;

        // 调用IHttpHandlerFactory对象的GetHandler方法获取具体的HttpHandler对象
        if( factory2 != null ) 
            handler = factory2.GetHandler(context, requestType, path, pathTranslated);                
        else 
            handler = factory.GetHandler(context, requestType, path.VirtualPathString, pathTranslated);

        // 将这二个对象都添加到【临时】回收列表。在管线处理的结尾处，会调用HandlerWithFactory.Recycle()
        // 进而会调用factory.ReleaseHandler()，最后会丢掉_handlerRecycleList的引用。
        // 因此factory的重用与这里无关，它只可能会影响handler
        this._handlerRecycleList.Add(new HandlerWithFactory(handler, factory));
    }
    return handler;
}

今天的代码将着重分析这段代码，以揭示HttpHandler的映射过程。

在这段代码中，有3个主要的调用过程：
1. this.GetHandlerMapping(context, requestType, path, useAppConfig)
2. this.GetFactory(mapping)
3. factory.GetHandler(context, requestType, path.VirtualPathString, pathTranslated)
后面将着重分析这三个调用。

HttpContext.RemapHandler()

在MapHttpHandler()方法的开始处，有这么一段代码，不知您注意没有？


IHttpHandler handler = (context.ServerExecuteDepth == 0) ? context.RemapHandlerInstance : null;

if( handler != null )
    return handler;

这段代码是什么意思呢？
为了能让您较为简单地理解这段代码的意义，请看我准备的一个示例：
我创建了一个TestRemapHandler.ashx文件：

<%@ WebHandler Language="C#" Class="TestRemapHandler" %>

using System;
using System.Web;

public class TestRemapHandler : IHttpHandler {
    
    public void ProcessRequest (HttpContext context) {
        context.Response.ContentType = "text/plain";
        context.Response.Write("Hello TestRemapHandler");
    }
 
    public bool IsReusable {
        get {
            return false;
        }
    }
}

至于这个文件在运行时能输出什么，我想我就不用截图了。
接下来，我再创建一个Global.asax文件，并写了一个事件处理方法：

//protected void Application_PostResolveRequestCache(object sender, EventArgs e)
//{
//    HttpApplication app = (HttpApplication)sender;
//    if( app.Request.FilePath.EndsWith(".ashx", StringComparison.OrdinalIgnoreCase) )
//        app.Context.RemapHandler(new MyTestHandler());
//}

// 或者是下面这样

protected void Application_PostResolveRequestCache(object sender, EventArgs e)
{
    HttpApplication app = (HttpApplication)sender;
    if( app.Request.FilePath.EndsWith("/TestRemapHandler.ashx", StringComparison.OrdinalIgnoreCase) )
        app.Context.RemapHandler(new MyTestHandler());
}

MyTestHandler是我定义的一个自定义的HttpHandler，后面的示例也会用到它，所以，我现在就将它的实现代码贴出来：

public class MyTestHandler : IHttpHandler
{
    private Counter _counter = new Counter();

    public bool IsReusable
    {
        get { return true; }
    }

    public void ProcessRequest(HttpContext context)
    {
        _counter.ShowCountAndRequestInfo(context);
    }
}

类型Counter是一个简单的计数器，它的实现如下：

/// <summary>
/// 一个简单的计数器
/// </summary>
public class Counter
{
    private int _count;

    public void ShowCountAndRequestInfo(HttpContext context)
    {
        _count++;
        context.Response.ContentType = "text/plain";
        context.Response.Write("count: " + _count.ToString());
        context.Response.Write("\r\n");
        context.Response.Write(context.Request.RawUrl);
    }
}

现在，您可以想像一下当我再次访问TestRemapHandler.ashx时，会在浏览器中看到什么？

以下是我看到的结果：

从截图中，我们可以看出，服务端的输出并不是TestRemapHandler.ashx产生的，而是由MyTestHandler产生的。这也说明我调用Context.RemapHandler()确实影响了后面的MapHttpHandler过程。现在我们再回过头来再看一下前面那段代码：


IHttpHandler handler = (context.ServerExecuteDepth == 0) ? context.RemapHandlerInstance : null;

if( handler != null )
    return handler;

这段代码也主要是为配合HttpContext.RemapHandler()一起工作的。这里要补充的是：context.ServerExecuteDepth的判断是说有没有调用HttpServerUtility.Execute()

小结：如果我们在MapHttpHandler事件前调用HttpContext.RemapHandler()，将会直接影响后面的映射过程，或者说，我们可以直接指定一个HttpHandler，而不是让ASP.NET来替我们来决定。

HttpContext.RemapHandler()的另类用途

我在【用Asp.net写自己的服务框架】曾演示过ASP.NET URL路由的设计思路，虽然那个示例能较好地反映微软的Routing组件的工作方式，但对于示例来说，有些代码还是可以简化的。今天我将使用HttpContext.RemapHandler()来简化那段代码，简化后的版本如下：

internal class MyServiceUrlRoutingModule2 : IHttpModule
{
    public void Init(HttpApplication app)
    {
        app.PostResolveRequestCache += new EventHandler(app_PostResolveRequestCache);
    }

    private void app_PostResolveRequestCache(object sender, EventArgs e)
    {
        HttpApplication app = (HttpApplication)sender;

        // 根据HttpContext，获取合适的HttpHandler，这个过程俗称路由
        // 通常就是根据URL去主动寻找一个合适的HttpHandler

        // 查找过程仍使用上一版的方法
        MyServiceHandler handler = MyServiceUrlRoutingModule.GetHandler(app.Context);
        if( handler != null )
            // 直接设置已找到的HttpHandler
            app.Context.RemapHandler(handler);
    }

    public void Dispose()
    {
    }
}

在MyServiceUrlRoutingModule2这个新版本中，基本上跳过了MapHttpHandler()中所有复杂的处理逻辑，因此会更快。

这种方法虽然更简单，但它只能设置一个参数IHttpHandler，因此，如果有其它的参数需要一起传递，则要修改相关的HttpHandler类型，以便容纳需要传递的参数。例如，在【我的服务框架】中， MyServiceHandler类型就专门定义了一个属性ServiceInfo来保存要调用的方法信息。 MyServiceUrlRoutingModule.GetHandler()的实现代码如下：

internal static MyServiceHandler GetHandler(HttpContext context)
{
    NamesPair pair = FrameworkRules.ParseNamesPair(context.Request);
    if( pair == null )
        return null;

    InvokeInfo vkInfo = ReflectionHelper.GetInvokeInfo(pair);
    if( vkInfo == null )
        ExceptionHelper.Throw404Exception(context);


    MyServiceHandler handler = MyServiceHandlerFactory.GetHandler(vkInfo);
    handler.ServiceInfo = new ServiceInfo(pair, vkInfo);
    return handler;
}

写到这里，有个问题把我难住了：为什么ASP.NET 3.5 UrlRoutingModule不用RemapHandler()而是采用较复杂的方法呢？难道是为了能保留二个参数吗？但那个【context.Request.Path】没有必要保存呢。实在是没有想通，最后想到ASP.NET 4.0 UrlRoutingModule会不会不一样了？于是，只好再次安装 .net framework 4.0 了（没办法，老家的旧机器上还真没有.net 4.0），结果当我用Reflector.exe找到4.0版本的UrlRoutingModule时，发现它已被移到System.Web.dll中，而且， ASPL.NET 4.0也在使用RemapHandler() ！看来微软当初忘记了这个方法。

GetHandlerMapping()

在MapHttpHandler()方法中，有下面这个调用：


// 到 <httpHandlers> 配置中查找一个能与requestType以及path匹配的配置项
HttpHandlerAction mapping = this.GetHandlerMapping(context, requestType, path, useAppConfig);

接下来，我们再来看一下这个调用的实现代码：

private HttpHandlerAction GetHandlerMapping(HttpContext context, string requestType, VirtualPath path, bool useAppConfig)
{
    CachedPathData pathData = null;
    HandlerMappingMemo cachedHandler = null;
    HttpHandlerAction mapping = null;
    if (!useAppConfig)
    {
        // 先从缓存中查找
        pathData = context.GetPathData(path);
        cachedHandler = pathData.CachedHandler;
        if ((cachedHandler != null) && !cachedHandler.IsMatch(requestType, path))
        {
            cachedHandler = null;
        }
    }
    if (cachedHandler == null)
    {
        // 根据配置文件，查找映射
        mapping = (useAppConfig ? RuntimeConfig.GetAppConfig().HttpHandlers 
                                : RuntimeConfig.GetConfig(context).HttpHandlers)
            .FindMapping(requestType, path);

        if (!useAppConfig)
        {
            // 将查找到的结果放入缓存
            cachedHandler = new HandlerMappingMemo(mapping, requestType, path);
            pathData.CachedHandler = cachedHandler;
        }
        return mapping;
    }
    return cachedHandler.Mapping;
}

代码中的重要阶段，我加了一点注释。我们尤其要注意的FindMapping(requestType, path)的那个调用。
但前面的那个RuntimeConfig.GetAppConfig().HttpHandlers 和RuntimeConfig.GetConfig(context).HttpHandlers) 又可以得到什么结果呢？
为了能让您更容易地理解这个调用，我准备了一段代码，可以直观地显示这个调用结果：

public partial class TestRuntimeConfig : System.Web.UI.Page
{
    protected string HttpHandlers;

    protected void Page_Load(object sender, EventArgs e)
    {
        string typeName = typeof(HttpRequest).AssemblyQualifiedName
                                        .Replace("HttpRequest", "Configuration.RuntimeConfig");
        Type type = Type.GetType(typeName);

        bool useAppConfig = Request.QueryString["useAppConfig"] == "1";

        // 由于RuntimeConfig类型的可见性是internal，
        // 所以，我不能直接用它声明变量，只能使用object类型
        object config = null;

        if( useAppConfig )
            config = type.InvokeMember("GetAppConfig",
                BindingFlags.InvokeMethod | BindingFlags.Static | BindingFlags.NonPublic,
                null, null, null);
        else
            config = type.InvokeMember("GetConfig",
                BindingFlags.InvokeMethod | BindingFlags.Static | BindingFlags.NonPublic,
                null, null, new object[] { this.Context });


        HttpHandlersSection section = (HttpHandlersSection)type.InvokeMember("HttpHandlers",
             BindingFlags.GetProperty | BindingFlags.Instance | BindingFlags.NonPublic,
             null, config, null);

        HttpHandlers = string.Format("总共 {0} 个配置项。<br />", section.Handlers.Count) +
            string.Join("<br />", (
                from h in section.Handlers.Cast<HttpHandlerAction>()
                let action = string.Format("path=\"{0}\" verb=\"{1}\" validate=\"{2}\" type=\"{3}\"",
                        h.Path, h.Verb, h.Validate, h.Type)
                select action).ToArray());
    }
}

我的示例网站中的web.config中的<httpHandlers>配置节定义如下：

<httpHandlers>
    <add path="Ajax*.*.aspx,Ajax*/*.aspx" verb="*" validate="true" 
                type="MySimpleServiceFramework.AjaxServiceHandler, MySimpleServiceFramework" />
    <add path="*.test" verb="*" validate="true" type="MyTestHandler" />
</httpHandlers>

那么，前面的示例代码的运行结果如下：

通过前面分析可知，代码中的HttpHandlers实际就是在运行时所能访问到的<httpHandlers>配置集合。而且，我们在网站中所指定的配置会放在集合的前面，ASP.NET的默认配置会在靠后的位置。接下来的FindMapping(requestType, path)的实现如下：

internal HttpHandlerAction FindMapping(string verb, VirtualPath path)
{
    this.ValidateHandlers();
    for (int i = 0; i < this.Handlers.Count; i++)
    {
        HttpHandlerAction action = this.Handlers[i];
        if (action.IsMatch(verb, path))
        {
            return action;
        }
    }
    return null;
}

从代码可以看出，其实所谓的【查找】过程，也就是【逐一匹配】每个在<httpHandlers>定义的配置项。

至于action.IsMatch()的匹配方式，我们可以从调用所传递的参数看出，其实只是判断【verb, path】这二个参数而已。这个匹配过程的实现代码较长，我就不贴出它们的实现代码了，而是打算通过示例来说明它是如何匹配的。

action.IsMatch()的匹配方式也可以算是GetHandlerMapping()的核心过程。而这里的action的类型其实是HttpHandlerAction，它与<httpHandlers>配置项一一对应。我们可以先来看一下MSDN是如何解释这个配置项的：

从MSDN的解释中可以看出：verb,path都可以支持【通配符(*)】，并且可以使用逗号(,)来分隔多个预期项。 ASP.NET在实现通配符时，内部使用正则表达式的方式，具体过程可以自己去阅读相关代码。

下面，我将通过一个具体的配置项来分析这些配置参数：


<add path="Ajax*.*.aspx,Ajax*/*.aspx" verb="*" validate="true" 
        type="MySimpleServiceFramework.AjaxServiceHandler, MySimpleServiceFramework" />

1. path="Ajax*.*.aspx,Ajax*/*.aspx"：表示可以接受【Ajax*.*.aspx】或者【Ajax*/*.aspx】这样的URL格式。
2. verb="*": 表示可以接受所有的HTTP调用，如：GET,POST 等等。
3. type="MySimpleServiceFramework.AjaxServiceHandler, MySimpleServiceFramework": 表示当某个请求匹配path,verb时，交给MySimpleServiceFramework程序集中的MySimpleServiceFramework.AjaxServiceHandler来处理请求。
4. validate="true"：表示在第一次读取<httpHandlers>时，验证type的设置是否有效。如果此项设为false，则表示延迟验证（创建时）。默认值：true

对于这4个属性，有2个比较重要：
1. type: type中的字符串必须能在运行时找到一个可创建的类型，且该类型必须实现IHttpHandler或者IHttpHandlerFactory接口。
2. path: 在很多资料以及技术书籍中，一般都设置为某类文件扩展名，如：*.xxx ，事实上，我们完全可以设置为一个URL模式，而且还可以设置多个URL模式。比如上面的配置示例中的path参数，具体在使用时，可以响应来自客户端的以下请求：

$(function(){
    $("#btnSubmit").click( function(){
        $.ajax({
                // 注意：下面的二个url地址都是可以使用的。
                url: "/AjaxServices/GetMd5.aspx",
                //url: "/AjaxServices.GetMd5.aspx",
                
                // 注意：下面的二种type的设置也都是可以使用的。
                type: "POST", 
                //type: "GET", 
                
                data: { str: $("#txtInput").val() },
                dataType: "text",
                success: function(responseText){
                    $("#md5Result").text(responseText);
                }
            });    
    });
});

注意：在path中直接使用某个扩展名的好处是不受配置项的顺序影响，而且容易理解，因为可读性较好。

这里要补充一点：MySimpleServiceFramework是我在博客【用Asp.net写自己的服务框架】中实现的那个框架。
在服务端，可以使用下面的代码来处理前面客户端发出的请求：

[MyService]
public class AjaxServices
{
    [MyServiceMethod]
    public string GetMd5(string str)
    {
        if( str == null )
            str = string.Empty;

        byte[] bb = (new MD5CryptoServiceProvider()).ComputeHash(Encoding.Default.GetBytes(str));
        return BitConverter.ToString(bb).Replace("-", "");
    }
}

前面的示例配置中：path="Ajax*.*.aspx,Ajax*/*.aspx" ，我使用了aspx这个扩展名。
我想大家都知道aspx这个扩展名是ASP.NET可处理的扩展名，为什么我还可以使用呢？
其实这个问题的答案在我前面的截图以及FindMapping的实现代码中：由于我们指定的配置要优先于ASP.NET的默认配置，所以先有机会参与匹配，并能匹配成功。

小结：在GetHandlerMapping()过程中，会根据请求的URL地址以及HTTP调用动作（GET,POST），返回一个在<httpHandlers>定义的配置项（HttpHandlerAction类型）。

GetFactory()

在GetHandlerMapping()返回一个HttpHandlerAction的配置项后， HttpApplication会调用this.GetFactory(mapping);获取一个IHttpHandlerFactory ，本小节将来分析这个过程。

首先，我们还是来看一下GetFactory的实现代码：

private Hashtable _handlerFactories = new Hashtable();

private IHttpHandlerFactory GetFactory(HttpHandlerAction mapping)
{
    // 先尝试从内部缓存中获取
    HandlerFactoryCache cache = (HandlerFactoryCache) this._handlerFactories[mapping.Type];
    if (cache == null)
    {
        // 创建一个缓存项并保存
        cache = new HandlerFactoryCache(mapping);
        this._handlerFactories[mapping.Type] = cache;
    }
    // 返回工厂对象
    return cache.Factory;
}

代码中做了哪些事情，我在注释中有说明。这个方法的最后一定会返回一个IHttpHandlerFactory的实例。

看到这里，您觉得奇怪吗？
可能我们仅仅只是实现了一个自定义的IHttpHanlder接口，并没有实现IHttpHandlerFactory，那么ASP.NET是如何处理的呢？

请注意 new HandlerFactoryCache(mapping) 这行代码，这可不是简单地创建一个缓存对象，具体实现代码如下：

internal class HandlerFactoryCache
{
    private IHttpHandlerFactory _factory;

    internal HandlerFactoryCache(HttpHandlerAction mapping)
    {
        // 根据HttpHandlerAction配置中的type字符串创建对应类型的对象
        object obj2 = mapping.Create();

        if( obj2 is IHttpHandler ) {
            // 如果我们的配置是一个IHttpHandler，
            // 那么ASP.NET会为我们包装成一个HandlerFactoryWrapper
            this._factory = new HandlerFactoryWrapper((IHttpHandler)obj2, this.GetHandlerType(mapping));
        }
        else {
            // 如果不是IHttpHandler以及IHttpHandlerFactory，就抛出异常
            if( !(obj2 is IHttpHandlerFactory) ) {
                throw new HttpException("Type_not_factory_or_handler");
            }
            this._factory = (IHttpHandlerFactory)obj2;
        }
    }

代码中，我加入的注释已经回答了前面提出的问题：如果是一个IHttpHandler对象，ASP.NET会再创建一个HandlerFactoryWrapper对象来包装IHttpHandler对象，如果是IHttpHandlerFactory对象，则直接返回。
我们再来看一下HandlerFactoryWrapper的实现代码：

internal class HandlerFactoryWrapper : IHttpHandlerFactory
{
    private IHttpHandler _handler;
    private Type _handlerType;

    internal HandlerFactoryWrapper(IHttpHandler handler, Type handlerType)
    {
        this._handler = handler;
        this._handlerType = handlerType;
    }

    public IHttpHandler GetHandler(HttpContext context, 
                                string requestType, string url, string pathTranslated)
    {
        if( this._handler == null ) 
            this._handler = (IHttpHandler)HttpRuntime.CreateNonPublicInstance(this._handlerType);

        return this._handler;
    }

    public void ReleaseHandler(IHttpHandler handler)
    {
        // 一个HttpHandler是否能重用，这里就是一个典型的实现方式
        if( !this._handler.IsReusable ) 
            this._handler = null;
    }
}

小结：HttpApplication会根据web.config中的配置去查找一个匹配的IHttpHandlerFactory类型, 即使我们配置的是自定义的IHttpHandler类型，而不是IHttpHandlerFactory类型，调用过程依然如此。

GetHandler()

在ASP.NET中，定义了二个版本的HttpHandlerFactory接口，分别为：

public interface IHttpHandlerFactory
{
    IHttpHandler GetHandler(HttpContext context, 
                            string requestType, string url, string pathTranslated);
    void ReleaseHandler(IHttpHandler handler);
}

internal interface IHttpHandlerFactory2 : IHttpHandlerFactory
{
    IHttpHandler GetHandler(HttpContext context, 
                            string requestType, VirtualPath virtualPath, string physicalPath);
}

设计IHttpHandlerFactory接口的目的是为了在创建和重用IHttpHandler对象时，保留了足够的扩展机会，而IHttpHandlerFactory2则是一个仅供微软使用的内部接口（因为VirtualPath类型的可见性也是internal）。

我们都知道aspx, ashx能直接处理HTTP请求，它们都实现了IHttpHandler接口。它们能处理HTTP请求也因为ASP.NET已经配置过它们。以下是它们的默认配置：

<httpHandlers>
    <add path="*.aspx" verb="*" type="System.Web.UI.PageHandlerFactory" validate="true"/>
    <add path="*.ashx" verb="*" type="System.Web.UI.SimpleHandlerFactory" validate="true"/>
</httpHandlers>

有趣的是：PageHandlerFactory和SimpleHandlerFactory都实现了IHttpHandlerFactory2接口，因此，它们都可以根据要请求的路径创建一个IHttpHandler实例。

从ASP.NET的默认配置，我们也可以看到：type参数是可以设置为一个实现IHttpHandlerFactory接口的类型，而不一定要求是实现IHttpHandler接口的类型。

小结：HttpApplication在处理请求时，并不会直接创建一个IHttpHandler的实例，而是先获取一个IHttpHandlerFactory的对象，再以接口的形式调用GetHandler()方法来获取一个IHttpHandler实例。

IHttpHandler.IsReusable

IHttpHandler接口有个IsReusable属性。MSDN对这个属性的说明也非常简单：

获取一个值，该值指示其他请求是否可以使用 IHttpHandler 实例。

按照这个说明，当我们直接在创建一个实现IHttpHandler的类型，并在web.config中注册到一个自定义的扩展名时，情况会如何呢？
我们再来看一下前面所提过的示例代码（MyTestHandler的）：

public class MyTestHandler : IHttpHandler
{
    private Counter _counter = new Counter();

    public bool IsReusable
    {
        get { return true; }
    }

    public void ProcessRequest(HttpContext context)
    {
        _counter.ShowCountAndRequestInfo(context);
    }
}

web.config中的配置为：

<httpHandlers>
    <add path="*.test" verb="*" validate="true" type="MyTestHandler" />
</httpHandlers>

当我连续5次访问 http://localhost:51652/abc.test?id=1 时，会在浏览器中看到以下输出结果：

从这个截图来看，显然：MyTestHandler的实例被重用了。

我想很多人都创建过ashx文件，IDE会为我们创建一个实现了IHttpHandler接口的类型，在实现IsReusable属性时，一般都会这样：

public bool IsReusable {
    get {
        return false;
    }
}

有些人看到这个，会想：如果返回true，就可以重用IHttpHandler实例，达到优化性能的目的。但事实上，即使你在ashx中返回true也是无意义的，因为您可以试着这样去实现这个属性：

public bool IsReusable
{
    get { throw new Exception("这里不起作用。"); }
}

如果您访问那个ashx，会发现：根本没有异常出现！
因此，我们可以得出一个结论：默认情况下，IsReusable不能决定一个ashx的实例是否能重用。

这个结果太奇怪了。为什么会这样呢？

前面我们看到*.ashx的请求交给SimpleHandlerFactory来创建相应的HttpHandler对象，然而当ASP.NET调用SimpleHandlerFactory.GetHandler()方法时，该方法会直接创建并返回我们实现的类型实例。换句话说：SimpleHandlerFactory根本不使用IHttpHandler.IsReusable的属性，因此，这种情况下，想重用ashx的实例是不可能的事，所以，即使我在实现IsReusable属性时，写上抛异常的语句，根本也不会被调用。

同样的事情还发在aspx页面的实例上，所以，在默认情况下，我们不可能重用aspx, ashx的实例。

至于aspx的实例不能重用，除了和PageHandlerFactory有关外，还与Page在实现IHttpHandler.IsReusable有关，以下是Page的实现方式：

public bool IsReusable
{
    get { return false; }
}

从代码可以看到微软在Page是否重用上的明确想法：就是不允许重用！

由于Page的IsReusable属性我们平时看不到，我想没人对它的重用性有产生过疑惑，但ashx就不同了，它的IsReusable属性的代码是摆在我们面前的，任何人都可以看到它，试想一下：当有人发现把它设为true or false时都不起作用，会是个什么想法？估计很多人会郁闷。

小结：IHttpHandler.IsReusable并不能决定是否重用HttpHanlder ！

实现自己的HttpHandlerFactory

通过前面的示例，我们也看到了，虽然IHttpHandler定义了一个IsReusable属性，但它并不能决定此类型的实例是否能得到重用。重不重用，其实是由HttpHandlerFactory来决定的。ashx的实例不能重用就是一个典型的例子。

下面我就来演示如何实现自己的HttpHandlerFactory来重用ashx的实例。示例代码如下（注意代码中的注释）：

internal class ReusableAshxHandlerFactory : IHttpHandlerFactory
{
    private Dictionary<string, IHttpHandler> _cache 
        = new Dictionary<string, IHttpHandler>(200, StringComparer.OrdinalIgnoreCase);

    public IHttpHandler GetHandler(HttpContext context, 
                            string requestType, string virtualPath, string physicalPath)
    {
        string cacheKey = requestType + virtualPath;

        // 检查是否有缓存的实例（或者可理解为：被重用的实例）
        IHttpHandler handler = null;
        if( _cache.TryGetValue(cacheKey, out handler) == false ) {
            // 根据请求路径创建对应的实例
            Type handlerType = BuildManager.GetCompiledType(virtualPath);

            // 确保一定是IHttpHandler类型
            if( typeof(IHttpHandler).IsAssignableFrom(handlerType) == false )
                throw new HttpException("要访问的资源没有实现IHttpHandler接口。");

            // 创建实例，并保存到成员字段中
            handler = (IHttpHandler)Activator.CreateInstance(handlerType, true);

            // 如果handler要求重用，则保存它的引用。
            if( handler.IsReusable )
                _cache[cacheKey] = handler;
        }

        return handler;
    }

    public void ReleaseHandler(IHttpHandler handler)
    {
        // 不需要处理这个方法。
    }
}

为了能让HttpHandlerFactory能在ASP.NET中运行，还需要在web.config中注册：

<httpHandlers>
    <add path="*.ashx" verb="*" validate="false" type="ReusableAshxHandlerFactory"/>
</httpHandlers>

有了这个配置后，我们可以创建一个Handler2.ashx来测试效果：

<%@ WebHandler Language="C#" Class="Handler2" %>

using System;
using System.Web;

public class Handler2 : IHttpHandler {

    private Counter _counter = new Counter();

    public bool IsReusable
    {
        get { return true; }
    }

    public void ProcessRequest(HttpContext context)
    {
        _counter.ShowCountAndRequestInfo(context);
    }
}

在多次访问Handler2.ashx后，我们可以看到以下效果：

再来看看按照IDE默认生成的IsReusable会在运行时出现什么结果。示例代码：

<%@ WebHandler Language="C#" Class="Handler1" %>

using System;
using System.Web;

public class Handler1 : IHttpHandler {

    private Counter _counter = new Counter();

    public bool IsReusable
    {
        get {
            // 如果在配置文件中启用ReusableAshxHandlerFactory，那么这里将会被执行。
            // 可以尝试切换下面二行代码测试效果。

            //throw new Exception("这里不起作用。");
            return false;
        }
    }

    public void ProcessRequest(HttpContext context)
    {
        _counter.ShowCountAndRequestInfo(context);
    }
}

此时，无论我访问Handler1.ashx多少次，浏览器始终显示如下结果：

如果我启用代码行 throw new Exception("这里不起作用。"); 将会看到以下结果：

终于，我们期待的黄页出现了。
此时，如果我在web.config中将ReusableAshxHandlerFactory的注册配置注释起来，发现Handler1.ashx还是可以访问的。

回想一下前面我们看到的IHttpHandlerFactory接口，它还定义了一个ReleaseHandler方法，这个方法又是做什么的呢？对于这个方法，MSDN也有一句简单的说明：

使工厂可以重用现有的处理程序实例。

对于这个说明，我认为并不恰当。如果按照HandlerFactoryWrapper的实现方式，那么这个解释是正确的。但我前面的示例中，我在实现这个方法时，没有任何代码，但一样可以达到重用HttpHandler的目的。因此，我认为重用的方式取决于具体的实现方式。

小结：IHttpHandler.IsReusable并不能完全决定HttpHandler的实例是否能重用，它只起到一个指示作用。 HttpHandler如何重用，关键还是要由HttpHandlerFactory来实现。

是否需要IsReusable = true ？

经过前面文字讲解以及示例演示，有些人可能会想：我在实现IHttpHandler的IsReusable属性时，要不要返回true呢？（千万别模仿我的示例代码抛异常哦。）

如果返回true，则HttpHandler能得到重用，或许某些场合下，是可以达到性能优化的目的。
但是，它也可能会引发新的问题：HttpHandler实例的一些状态会影响后续的请求。
也正是由于这个原因，aspx, ashx 的实例在默认情况下，都是不重用的。

有些人还可能会担心：被重用的HttpHandler是否有线程安全问题？
理论上，在ASP.NET中，只要使用static的数据成员都会有这个问题。不过，这里所说的被重用的单个HttpHandler实例在处理请求过程中，只会被一个线程所调用，因此，它的实例成员还是线程安全的。但有一点需要注意：在HttpHandlerFactory中实现重用HttpHandler时，缓存HttpHandler的容器要保证是线程安全的。

如果您希望重用HttpHandler来提升程序性能，那么我建议应该考虑以下问题：
HttpHandler的所有数据成员都能在处理请求前初始化。（通常会在后期维护时遗忘，尤其是多人维护时）

小结：在通常情况下，当实现IsReusable时返回false，虽然性能上不是最优，但却是最安全的做法。

HttpHandlerFactory的主要用途

前面示例演示了如何使用HttpHandlerFactory来重用HttpHandler，但设计HttpHandlerFactory并不是完全为了这个目的，它的主要用途还是如何创建HttpHandler，而且定义IHttpHandlerFactory的主要目的是为了扩展性。

我想很多人也许使用过 Web Service ，它运行在ASP.NET平台上，自然也有对应的HttpHandler，我们来看看asmx这个扩展名是如何映射的。


<add path="*.asmx" verb="*"  validate="false"
     type="System.Web.Services.Protocols.WebServiceHandlerFactory, 
     System.Web.Services, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"/>

接着找WebServiceHandlerFactory，最后发现是这样创建的HttpHandler :

internal IHttpHandler CoreGetHandler(Type type, 
        HttpContext context, HttpRequest request, HttpResponse response)
{
    // ..... 已删除一些无关的代码

    bool isAsync = protocol.MethodInfo.IsAsync;
    bool enableSession = protocol.MethodAttribute.EnableSession;
    if( isAsync ) {
        if( enableSession ) {
            return new AsyncSessionHandler(protocol);
        }
        return new AsyncSessionlessHandler(protocol);
    }
    if( enableSession ) {
        return new SyncSessionHandler(protocol);
    }
    return new SyncSessionlessHandler(protocol);
}

这才是Factory嘛！

老实说，看到这几句话，我是眼前一亮：用HttpHandlerFactory来动态处理【是否支持Session】实在是太合适了。

这里有必要补充一下：

internal class SyncSessionHandler : SyncSessionlessHandler, IRequiresSessionState
{
}

小结：HttpHandlerFactory用途并非是为了专门处理HttpHandler的重用，它只是一个Factory， WebServiceHandlerFactory从另一个角度向我们展示了HttpHandlerFactory在扩展性方面所体现的重要作用。

点击此处下载示例代码

如果，您认为阅读这篇博客让您有些收获，不妨点击一下右下角的【推荐】按钮。
如果，您希望更容易地发现我的新博客，不妨点击一下右下角的【关注 Fish Li】。
因为，我的写作热情也离不开您的肯定支持。

感谢您的阅读，如果您对我的博客所讲述的内容有兴趣，请继续关注我的后续博客，我是Fish Li 。

posted on 2012-01-29 22:14 Fish Li 阅读(49390) 评论(101) 编辑收藏举报

刷新页面返回顶部