详解Asp.net Core 使用Redis存储Session
前言
Asp.netCore改变了之前的封闭，现在开源且开放，下面我们来用Redis存储Session来做一个简单的测试，或者叫做中间件（middleware）。
对于Session来说褒贬不一，很多人直接说不要用，也有很多人在用，这个也没有绝对的这义，个人认为只要不影什么且又可以方便实现的东西是可以用的，现在不对可不可用做表态，我们只关心实现。
类库引用
这个相对于之前的.net是方便了不少，需要在project.json中的dependencies节点中添加如下内容：
"StackExchange.Redis":"1.1.604-alpha", "Microsoft.AspNetCore.Session":"1.1.0-alpha1-21694"
Redis实现
这里并非我实现，而是借用不知道为什么之前还有这个类库，而现在NUGET止没有了，为了不影响日后升级我的命名空间也用Microsoft.Extensions.Caching.Redis
可以看到微软这里有四个类，其实我们只需要三个，第四个拿过来反而会出错：
usingSystem;
usingSystem.Threading.Tasks;
usingMicrosoft.Extensions.Caching.Distributed;
usingMicrosoft.Extensions.Options;
usingStackExchange.Redis;
namespaceMicrosoft.Extensions.Caching.Redis
{
publicclassRedisCache:IDistributedCache,IDisposable
{
//KEYS[1]==key
//ARGV[1]=absolute-expiration-ticksaslong(-1fornone)
//ARGV[2]=sliding-expiration-ticksaslong(-1fornone)
//ARGV[3]=relative-expiration(long,inseconds,-1fornone)-Min(absolute-expiration-Now,sliding-expiration)
//ARGV[4]=data-byte[]
//thisordershouldnotchangeLUAscriptdependsonit
privateconststringSetScript=(@"
redis.call('HMSET',KEYS[1],'absexp',ARGV[1],'sldexp',ARGV[2],'data',ARGV[4])
ifARGV[3]~='-1'then
redis.call('EXPIRE',KEYS[1],ARGV[3])
end
return1");
privateconststringAbsoluteExpirationKey="absexp";
privateconststringSlidingExpirationKey="sldexp";
privateconststringDataKey="data";
privateconstlongNotPresent=-1;
privateConnectionMultiplexer_connection;
privateIDatabase_cache;
privatereadonlyRedisCacheOptions_options;
privatereadonlystring_instance;
publicRedisCache(IOptions<RedisCacheOptions>optionsAccessor)
{
if(optionsAccessor==null)
{
thrownewArgumentNullException(nameof(optionsAccessor));
}
_options=optionsAccessor.Value;
//Thisallowspartitioningasinglebackendcacheforusewithmultipleapps/services.
_instance=_options.InstanceName??string.Empty;
}
publicbyte[]Get(stringkey)
{
if(key==null)
{
thrownewArgumentNullException(nameof(key));
}
returnGetAndRefresh(key,getData:true);
}
publicasyncTask<byte[]>GetAsync(stringkey)
{
if(key==null)
{
thrownewArgumentNullException(nameof(key));
}
returnawaitGetAndRefreshAsync(key,getData:true);
}
publicvoidSet(stringkey,byte[]value,DistributedCacheEntryOptionsoptions)
{
if(key==null)
{
thrownewArgumentNullException(nameof(key));
}
if(value==null)
{
thrownewArgumentNullException(nameof(value));
}
if(options==null)
{
thrownewArgumentNullException(nameof(options));
}
Connect();
varcreationTime=DateTimeOffset.UtcNow;
varabsoluteExpiration=GetAbsoluteExpiration(creationTime,options);
varresult=_cache.ScriptEvaluate(SetScript,newRedisKey[]{_instance+key},
newRedisValue[]
{
absoluteExpiration?.Ticks??NotPresent,
options.SlidingExpiration?.Ticks??NotPresent,
GetExpirationInSeconds(creationTime,absoluteExpiration,options)??NotPresent,
value
});
}
publicasyncTaskSetAsync(stringkey,byte[]value,DistributedCacheEntryOptionsoptions)
{
if(key==null)
{
thrownewArgumentNullException(nameof(key));
}
if(value==null)
{
thrownewArgumentNullException(nameof(value));
}
if(options==null)
{
thrownewArgumentNullException(nameof(options));
}
awaitConnectAsync();
varcreationTime=DateTimeOffset.UtcNow;
varabsoluteExpiration=GetAbsoluteExpiration(creationTime,options);
await_cache.ScriptEvaluateAsync(SetScript,newRedisKey[]{_instance+key},
newRedisValue[]
{
absoluteExpiration?.Ticks??NotPresent,
options.SlidingExpiration?.Ticks??NotPresent,
GetExpirationInSeconds(creationTime,absoluteExpiration,options)??NotPresent,
value
});
}
publicvoidRefresh(stringkey)
{
if(key==null)
{
thrownewArgumentNullException(nameof(key));
}
GetAndRefresh(key,getData:false);
}
publicasyncTaskRefreshAsync(stringkey)
{
if(key==null)
{
thrownewArgumentNullException(nameof(key));
}
awaitGetAndRefreshAsync(key,getData:false);
}
privatevoidConnect()
{
if(_connection==null)
{
_connection=ConnectionMultiplexer.Connect(_options.Configuration);
_cache=_connection.GetDatabase();
}
}
privateasyncTaskConnectAsync()
{
if(_connection==null)
{
_connection=awaitConnectionMultiplexer.ConnectAsync(_options.Configuration);
_cache=_connection.GetDatabase();
}
}
privatebyte[]GetAndRefresh(stringkey,boolgetData)
{
if(key==null)
{
thrownewArgumentNullException(nameof(key));
}
Connect();
//ThisalsoresetstheLRUstatusasdesired.
//TODO:Canthisbedoneinoneoperationontheserverside?Probably,thetrickwouldjustbetheDateTimeOffsetmath.
RedisValue[]results;
if(getData)
{
results=_cache.HashMemberGet(_instance+key,AbsoluteExpirationKey,SlidingExpirationKey,DataKey);
}
else
{
results=_cache.HashMemberGet(_instance+key,AbsoluteExpirationKey,SlidingExpirationKey);
}
//TODO:Errorhandling
if(results.Length>=2)
{
//Notewealwaysgetbacktworesults,eveniftheyareallnull.
//Theseoperationswillno-opinthenullscenario.
DateTimeOffset?absExpr;
TimeSpan?sldExpr;
MapMetadata(results,outabsExpr,outsldExpr);
Refresh(key,absExpr,sldExpr);
}
if(results.Length>=3&&results[2].HasValue)
{
returnresults[2];
}
returnnull;
}
privateasyncTask<byte[]>GetAndRefreshAsync(stringkey,boolgetData)
{
if(key==null)
{
thrownewArgumentNullException(nameof(key));
}
awaitConnectAsync();
//ThisalsoresetstheLRUstatusasdesired.
//TODO:Canthisbedoneinoneoperationontheserverside?Probably,thetrickwouldjustbetheDateTimeOffsetmath.
RedisValue[]results;
if(getData)
{
results=await_cache.HashMemberGetAsync(_instance+key,AbsoluteExpirationKey,SlidingExpirationKey,DataKey);
}
else
{
results=await_cache.HashMemberGetAsync(_instance+key,AbsoluteExpirationKey,SlidingExpirationKey);
}
//TODO:Errorhandling
if(results.Length>=2)
{
//Notewealwaysgetbacktworesults,eveniftheyareallnull.
//Theseoperationswillno-opinthenullscenario.
DateTimeOffset?absExpr;
TimeSpan?sldExpr;
MapMetadata(results,outabsExpr,outsldExpr);
awaitRefreshAsync(key,absExpr,sldExpr);
}
if(results.Length>=3&&results[2].HasValue)
{
returnresults[2];
}
returnnull;
}
publicvoidRemove(stringkey)
{
if(key==null)
{
thrownewArgumentNullException(nameof(key));
}
Connect();
_cache.KeyDelete(_instance+key);
//TODO:Errorhandling
}
publicasyncTaskRemoveAsync(stringkey)
{
if(key==null)
{
thrownewArgumentNullException(nameof(key));
}
awaitConnectAsync();
await_cache.KeyDeleteAsync(_instance+key);
//TODO:Errorhandling
}
privatevoidMapMetadata(RedisValue[]results,outDateTimeOffset?absoluteExpiration,outTimeSpan?slidingExpiration)
{
absoluteExpiration=null;
slidingExpiration=null;
varabsoluteExpirationTicks=(long?)results[0];
if(absoluteExpirationTicks.HasValue&&absoluteExpirationTicks.Value!=NotPresent)
{
absoluteExpiration=newDateTimeOffset(absoluteExpirationTicks.Value,TimeSpan.Zero);
}
varslidingExpirationTicks=(long?)results[1];
if(slidingExpirationTicks.HasValue&&slidingExpirationTicks.Value!=NotPresent)
{
slidingExpiration=newTimeSpan(slidingExpirationTicks.Value);
}
}
privatevoidRefresh(stringkey,DateTimeOffset?absExpr,TimeSpan?sldExpr)
{
if(key==null)
{
thrownewArgumentNullException(nameof(key));
}
//NoteRefreshhasnoeffectifthereisjustanabsoluteexpiration(orneither).
TimeSpan?expr=null;
if(sldExpr.HasValue)
{
if(absExpr.HasValue)
{
varrelExpr=absExpr.Value-DateTimeOffset.Now;
expr=relExpr<=sldExpr.Value?relExpr:sldExpr;
}
else
{
expr=sldExpr;
}
_cache.KeyExpire(_instance+key,expr);
//TODO:Errorhandling
}
}
privateasyncTaskRefreshAsync(stringkey,DateTimeOffset?absExpr,TimeSpan?sldExpr)
{
if(key==null)
{
thrownewArgumentNullException(nameof(key));
}
//NoteRefreshhasnoeffectifthereisjustanabsoluteexpiration(orneither).
TimeSpan?expr=null;
if(sldExpr.HasValue)
{
if(absExpr.HasValue)
{
varrelExpr=absExpr.Value-DateTimeOffset.Now;
expr=relExpr<=sldExpr.Value?relExpr:sldExpr;
}
else
{
expr=sldExpr;
}
await_cache.KeyExpireAsync(_instance+key,expr);
//TODO:Errorhandling
}
}
privatestaticlong?GetExpirationInSeconds(DateTimeOffsetcreationTime,DateTimeOffset?absoluteExpiration,DistributedCacheEntryOptionsoptions)
{
if(absoluteExpiration.HasValue&&options.SlidingExpiration.HasValue)
{
return(long)Math.Min(
(absoluteExpiration.Value-creationTime).TotalSeconds,
options.SlidingExpiration.Value.TotalSeconds);
}
elseif(absoluteExpiration.HasValue)
{
return(long)(absoluteExpiration.Value-creationTime).TotalSeconds;
}
elseif(options.SlidingExpiration.HasValue)
{
return(long)options.SlidingExpiration.Value.TotalSeconds;
}
returnnull;
}
privatestaticDateTimeOffset?GetAbsoluteExpiration(DateTimeOffsetcreationTime,DistributedCacheEntryOptionsoptions)
{
if(options.AbsoluteExpiration.HasValue&&options.AbsoluteExpiration<=creationTime)
{
thrownewArgumentOutOfRangeException(
nameof(DistributedCacheEntryOptions.AbsoluteExpiration),
options.AbsoluteExpiration.Value,
"Theabsoluteexpirationvaluemustbeinthefuture.");
}
varabsoluteExpiration=options.AbsoluteExpiration;
if(options.AbsoluteExpirationRelativeToNow.HasValue)
{
absoluteExpiration=creationTime+options.AbsoluteExpirationRelativeToNow;
}
returnabsoluteExpiration;
}
publicvoidDispose()
{
if(_connection!=null)
{
_connection.Close();
}
}
}
}
usingMicrosoft.Extensions.Options;
namespaceMicrosoft.Extensions.Caching.Redis
{
///<summary>
///Configurationoptionsfor<seecref="RedisCache"/>.
///</summary>
publicclassRedisCacheOptions:IOptions<RedisCacheOptions>
{
///<summary>
///TheconfigurationusedtoconnecttoRedis.
///</summary>
publicstringConfiguration{get;set;}
///<summary>
///TheRedisinstancename.
///</summary>
publicstringInstanceName{get;set;}
RedisCacheOptionsIOptions<RedisCacheOptions>.Value
{
get{returnthis;}
}
}
}
usingSystem.Threading.Tasks;
usingStackExchange.Redis;
namespaceMicrosoft.Extensions.Caching.Redis
{
internalstaticclassRedisExtensions
{
privateconststringHmGetScript=(@"returnredis.call('HMGET',KEYS[1],unpack(ARGV))");
internalstaticRedisValue[]HashMemberGet(thisIDatabasecache,stringkey,paramsstring[]members)
{
varresult=cache.ScriptEvaluate(
HmGetScript,
newRedisKey[]{key},
GetRedisMembers(members));
//TODO:Errorchecking?
return(RedisValue[])result;
}
internalstaticasyncTask<RedisValue[]>HashMemberGetAsync(
thisIDatabasecache,
stringkey,
paramsstring[]members)
{
varresult=awaitcache.ScriptEvaluateAsync(
HmGetScript,
newRedisKey[]{key},
GetRedisMembers(members));
//TODO:Errorchecking?
return(RedisValue[])result;
}
privatestaticRedisValue[]GetRedisMembers(paramsstring[]members)
{
varredisMembers=newRedisValue[members.Length];
for(inti=0;i<members.Length;i++)
{
redisMembers[i]=(RedisValue)members[i];
}
returnredisMembers;
}
}
}
配置启用Session
我们在Startup中ConfigureServices增加
services.AddSingleton<IDistributedCache>(
serviceProvider=>
newRedisCache(newRedisCacheOptions
{
Configuration="192.168.178.141:6379",
InstanceName="Sample:"
}));
services.AddSession();
在Startup中Configure增加
app.UseSession(newSessionOptions(){IdleTimeout=TimeSpan.FromMinutes(30)});
到此我们的配置完毕，可以测试一下是否写到了Redis中
验证结果
在Mvc项目中，我们来实现如下代码
if(string.IsNullOrEmpty(HttpContext.Session.GetString("D")))
{
vard=DateTime.Now.ToString();
HttpContext.Session.SetString("D",d);
HttpContext.Response.ContentType="text/plain";
awaitHttpContext.Response.WriteAsync("HelloFirsttimer///"+d);
}
else
{
HttpContext.Response.ContentType="text/plain";
awaitHttpContext.Response.WriteAsync("Hellooldtimer///"+HttpContext.Session.GetString("D"));
}
运行我们发现第一次出现了HelloFirsttimer字样，刷新后出现了Hellooldtimer字样，证明Session成功，再查看一下Redis看一下，有值了，这样一个分布式的Session就成功实现了。
对于上面的实例我把源码放在了：demo下载
Tianwei.Microsoft.Extensions.Caching.Redis,只是ID加了Tianwei空间名还是Microsoft.Extensions.Caching.Redis
从上面的实例我们发现微软这次是真的开放了，这也意味着如果我们使用某些类不顺手或不合适时可以自已写自已扩展
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持毛票票。