.net core 中redis缓存的详细使用
项目搭建了一个基础的框架，实现缓存的AOP拦截，首次查询从数据库获取，再写入缓存，设置过期时间，再次查询数据时从缓存获取。
话不多说我们来上代码实现：
1.定义缓存的接口和实现类
定义缓存接口IRedisOperationRepository：
/// <summary>
/// Redis缓存接口
/// </summary>
public interface IRedisOperationRepository
{
//获取 Reids 缓存值
Task<string> Get(string key);
//获取值，并序列化
Task<TEntity> Get<TEntity>(string key);
//保存
Task Set(string key, object value, TimeSpan cacheTime);
//判断是否存在
Task<bool> Exist(string key);
//移除某一个缓存值
Task Remove(string key);
//全部清除
Task Clear();
/// <summary>
/// 根据key获取RedisValue
/// </summary>
/// <param name="redisKey"></param>
/// <returns></returns>
Task<RedisValue[]> ListRangeAsync(string redisKey);
/// <summary>
/// 在列表头部插入值。如果键不存在，先创建再插入值
/// </summary>
/// <param name="redisKey"></param>
/// <param name="redisValue"></param>
/// <returns></returns>
Task<long> ListLeftPushAsync(string redisKey, string redisValue);
/// <summary>
/// 在列表尾部插入值。如果键不存在，先创建再插入值
/// </summary>
/// <param name="redisKey"></param>
/// <param name="redisValue"></param>
/// <returns></returns>
Task<long> ListRightPushAsync(string redisKey, string redisValue);
/// <summary>
/// 在列表尾部插入数组集合。如果键不存在，先创建再插入值
/// </summary>
/// <param name="redisKey"></param>
/// <param name="redisValue"></param>
/// <returns></returns>
Task<long> ListRightPushAsync(string redisKey, IEnumerable<string> redisValue);
/// <summary>
/// 移除并返回存储在该键列表的第一个元素 反序列化
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="redisKey"></param>
/// <returns></returns>
Task<T> ListLeftPopAsync<T>(string redisKey) where T : class;
/// <summary>
/// 移除并返回存储在该键列表的最后一个元素 反序列化
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="redisKey"></param>
/// <returns></returns>
Task<T> ListRightPopAsync<T>(string redisKey) where T : class;
/// <summary>
/// 移除并返回存储在该键列表的第一个元素
/// </summary>
/// <param name="redisKey"></param>
/// <returns></returns>
Task<string> ListLeftPopAsync(string redisKey);
/// <summary>
/// 移除并返回存储在该键列表的最后一个元素
/// </summary>
/// <param name="redisKey"></param>
/// <returns></returns>
Task<string> ListRightPopAsync(string redisKey);
/// <summary>
/// 列表长度
/// </summary>
/// <param name="redisKey"></param>
/// <returns></returns>
Task<long> ListLengthAsync(string redisKey);
/// <summary>
/// 返回在该列表上键所对应的元素
/// </summary>
/// <param name="redisKey"></param>
/// <param name="db"></param>
/// <returns></returns>
Task<IEnumerable<string>> ListRangeAsync(string redisKey, int db = -1);
/// <summary>
/// 根据索引获取指定位置数据
/// </summary>
/// <param name="redisKey"></param>
/// <param name="start"></param>
/// <param name="stop"></param>
/// <returns></returns>
Task<IEnumerable<string>> ListRangeAsync(string redisKey, int start, int stop);
/// <summary>
/// 删除List中的元素 并返回删除的个数
/// </summary>
/// <param name="redisKey"></param>
/// <param name="redisValue"></param>
/// <param name="type"></param>
/// <returns></returns>
Task<long> ListDelRangeAsync(string redisKey, string redisValue, long type = 0);
/// <summary>
/// 清空List
/// </summary>
/// <param name="redisKey"></param>
/// <returns></returns>
Task ListClearAsync(string redisKey);
/// <summary>
/// 有序集合/定时任务延迟队列用的多
/// </summary>
/// <param name="redisKey">key</param>
/// <param name="redisValue">元素</param>
/// <param name="score">分数</param>
Task SortedSetAddAsync(string redisKey, string redisValue, double score);
}
定义缓存实现类RedisOperationRepository：
public class RedisOperationRepository : IRedisOperationRepository
{
private readonly ILogger<RedisOperationRepository> _logger;
private readonly ConnectionMultiplexer _redis;
private readonly IDatabase _database;
public RedisOperationRepository(ILogger<RedisOperationRepository> logger, ConnectionMultiplexer redis)
{
_logger = logger;
_redis = redis;
_database = redis.GetDatabase();
}
private IServer GetServer()
{
var endpoint = _redis.GetEndPoints();
return _redis.GetServer(endpoint.First());
}
public async Task Clear()
{
foreach (var endPoint in _redis.GetEndPoints())
{
var server = GetServer();
foreach (var key in server.Keys())
{
await _database.KeyDeleteAsync(key);
}
}
}
public async Task<bool> Exist(string key)
{
return await _database.KeyExistsAsync(key);
}
public async Task<string> Get(string key)
{
return await _database.StringGetAsync(key);
}
public async Task Remove(string key)
{
await _database.KeyDeleteAsync(key);
}
public async Task Set(string key, object value, TimeSpan cacheTime)
{
if (value != null)
{
//序列化，将object值生成RedisValue
await _database.StringSetAsync(key, JsonConvert.SerializeObject(value), cacheTime);
}
}
public async Task<TEntity> Get<TEntity>(string key)
{
var value = await _database.StringGetAsync(key);
if (value.HasValue)
{
//需要用的反序列化，将Redis存储的Byte[]，进行反序列化
return JsonConvert.DeserializeObject<TEntity>(value);
}
else
{
return default;
}
}
/// <summary>
/// 根据key获取RedisValue
/// </summary>
/// <param name="redisKey"></param>
/// <returns></returns>
public async Task<RedisValue[]> ListRangeAsync(string redisKey)
{
return await _database.ListRangeAsync(redisKey);
}
/// <summary>
/// 在列表头部插入值。如果键不存在，先创建再插入值
/// </summary>
/// <param name="redisKey"></param>
/// <param name="redisValue"></param>
/// <returns></returns>
public async Task<long> ListLeftPushAsync(string redisKey, string redisValue)
{
return await _database.ListLeftPushAsync(redisKey, redisValue);
}
/// <summary>
/// 在列表尾部插入值。如果键不存在，先创建再插入值
/// </summary>
/// <param name="redisKey"></param>
/// <param name="redisValue"></param>
/// <returns></returns>
public async Task<long> ListRightPushAsync(string redisKey, string redisValue)
{
return await _database.ListRightPushAsync(redisKey, redisValue);
}
/// <summary>
/// 在列表尾部插入数组集合。如果键不存在，先创建再插入值
/// </summary>
/// <param name="redisKey"></param>
/// <param name="redisValue"></param>
/// <returns></returns>
public async Task<long> ListRightPushAsync(string redisKey, IEnumerable<string> redisValue)
{
var redislist = new List<RedisValue>();
foreach (var item in redisValue)
{
redislist.Add(item);
}
return await _database.ListRightPushAsync(redisKey, redislist.ToArray());
}
/// <summary>
/// 移除并返回存储在该键列表的第一个元素 反序列化
/// </summary>
/// <param name="redisKey"></param>
/// <returns></returns>
public async Task<T> ListLeftPopAsync<T>(string redisKey) where T : class
{
var cacheValue = await _database.ListLeftPopAsync(redisKey);
if (string.IsNullOrEmpty(cacheValue)) return null;
var res = JsonConvert.DeserializeObject<T>(cacheValue);
return res;
}
/// <summary>
/// 移除并返回存储在该键列表的最后一个元素 反序列化
/// 只能是对象集合
/// </summary>
/// <param name="redisKey"></param>
/// <returns></returns>
public async Task<T> ListRightPopAsync<T>(string redisKey) where T : class
{
var cacheValue = await _database.ListRightPopAsync(redisKey);
if (string.IsNullOrEmpty(cacheValue)) return null;
var res = JsonConvert.DeserializeObject<T>(cacheValue);
return res;
}
/// <summary>
/// 移除并返回存储在该键列表的第一个元素
/// </summary>
/// <param name="redisKey"></param>
/// <returns></returns>
public async Task<string> ListLeftPopAsync(string redisKey)
{
return await _database.ListLeftPopAsync(redisKey);
}
/// <summary>
/// 移除并返回存储在该键列表的最后一个元素
/// </summary>
/// <param name="redisKey"></param>
/// <returns></returns>
public async Task<string> ListRightPopAsync(string redisKey)
{
return await _database.ListRightPopAsync(redisKey);
}
/// <summary>
/// 列表长度
/// </summary>
/// <param name="redisKey"></param>
/// <returns></returns>
public async Task<long> ListLengthAsync(string redisKey)
{
return await _database.ListLengthAsync(redisKey);
}
/// <summary>
/// 返回在该列表上键所对应的元素
/// </summary>
/// <param name="redisKey"></param>
/// <returns></returns>
public async Task<IEnumerable<string>> ListRangeAsync(string redisKey, int db = -1)
{
var result = await _database.ListRangeAsync(redisKey);
return result.Select(o => o.ToString());
}
/// <summary>
/// 根据索引获取指定位置数据
/// </summary>
/// <param name="redisKey"></param>
/// <param name="start"></param>
/// <param name="stop"></param>
/// <returns></returns>
public async Task<IEnumerable<string>> ListRangeAsync(string redisKey, int start, int stop)
{
var result = await _database.ListRangeAsync(redisKey, start, stop);
return result.Select(o => o.ToString());
}
/// <summary>
/// 删除List中的元素 并返回删除的个数
/// </summary>
/// <param name="redisKey">key</param>
/// <param name="redisValue">元素</param>
/// <param name="type">大于零 : 从表头开始向表尾搜索，小于零 : 从表尾开始向表头搜索，等于零：移除表中所有与 VALUE 相等的值</param>
/// <returns></returns>
public async Task<long> ListDelRangeAsync(string redisKey, string redisValue, long type = 0)
{
return await _database.ListRemoveAsync(redisKey, redisValue, type);
}
/// <summary>
/// 清空List
/// </summary>
/// <param name="redisKey"></param>
public async Task ListClearAsync(string redisKey)
{
await _database.ListTrimAsync(redisKey, 1, 0);
}
/// <summary>
/// 有序集合/定时任务延迟队列用的多
/// </summary>
/// <param name="redisKey">key</param>
/// <param name="redisValue">元素</param>
/// <param name="score">分数</param>
public async Task SortedSetAddAsync(string redisKey, string redisValue, double score)
{
await _database.SortedSetAddAsync(redisKey, redisValue, score);
}
}
2.定义缓存的特性CachingAttribute：
/// <summary>
/// 这个Attribute就是使用时候的验证，把它添加到要缓存数据的方法中，即可完成缓存的操作。
/// </summary>
[AttributeUsage(AttributeTargets.Method, Inherited = true)]
public class CachingAttribute : System.Attribute
{
/// <summary>
/// 缓存绝对过期时间（分钟）
/// </summary>
public int AbsoluteExpiration { get; set; } = 30;
}
3.RedisCacheSetup 配置启动Redis服务
/// <summary>
/// Redis缓存 启动服务
/// </summary>
public static class RedisCacheSetup
{
public static void AddRedisCacheSetup(this IServiceCollection services)
{
if (services == null) throw new ArgumentNullException(nameof(services));
services.AddTransient<IRedisOperationRepository, RedisOperationRepository>();
// 配置启动Redis服务，虽然可能影响项目启动速度，但是不能在运行的时候报错，所以是合理的
services.AddSingleton<ConnectionMultiplexer>(sp =>
{
//获取连接字符串
string redisConfiguration = AppSettingsConstVars.RedisConfigConnectionString;
var configuration = ConfigurationOptions.Parse(redisConfiguration, true);
configuration.ResolveDns = true;
return ConnectionMultiplexer.Connect(configuration);
});
}
}
4.面向切面的Redis缓存使用RedisCacheAop继承CacheAopBase类：
/// <summary>
/// 面向切面的Redis缓存使用
/// </summary>
public class RedisCacheAop : CacheAopBase
{
//通过注入的方式，把缓存操作接口通过构造函数注入
private readonly IRedisOperationRepository _cache;
public RedisCacheAop(IRedisOperationRepository cache)
{
_cache = cache;
}
//Intercept方法是拦截的关键所在，也是IInterceptor接口中的唯一定义
public override void Intercept(IInvocation invocation)
{
var method = invocation.MethodInvocationTarget ?? invocation.Method;
if (method.ReturnType == typeof(void) || method.ReturnType == typeof(Task))
{
invocation.Proceed();
return;
}
//对当前方法的特性验证
if (method.GetCustomAttributes(true).FirstOrDefault(x => x.GetType() == typeof(CachingAttribute)) is CachingAttribute qCachingAttribute)
{
//获取自定义缓存键
var cacheKey = CustomCacheKey(invocation);
//注意是 string 类型，方法GetValue
var cacheValue = _cache.Get(cacheKey).Result;
if (cacheValue != null)
{
//将当前获取到的缓存值，赋值给当前执行方法
var returnType = typeof(Task).IsAssignableFrom(method.ReturnType) ? method.ReturnType.GenericTypeArguments.FirstOrDefault() : method.ReturnType;
dynamic result = JsonConvert.DeserializeObject(cacheValue, returnType);
invocation.ReturnValue = (typeof(Task).IsAssignableFrom(method.ReturnType)) ? Task.FromResult(result) : result;
Console.WriteLine(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss") + " 获取缓存中的数据，" + "redis缓存key：" + cacheKey +",缓存数据：" + JsonConvert.SerializeObject(result));
return;
}
//去执行当前的方法
invocation.Proceed();
//存入缓存
if (!string.IsNullOrWhiteSpace(cacheKey))
{
object response;
//Type type = invocation.ReturnValue?.GetType();
var type = invocation.Method.ReturnType;
if (typeof(Task).IsAssignableFrom(type))
{
var resultProperty = type.GetProperty("Result");
response = resultProperty.GetValue(invocation.ReturnValue);
}
else
{
response = invocation.ReturnValue;
}
response ??= string.Empty;
_cache.Set(cacheKey, response, TimeSpan.FromMinutes(qCachingAttribute.AbsoluteExpiration)).Wait();
Console.WriteLine(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss") + " 成功写入缓存数据，" + "redis缓存key：" + cacheKey);
}
}
else
{
invocation.Proceed();//直接执行被拦截方法
}
}
}
5.在AutofacModuleRegister 模块注册类实现模块间的解耦，在这里实现RedisCacheAop的拦截开启
6.在program里注册缓存
7.缓存配置
在appsettings.json配置文件上配置数据库链接，以及redis缓存连接，
如果设置UseCache=true，那么就开启redis缓存，设置UseCache=false则开启memoryCache缓存；
8.8.启动项目，分别调用方法：GetUserInfo和GetUserCache
1.调用GetUserInfo查询数据，写入缓存成功
2.再次调用GetUserCache，一样的缓存key和返回一样的用户信息：
以上就是redis缓存的简单使用！
源代码地址：https://gitee.com/chenshibao/webapi
谢谢阅览，如果对你有帮助欢迎一键三连：点赞，收藏，评论！
浙公网安备 33010602011771号