Http Pipeline详细分析(上)

文章内容

继续上一章节的内容,通过HttpApplicationFactory的GetApplicationInstance静态方法获取实例,然后执行该实例的BeginProcessRequest方法进行执行余下的Http Pipeline 操作,代码如下:

// Get application instance 
IHttpHandler app = HttpApplicationFactory.GetApplicationInstance(context);

那GetApplicationInstance这个方法究竟做了啥呢?难道只是new一个新对象出来?感觉应该不像,那我们就来看看HttpApplicationFactory类的GetApplicationInstance静态方法源码:

internal static IHttpHandler GetApplicationInstance(HttpContext context) { 
    if (_customApplication != null)
        return _customApplication; 
 
    // Check to see if it's a debug auto-attach request
    if (context.Request.IsDebuggingRequest) 
        return new HttpDebugHandler();

    _theApplicationFactory.EnsureInited();
 
    _theApplicationFactory.EnsureAppStartCalled(context);
 
    return _theApplicationFactory.GetNormalApplicationInstance(context); 
}

里面有3行代码我已经标记为粗体了,在解释每行代码的具体作用之前,先看看_theApplicationFactory对象实例从哪里来,通过查看该字段的声明代码可以看到它是单例的实现。

// the only instance of application factory
private static HttpApplicationFactory _theApplicationFactory = new HttpApplicationFactory();

第一行粗体代码是执行,该实例的EnsureInited方法,这个方法会通过lock的方式调用Init方法(好处自然不用多说了吧),代码如下:

private void EnsureInited() {
    if (!_inited) {
        lock (this) { 
            if (!_inited) {
                Init(); 
                _inited = true; 
            }
        } 
    }
}

通过查找 Init方法的代码以及其中2行如下代码里的细节,我们可以得知,这2行代码主要是从global.asax获取内容,然后进行编译。

_appFilename = GetApplicationFile(); 
CompileApplication();

所以,HttpApplicationFactory._theApplicationFactory.EnsureInited() 的方法首先检查HttpApplicationFactory是否被初始化,如果没有,就通过HttpApplicationFactory.Init()进行初始化。在Init()中,先获取global.asax文件的完整路径,然后调用CompileApplication()对global.asax进行编译。

第2行粗体的EnsureAppStartCalled方法,最终会调用如下的私有方法FireApplicationOnStart,代码如下:

private void FireApplicationOnStart(HttpContext context) { 
    if (_onStartMethod != null) { 
        HttpApplication app = GetSpecialApplicationInstance();
 
        app.ProcessSpecialRequest(
                                    context,
                                    _onStartMethod,
                                    _onStartParamCount, 
                                    this,
                                    EventArgs.Empty, 
                                    null); 

        RecycleSpecialApplicationInstance(app); 
    }
}

通过代码我们能够得知HttpApplicationFactory._theApplicationFactory.EnsureAppStartCalled(context)  创建特定的HttpApplication实例,触发ApplicationOnStart事件,执行ASP.global_asax中的Application_Start(object sender, EventArgs e)方法。然后在处理完事件以后就立即被回收掉,因为系统初始化只需要一次,但是其中的GetSpecialApplicationInstance里会对IIS7做一些特殊的事情,我们后面的章节会讲到。

第3行的粗体代码是我们这里要说的重点,它方法里的代码如下:

private HttpApplication GetNormalApplicationInstance(HttpContext context) {
    HttpApplication app = null; 

    lock (_freeList) {
        if (_numFreeAppInstances > 0) {
            app = (HttpApplication)_freeList.Pop(); 
            _numFreeAppInstances--;
 
            if (_numFreeAppInstances < _minFreeAppInstances) { 
                _minFreeAppInstances = _numFreeAppInstances;
            } 
        }
    }

    if (app == null) { 
        // If ran out of instances, create a new one
        app = (HttpApplication)HttpRuntime.CreateNonPublicInstance(_theApplicationType); 
 
        using (new ApplicationImpersonationContext()) {
            app.InitInternal(context, _state, _eventHandlerMethods); 
        }
    }

    return app; 
}

如果在有空闲的HttpApplication实例,就直接用,如果没有就新创建,然后调用InitInternal方法进行初始化相关的内容,最后返回该HttpApplication实例。

让我们来看看HttpApplication的核心方法InitInternal里都是干了什么事儿吧,先上代码,有点多,但是很值得:

internal void InitInternal(HttpContext context, HttpApplicationState state, MethodInfo[] handlers) { 
    Debug.Assert(context != null, "context != null");

    // Remember state
    _state = state; 

    PerfCounters.IncrementCounter(AppPerfCounter.PIPELINES); 
 
    try {
        try { 
            // Remember context for config lookups
            _initContext = context;
            _initContext.ApplicationInstance = this;
 
            // Set config path to be application path for the application initialization
            context.ConfigurationPath = context.Request.ApplicationPathObject; 
 
            // keep HttpContext.Current working while running user code
            using (new DisposableHttpContextWrapper(context)) { 

                // Build module list from config
                if (HttpRuntime.UseIntegratedPipeline) {
 
                    Debug.Assert(_moduleConfigInfo != null, "_moduleConfigInfo != null");
                    Debug.Assert(_moduleConfigInfo.Count >= 0, "_moduleConfigInfo.Count >= 0"); 
 
                    try {
                        context.HideRequestResponse = true; 
                        _hideRequestResponse = true;
                        InitIntegratedModules();
                    }
                    finally { 
                        context.HideRequestResponse = false;
                        _hideRequestResponse = false; 
                    } 
                }
                else { 
                    InitModules();

                    // this is used exclusively for integrated mode
                    Debug.Assert(null == _moduleContainers, "null == _moduleContainers"); 
                }
 
                // Hookup event handlers via reflection 
                if (handlers != null)
                    HookupEventHandlersForApplicationAndModules(handlers); 

                // Initialization of the derived class
                _context = context;
                if (HttpRuntime.UseIntegratedPipeline && _context != null) { 
                    _context.HideRequestResponse = true;
                } 
                _hideRequestResponse = true; 

                try { 
                    Init();
                }
                catch (Exception e) {
                    RecordError(e); 
                }
            } 
 
            if (HttpRuntime.UseIntegratedPipeline && _context != null) {
                _context.HideRequestResponse = false; 
            }
            _hideRequestResponse = false;
            _context = null;
            _resumeStepsWaitCallback= new WaitCallback(this.ResumeStepsWaitCallback); 

            // Construct the execution steps array 
            if (HttpRuntime.UseIntegratedPipeline) { 
                _stepManager = new PipelineStepManager(this);
            } 
            else {
                _stepManager = new ApplicationStepManager(this);
            }
 
            _stepManager.BuildSteps(_resumeStepsWaitCallback);
        } 
        finally { 
            _initInternalCompleted = true;
 
            // Reset config path
            context.ConfigurationPath = null;

            // don't hold on to the context 
            _initContext.ApplicationInstance = null;
            _initContext = null; 
        } 
    }
    catch { // Protect against exception filters 
        throw;
    }
}

该代码主要有2个功能,一个是初始化大家熟悉的HttpModules,一个是通过BuildSteps执行20多个生命周期事件的处理函数(这部分内容,我们将在下一章节详细讲解Http Pipeline)。通过上面的代码我们可以看出,每个功能都有一个特殊判断,判断IIS是否是IIS7的集成模式,如果是就有特殊的步骤,如果不是就走一般的步骤,两者直接的差异分别是:IIS7初始化HttpModules的时候会从网站配置的Modules里读取(因为IIS7预加载CLR和大批量Modules),BuildSteps的时候, IIS7集成模式走的是自己特殊的流程(加载服务器上的HttpModules)。

让我们先总结一下再看代码,InitInternal方法的主要功能如下:

  1. InitModules():根据Web.Config的设置,加载相应的HttpModules。

  2. InitIntegratedModules():会加载IIS7集成模式下在服务器上设定的HttpModuels和Web.config里system.webserver下的HttpModuels。

  3. HookupEventHandlersForAppplicationAndModules:根据发生的事件,调用HttpApplication实例中相应的事件处理函数。

  4. 创建很多实现IExecutionStep接口的类的实例并添加到当前HttpApplication实例的_execSteps中,等待回调时执行。从这里我们可以看到HttpApplication是以异步的方式处理请求, 对请求的很多处理工作都放入了_execStep等待回调时执行。

至此,除了20多个周期事件和Handler相关的代码我们没有讲解,其它和HttpApplication相关的并且对我们有帮助的,已经差不多清晰了。关于20多个周期事件和执行Handler方面的内容,我们下一章节再做详细解释。

参考资料:

http://msdn.microsoft.com/en-us/magazine/cc188942.aspx

http://msdn.microsoft.com/en-us/library/bb470252.aspx

http://www.cnblogs.com/zhaoyang/archive/2011/11/16/2251200.html