public AbpPerRequestRedisCache_Test()
{
_currentHttpContext = GetNewContextSubstitute();
var httpContextAccessor = Substitute.For <IHttpContextAccessor>();
httpContextAccessor.HttpContext.Returns(info => _currentHttpContext);
LocalIocManager.IocContainer.Register(Component.For <IHttpContextAccessor>().Instance(httpContextAccessor).LifestyleSingleton().IsDefault());
_redisDatabase = Substitute.For <IDatabase>();
var redisDatabaseProvider = Substitute.For <IAbpRedisCacheDatabaseProvider>();
redisDatabaseProvider.GetDatabase().Returns(_redisDatabase);
LocalIocManager.IocContainer.Register(Component.For <IAbpRedisCacheDatabaseProvider>().Instance(redisDatabaseProvider).LifestyleSingleton().IsDefault());
LocalIocManager.IocContainer.Register(Component.For <IAbpStartupConfiguration>().Instance(Substitute.For <IAbpStartupConfiguration>()).IsDefault());
LocalIocManager.Resolve <ICachingConfiguration>().Configure("MyTestCacheItems", cache => { cache.DefaultSlidingExpireTime = TimeSpan.FromHours(12); });
LocalIocManager.Resolve <ICachingConfiguration>().Configure("MyPerRequestRedisTestCacheItems", cache => { cache.DefaultSlidingExpireTime = TimeSpan.FromHours(24); });
_redisSerializer = LocalIocManager.Resolve <IRedisCacheSerializer>();
_perRequestRedisCache = LocalIocManager.Resolve <IAbpPerRequestRedisCacheManager>().GetCache <string, MyCacheItem>("MyPerRequestRedisTestCacheItems");
_normalRedisCache = LocalIocManager.Resolve <ICacheManager>().GetCache <string, MyCacheItem>("MyTestCacheItems");
}
/// <summary>
/// Constructor.
/// </summary>
public AbpRedisCache(
string name,
IRedisCacheSerializer redisCacheSerializer)
: base(name)
{
_serializer = redisCacheSerializer;
}
public RedisCache(string name, IRedisCacheDatabaseProvider redisCacheDatabaseProvider, IRedisCacheSerializer redisCacheSerializer)
{
_redisCacheDatabaseProvider = redisCacheDatabaseProvider;
_database = redisCacheDatabaseProvider.GetDatabase();
_serializer = redisCacheSerializer;
Name = name;
_redisCacheDatabaseProvider.RegisterReConnectionEvent((connection) => _database = connection.GetDatabase());
}
/// <summary>
/// Constructor.
/// </summary>
public StudioXRedisCache(
string name,
IStudioXRedisCacheDatabaseProvider redisCacheDatabaseProvider,
IRedisCacheSerializer redisCacheSerializer)
: base(name)
{
database = redisCacheDatabaseProvider.GetDatabase();
serializer = redisCacheSerializer;
}
/// <summary>
/// Constructor.
/// </summary>
public StoveRedisCache(
[NotNull] string name,
IRedisCacheSerializer serializer,
IStoveRedisCacheDatabaseProvider redisCacheDatabaseProvider) : base(name)
{
_serializer = serializer;
_redisCacheDatabaseProvider = redisCacheDatabaseProvider;
_database = _redisCacheDatabaseProvider.GetDatabase();
}
/// <summary>
/// Constructor.
/// </summary>
public AbpRedisCache(
string name,
IAbpRedisCacheDatabaseProvider redisCacheDatabaseProvider,
IRedisCacheSerializer redisCacheSerializer)
: base(name)
{
_database = redisCacheDatabaseProvider.GetDatabase();
_serializer = redisCacheSerializer;
}
/// <summary>
/// Constructor.
/// </summary>
public AbpRedisCache(
string name,
IAbpRedisCacheDatabaseProvider redisCacheDatabaseProvider,
IRedisCacheSerializer redisCacheSerializer)
: base(name)
{
_database = redisCacheDatabaseProvider.GetDatabase();
_serializer = redisCacheSerializer;
}
public AbpPerRequestRedisCache(
string name,
IAbpRedisCacheDatabaseProvider redisCacheDatabaseProvider,
IRedisCacheSerializer redisCacheSerializer,
IHttpContextAccessor httpContextAccessor)
: base(name, redisCacheDatabaseProvider, redisCacheSerializer)
{
_httpContextAccessor = httpContextAccessor;
}
protected PerRequestRedisCacheTestsBase()
{
var httpContextAccessor = Substitute.For <IHttpContextAccessor>();
httpContextAccessor.HttpContext.Returns(info => CurrentHttpContext);
LocalIocManager.IocContainer.Register(Component.For <IHttpContextAccessor>().Instance(httpContextAccessor).LifestyleSingleton().IsDefault());
RedisSerializer = LocalIocManager.Resolve <IRedisCacheSerializer>();
}
private IRedisCacheSerializer FindSerializer(string name, bool throwIfMissed)
{
string id = name.IfNullOrWhiteSpace(RedisSerializerNames.JsonNet);
IRedisCacheSerializer ser = null;
if (_redisCacheSerializers.TryGetValue(id, out ser))
{
return(ser);
}
else
{
if (throwIfMissed)
{
throw new SchubertException($"找不到名为 {name} 的 Redis 序列化提供程序。");
}
else
{
_logger.WriteWarning($"找不到名为 {name} 的 Redis 序列化提供程序。");
}
return(null);
}
}
public RedisCacheManager_Test()
{
LocalIocManager.Register <AbpRedisCacheOptions>();
LocalIocManager.Register <ICachingConfiguration, CachingConfiguration>();
_redisDatabase = Substitute.For <IDatabase>();
_redisDatabaseProvider = Substitute.For <IAbpRedisCacheDatabaseProvider>();
_redisDatabaseProvider.GetDatabase().Returns(_redisDatabase);
LocalIocManager.IocContainer.Register(Component.For <IAbpRedisCacheDatabaseProvider>().Instance(_redisDatabaseProvider).LifestyleSingleton());
LocalIocManager.Register <ICacheManager, AbpRedisCacheManager>();
LocalIocManager.Register <IRedisCacheSerializer, DefaultRedisCacheSerializer>();
_redisSerializer = LocalIocManager.Resolve <IRedisCacheSerializer>();
LocalIocManager.IocContainer.Register(Component.For <IAbpStartupConfiguration>().Instance(Substitute.For <IAbpStartupConfiguration>()));
LocalIocManager.Resolve <ICachingConfiguration>().Configure("MyTestCacheItems", cache =>
{
cache.DefaultSlidingExpireTime = TimeSpan.FromHours(24);
});
_cache = LocalIocManager.Resolve <ICacheManager>().GetCache <string, MyCacheItem>("MyTestCacheItems");
}
public DefaultRedisCacheSerializer_Tests()
{
LocalIocManager.Register <IRedisCacheSerializer, DefaultRedisCacheSerializer>();
_redisCacheSerializer = LocalIocManager.Resolve <IRedisCacheSerializer>();
}
public RedisCacheManager(ICachingConfiguration configuration, IRedisCacheDatabaseProvider redisCacheDatabaseProvider, IRedisCacheSerializer redisCacheSerializer) : base(configuration)
{
RedisCacheDatabaseProvider = redisCacheDatabaseProvider;
RedisCacheSerializer = redisCacheSerializer;
}
public RedisMemoryCache(string name, IEddoRedisCacheDatabaseProvider redisCacheDatabaseProvider, IRedisCacheSerializer serializer) : base(name)
{
_redisCacheDatabaseProvider = redisCacheDatabaseProvider;
_database = _redisCacheDatabaseProvider.GetDatabase();
_serializer = serializer;
}
public LclRedisCache(IAbpRedisCacheDatabaseProvider redisCacheDatabaseProvider, IRedisCacheSerializer redisCacheSerializer)
{
_database = redisCacheDatabaseProvider.GetDatabase();
_serializer = redisCacheSerializer;
}
private bool DeserializeData(string key, string serName, Type type, RedisValue data, bool gzipCompress, out object item)
{
item = null;
if (data.IsNull)
{
return(true);
}
if (type.Equals(typeof(String)))
{
item = (string)data;
return(true);
}
if (type.Equals(typeof(Int32)))
{
item = (int)data;
return(true);
}
if (type.Equals(typeof(Double)))
{
item = (double)data;
return(true);
}
if (type.Equals(typeof(Single)))
{
item = (float)data;
return(true);
}
if (type.Equals(typeof(Byte)))
{
item = (byte)data;
return(true);
}
if (type.Equals(typeof(Boolean)))
{
item = (bool)data;
return(true);
}
if (type.Equals(typeof(byte[])))
{
item = (byte[])data;
return(true);
}
byte[] bytes = (byte[])data;
IRedisCacheSerializer serializer = this.FindSerializer(serName, false);
if (serializer == null)
{
return(false);
}
using (MemoryStream stream = new MemoryStream(bytes))
{
Stream gzs = null;
if (gzipCompress)
{
gzs = new GZipStream(stream, CompressionMode.Decompress, true);
}
try
{
using (StreamReader reader = new StreamReader(gzipCompress ? gzs : stream, Encoding.UTF8))
{
item = serializer.Deserialize(reader, type);
return(true);
}
}
catch (Exception ex)
{
var oex = ex.GetOriginalException();
_logger.WriteWarning(0, $@"Redies 获取对象时发生反序列错误，可能由于数据结构变化，类型 {type.Name}。",
extensions: new
{
RedisKey = key,
RawValue = Encoding.UTF8.GetString(data),
Exception = $"（{oex.GetType().Name}）{oex.Message}",
StackTrace = oex.StackTrace
});
ex.ThrowIfNecessary();
return(false);
}
finally
{
if (gzs != null)
{
gzs.Dispose();
}
}
}
}
public RedisSerializer([NotNull] IRedisCacheSerializer redisCacheSerializer)
{
_redisCacheSerializer = redisCacheSerializer;
}
private RedisValue SerializeData(object data, string serializerName, bool gzipCompress = false)
{
if (data.GetType().Equals(typeof(String)))
{
return((String)data);
}
if (data.GetType().Equals(typeof(Int32)))
{
return((int)data);
}
if (data.GetType().Equals(typeof(Double)))
{
return((double)data);
}
if (data.GetType().Equals(typeof(Single)))
{
return((float)data);
}
if (data.GetType().Equals(typeof(Byte)))
{
return((byte)data);
}
if (data.GetType().Equals(typeof(Boolean)))
{
return((bool)data);
}
if (data.GetType().Equals(typeof(byte[])))
{
return((byte[])data);
}
IRedisCacheSerializer serializer = this.FindSerializer(serializerName, false) ?? this._redisCacheSerializers.FirstOrDefault().Value;
using (MemoryStream stream = new MemoryStream())
{
Stream gzs = null;
if (gzipCompress)
{
gzs = new GZipStream(stream, CompressionMode.Compress, true);
}
try
{
using (StreamWriter writer = new StreamWriter(gzipCompress ? gzs : stream, Encoding.UTF8, 1024, true))
{
serializer.Serialize(writer, data);
}
if (gzipCompress)
{
gzs.Dispose();
gzs = null;
}
stream.Position = 0;
return(stream.ToArray());
}
finally
{
if (gzs != null)
{
gzs.Dispose();
}
}
}
}
public RedisSerializer(IRedisCacheSerializer redisCacheSerializer)
{
_redisCacheSerializer = redisCacheSerializer;
}
public RedisCache Initialize(IRedisCacheDatabaseProvider redisCacheDatabaseProvider, IRedisCacheSerializer redisCacheSerializer)
{
_database = redisCacheDatabaseProvider.GetDatabase();
_serializer = redisCacheSerializer;
return(this);
}
