.NET Core教程–给API加一个服务端缓存啦

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

// redis key 
var bookRedisKey = ConstRedisKey.RecommendationBooks.CopyOne(bookId);
// 获取缓存数据         
var cacheBookIds = _redisService.ReadCache<List<string>>(bookRedisKey);
if (cacheBookIds != null)
{
    // return
}
else
{
   // 执行另外的逻辑获取数据, 然后写入缓存
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107

using System;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.Filters;
using Newtonsoft.Json.Linq;

namespace XXXAPI.Filters
{
    public class DefaultCacheFilterAttribute : ActionFilterAttribute
    {
        // 这个时间用于给子类重写,实现不同时间级别的缓存
        protected TimeSpan _expireTime;
     
        // redis读写的类,没撒看的
        private readonly RedisService _redisService;

        public DefaultCacheFilterAttribute(RedisService redisService)
        {
            _redisService = redisService;

        }

        public override void OnActionExecuting(ActionExecutingContext context)
        {
            if (context.HttpContext.Request.Query.ContainsKey("refresh"))
            {
                return;
            }
            KeyConfig redisKey = GetRequestRedisKey(context.HttpContext);
            var redisCache = _redisService.ReadCache<JToken>(redisKey);
            if (redisCache != null)
            {
                context.Result = new ObjectResult(redisCache);
            }
            return;
        }

        public override void OnActionExecuted(ActionExecutedContext context)
        {
            KeyConfig redisKey = GetRequestRedisKey(context.HttpContext);
            var objResult = (ObjectResult)context.Result;
            if (objResult == null)
            {
                return;
            }
            var jToken = JToken.FromObject(objResult.Value);
            _redisService.WriteCache(redisKey, jToken);
        }

        private KeyConfig GetRequestRedisKey(HttpContext httpContext)
        {
            var requestPath = httpContext.Request.Path.Value;
            if (!string.IsNullOrEmpty(httpContext.Request.QueryString.Value))
            {
                requestPath = requestPath + httpContext.Request.QueryString.Value;
            }
            if (httpContext.Request.Query.ContainsKey("refresh"))
            {
                if (httpContext.Request.Query.Count == 1)
                {
                    requestPath = requestPath.Replace("?refresh=true", "");
                }
                else
                {
                    requestPath = requestPath.Replace("refresh=true", "");
                }
            }
            // 这里也就一个redis key的类
            var redisKey = ConstRedisKey.HTTPRequest.CopyOne(requestPath);
            if (_expireTime != default(TimeSpan))
            {
                redisKey.ExpireTime = _expireTime;
            }
            return redisKey;
        }
    }

    public static class ConstRedisKey
    {
        public readonly static KeyConfig HTTPRequest = new KeyConfig()
        {
            Key = "lemon_req_",
            ExpireTime = new TimeSpan(TimeSpan.TicksPerMinute * 30),
            DBName = 5
        };
    }

    public class KeyConfig
    {
        public string Key { get; set; }

        public TimeSpan ExpireTime { get; set; }

        public int DBName { get; set; }


        public KeyConfig CopyOne(string state)
        {
            var one = new KeyConfig();
            one.DBName = this.DBName;
            one.Key = !string.IsNullOrEmpty(this.Key) ? this.Key + state : state;
            one.ExpireTime = this.ExpireTime;
            return one;
        }

    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

        [HttpGet("v1/xxx/latest")]
        [ServiceFilter(typeof(DefaultCacheFilterAttribute))]
        public IActionResult GetLatestList([FromQuery] int page = 0, [FromQuery]int pageSize = 30)
        {
            return Ok(new
            {
                data = _service.LoadLatest(page, pageSize),
                code = 0
            });
        }