如何在.NET Core 6 Api的Hangfire定时任务中携带JWT Token调用接口

思路一：使用预生成的长期有效JWT Token #

适合内部接口场景，直接生成一个有效期较长的JWT Token（比如1年），存储在配置文件中，Hangfire任务发起请求时直接携带这个Token。

1. 在appsettings.json中添加Token配置：

"AppSettings": {
  "HangfireApiToken": "你的长期有效JWT Token"
}

2. 在Hangfire任务方法中，创建HttpClient并添加Authorization头：

public class HangfireJobs
{
    private readonly IConfiguration _config;
    private readonly HttpClient _httpClient;

    public HangfireJobs(IConfiguration config, HttpClient httpClient)
    {
        _config = config;
        _httpClient = httpClient;
    }

    public async Task CallProtectedApi()
    {
        var token = _config["AppSettings:HangfireApiToken"];
        _httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);
        
        var response = await _httpClient.GetAsync("https://yourapi.com/api/protected");
        response.EnsureSuccessStatusCode();
        // 处理响应逻辑
    }
}

思路二：动态获取JWT Token后发起请求 #

如果不想用长期Token，可以在Hangfire任务中先调用登录接口获取临时Token，再用这个Token调用目标接口，还可以对Token做简单缓存避免重复请求。

public class HangfireJobs
{
    private readonly HttpClient _httpClient;
    private string _cachedToken;
    private DateTime _tokenExpiry;

    public HangfireJobs(HttpClient httpClient)
    {
        _httpClient = httpClient;
    }

    private async Task<string> GetValidToken()
    {
        if (!string.IsNullOrEmpty(_cachedToken) && DateTime.UtcNow < _tokenExpiry)
        {
            return _cachedToken;
        }

        // 调用登录接口获取Token
        var loginRequest = new { Username = "hangfire_user", Password = "your_password" };
        var loginResponse = await _httpClient.PostAsJsonAsync("https://yourapi.com/api/auth/login", loginRequest);
        loginResponse.EnsureSuccessStatusCode();
        
        var tokenResult = await loginResponse.Content.ReadFromJsonAsync<TokenResponse>();
        _cachedToken = tokenResult.AccessToken;
        _tokenExpiry = DateTime.UtcNow.AddSeconds(tokenResult.ExpiresIn);
        
        return _cachedToken;
    }

    public async Task CallProtectedApi()
    {
        var token = await GetValidToken();
        _httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);
        
        var response = await _httpClient.GetAsync("https://yourapi.com/api/protected");
        response.EnsureSuccessStatusCode();
        // 处理响应逻辑
    }

    private class TokenResponse
    {
        public string AccessToken { get; set; }
        public int ExpiresIn { get; set; }
    }
}

思路三：直接调用业务逻辑方法（跳过HTTP请求） #

如果Hangfire和目标接口属于同一个API项目，完全可以跳过HTTP请求，直接注入接口对应的业务服务，调用核心逻辑方法，这样既不需要Token，也能提升性能。

public class HangfireJobs
{
    private readonly IProtectedService _protectedService;

    public HangfireJobs(IProtectedService protectedService)
    {
        _protectedService = protectedService;
    }

    public async Task ExecuteBusinessLogic()
    {
        // 直接调用业务方法，无需HTTP请求和Token
        await _protectedService.DoProtectedWork();
    }
}

// 对应的业务服务接口和实现
public interface IProtectedService
{
    Task DoProtectedWork();
}

public class ProtectedService : IProtectedService
{
    public async Task DoProtectedWork()
    {
        // 这里是原来接口中的业务逻辑
    }
}

注意事项 #

• 思路一中的长期Token要确保权限最小化，只赋予Hangfire任务需要的接口权限，避免泄露后造成安全风险。
• 思路二中要处理登录失败、Token获取失败的异常情况，比如添加重试逻辑。
• 思路三中要保证业务方法是无状态的，适合后台任务调用，避免依赖HTTP上下文等请求相关的对象。

内容的提问来源于stack exchange，提问作者Osman Yalçınkaya