《ASP.NET Core 与 RESTful API 开发实战》-- （第7章）-- 读书笔记（上）

第 7 章 高级主题

7.1 缓存

缓存是一种通过存储资源的备份，在请求时返回资源备份的技术。ASP.NET Core 支持多种形式的缓存，既支持基于 HTTP 的缓存，也支持内存缓存和分布式缓存，还提供响应缓存中间件

HTTP 缓存，服务端返回资源时，能够在响应消息中包含 HTTP 缓存消息头

验证缓存资源的方式有两种：

• 通过响应消息头中的 Last-Modified
• 使用实体标签消息头

ASP.NET Core 提供的 [ResponseCache] 特性能够为资源指定 HTTP 缓存行为

在 AuthorController 中为 GetAuthorAsync 方法添加该特性

[HttpGet("{authorId}", Name = nameof(GetAuthorAsync))]
[ResponseCache(Duration = 60, Location = ResponseCacheLocation.Client)]
public async Task<ActionResult<AuthorDto>> GetAuthorAsync(Guid authorId)

请求该接口时，可以看到响应消息头中包含了缓存信息

当应用中多个接口需要添加同样的缓存行为时，为了避免重复，还可以使用缓存配置来完成同样的功能

在 Startup 的 ConfigureServices 中添加

services.AddMvc(configure =>
{
    configure.CacheProfiles.Add("Default", new CacheProfile {Duration = 60});
    configure.CacheProfiles.Add("Never",
        new CacheProfile {Location = ResponseCacheLocation.None, NoStore = true});
。。。

接着在特性中使用即可

[ResponseCache(CacheProfileName = "Default")]

当缓存的资源已经过时后，客户端需要到服务器验证资源是否有效，可以通过实体标签头验证

[HttpGet("{authorId}", Name = nameof(GetAuthorAsync))]
[ResponseCache(Duration = 60, Location = ResponseCacheLocation.Client)]
public async Task<ActionResult<AuthorDto>> GetAuthorAsync(Guid authorId)
{
    var author = await RepositoryWrapper.Author.GetByIdAsync(authorId);
    if (author == null)
    {
        return NotFound();
    }

    var entityHash = HashFactory.GetHash(author);
    Response.Headers[HeaderNames.ETag] = entityHash;
    if (Request.Headers.TryGetValue(HeaderNames.IfNoneMatch, out var requestETag) && entityHash == requestETag)
    {
        return StatusCode(StatusCodes.Status304NotModified);
    }

    var authorDto = Mapper.Map<AuthorDto>(author);
    return authorDto;
}

GetHash 方法内容如下：

namespace Library.API.Helpers
{
    public class HashFactory
    {
        public static string GetHash(object entity)
        {
            string result = string.Empty;
            var json = JsonConvert.SerializeObject(entity);
            var bytes = Encoding.UTF8.GetBytes(json);

            using (var hasher = MD5.Create())
            {
                var hash = hasher.ComputeHash(bytes);
                result = BitConverter.ToString(hash);
                result = result.Replace("-", "");
            }

            return result;
        }
    }
}

响应缓存中间件，使用它能够为应用程序添加服务器端缓存功能

在 Startup 中配置响应缓存

public void ConfigureServices(IServiceCollection services)
{
    services.AddResponseCaching(options =>
    {
        options.UseCaseSensitivePaths = true;
        options.MaximumBodySize = 1024;
    });
    。。。
    
public void Configure(IApplicationBuilder app, IWebHostEnvironment env, IMapper mapper, ILoggerFactory loggerFactory)
{
    app.UseResponseCaching();
    。。。

添加响应缓存服务时，ResponseCachingOptions 包含3个属性：

• SizeLimit：缓存大小
• MaximumBodySize：响应正文最大值
• UseCaseSensitivePaths：是否区分请求路径大小写

响应缓存中间件同样使用特性设置

[ResponseCache(Duration = 60,VaryByQueryKeys = new string[]{"sortBy","searchQuery"})]

当服务端第二次接收同样的请求时，它将从缓存直接响应客户端

VaryByQueryKeys 属性可以根据不同的查询关键字来区分不同的响应

内存缓存，利用服务器上的内存来实现对数据的缓存

需要先在 Startup 中添加该服务

public void ConfigureServices(IServiceCollection services)
{
    services.AddMemoryCache();
    。。。

然后在需要缓存的位置注入 IMemoryCache 接口，并调用相关方法

public class BookController : ControllerBase
{
    public IMapper Mapper { get; set; }
    public IRepositoryWrapper RepositoryWrapper { get; set; }

    public IMemoryCache MemoryCache { get; set; }

    public BookController(IMapper mapper, IRepositoryWrapper repositoryWrapper, IMemoryCache memoryCache)
    {
        Mapper = mapper;
        RepositoryWrapper = repositoryWrapper;
        MemoryCache = memoryCache;
    }
    
    [HttpGet]
    public async Task<ActionResult<List<BookDto>>> GetBooksAsync(Guid authorId)
    {
        List<BookDto> bookDtoList = new List<BookDto>();
        string key = $"{authorId}_books";
        if (!MemoryCache.TryGetValue(key, out bookDtoList))
        {
            var books = await RepositoryWrapper.Book.GetBookAsync(authorId);
            bookDtoList = Mapper.Map<IEnumerable<BookDto>>(books).ToList();
            MemoryCache.Set(key, bookDtoList);
        }

        //var books = await RepositoryWrapper.Book.GetBooksAsync(authorId);
        //var bookDtoList = Mapper.Map<IEnumerable<BookDto>>(books);

        return bookDtoList.ToList();
    }
    。。。

还可以使用 MemoryCacheEntryOptions 对象来控制缓存时间和优先级

//MemoryCache.Set(key, bookDtoList);
MemoryCacheEntryOptions options = new MemoryCacheEntryOptions();
options.AbsoluteExpiration = DateTime.Now.AddMinutes(10);
options.Priority = CacheItemPriority.Normal;
MemoryCache.Set(key, bookDtoList, options);

分布式缓存，有效解决内存缓存不足的问题，由多个应用服务器共享

ASP.NET Core 使用分布式缓存，需要用到 IDistributedCache

ASP.NET Core 提供了 IDistributedCache 接口的3种实现方式：

• 分布式内存缓存
• 分布式 SQLServer 缓存
• 分布式 Redis 缓存

分布式内存缓存实际上并非分布式缓存，与内存缓存一样，可用于开发测试阶段

public void ConfigureServices(IServiceCollection services, IWebHostEnvironment env)
{
    if (env.IsDevelopment())
    {
        services.AddDistributedMemoryCache();
    }
    else
    {
        // 使用其他分布式缓存
    }
    。。。

分布式 SQLServer 缓存使用前，需要使用命令 dotnet sql-cache create 创建缓存数据库

dotnet sql-cache create “Date Source=(localdb)MSSQLLocalDB;Initial Catalog=DistCache;Integrated Security=True;” dbo TestCache

添加nuget

Install-Package Microsoft.Extensions.Caching.SqlServer

之后在容器种注入服务

public void ConfigureServices(IServiceCollection services, IWebHostEnvironment env)
{
    services.AddDistributedSqlServerCache(options =>
    {
        options.ConnectionString = Configuration["DistCache_ConnectionString"];
        options.SchemaName = "dbo";
        options.TableName = "TestCache";
    });
。。。        

分布式 Redis 缓存

添加nuget

Install-Package Microsoft.Extensions.Caching.Redis

之后在容器种注入服务

public void ConfigureServices(IServiceCollection services, IWebHostEnvironment env)
{
    services.AddDistributedRedisCache(options =>
    {
        options.Configuration = Configuration["Caching:Host"];
        options.InstanceName = Configuration["Caching:Instance"];
    });
    。。。

同时，在 appsettings.json 配置文件中添加 Redis 服务配置信息

"Caching": {
"Host": "127.0.0.1:6379",
"Instance": "master" 
}

然后，在 AuthorController 注入 IDistributedCache 接口即可使用

public IDistributedCache DistributedCache { get; set; }

public AuthorController(IMapper mapper, IRepositoryWrapper repositoryWrapper, ILogger<AuthorController> logger, IDistributedCache distributedCache)
{
Mapper = mapper;
RepositoryWrapper = repositoryWrapper;
Logger = logger;
DistributedCache = distributedCache;
}

接下来，在 GetAuthorsAsync 方法中使用

    public async Task<ActionResult<List<AuthorDto>>> GetAuthorsAsync([FromQuery] AuthorResourceParameters parameters)
    {
        PagedList<Author> pagedList = null;
        
        // 为了简单，仅当请求中不包含过滤和搜索查询字符串时，才进行缓存，实际情况不应该有此限制
        if (string.IsNullOrWhiteSpace(parameters.BirthPlace) && string.IsNullOrWhiteSpace(parameters.SearchQuery))
        {
            string cacheKey =
                $"authors_page_{parameters.PageNumber}_pageSize_{parameters.PageSize}_{parameters.SortBy}";
            string cacheContent = await DistributedCache.GetStringAsync(cacheKey);

            JsonSerializerSettings settings = new JsonSerializerSettings();
            settings.Converters.Add(new PagedListConvert<Author>());
            settings.Formatting = Formatting.Indented;

            if (string.IsNullOrWhiteSpace(cacheContent))
            {
                pagedList = await RepositoryWrapper.Author.GetAllAsync(parameters);
                DistributedCacheEntryOptions options = new DistributedCacheEntryOptions
                {
                    SlidingExpiration = TimeSpan.FromMinutes(2)
                };

                var serializedContent = JsonConvert.SerializeObject(pagedList, settings);
                await DistributedCache.SetStringAsync(cacheKey, serializedContent);
            }
            else
            {
                pagedList = JsonConvert.DeserializeObject<PagedList<Author>>(cacheContent, settings);
            }
        }
        else
        {
            pagedList = await RepositoryWrapper.Author.GetAllAsync(parameters);
        }

        //var pagedList = await RepositoryWrapper.Author.GetAllAsync(parameters);
        。。。

由于 Json.NET 在序列化集合对象时会将其作为数组处理，因而会忽略集合对象中的其他属性，为了保留这些属性，需要自定义 JsonConvert 类

namespace Library.API.Helpers
{
    public class PagedListConvert<T> : JsonConverter
    {
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            PagedList<T> result = (PagedList<T>) value;
            JObject jsonObj = new JObject();

            jsonObj.Add("totalCount", result.TotalCount);
            jsonObj.Add("pageNumber", result.CurrentPage);
            jsonObj.Add("pageSize", result.PageSize);
            jsonObj.Add("Items", JArray.FromObject(result.ToArray(), serializer));
            jsonObj.WriteTo(writer);
        }

        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            JObject jsonObj = JObject.Load(reader);

            var totalCount = (int) jsonObj["totalCount"];
            var pageNumber = (int) jsonObj["pageNumber"];
            var pageSize = (int) jsonObj["pageSize"];
            var items = jsonObj["Items"].ToObject<T[]>(serializer);

            PagedList<T> pageList = new PagedList<T>(items.ToList(), totalCount, pageNumber, pageSize);
            return pageList;
        }

        public override bool CanConvert(Type objectType)
        {
            return objectType == typeof(PagedList<T>);
        }
    }
}

本作品采用知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议进行许可。

欢迎转载、使用、重新发布，但务必保留文章署名 郑子铭 （包含链接： http://www.cnblogs.com/MingsonZheng/ ），不得用于商业目的，基于本文修改后的作品务必以相同的许可发布。

如有任何疑问，请与我联系 (MingsonZheng@outlook.com) 。