源码分析Session的台前幕后(Asp .Net MVC5)

　　在这篇文章里，我们从源代码的角度重点分析Session的创建、缓存、销毁、管理。

　　通常我们说的Session指的是在控制器中使用的Session字段，该字段的类型是HttpSessionState。可以获取SessionID,可以存储数据，可以增加删除数据等等。Session字段中使用的HttpSessionState对象，就是在下面介绍的模块中产生的。

　　在.Net Framework内部，来自浏览器的请求像工厂的流水线加工产品一样，在不同的部位进行不同的处理，最终被加工为一件成品。我们的请求也是如此，内部有许多的模块(实现了接口IHttpModule)对我们的请求进行处理，比如映射路由的模块(UrlRoutingModule)，该模块的作用是从用户请求的url中获取信息，找到能处理这个IHttpHandler对象，用于后续处理处理请求。而我们这里讨论的则是关于会话Session的一个模块--SessionStateModule。

　　在这里模块里，有诸如这样的功能，生成SessionID、生成用于HttpSessionState内部存储数据的ISessionStateItemCollection对象。然后将这样的不同对象封装起来。

　　在IIS中，Session的存储生成有4中模式。

　　1-InProc进程内模式，将Session存储在web应用程序进程内部。这也是系统默认的模式。这种方式优点显而易见---存取速度很快，缺点也显而易见--一旦因为某种原因应用程序被关闭，不管是否重启应用程序，所有用户的Session全部都会丢失，这是不能接受的。

而且因为是进行内存储，当我们想做分布式的时候，Session无法共享。

　　2-StateServer状态服务器模式。在这种模式下，应用程序会启动一个会话状态服务器，专门用于存储Session。这种方式解决了重启web应用程序后session丢失的问题，但状态服务器本身会有问题，如：不支持故障转移等。

　　3-SQLServer数据库模式。在这种模式下，所有的会话数据都被存储在SQLServer数据库中，但是要求session中存储的时候是可以序列化的。在这种模式下，数据库强大的存储、搜索、故障转移群集等稳定功能，会给session带来强大的支持。

　　4-Custom自定义模式。在这种模式下，用户可以定义自己的session存储方式。

　　这些内容仅在这里做简单介绍，有兴趣的朋友可以查看微软官方的文档。https://msdn.microsoft.com/zh-cn/library/ms178586(v=vs.100).aspx

　　

        void InitModuleFromConfig(HttpApplication app, SessionStateSection config) {
            if (config.Mode == SessionStateMode.Off) {
                return;
            }

            app.AddOnAcquireRequestStateAsync(
                    new BeginEventHandler(this.BeginAcquireState),
                    new EndEventHandler(this.EndAcquireState));

            app.ReleaseRequestState += new EventHandler(this.OnReleaseState);
            app.EndRequest += new EventHandler(this.OnEndRequest);

            _partitionResolver = InitPartitionResolver(config);

            switch (config.Mode) {
                case SessionStateMode.InProc:
                    if (HttpRuntime.UseIntegratedPipeline) {
                        s_canSkipEndRequestCall = true;
                    }
                    _store = new InProcSessionStateStore();
                    _store.Initialize(null, null);
                    break;
                    
                case SessionStateMode.StateServer:
                    if (HttpRuntime.UseIntegratedPipeline) {
                        s_canSkipEndRequestCall = true;
                    }
                    _store = new OutOfProcSessionStateStore();
                    ((OutOfProcSessionStateStore)_store).Initialize(null, null, _partitionResolver);
                    break;

                case SessionStateMode.SQLServer:
                    _store = new SqlSessionStateStore();
                    ((SqlSessionStateStore)_store).Initialize(null, null, _partitionResolver);
                    break;
                    
                case SessionStateMode.Custom:
                    _store = InitCustomStore(config);
                    break;
                default:
                    break;
            }

            // 依赖SessionIDManager管理session id，所以在这里对管理器进行初始化
            _idManager = InitSessionIDManager(config);

            if ((config.Mode == SessionStateMode.InProc || config.Mode == SessionStateMode.StateServer) &&
                _usingAspnetSessionIdManager) {
                //如果我们使用InProc模式或者StateServer模式，并且也使用我们自己的会话ID模块，
                //我们知道我们不关心在所有会话状态存储读/写和会话ID读/写中的模拟。
                _ignoreImpersonation = true;
            }
        }

      模块进行初始化时，会进行许多设置，上面的方法时其中的设置之一。上面的方法中，如果会话状态的模式是关闭，则直接返回，不再进行任何操作。

　　然后向HttpApplication对象注册事件，当这个对象需要获取会话状态时，就调用这里注册的方法，进行会话状态的创建等共走。供后面的步骤使用。

　　然后根据会话状态模式加载不同的会话状态存储提供程序，默认的模式是SessionStateMode.InProc，则加载的提供程序是类是InProcSessionStateStore。

　　InProcSessionStateStore类内部实现的存储会话状态的方式是存储在运行时的缓存中。 

　　

　　从缓存中读取会话状态：

　　 HttpRuntime.CacheInternal.Get(key)。

　　

　　将回话状态写入缓存：

　　HttpRuntime.CacheInternal.UtcInsert(

　　key,/*缓存的key，此处缓存会话，所以是在sessionid的基础上进行了其他操作组合而成。*/

　　state,/*这就是我们的会话状态*/

　　null,/*依赖属性，这里不需要，所以传空值*/

　　Cache.NoAbsoluteExpiration,/*绝对过期时间。在这里我们不希望有绝对过期时间，所以传递了Cache.NoAbsoluteExpiration，该字段的值是 DateTime.MaxValue;*/

　　new TimeSpan(0, state._timeout, 0),/*滑动到期时间，传递的是会话状态的过期值。*/

　　CacheItemPriority.NotRemovable,/*缓存优先级，告诉运行时缓存，在进行内存优化时，不能删除这个缓存值*/

　　_callback /*缓存项被移除的回调方法。正是因为InProcSessionStateStore类内部使用运行时缓存且运行时缓存带有缓存项移除回调方法，所以在SessionStateMode.InProc模式下，会话状态过期时，会调用在Global.asax中注册的Session_End方法*/

　　);

 

　　继续看代码。

　　紧接着，会根据配置文件对SessionIDManager进行初始化，默认情况下会初始化一个SessionIDManager的对象。我们使用这个会话管理器进行sessionid的管理。创建sessionid,验证sessionid的合法性等功能。

　　模块的初始化工作已经介绍完毕，这里介绍的只是最基础的一部分，其他还涉及的会话状态的锁定、优化等扩展开来则过于复杂。

 

---

　　下面我们按一个请求的处理过程为顺序，介绍会话状态的相关处理。从获得会话状态开始。上代码。

        IAsyncResult BeginAcquireState(Object source, EventArgs e, AsyncCallback cb, Object extraData) {
            bool                requiresState;
            bool                isCompleted = true;
            bool                skipReadingId = false;

            _acquireCalled = true;
            _releaseCalled = false;
            ResetPerRequestFields();

            _rqContext = ((HttpApplication)source).Context;
            _rqAr = new HttpAsyncResult(cb, extraData);

            ChangeImpersonation(_rqContext, false);

            try {

                /* Notify the store we are beginning to get process request */
                _store.InitializeRequest(_rqContext);

                /* determine if the request requires state at all */
                requiresState = _rqContext.RequiresSessionState;

                // SessionIDManager may need to do a redirect if cookieless setting is AutoDetect
                if (_idManager.InitializeRequest(_rqContext, false, out _rqSupportSessionIdReissue)) {
                    _rqAr.Complete(true, null, null);
                    return _rqAr;
                }

                // See if we can skip reading the session id.  See inline doc of s_allowInProcOptimization
                // for details.
                if (s_allowInProcOptimization &&
                    !s_sessionEverSet &&
                     (!requiresState ||             // Case 1
                      !((SessionIDManager)_idManager).UseCookieless(_rqContext)) ) {  // Case 2

                    skipReadingId = true;
                }
                else {
                    /* Get sessionid */
                    _rqId = _idManager.GetSessionID(_rqContext);
                }

                if (!requiresState) {
                    if (_rqId == null) {
                    }
                    else {
                        // Still need to update the sliding timeout to keep session alive.
                        // There is a plan to skip this for perf reason.  But it was postponed to
                        // after Whidbey.
                        _store.ResetItemTimeout(_rqContext, _rqId);
                    }
                    _rqAr.Complete(true, null, null);
                    return _rqAr;
                }

                _rqExecutionTimeout = _rqContext.Timeout;

                if (_rqExecutionTimeout == DEFAULT_DBG_EXECUTION_TIMEOUT) {
                    _rqExecutionTimeout = s_configExecutionTimeout;
                }

                /* determine if we need just read-only access */
                _rqReadonly = _rqContext.ReadOnlySessionState;

                if (_rqId != null) {
                    /* get the session state corresponding to this session id */
                    isCompleted = GetSessionStateItem();
                }
                else if (!skipReadingId) {
                    /* if there's no id yet, create it */
                    bool    redirected = CreateSessionId();

                    _rqIdNew = true;

                    if (redirected) {
                        if (s_configRegenerateExpiredSessionId) {
                            // See inline comments in CreateUninitializedSessionState()
                            CreateUninitializedSessionState();
                        }
                        _rqAr.Complete(true, null, null);
                        return _rqAr;
                    }
                }

                if (isCompleted) {
                    CompleteAcquireState();
                    _rqAr.Complete(true, null, null);
                }

                return _rqAr;
            }
            finally {
                RestoreImpersonation();
            }
        }

　　这是获取Session的入口，每当有请求到达时，这是必须要有的步骤，经过这个方法处理后，请求上下文会拥有一个与当前请求匹配的Session。

　　下面我们具体分析方法中的一些代码。

　　requiresState = _rqContext.RequiresSessionState;

　　上面这行代码判断请求是否需要会话状态。主要取决于两方面，一方面是我们的控制器是否需要会话状态.控制器本身是否设置了SessionStateAttribute特性或者用于处理请求的实现了IHttpHandler接口的类是否标记了IRequiresSessionState这个接口。

 　　

 

当我们没有给控制器标记SessionStateAttribute特性时，会默认使用SessionStateBehavior.Default这个选项。这个选项的意思参考第一个截图。

 

我把这个属性的内部代码贴出来，有兴趣的可以看看。

internal bool RequiresSessionState {
            get {
                switch (SessionStateBehavior) {
                    case SessionStateBehavior.Required:
                    case SessionStateBehavior.ReadOnly:
                        return true;
                    case SessionStateBehavior.Disabled:
                        return false;
                    case SessionStateBehavior.Default:
                    default:
                        return _requiresSessionStateFromHandler;
                }
            }
        }
        //从上面的代码中可以看出，当设置SessionStateBehavior.Default时，
        //会返回_requiresSessionStateFromHandler这个变量的值。
        //我们再看看这个值是如何被设置的.
        public IHttpHandler Handler {
            get { return _handler;}
            set {
                _handler = value;
                _requiresSessionStateFromHandler = false;
                _readOnlySessionStateFromHandler = false;
                InAspCompatMode = false;
                if (_handler != null) {
                    if (_handler is IRequiresSessionState) {
                        _requiresSessionStateFromHandler = true;
                    }
                    if (_handler is IReadOnlySessionState) {
                        _readOnlySessionStateFromHandler = true;
                    }
                    Page page = _handler as Page;
                    if (page != null && page.IsInAspCompatMode) {
                        InAspCompatMode = true;
                    }
                }
            }
        }
        //从上面代码中的可以看出，
        // if (_handler is IRequiresSessionState) {
        //     _requiresSessionStateFromHandler = true;
        // }
        //而我们的MvcHandler是扩展了IRequiresSessionState这个接口的，所以_requiresSessionStateFromHandler是true;

BeginAcquireState方法中的代码主要是用来判断是否满足优化的目的。比如是否要延迟获取一个session id，是否要加载session等。

我们假设是第一次请求，走一次完整的流程。那么，我们的代码就要进入CompleteAcquireState这个方法中了。

在介绍这个方法前，首先介绍一个点。

在控制器中访问的Session共分两个部分，一个是用来存储数据的部分，例如这样的形式--Session["key1"] = 123;

一个是Session的id---Session.SessionID

他们虽然都归属在Session下面，但是它们的生成、存储、删除等机制完全不同。

        // Called when AcquireState is done.  This function will add the returned
        // SessionStateStore item to the request context.
        void CompleteAcquireState() {
            bool delayInitStateStoreItem = false;
            try {
                //_rqItem就是session中用来存储数据的
                //当第一次访问时，这个值肯定是空值，所以会走else的分支
                if (_rqItem != null) {
                    _rqSessionStateNotFound = false;

                    if ((_rqActionFlags & SessionStateActions.InitializeItem) != 0) {
                        _rqIsNewSession = true;
                    }
    

该函数将把返回的SessionStateStore项添加到请求上下文中。

这个方法的主要作用是向请求上下文中(HttpContext)添加一个会话状态存储，Session中存储数据的功能就是靠这个对象实现的。

这个方法中，添加会话状态存储的功能是靠InitStateStoreItem这个方法来实现的。我们也看看这个方法的内部。

        internal void InitStateStoreItem(bool addToContext) {
            try {

                if (_rqItem == null) {
                    _rqItem = _store.CreateNewStoreData(_rqContext, s_timeout);
                }

                _rqSessionItems = _rqItem.Items;
                if (_rqSessionItems == null) {
                    throw new HttpException(SR.GetString(SR.Null_value_for_SessionStateItemCollection));
                }

                // No check for null because we allow our custom provider to return a null StaticObjects.
                _rqStaticObjects = _rqItem.StaticObjects;

                _rqSessionItems.Dirty = false;

                _rqSessionState = new HttpSessionStateContainer(
                        this,
                        _rqId,            // could be null if we're using InProc optimization
                        _rqSessionItems,
                        _rqStaticObjects,
                        _rqItem.Timeout,
                        _rqIsNewSession,
                        s_configCookieless,
                        s_configMode,
                        _rqReadonly);

                if (addToContext) {
                    SessionStateUtility.AddHttpSessionStateToContext(_rqContext, _rqSessionState);
                }
            }
            finally {
                RestoreImpersonation();
            }
        }
        public static class SessionStateUtility {
            // Called by custom session state module
            static public void AddHttpSessionStateToContext(HttpContext context, IHttpSessionState container) {
                HttpSessionState sessionState = new HttpSessionState(container);
                
                //在这个方法中，将用于存取数据的数据结构存储在了context.Items中。
                //存储的key是变量SESSION_KEY
                try {
                    context.Items.Add(SESSION_KEY, sessionState);
                }
                catch (ArgumentException) {
                    throw new HttpException(SR.GetString(SR.Cant_have_multiple_session_module));
                }
            }
        }
        
        
        //这是HttpContext中Session的内部代码
        public HttpSessionState Session {
            get {
                if (HasWebSocketRequestTransitionCompleted) {
                    // Session is unavailable at this point
                    return null;
                }
                //省略了部分代码
                
                //访问session时，从context.Items中取出这一数据结构
                //存储的key是变量SESSION_KEY
                return(HttpSessionState)Items[SessionStateUtility.SESSION_KEY];
            }
        }

经过这个方法后，我们的请求上下文真正有了用了可以让我们用于访问，用于存取数据的对象。

---

 

经过上面的两个大方法，我们的请求上下文终于获得了session，然后代码进入了我们的控制器，我们在控制器中会具体的处理的代码，与session相关的可能就是从session中读取数据，但是这个数据只是存储在这个用来存储数据的对象中了，并没有存储在缓存中。当我们再次请求时，数据从哪里来呢？下面介绍的方法就是负责session相关的收尾工作---OnReleaseState。

　　当控制器中的代码处理完毕后。应用程序就会进行其他的一些收尾步骤，比如将session中的数据存储起来，再次查询时使用。

　　在下面的代码中，对部分关键代码做了相应的注释。

　　这个方法的主要作用就是判断是否要把会话存储放进系统缓存中，是否把session id继续保存在cookie中

        void OnReleaseState(Object source, EventArgs eventArgs) {
            HttpApplication             app;
            HttpContext                 context;
            bool                        setItemCalled = false;

            _releaseCalled = true;

            app = (HttpApplication)source;
            context = app.Context;

            ChangeImpersonation(context, false);

            try {
                if (_rqSessionState != null) {
                    bool delayedSessionState = (_rqSessionState == s_delayedSessionState);
                    SessionStateUtility.RemoveHttpSessionStateFromContext(_rqContext, delayedSessionState);

                    if (
                                //如果会话状态是新的，并且没有被访问过，
                                //那么这样的会话状态存储不用保存到系统的缓存中，保存了没有意义。
                                //所以不做任何处理(不保存在系统缓存中)
                                _rqSessionStateNotFound
                               && _sessionStartEventHandler == null
                               // Nothing has been stored in session state
                               && (delayedSessionState || !_rqSessionItems.Dirty)
                               && (delayedSessionState || _rqStaticObjects == null || _rqStaticObjects.NeverAccessed)
                        ) {
                    }
                    //如果会话被丢弃了，即我们在控制器中调用了Session.Abandon(),常用于注销操作。
                    else if (_rqSessionState.IsAbandoned) {
                        if (_rqSessionStateNotFound) {
                            // The store provider doesn't have it, and so we don't need to remove it from the store.

                            // However, if the store provider supports session expiry, and we have a Session_End in global.asax,
                            // we need to explicitly call Session_End.
                            if (_supportSessionExpiry) {
                                if (delayedSessionState) {
                                    InitStateStoreItem(false /*addToContext*/);
                                }
                                _onEndTarget.RaiseSessionOnEnd(ReleaseStateGetSessionID(), _rqItem);
                            }
                        }
                        else {
                            // Remove it from the store because the session is abandoned.
                            _store.RemoveItem(_rqContext, ReleaseStateGetSessionID(), _rqLockId, _rqItem);
                        }
                    }
                    else if (!_rqReadonly ||
                             (_rqReadonly &&
                              _rqIsNewSession &&
                              _sessionStartEventHandler != null &&
                              !SessionIDManagerUseCookieless)) {

                        // We save it only if there is no error, and if something has changed (unless it's a new session)
                        if (    context.Error == null   // no error
                                && (    _rqSessionStateNotFound
                                    || _rqSessionItems.Dirty    // SessionItems has changed.
                                    || (_rqStaticObjects != null && !_rqStaticObjects.NeverAccessed) // Static objects have been accessed
                                    || _rqItem.Timeout != _rqSessionState.Timeout   // Timeout value has changed
                                    )
                            ) {

                            if (delayedSessionState) {
                                InitStateStoreItem(false /*addToContext*/);
                            }
                            if (_rqItem.Timeout != _rqSessionState.Timeout) {
                                _rqItem.Timeout = _rqSessionState.Timeout;
                            }
                            //该标识设置为true，说明该模块设置过session，该标识用于一些优化
                            s_sessionEverSet = true;
                            //为true说明我们已经把当前的session保存进系统缓存中了
                            setItemCalled = true;
                            //将这个会话状态存储放入系统缓存中,在这个代码中，我们看到使用了ReleaseStateGetSessionID()这个方法去获取session id
                            //有这样的意思。如果已经有session id了，则直接使用，如果没有则会创建一个session id，且写入cookie ，则浏览器端就有了这个id
                            //如果这是一个全新的请求，而且也没有在控制器中也没有Session.SessionID这样的访问，那么到了此处，session id就是空值
                            _store.SetAndReleaseItemExclusive(_rqContext, ReleaseStateGetSessionID(), _rqItem, _rqLockId, _rqSessionStateNotFound);
                        }
                        else {
                            // Can't save it because of various reason.  Just release our exclusive lock on it.
                            if (!_rqSessionStateNotFound) {
                                _store.ReleaseItemExclusive(_rqContext, ReleaseStateGetSessionID(), _rqLockId);
                            }
                        }
                    }
                }
                //上面是决定是否保存会话状态存储的代码，下面是决定是否将session id保存在cookie中的代码
                //有这样一种情况，在一次全新的请求中，如果我们在控制器中有了Session.SessionID这样的访问
                //那么，此时会创建一个SessionID且写入cookie中,但是如果我们没有向Session中存储数据
                //那么这样的SessionID继续保存在cookie中，就是没有意义的，所以就从cookie中删除这个id
                if (_rqAddedCookie && !setItemCalled && context.Response.IsBuffered()) {
                    _idManager.RemoveSessionID(_rqContext);
                }
            }
            finally {
                RestoreImpersonation();
            }

            bool implementsIRequiresSessionState = context.RequiresSessionState;
            if (HttpRuntime.UseIntegratedPipeline 
                && (context.NotificationContext.CurrentNotification == RequestNotification.ReleaseRequestState) 
                && (s_canSkipEndRequestCall || !implementsIRequiresSessionState)) {
                context.DisableNotifications(RequestNotification.EndRequest, 0 /*postNotifications*/);
                _acquireCalled = false;
                _releaseCalled = false;
                ResetPerRequestFields();
            }
        }

 

---

 

　　上面对于初次的访问关于session的获取等已经介绍完毕，而对于非初次访问(已经想session中存储过数据)，则简单很多。

　　因为已经存储过数据，所以cookie中有session id，系统缓存中数据。

　　则先从cookie中读取session id，然后根据此id去缓存中读取数据，然后返回。

---

 

　　结束语：SessionStateModule模块已经介绍完毕，这个模块的主要作用，就是在正式处理请求前，为我们生成存储数据用的session内部对象，请求处理完毕后，将

　　　　　　存储数据的对象保存在系统缓存中。这些功能也是这个模块的部分功能，还有其他很重要的功能。比如用于同步的锁机制，比如生成sessionid的类等。这些内容                      就放在其他文章里再做介绍。