using System;
|
using System.Linq;
|
using StackExchange.Redis;
|
using System.Configuration;
|
using System.Collections.Generic;
|
using System.Runtime.Serialization.Formatters.Binary;
|
using System.IO;
|
using System.Threading.Tasks;
|
using System.Runtime.Serialization;
|
using System.Text;
|
namespace IStation
|
{
|
/// <summary>
|
/// Redis客户端辅助类
|
/// </summary>
|
public class RedisClientHelper
|
{
|
|
/// <summary>
|
/// redis 连接对象
|
/// </summary>
|
private static IConnectionMultiplexer _connMultiplexer;
|
|
/// <summary>
|
/// 锁
|
/// </summary>
|
private static readonly object Locker = new object();
|
|
/// <summary>
|
/// 数据库访问对象
|
/// </summary>
|
private readonly IDatabase _db;
|
|
/// <summary>
|
/// 采用双重锁单例模式，保证数据访问对象有且仅有一个
|
/// </summary>
|
/// <returns></returns>
|
public IConnectionMultiplexer GetConnectionRedisMultiplexer()
|
{
|
if ((_connMultiplexer == null || !_connMultiplexer.IsConnected))
|
{
|
lock (Locker)
|
{
|
if ((_connMultiplexer == null || !_connMultiplexer.IsConnected))
|
{
|
_connMultiplexer = ConnectionMultiplexer.Connect(Settings.Redis.Url);
|
}
|
}
|
}
|
return _connMultiplexer;
|
}
|
|
/// <summary>
|
/// 添加事务处理
|
/// </summary>
|
/// <returns></returns>
|
public ITransaction GetTransaction()
|
{
|
//创建事务
|
return _db.CreateTransaction();
|
}
|
|
#region 构造函数
|
|
/// <summary>
|
/// 静态的构造函数,
|
/// 构造函数是属于类的，而不是属于实例的
|
/// 就是说这个构造函数只会被执行一次。也就是在创建第一个实例或引用任何静态成员之前，由.NET自动调用。
|
/// </summary>
|
static RedisClientHelper()
|
{
|
_connMultiplexer = ConnectionMultiplexer.Connect(Settings.Redis.Url);
|
RegisterEvent();
|
}
|
|
/// <summary>
|
/// 重载构造器，获取redis内部数据库的交互式连接
|
/// </summary>
|
/// <param name="db">要获取的数据库ID</param>
|
public RedisClientHelper(int db = -1)
|
{
|
_db = _connMultiplexer.GetDatabase(db);
|
}
|
|
#endregion
|
|
#region stringGet
|
|
/// <summary>
|
/// 设置key，并保存字符串
|
/// </summary>
|
public bool StringSet(string redisKey, string redisValue)
|
{
|
return _db.StringSet(redisKey, redisValue);
|
}
|
|
/// <summary>
|
/// 保存多个key-value
|
/// </summary>
|
public bool StringSet(IEnumerable<KeyValuePair<RedisKey, RedisValue>> keyValuePairs)
|
{
|
if (keyValuePairs == null || keyValuePairs.Count() < 1)
|
return false;
|
return _db.StringSet(keyValuePairs.ToArray());
|
}
|
|
/// <summary>
|
/// 获取字符串
|
/// </summary>
|
public RedisValue StringGet(string redisKey)
|
{
|
return _db.StringGet(redisKey);
|
}
|
|
/// <summary>
|
/// 获取字符串(多个)
|
/// </summary>
|
public RedisValue[] StringGet(List<string> redisKey)
|
{
|
if (redisKey == null || redisKey.Count() == 0)
|
return null;
|
|
List<RedisKey> redisKey2 = new List<RedisKey>();
|
redisKey.ForEach(t => redisKey2.Add(t));
|
return _db.StringGet(redisKey2.ToArray());
|
}
|
|
/// <summary>
|
///
|
/// </summary>
|
public bool StringSetJson<T>(string redisKey, T redisValue)
|
{
|
var json = JsonHelper.Object2Json(redisValue);
|
return _db.StringSet(redisKey, json);
|
}
|
|
/// <summary>
|
///
|
/// </summary>
|
public T StringGetJson<T>(string redisKey)
|
{
|
return JsonHelper.Json2Object<T>(_db.StringGet(redisKey));
|
}
|
|
|
#endregion
|
|
#region Hash
|
|
/// <summary>
|
/// 判断字段是否在hash中
|
/// </summary>
|
public bool HashExist(string redisKey, string hashField)
|
{
|
return _db.HashExists(redisKey, hashField);
|
}
|
|
/// <summary>
|
/// 从 hash 中删除字段
|
/// </summary>
|
public bool HashDelete(string redisKey, string hashField)
|
{
|
return _db.HashDelete(redisKey, hashField);
|
}
|
|
/// <summary>
|
/// 从hash中移除指定字段
|
/// </summary>
|
public long HashDelete(string redisKey, IEnumerable<RedisValue> hashField)
|
{
|
return _db.HashDelete(redisKey, hashField.ToArray());
|
}
|
|
/// <summary>
|
/// 在hash中设定值
|
/// </summary>
|
public bool HashSet(string redisKey, string hashField, string value)
|
{
|
return _db.HashSet(redisKey, hashField, value);
|
}
|
|
/// <summary>
|
/// 从Hash 中获取值
|
/// </summary>
|
public RedisValue HashGet(string redisKey, string hashField)
|
{
|
return _db.HashGet(redisKey, hashField);
|
}
|
|
/// <summary>
|
/// 从Hash 中获取值
|
/// </summary>
|
public RedisValue[] HashGet(string redisKey, RedisValue[] hashField)
|
{
|
return _db.HashGet(redisKey, hashField);
|
}
|
|
/// <summary>
|
/// 获取所有
|
/// </summary>
|
public HashEntry[] HashGetAll(string redisKey)
|
{
|
return _db.HashGetAll(redisKey);
|
}
|
|
/// <summary>
|
/// 从hash 返回所有的key值
|
/// </summary>
|
public IEnumerable<RedisValue> HashKeys(string redisKey)
|
{
|
return _db.HashKeys(redisKey);
|
}
|
|
/// <summary>
|
/// 根据key返回hash中的值
|
/// </summary>
|
public RedisValue[] HashValues(string redisKey)
|
{
|
return _db.HashValues(redisKey);
|
}
|
|
/// <summary>
|
/// 根据关键词模糊匹配所有key
|
/// </summary>
|
public string[] AllKeys(string keyPattern)
|
{
|
var script = "return redis.call('keys',@pattern)";
|
var prepared = LuaScript.Prepare(script);
|
var cacheResult = _db.ScriptEvaluate(prepared, new { pattern = keyPattern });
|
if (cacheResult.IsNull)
|
{
|
return null;
|
}
|
return (string[])cacheResult;
|
}
|
|
/// <summary>
|
/// 在hash中设定值 json序列化
|
/// </summary>
|
public bool HashSetJosn<T>(string redisKey, string hashField, T value)
|
{
|
var result = false;
|
try
|
{
|
var json = JsonHelper.Object2Json(value);
|
result= _db.HashSet(redisKey, hashField, json);
|
}
|
catch (Exception ex)
|
{
|
var a= ex.Message;
|
}
|
return result;
|
}
|
|
/// <summary>
|
/// 在hash 中获取值 json反序列化
|
/// </summary>
|
public T HashGetJson<T>(string redisKey, string hashField)
|
{
|
var redisValue = _db.HashGet(redisKey, hashField);
|
return JsonHelper.Json2Object<T>(redisValue);
|
}
|
|
/// <summary>
|
/// 获取所有
|
/// </summary>
|
public List<T> HashGetJsonAll<T>(string redisKey)
|
{
|
var allRedisValueList = _db.HashValues(redisKey);
|
return allRedisValueList?.Select(x => JsonHelper.Json2Object<T>(x)).Where(x => x != null).ToList();
|
}
|
|
#endregion
|
|
#region list operation
|
|
/// <summary>
|
/// 移除并返回key所对应列表的第一个元素
|
/// </summary>
|
public string ListLeftPop(string redisKey)
|
{
|
return _db.ListLeftPop(redisKey);
|
}
|
|
/// <summary>
|
/// 移除并返回key所对应列表的最后一个元素
|
/// </summary>
|
public string ListRightPop(string redisKey)
|
{
|
return _db.ListRightPop(redisKey);
|
}
|
|
/// <summary>
|
/// 移除指定key及key所对应的元素
|
/// </summary>
|
public long ListRemove(string redisKey, string redisValue)
|
{
|
return _db.ListRemove(redisKey, redisValue);
|
}
|
|
/// <summary>
|
/// 在列表尾部插入值，如果键不存在，先创建再插入值
|
/// </summary>
|
public long ListRightPush(string redisKey, string redisValue)
|
{
|
return _db.ListRightPush(redisKey, redisValue);
|
}
|
|
/// <summary>
|
/// 在列表头部插入值，如果键不存在，先创建再插入值
|
/// </summary>
|
public long ListLeftPush(string redisKey, string redisValue)
|
{
|
return _db.ListLeftPush(redisKey, redisValue);
|
}
|
|
|
/// <summary>
|
///
|
/// </summary>
|
public void ListLtrim(string redisKey, long start, long stop)
|
{
|
_db.ListTrim(redisKey, start, stop);
|
}
|
|
/// <summary>
|
/// 返回列表上该键的长度，如果不存在，返回0
|
/// </summary>
|
public long ListLength(string redisKey)
|
{
|
return _db.ListLength(redisKey);
|
}
|
|
/// <summary>
|
/// 返回在该列表上键所对应的元素
|
/// </summary>
|
public IEnumerable<RedisValue> ListRange(string redisKey)
|
{
|
return _db.ListRange(redisKey);
|
}
|
|
/// <summary>
|
/// 返回在该列表上键所对应的元素
|
/// </summary>
|
public IEnumerable<RedisValue> ListLastRecord(string redisKey, int iCount = 1)
|
{
|
return _db.ListRange(redisKey, 0, iCount - 1);
|
}
|
|
#endregion
|
|
#region SortedSet 操作
|
|
/// <summary>
|
/// sortedset 新增
|
/// </summary>
|
public bool SortedSetAdd(string redisKey, string member, double score)
|
{
|
return _db.SortedSetAdd(redisKey, member, score);
|
}
|
|
/// <summary>
|
/// 在有序集合中返回指定范围的元素，默认情况下由低到高
|
/// </summary>
|
public IEnumerable<RedisValue> SortedSetRangeByRank(string redisKey)
|
{
|
return _db.SortedSetRangeByRank(redisKey);
|
}
|
|
/// <summary>
|
/// 返回有序集合的个数
|
/// </summary>
|
public long SortedSetLength(string redisKey)
|
{
|
return _db.SortedSetLength(redisKey);
|
}
|
|
/// <summary>
|
/// 返回有序集合的元素个数
|
/// </summary>
|
public bool SortedSetLength(string redisKey, string member)
|
{
|
return _db.SortedSetRemove(redisKey, member);
|
}
|
|
|
#endregion
|
|
#region key operation
|
|
/// <summary>
|
/// 移除指定key
|
/// </summary>
|
public bool KeyDelete(string redisKey)
|
{
|
return _db.KeyDelete(redisKey);
|
}
|
|
/// <summary>
|
/// 移除start开始的所有key
|
/// </summary>
|
public long KeyDeleteStartWidth(string start)
|
{
|
|
var mutlti = GetConnectionRedisMultiplexer();
|
|
List<string> keyList = new List<string>();
|
var endpoints = mutlti.GetEndPoints();
|
foreach (var ep in endpoints)
|
{
|
IServer server = mutlti.GetServer(ep);
|
var keys = server.Keys(0, string.Format("{0}*", start));
|
foreach (var item in keys)
|
{
|
keyList.Add((string)item);
|
}
|
}
|
|
//redisKey = AddKeyPrefix(redisKey);
|
var keys2 = keyList.Select(x => (RedisKey)x);
|
return _db.KeyDelete(keys2.ToArray());
|
}
|
|
/// <summary>
|
/// 删除指定key
|
/// </summary>
|
public long KeyDelete(IEnumerable<string> redisKeys)
|
{
|
var keys = redisKeys.Select(x => (RedisKey)x);
|
return _db.KeyDelete(keys.ToArray());
|
}
|
|
/// <summary>
|
/// 所有key
|
/// </summary>
|
public List<string> AllKey()
|
{
|
var mutlti = GetConnectionRedisMultiplexer();
|
var endpoints = mutlti.GetEndPoints();
|
List<string> keyList = new List<string>();
|
foreach (var ep in endpoints)
|
{
|
var server = mutlti.GetServer(ep);
|
var keys = server.Keys(0, "*");
|
foreach (var item in keys)
|
{
|
keyList.Add((string)item);
|
}
|
}
|
//mutlti.Close(true);
|
return keyList;
|
//
|
//throw new Exception(string.Join(",", keyList));
|
}
|
|
/// <summary>
|
/// 检验key是否存在
|
/// </summary>
|
public List<string> AllKeyStartWidth(string start)
|
{
|
|
var mutlti = GetConnectionRedisMultiplexer();
|
var endpoints = mutlti.GetEndPoints();
|
List<string> keyList = new List<string>();
|
foreach (var ep in endpoints)
|
{
|
var server = mutlti.GetServer(ep);
|
var keys = server.Keys(0, string.Format("{0}*", start));
|
foreach (var item in keys)
|
{
|
keyList.Add((string)item);
|
}
|
}
|
|
//mutlti.Close(true);
|
return keyList;
|
}
|
|
/// <summary>
|
/// 检验key是否存在
|
/// </summary>
|
public List<RedisKey> AllKeyPattern(string pattern)
|
{
|
|
var mutlti = GetConnectionRedisMultiplexer();
|
var endpoints = mutlti.GetEndPoints();
|
//List<string> keyList = new List<string>();
|
|
var keyList = new List<RedisKey>();
|
foreach (var ep in endpoints)
|
{
|
var server = mutlti.GetServer(ep);
|
var keys = server.Keys(0, pattern);
|
foreach (var item in keys)
|
{
|
keyList.Add(item);
|
}
|
}
|
|
//mutlti.Close(true);
|
return keyList;
|
}
|
|
/// <summary>
|
/// 检验key是否存在
|
/// </summary>
|
public bool KeyExists(string redisKey)
|
{
|
return _db.KeyExists(redisKey);
|
}
|
|
/// <summary>
|
/// 重命名key
|
/// </summary>
|
public bool KeyReName(string oldKeyName, string newKeyName)
|
{
|
return _db.KeyRename(oldKeyName, newKeyName);
|
}
|
|
/// <summary>
|
/// 设置key 的过期时间
|
/// </summary>
|
public bool KeyExpire(string redisKey, TimeSpan? expired = null)
|
{
|
return _db.KeyExpire(redisKey, expired);
|
}
|
|
#region key-async
|
|
/// <summary>
|
/// 移除指定的key
|
/// </summary>
|
public async Task<bool> KeyDeleteAsync(string redisKey)
|
{
|
return await _db.KeyDeleteAsync(redisKey);
|
}
|
|
/// <summary>
|
/// 删除指定的key
|
/// </summary>
|
public async Task<long> KeyDeleteAsync(IEnumerable<string> redisKeys)
|
{
|
var keys = redisKeys.Select(x => (RedisKey)x);
|
return await _db.KeyDeleteAsync(keys.ToArray());
|
}
|
|
/// <summary>
|
/// 检验key 是否存在
|
/// </summary>
|
public async Task<bool> KeyExistsAsync(string redisKey)
|
{
|
return await _db.KeyExistsAsync(redisKey);
|
}
|
|
/// <summary>
|
/// 重命名key
|
/// </summary>
|
public async Task<bool> KeyRenameAsync(string redisKey, string redisNewKey)
|
{
|
return await _db.KeyRenameAsync(redisKey, redisNewKey);
|
}
|
|
/// <summary>
|
/// 设置 key 时间
|
/// </summary>
|
public async Task<bool> KeyExpireAsync(string redisKey, TimeSpan? expired)
|
{
|
return await _db.KeyExpireAsync(redisKey, expired);
|
}
|
|
#endregion key-async
|
|
#endregion
|
|
#region 发布订阅
|
|
/// <summary>
|
/// 订阅
|
/// </summary>
|
public void Subscribe(RedisChannel channel, Action<RedisChannel, RedisValue> handle)
|
{
|
//getSubscriber() 获取到指定服务器的发布者订阅者的连接
|
var sub = _connMultiplexer.GetSubscriber();
|
//订阅执行某些操作时改变了 优先/主动 节点广播
|
sub.Subscribe(channel, handle);
|
}
|
|
/// <summary>
|
/// 发布
|
/// </summary>
|
public long Publish(RedisChannel channel, RedisValue message)
|
{
|
var sub = _connMultiplexer.GetSubscriber();
|
return sub.Publish(channel, message);
|
}
|
|
#region 发布订阅-async
|
|
/// <summary>
|
/// 订阅
|
/// </summary>
|
public async Task SubscribeAsync(RedisChannel redisChannel, Action<RedisChannel, RedisValue> handle)
|
{
|
var sub = _connMultiplexer.GetSubscriber();
|
await sub.SubscribeAsync(redisChannel, handle);
|
}
|
|
/// <summary>
|
/// 发布
|
/// </summary>
|
public async Task<long> PublishAsync(RedisChannel redisChannel, RedisValue message)
|
{
|
var sub = _connMultiplexer.GetSubscriber();
|
return await sub.PublishAsync(redisChannel, message);
|
}
|
|
#endregion 发布订阅-async
|
|
#endregion
|
|
#region 注册事件
|
|
/// <summary>
|
/// 注册事件
|
/// </summary>
|
private static void RegisterEvent()
|
{
|
_connMultiplexer.ConnectionRestored += ConnMultiplexer_ConnectionRestored;
|
_connMultiplexer.ConnectionFailed += ConnMultiplexer_ConnectionFailed;
|
_connMultiplexer.ErrorMessage += ConnMultiplexer_ErrorMessage;
|
_connMultiplexer.ConfigurationChanged += ConnMultiplexer_ConfigurationChanged;
|
_connMultiplexer.HashSlotMoved += ConnMultiplexer_HashSlotMoved;
|
_connMultiplexer.InternalError += ConnMultiplexer_InternalError;
|
_connMultiplexer.ConfigurationChangedBroadcast += ConnMultiplexer_ConfigurationChangedBroadcast;
|
}
|
|
/// <summary>
|
/// 重新配置广播时(主从同步更改)
|
/// </summary>
|
private static void ConnMultiplexer_ConfigurationChangedBroadcast(object sender, EndPointEventArgs e)
|
{
|
Console.WriteLine($"{nameof(ConnMultiplexer_ConfigurationChangedBroadcast)}: {e.EndPoint}");
|
}
|
|
/// <summary>
|
/// 发生内部错误时(调试用)
|
/// </summary>
|
private static void ConnMultiplexer_InternalError(object sender, InternalErrorEventArgs e)
|
{
|
Console.WriteLine($"{nameof(ConnMultiplexer_InternalError)}: {e.Exception}");
|
}
|
|
/// <summary>
|
/// 更改集群时
|
/// </summary>
|
private static void ConnMultiplexer_HashSlotMoved(object sender, HashSlotMovedEventArgs e)
|
{
|
Console.WriteLine($"{nameof(ConnMultiplexer_HashSlotMoved)}: {nameof(e.OldEndPoint)}-{e.OldEndPoint} To {nameof(e.NewEndPoint)}-{e.NewEndPoint} ");
|
}
|
|
/// <summary>
|
/// 配置更改时
|
/// </summary>
|
private static void ConnMultiplexer_ConfigurationChanged(object sender, EndPointEventArgs e)
|
{
|
Console.WriteLine($"{nameof(ConnMultiplexer_ConfigurationChanged)}: {e.EndPoint}");
|
}
|
|
/// <summary>
|
/// 发生错误时
|
/// </summary>
|
private static void ConnMultiplexer_ErrorMessage(object sender, RedisErrorEventArgs e)
|
{
|
Console.WriteLine($"{nameof(ConnMultiplexer_ErrorMessage)}: {e.Message}");
|
}
|
|
/// <summary>
|
/// 物理连接失败时
|
/// </summary>
|
private static void ConnMultiplexer_ConnectionFailed(object sender, ConnectionFailedEventArgs e)
|
{
|
Console.WriteLine($"{nameof(ConnMultiplexer_ConnectionFailed)}: {e.Exception}");
|
}
|
|
/// <summary>
|
/// 建立物理连接时
|
/// </summary>
|
private static void ConnMultiplexer_ConnectionRestored(object sender, ConnectionFailedEventArgs e)
|
{
|
Console.WriteLine($"{nameof(ConnMultiplexer_ConnectionRestored)}: {e.Exception}");
|
}
|
|
#endregion
|
|
}
|
}
|
