.NET Core Session源码探究-低调大师

.NET Core Session源码探究

2020-06-04 564

.NET Core Session源码探究

前言#
随着互联网的兴起,技术的整体架构设计思路有了质的提升，曾经Web开发必不可少的内置对象Session已经被慢慢的遗弃。主要原因有两点，一是Session依赖Cookie存放SessionID，即使不通过Cookie传递，也要依赖在请求参数或路径上携带Session标识，对于目前前后端分离项目来说操作起来限制很大，比如跨域问题。二是Session数据跨服务器同步问题，现在基本上项目都使用负载均衡技术，Session同步存在一定的弊端，虽然可以借助Redis或者其他存储系统实现中心化存储，但是略显鸡肋。虽然存在一定的弊端，但是在.NET Core也并没有抛弃它，而且借助了更好的实现方式提升了它的设计思路。接下来我们通过分析源码的方式，大致了解下新的工作方式。

Session如何使用#
.NET Core的Session使用方式和传统的使用方式有很大的差别，首先它依赖存储系统IDistributedCache来存储数据，其次它依赖SessionMiddleware为每一次请求提供具体的实例。所以使用Session之前需要配置一些操作，相信介绍情参阅微软官方文档会话状态。简单来说大致配置如下

Copy
public class Startup
{

public Startup(IConfiguration configuration)
{
    Configuration = configuration;
}
public IConfiguration Configuration { get; }

public void ConfigureServices(IServiceCollection services)
{
    services.AddDistributedMemoryCache();
    services.AddSession(options =>
    {
        options.IdleTimeout = TimeSpan.FromSeconds(10);
        options.Cookie.HttpOnly = true;
        options.Cookie.IsEssential = true;
    });
}

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    app.UseSession();
}

}
Session注入代码分析#
注册的地方设计到了两个扩展方法AddDistributedMemoryCache和AddSession.其中AddDistributedMemoryCache这是借助IDistributedCache为Session数据提供存储，AddSession是Session实现的核心的注册操作。

IDistributedCache提供存储#
上面的示例中示例中使用的是基于本地内存存储的方式，也可以使用IDistributedCache针对Redis和数据库存储的扩展方法。实现也非常简单就是给IDistributedCache注册存储操作实例

Copy
public static IServiceCollection AddDistributedMemoryCache(this IServiceCollection services)
{

if (services == null)
{
    throw new ArgumentNullException(nameof(services));
}
services.AddOptions();
services.TryAdd(ServiceDescriptor.Singleton<IDistributedCache, MemoryDistributedCache>());
return services;

}
关于IDistributedCache的其他使用方式请参阅官方文档的分布式缓存篇，关于分布式缓存源码实现可以通过Cache的Github地址自行查阅。

AddSession核心操作#
AddSession是Session实现的核心的注册操作，具体实现代码来自扩展类SessionServiceCollectionExtensions，AddSession扩展方法大致实现如下

Copy
public static IServiceCollection AddSession(this IServiceCollection services)
{

if (services == null)
{
    throw new ArgumentNullException(nameof(services));
}
services.TryAddTransient<ISessionStore, DistributedSessionStore>();
services.AddDataProtection();
return services;

}
这个方法就做了两件事，一个是注册了Session的具体操作，另一个是添加了数据保护保护条例支持。和Session真正相关的其实只有ISessionStore，话不多说，继续向下看DistributedSessionStore实现

Copy
public class DistributedSessionStore : ISessionStore
{

private readonly IDistributedCache _cache;
private readonly ILoggerFactory _loggerFactory;

public DistributedSessionStore(IDistributedCache cache, ILoggerFactory loggerFactory)
{
    if (cache == null)
    {
        throw new ArgumentNullException(nameof(cache));
    }
    if (loggerFactory == null)
    {
        throw new ArgumentNullException(nameof(loggerFactory));
    }
    _cache = cache;
    _loggerFactory = loggerFactory;
}
public ISession Create(string sessionKey, TimeSpan idleTimeout, TimeSpan ioTimeout, Func<bool> tryEstablishSession, bool isNewSessionKey)
{
    if (string.IsNullOrEmpty(sessionKey))
    {
        throw new ArgumentException(Resources.ArgumentCannotBeNullOrEmpty, nameof(sessionKey));
    }
    if (tryEstablishSession == null)
    {
        throw new ArgumentNullException(nameof(tryEstablishSession));
    }
    return new DistributedSession(_cache, sessionKey, idleTimeout, ioTimeout, tryEstablishSession, _loggerFactory, isNewSessionKey);
}

}
这里的实现也非常简单就是创建Session实例DistributedSession，在这里我们就可以看出创建Session是依赖IDistributedCache的,这里的sessionKey其实是SessionID,当前会话唯一标识。继续向下找到DistributedSession实现,这里的代码比较多，因为这是封装Session操作的实现类。老规矩先找到我们最容易下手的Get方法

Copy
public bool TryGetValue(string key, out byte[] value)
{

Load();
return _store.TryGetValue(new EncodedKey(key), out value);

}
我们看到调用TryGetValue之前先调用了Load方法，这是内部的私有方法

Copy
private void Load()
{

//判断当前会话中有没有加载过数据
if (!_loaded)
{
    try
    {
        //根据会话唯一标识在IDistributedCache中获取数据
        var data = _cache.Get(_sessionKey);
        if (data != null)
        {
            //由于存储的是按照特定的规则得到的二进制数据，所以获取的时候要将数据反序列化
            Deserialize(new MemoryStream(data));
        }
        else if (!_isNewSessionKey)
        {
            _logger.AccessingExpiredSession(_sessionKey);
        }
        //是否可用标识
        _isAvailable = true;
    }
    catch (Exception exception)
    {
        _logger.SessionCacheReadException(_sessionKey, exception);
        _isAvailable = false;
        _sessionId = string.Empty;
        _sessionIdBytes = null;
        _store = new NoOpSessionStore();
    }
    finally
    {
       //将数据标识设置为已加载状态
        _loaded = true;
    }
}

}

private void Deserialize(Stream content)
{

if (content == null || content.ReadByte() != SerializationRevision)
{
    // Replace the un-readable format.
    _isModified = true;
    return;
}

int expectedEntries = DeserializeNumFrom3Bytes(content);
_sessionIdBytes = ReadBytes(content, IdByteCount);

for (int i = 0; i < expectedEntries; i++)
{
    int keyLength = DeserializeNumFrom2Bytes(content);
    //在存储的数据中按照规则获取存储设置的具体key
    var key = new EncodedKey(ReadBytes(content, keyLength));
    int dataLength = DeserializeNumFrom4Bytes(content);
    //将反序列化之后的数据存储到_store
    _store[key] = ReadBytes(content, dataLength);
}

if (_logger.IsEnabled(LogLevel.Debug))
{
    _sessionId = new Guid(_sessionIdBytes).ToString();
    _logger.SessionLoaded(_sessionKey, _sessionId, expectedEntries);
}

}
通过上面的代码我们可以得知Get数据之前之前先Load数据,Load其实就是在IDistributedCache中获取数据然后存储到了_store中，通过当前类源码可知_store是本地字典，也就是说Session直接获取的其实是本地字典里的数据。

Copy
private IDictionary _store；
这里其实产生两点疑问:
1.针对每个会话存储到IDistributedCache的其实都在一个Key里，就是以当前会话唯一标识为key的value里,为什么没有采取组合会话key单独存储。
2.每次请求第一次操作Session，都会把IDistributedCache里针对当前会话的数据全部加载到本地字典里，一般来说每次会话操作Session的次数并不会很多，感觉并不会节约性能。接下来我们在再来查看另一个我们比较熟悉的方法Set方法

Copy
public void Set(string key, byte[] value)
{

if (value == null)
{
    throw new ArgumentNullException(nameof(value));
}
if (IsAvailable)
{
    //存储的key是被编码过的
    var encodedKey = new EncodedKey(key);
    if (encodedKey.KeyBytes.Length > KeyLengthLimit)
    {
        throw new ArgumentOutOfRangeException(nameof(key),
            Resources.FormatException_KeyLengthIsExceeded(KeyLengthLimit));
    }
    if (!_tryEstablishSession())
    {
        throw new InvalidOperationException(Resources.Exception_InvalidSessionEstablishment);
    }
    //是否修改过标识
    _isModified = true;
    //将原始内容转换为byte数组
    byte[] copy = new byte[value.Length];
    Buffer.BlockCopy(src: value, srcOffset: 0, dst: copy, dstOffset: 0, count: value.Length);
    //将数据存储到本地字典_store
    _store[encodedKey] = copy;
}

}
这里我们可以看到Set方法并没有将数据放入到存储系统，只是放入了本地字典里。我们再来看其他方法

Copy
public void Remove(string key)
{

Load();
_isModified |= _store.Remove(new EncodedKey(key));

}

public void Clear()
{

Load();
_isModified |= _store.Count > 0;
_store.Clear();

}
这些方法都没有对存储系统DistributedCache里的数据进行操作，都只是操作从存储系统Load到本地的字典数据。那什么地方进行的存储呢，也就是说我们要找到调用_cache.Set方法的地方，最后在这个地方找到了Set方法,而且看这个方法名就知道是提交Session数据的地方

Copy
public async Task CommitAsync(CancellationToken cancellationToken = default)
{

//超过_ioTimeout CancellationToken将自动取消
using (var timeout = new CancellationTokenSource(_ioTimeout))
{
    var cts = CancellationTokenSource.CreateLinkedTokenSource(timeout.Token, cancellationToken);
    //数据被修改过
    if (_isModified)
    {
        if (_logger.IsEnabled(LogLevel.Information))
        {
            try
            {
                cts.Token.ThrowIfCancellationRequested();
                var data = await _cache.GetAsync(_sessionKey, cts.Token);
                if (data == null)
                {
                    _logger.SessionStarted(_sessionKey, Id);
                }
            }
            catch (OperationCanceledException)
            {
            }
            catch (Exception exception)
            {
                _logger.SessionCacheReadException(_sessionKey, exception);
            }
        }
        var stream = new MemoryStream();
        //将_store字典里的数据写到stream里
        Serialize(stream);
        try
        {
            cts.Token.ThrowIfCancellationRequested();
            //将读取_store的流写入到DistributedCache存储里
            await _cache.SetAsync(
                _sessionKey,
                stream.ToArray(),
                new DistributedCacheEntryOptions().SetSlidingExpiration(_idleTimeout),
                cts.Token);
            _isModified = false;
            _logger.SessionStored(_sessionKey, Id, _store.Count);
        }
        catch (OperationCanceledException oex)
        {
            if (timeout.Token.IsCancellationRequested)
            {
                _logger.SessionCommitTimeout();
                throw new OperationCanceledException("Timed out committing the session.", oex, timeout.Token);
            }
            throw;
        }
    }
    else
    {
        try
        {
            await _cache.RefreshAsync(_sessionKey, cts.Token);
        }
        catch (OperationCanceledException oex)
        {
            if (timeout.Token.IsCancellationRequested)
            {
                _logger.SessionRefreshTimeout();
                throw new OperationCanceledException("Timed out refreshing the session.", oex, timeout.Token);
            }
            throw;
        }
    }
}

}

private void Serialize(Stream output)
{

output.WriteByte(SerializationRevision);
SerializeNumAs3Bytes(output, _store.Count);
output.Write(IdBytes, 0, IdByteCount);
//将_store字典里的数据写到Stream里
foreach (var entry in _store)
{
    var keyBytes = entry.Key.KeyBytes;
    SerializeNumAs2Bytes(output, keyBytes.Length);
    output.Write(keyBytes, 0, keyBytes.Length);
    SerializeNumAs4Bytes(output, entry.Value.Length);
    output.Write(entry.Value, 0, entry.Value.Length);
}

}
那么问题来了当前类里并没有地方调用CommitAsync，那么到底是在什么地方调用的该方法呢？姑且别着急，我们之前说过使用Session的三要素，现在才说了两个，还有一个UseSession的中间件没有提及到呢。

UseSession中间件#
通过上面注册的相关方法我们大概了解到了Session的工作原理。接下来我们查看UseSession中间件里的代码，探究这里究竟做了什么操作。我们找到UseSession方法所在的地方SessionMiddlewareExtensions找到第一个方法

Copy
public static IApplicationBuilder UseSession(this IApplicationBuilder app)
{

if (app == null)
{
    throw new ArgumentNullException(nameof(app));
}
return app.UseMiddleware<SessionMiddleware>();

}
SessionMiddleware的源码

Copy
public class SessionMiddleware
{
private static readonly RandomNumberGenerator CryptoRandom = RandomNumberGenerator.Create();
private const int SessionKeyLength = 36; // "382c74c3-721d-4f34-80e5-57657b6cbc27"
private static readonly Func ReturnTrue = () => true;
private readonly RequestDelegate _next;
private readonly SessionOptions _options;
private readonly ILogger _logger;
private readonly ISessionStore _sessionStore;
private readonly IDataProtector _dataProtector;

public SessionMiddleware(

  RequestDelegate next,
  ILoggerFactory loggerFactory,
  IDataProtectionProvider dataProtectionProvider,
  ISessionStore sessionStore,
  IOptions<SessionOptions> options)

{

  if (next == null)
  {
      throw new ArgumentNullException(nameof(next));
  }
  if (loggerFactory == null)
  {
      throw new ArgumentNullException(nameof(loggerFactory));
  }
  if (dataProtectionProvider == null)
  {
      throw new ArgumentNullException(nameof(dataProtectionProvider));
  }
  if (sessionStore == null)
  {
      throw new ArgumentNullException(nameof(sessionStore));
  }
  if (options == null)
  {
      throw new ArgumentNullException(nameof(options));
  }
  _next = next;
  _logger = loggerFactory.CreateLogger<SessionMiddleware>();
  _dataProtector = dataProtectionProvider.CreateProtector(nameof(SessionMiddleware));
  _options = options.Value;
 //Session操作类在这里被注入的
  _sessionStore = sessionStore;

}

public async Task Invoke(HttpContext context)
{

  var isNewSessionKey = false;
  Func<bool> tryEstablishSession = ReturnTrue;
  var cookieValue = context.Request.Cookies[_options.Cookie.Name];
  var sessionKey = CookieProtection.Unprotect(_dataProtector, cookieValue, _logger);
  //会话首次建立
  if (string.IsNullOrWhiteSpace(sessionKey) || sessionKey.Length != SessionKeyLength)
  {
      //将会话唯一标识通过Cookie返回到客户端
      var guidBytes = new byte[16];
      CryptoRandom.GetBytes(guidBytes);
      sessionKey = new Guid(guidBytes).ToString();
      cookieValue = CookieProtection.Protect(_dataProtector, sessionKey);
      var establisher = new SessionEstablisher(context, cookieValue, _options);
      tryEstablishSession = establisher.TryEstablishSession;
      isNewSessionKey = true;
  }
  var feature = new SessionFeature();
  //创建Session
  feature.Session = _sessionStore.Create(sessionKey, _options.IdleTimeout, _options.IOTimeout, tryEstablishSession, isNewSessionKey);
  //放入到ISessionFeature,给HttpContext中的Session数据提供具体实例
  context.Features.Set<ISessionFeature>(feature);
  try
  {
      await _next(context);
  }
  finally
  {
      //置空为了在请求结束后可以回收掉Session
      context.Features.Set<ISessionFeature>(null);
      if (feature.Session != null)
      {
          try
          {
              //请求完成后提交保存Session字典里的数据到DistributedCache存储里
              await feature.Session.CommitAsync();
          }
          catch (OperationCanceledException)
          {
              _logger.SessionCommitCanceled();
          }
          catch (Exception ex)
          {
              _logger.ErrorClosingTheSession(ex);
          }
      }
  }

}

private class SessionEstablisher
{

  private readonly HttpContext _context;
  private readonly string _cookieValue;
  private readonly SessionOptions _options;
  private bool _shouldEstablishSession;

  public SessionEstablisher(HttpContext context, string cookieValue, SessionOptions options)
  {
      _context = context;
      _cookieValue = cookieValue;
      _options = options;
      context.Response.OnStarting(OnStartingCallback, state: this);
  }

  private static Task OnStartingCallback(object state)
  {
      var establisher = (SessionEstablisher)state;
      if (establisher._shouldEstablishSession)
      {
          establisher.SetCookie();
      }
      return Task.FromResult(0);
  }

  private void SetCookie()
  {
      //会话标识写入到Cookie操作
      var cookieOptions = _options.Cookie.Build(_context);
      var response = _context.Response;
      response.Cookies.Append(_options.Cookie.Name, _cookieValue, cookieOptions);
      var responseHeaders = response.Headers;
      responseHeaders[HeaderNames.CacheControl] = "no-cache";
      responseHeaders[HeaderNames.Pragma] = "no-cache";
      responseHeaders[HeaderNames.Expires] = "-1";
  }

  internal bool TryEstablishSession()
  {
      return (_shouldEstablishSession |= !_context.Response.HasStarted);
  }

}
}
通过SessionMiddleware中间件里的代码我们了解到了每次请求Session的创建，以及Session里的数据保存到DistributedCache都是在这里进行的。不过这里仍存在一个疑问由于调用CommitAsync是在中间件执行完成后统一进行存储的，也就是说中途对Session进行的Set Remove Clear的操作都是在Session方法的本地字典里进行的，并没有同步到DistributedCache里，如果中途出现程序异常结束的情况下，保存到Session里的数据，并没有真正的存储下来，会出现丢失的情况，不知道在设计这部分逻辑的时候是出于什么样的考虑。

总结#
通过阅读Session相关的部分源码大致了解了Session的原理，工作三要素，IDistributedCache存储Session里的数据，SessionStore是Session的实现类，UseSession是Session被创建到当前请求的地方。同时也留下了几点疑问

针对每个会话存储到IDistributedCache的其实都在一个Key里，就是以当前会话唯一标识为key的value里,为什么没有采取组合会话key单独存储。
每次请求第一次操作Session，都会把IDistributedCache里针对当前会话的数据全部加载到本地字典里，一般来说每次会话操作Session的次数并不会很多，感觉并不会节约性能。
调用CommitAsync是在中间件执行完成后统一进行存储的，也就是说中途对Session进行的Set Remove Clear的操作都是在Session方法的本地字典里进行的，并没有同步到DistributedCache里，如果中途出现程序异常结束的情况下，保存到Session里的数据，并没有真正的存储下来，会出现丢失的情况。
对于以上疑问，不知道是个人理解不足，还是在设计的时候出于别的考虑。欢迎在评论区多多沟通交流，希望能从大家那里得到更好的解释和答案。

作者： yi念之间

出处：https://www.cnblogs.com/wucy/p/13044467.html

微信关注我们

原文链接：https://yq.aliyun.com/articles/763843

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

你必须知道的云计算知识（上）

最近订阅学习了《深入浅出云计算》专栏，一口气学完之后，做了一些总结笔记形成此文，特分享与你，希望对你有所帮助！本文为上半部分，主要总结了IaaS篇的核心要点。零、开篇词 1、开发者为何要学习云计算？（1）历经多年发展已成熟并成为一种潮流，企业数字化转型的组成部分。（2）产业的发展必然影响个体：未来更多的应用都会运行在云上，架构模式和思维方式也会更多地与云契合共生！（3）很多人对云的特性还不够熟悉，对云产品存在误解甚至偏见。 2、开发者应该如何学习云计算？尽可能多地结合应用场景来解析云的概念和能力，学习“用云”而非“做云”；对于我们程序员学习者而言，也是如此，重点放在用云上即可！不进行“厂商绑定”而是同时观察运用多个主流云厂商的服务，了解共性和差异性；对于我们学习者而言，先了解共性和差异，再重点放在企业所选择的云服务商提供的产品上重点关注！一、Iaas篇 IaaS 的本质，是对云数据中心和各类 IT 基础设施的抽象，是基于软件技术对物理硬件进行的封装和虚拟。 1、区域和可用区区域对应云厂商在某个地理位置提供的所有云服务的组合=>对外提供云服务的基本单位和容器；区域...

2020-06-04

661

【Spring注解驱动开发】聊聊Spring注解驱动开发那些事儿！写在前面今天，面了一个工作5年的小伙伴，面试结果不理想啊！也不是我说，工作5年了，问多线程的知识：就只知道继承Thread类和实现Runnable接口！问Java集合，竟然说HashMap是线程安全的！问MySQL的MyISAM存储引擎和InnoDB存储引擎的区别，竟然说成是MyISAM存储引擎支持事务，InnoDB不支持！问Spring就只知道IOC和AOP的概念，深一点就不知道了！再问项目。。。哎，算了，不说了！大家对于设计模式、高并发和Java8新特性，不了解的，就去看我的专栏吧！今天，我们来聊聊关于Spring注解驱动开发的那些事儿，也算是Spring专栏的开篇吧！关于Spring说起Spring，绝对是Java开发领域的佼佼者，试问，做Java开发的有谁不知道Spring？做Java开发的又有谁没用过Spring?又有哪家公司在Java Web项目中没使用过Spring？就算有，那也应该很少吧！所以，骚年，如果你选择了Java开发这条不归路，你就必须牢牢掌握Spring！ Spring注解驱动如果小伙伴们...

2020-06-05

545

资源下载

更多资源

优质分享App

近一个月的开发和优化，本站点的第一个app全新上线。该app采用极致压缩，本体才4.36MB。系统里面做了大量数据访问、缓存优化。方便用户在手机上查看文章。后续会推出HarmonyOS的适配版本。

腾讯云软件源

为解决软件依赖安装时官方源访问速度慢的问题，腾讯云为一些软件搭建了缓存服务。您可以通过使用腾讯云软件源站来提升依赖包的安装速度。为了方便用户自由搭建服务架构，目前腾讯云软件源站支持公网访问和内网访问。

Rocky Linux

Rocky Linux（中文名：洛基）是由Gregory Kurtzer于2020年12月发起的企业级Linux发行版，作为CentOS稳定版停止维护后与RHEL（Red Hat Enterprise Linux）完全兼容的开源替代方案，由社区拥有并管理，支持x86_64、aarch64等架构。其通过重新编译RHEL源代码提供长期稳定性，采用模块化包装和SELinux安全架构，默认包含GNOME桌面环境及XFS文件系统，支持十年生命周期更新。

Sublime Text

Sublime Text具有漂亮的用户界面和强大的功能，例如代码缩略图，Python的插件，代码段等。还可自定义键绑定，菜单和工具栏。Sublime Text 的主要功能包括：拼写检查，书签，完整的 Python API ， Goto 功能，即时项目切换，多选择，多窗口等等。Sublime Text 是一个跨平台的编辑器，同时支持Windows、Linux、Mac OS X等操作系统。