ASP.NET Core 3.1中存储OAuth 2访问令牌的最优方案是什么

首选方案为**IDistributedCache 分布式缓存 + IHttpClientFactory 类型化HttpClient**的组合实现，完全规避静态HttpClient的各类问题，同时适配单实例、分布式集群等多种部署场景，天然支持线程安全和令牌生命周期自动管理。

方案核心优势 #

• 完全替代静态HttpClient实现，规避静态实例的DNS更新不生效、socket资源耗尽等原生问题
• 存储层可灵活切换，单实例部署用内存缓存即可，分布式部署无缝切换为Redis等分布式缓存
• 令牌申请、续期、存储逻辑统一封装，业务代码无感知
• 高并发场景下可扩展支持分布式锁，避免缓存击穿导致的重复申请令牌问题

具体实现步骤 #

1. 注册缓存服务 #

在Startup.cs的ConfigureServices方法中注册缓存服务：

// 单实例部署用内存分布式缓存，不需要额外依赖
services.AddDistributedMemoryCache();

// 分布式部署直接替换为Redis缓存即可
// services.AddStackExchangeRedisCache(options =>
// {
//     options.Configuration = "你的Redis连接字符串";
// });

2. 定义类型化HttpClient与令牌管理逻辑 #

统一封装第三方API调用、令牌申请、缓存逻辑：

using System.Net.Http.Headers;
using System.Text.Json.Serialization;
using Microsoft.Extensions.Caching.Distributed;

// 第三方API类型化客户端
public class ThirdPartyApiClient
{
    private readonly HttpClient _httpClient;
    private readonly IDistributedCache _cache;
    // 缓存Key可根据实际场景自定义
    private const string TokenCacheKey = "ThirdParty_OAuth2_Access_Token";
    // 替换为你实际的第三方OAuth2配置
    private const string ClientId = "你的应用ClientId";
    private const string ClientSecret = "你的应用ClientSecret";
    private const string OAuthTokenEndpoint = "第三方令牌申请接口地址";

    public ThirdPartyApiClient(HttpClient httpClient, IDistributedCache cache)
    {
        _httpClient = httpClient;
        _cache = cache;
    }

    // 获取有效令牌的统一方法
    private async Task<string> GetValidAccessToken()
    {
        // 优先读取缓存中的有效令牌
        var cachedToken = await _cache.GetStringAsync(TokenCacheKey);
        if (!string.IsNullOrWhiteSpace(cachedToken))
        {
            return cachedToken;
        }

        // 缓存无有效令牌，申请新令牌
        var newToken = await RequestNewAccessToken();
        // 缓存过期时间比令牌实际过期时间提前1分钟，避免边界时间的过期问题
        var cacheExpireTime = TimeSpan.FromSeconds(newToken.ExpiresIn - 60);
        await _cache.SetStringAsync(TokenCacheKey, newToken.AccessToken, new DistributedCacheEntryOptions
        {
            AbsoluteExpirationRelativeToNow = cacheExpireTime
        });

        return newToken.AccessToken;
    }

    // 向第三方申请新令牌的逻辑，根据实际OAuth2授权模式调整
    private async Task<TokenResponse> RequestNewAccessToken()
    {
        var requestParams = new FormUrlEncodedContent(new Dictionary<string, string>
        {
            ["grant_type"] = "client_credentials",
            ["client_id"] = ClientId,
            ["client_secret"] = ClientSecret
        });

        var response = await _httpClient.PostAsync(OAuthTokenEndpoint, requestParams);
        response.EnsureSuccessStatusCode();
        return await response.Content.ReadFromJsonAsync<TokenResponse>();
    }

    // 封装第三方API的GET调用，可按需扩展POST、PUT等方法
    public async Task<T> GetApiResultAsync<T>(string apiPath)
    {
        var accessToken = await GetValidAccessToken();
        using var request = new HttpRequestMessage(HttpMethod.Get, apiPath);
        request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
        
        var response = await _httpClient.SendAsync(request);
        response.EnsureSuccessStatusCode();
        return await response.Content.ReadFromJsonAsync<T>();
    }
}

// 第三方令牌接口返回实体
// 如果项目用Newtonsoft.Json，将JsonPropertyName替换为JsonProperty即可
public class TokenResponse
{
    [JsonPropertyName("access_token")]
    public string AccessToken { get; set; }
    
    [JsonPropertyName("expires_in")]
    public int ExpiresIn { get; set; }
}

3. 注册类型化HttpClient #

同样在ConfigureServices方法中添加注册：

services.AddHttpClient<ThirdPartyApiClient>(client =>
{
    // 替换为第三方API的根地址
    client.BaseAddress = new Uri("https://api.thirdparty.com/");
    // 可按需配置全局超时、默认头等
    client.Timeout = TimeSpan.FromSeconds(30);
});

4. 业务层直接注入使用 #

public class YourBusinessService
{
    private readonly ThirdPartyApiClient _thirdPartyApiClient;

    // 构造函数注入即可使用
    public YourBusinessService(ThirdPartyApiClient thirdPartyApiClient)
    {
        _thirdPartyApiClient = thirdPartyApiClient;
    }

    public async Task ProcessBusiness()
    {
        var result = await _thirdPartyApiClient.GetApiResultAsync<YourBusinessEntity>("/target/api/path");
        // 处理返回结果
    }
}

高并发场景优化 #

如果服务并发量较高，缓存失效瞬间可能出现多个请求同时申请令牌的情况，可以叠加分布式锁逻辑，避免重复申请令牌的资源浪费。

内容的提问来源于stack exchange，提问作者Diego peña