代码：
RedisCommon
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using ServiceStack.Redis;
using System.Configuration;
using ServiceStack.Redis.Generic;
using Newtonsoft.Json; namespace Rongzi.BZone.Common.Util
{
public class RedisCommon
{
private static readonly Lazy<RedisCommon> _instance = new Lazy<RedisCommon>(() => new RedisCommon());
private static readonly string redisUrl = ConfigurationManager.AppSettings["Redis_Server"];
private static readonly string redisPort = ConfigurationManager.AppSettings["Redis_Port"];
private RedisCommon()
{ }
public static RedisCommon getInstance
{
get
{
return _instance.Value;
}
} public RedisClient getRedisClient()
{
return new RedisClient(redisUrl, int.Parse(redisPort));
} #region string类型操作 /// <summary>
/// 根据key获取对应的对象T
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <returns></returns>
public T GetObj<T>(string key)
{
T result;
try
{
using (var redis = this.getRedisClient())
{
result = redis.Get<T>(key);
}
}
catch (Exception)
{ result = default(T);
}
return result;
} /// <summary>
/// 根据key存储T对象
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <param name="val"></param>
/// <param name="dateTime"></param>
/// <returns></returns>
public bool SetObj<T>(string key, T val, DateTime dateTime)
{
bool result = false;
try
{
using (var redis = this.getRedisClient())
{
result = redis.Set<T>(key, val, dateTime);
}
}
catch
{ result = false;
}
return result;
} /// <summary>
/// 根据key更新T
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <param name="t"></param>
/// <returns></returns>
public bool UpdateObj<T>(string key, T t)
{
bool result = false;
using (var redis = this.getRedisClient())
{
var value = JsonConvert.SerializeObject(t);
result = redis.Set<string>(key, value);
}
return result;
} /// <summary>
/// 删除对应key的value
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public bool RemoveObj(string key)
{
bool result = false;
using (var redis = this.getRedisClient())
{
result = redis.Remove(key);
}
return result;
}
#endregion #region hash类型操作 /// <summary>
/// 从hash表获取数据
/// </summary>
public T Get<T>(string hashId, string key)
{
using (var redis = this.getRedisClient())
{
string value = redis.GetValueFromHash(hashId, key);
return JsonConvert.DeserializeObject<T>(value);
}
} /// <summary>
/// 获取整个hash的数据
/// </summary>
public List<T> GetAll<T>(string hashId)
{
using (var redis = this.getRedisClient())
{
var result = new List<T>();
var list = redis.GetHashValues(hashId);
if (list != null && list.Count > )
{
list.ForEach(x =>
{
var value = JsonConvert.DeserializeObject<T>(x);
result.Add(value);
});
}
return result;
}
} /// <summary>
/// 判断某个数据是否已经被缓存
/// </summary>
public bool Exist<T>(string hashId, string key)
{
bool result = false;
using (var redis = this.getRedisClient())
{
result = redis.HashContainsEntry(hashId, key);
}
return result;
} /// <summary>
/// 存储数据到hash表
/// </summary>
public bool Set<T>(string hashId, string key, T t)
{
bool result = false;
try
{
using (var redis = this.getRedisClient())
{
var value = JsonConvert.SerializeObject(t);
result = redis.SetEntryInHash(hashId, key, value);
}
}
catch
{ result = false;
}
return result;
} /// <summary>
/// 移除hash中的某值
/// </summary>
public bool Remove(string hashId, string key)
{
bool result = false;
try
{
using (var redis = this.getRedisClient())
{
result = redis.RemoveEntryFromHash(hashId, key);
}
}
catch
{
result = false;
}
return result;
} /// <summary>
/// 移除整个hash
/// </summary>
public bool RemoveAll(string hashId)
{
bool result = false;
using (var redis = this.getRedisClient())
{
result = redis.Remove(hashId);
}
return result;
} /// <summary>
/// 设置缓存过期
/// </summary>
public void SetExpire(string hashId, DateTime datetime)
{
using (var redis = this.getRedisClient())
{
redis.ExpireEntryAt(hashId, datetime);
}
} #endregion #region 保存到硬盘
/// <summary>
/// 保存数据DB文件到硬盘
/// </summary>
public void Save()
{
using (var redis = this.getRedisClient())
{
redis.Save();
}
} /// <summary>
/// 异步保存数据DB文件到硬盘
/// </summary>
public void SaveAsync()
{
using (var redis = this.getRedisClient())
{
redis.SaveAsync();
}
}
#endregion
}
}
TokenManager
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;
using Rongzi.BZone.Admin.Models;
using Rongzi.BZone.Common.Util;
using System.Configuration; namespace Rongzi.BZone.Admin.Functions
{
public class TokenManager
{
/// <summary>
/// 设置对象过期时间
/// </summary>
private static readonly int interval = Convert.ToInt32(ConfigurationManager.AppSettings["Redis_TimeInterval"]); /// <summary>
/// 存储对象val，获取对应的token
/// </summary>
/// <param name="val"></param>
/// <returns></returns>
public static RedisOpearteResult getToken(Manage_UserInfo val)
{
string tokenID = Guid.NewGuid().ToString();
RedisOpearteResult result = new RedisOpearteResult
{
isok = RedisCommon.getInstance.SetObj<Manage_UserInfo>(tokenID, val, DateTime.Now.AddMinutes(interval)),
token = tokenID,
result = JsonConvert.SerializeObject(val)
};
return result;
} /// <summary>
/// 根据tokenID更新用户对象
/// </summary>
/// <param name="tokenID"></param>
/// <param name="val"></param>
/// <returns></returns>
public static RedisOpearteResult RefreshLoginTokenData(String tokenID, Manage_UserInfo val)
{
RedisOpearteResult result = new RedisOpearteResult
{
isok = RedisCommon.getInstance.SetObj<Manage_UserInfo>(tokenID, val, DateTime.Now.AddMinutes(interval)),
token = tokenID,
result = JsonConvert.SerializeObject(val)
};
return result;
} /// <summary>
/// 刷新用户token
/// </summary>
/// <param name="tokenID"></param>
public static RedisOpearteResult RefreshUserToken(string tokenID)
{
var obj = RedisCommon.getInstance.GetObj<Manage_UserInfo>(tokenID);
var isExist = obj != null;
RedisOpearteResult result = new RedisOpearteResult
{
isok = isExist,
token = tokenID,
result = "Token过期"
};
if (isExist)
{
result.result = "成功延迟";
RedisCommon.getInstance.SetObj<Manage_UserInfo>(tokenID, obj, DateTime.Now.AddMinutes(interval));
}
return result;
} /// <summary>
/// 退出
/// </summary>
/// <param name="tokenID"></param>
/// <returns></returns>
public static RedisOpearteResult LoginOff(string tokenID)
{
var obj = RedisCommon.getInstance.GetObj<Manage_UserInfo>(tokenID);
var isExist = obj != null;
RedisOpearteResult result = new RedisOpearteResult
{
isok = isExist,
token = tokenID,
result = "Token过期"
};
if (isExist)
{
result.result = "退出成功";
RedisCommon.getInstance.RemoveObj(tokenID);
}
return result;
} /// <summary>
/// 通过token 获取用户信息
/// </summary>
/// <param name="token">tokenID</param>
/// <returns></returns>
public static bool getUserByToken(string token, out Manage_UserInfo user)
{
bool isok = false;
user = null;
if (!string.IsNullOrEmpty(token) && RedisCommon.getInstance.GetObj<Manage_UserInfo>(token)!=null)
{
user = RedisCommon.getInstance.GetObj<Manage_UserInfo>(token);
isok = true;
}
return isok;
}
}
}