ASP.NET Core无HTTP请求时，如何基于MassTransit确定Finbuckle租户？

核心思路是利用总线与租户的绑定关系（每个租户对应独立RabbitMQ vhost和总线），在MassTransit消息消费流程中注入租户上下文，让Finbuckle能正确识别租户，从而实例化多租户DbContext。

步骤1：建立总线与租户的映射关系 #

注册MassTransit总线时，为每个租户创建独立总线，并将总线实例与租户ID关联存储：

// 假设你已从配置/数据库中获取租户列表，每个租户包含Id和RabbitMQ Vhost
var tenants = GetTenantList();
var busTenantMap = new Dictionary<IBus, string>();

foreach (var tenant in tenants)
{
    // 为当前租户创建专属总线
    var bus = Bus.Factory.CreateUsingRabbitMq(cfg =>
    {
        var host = cfg.Host("rabbitmq://localhost", tenant.Vhost, h =>
        {
            h.Username("guest");
            h.Password("guest");
        });

        // 配置当前租户的消费者、队列等
        cfg.ReceiveEndpoint(host, $"{tenant.Id}-order-queue", e =>
        {
            e.Consumer<OrderCreatedConsumer>();
        });
    });

    // 绑定总线与租户ID
    busTenantMap.Add(bus, tenant.Id);
    
    // 将总线注册为单例服务
    services.AddSingleton(bus);
    
    // 启动总线（可放在应用启动逻辑中）
    await bus.StartAsync();
}

// 将总线-租户映射注册为单例，供后续逻辑使用
services.AddSingleton(busTenantMap);

步骤2：通过MassTransit中间件注入租户上下文 #

实现MassTransit消费管道中间件，在消息处理前自动设置Finbuckle的租户上下文，确保DbContext能获取到租户信息：

public class TenantConsumeMiddleware : IFilter<ConsumeContext>
{
    private readonly Dictionary<IBus, string> _busTenantMap;
    private readonly IMultiTenantContextAccessor _tenantContextAccessor;

    public TenantConsumeMiddleware(Dictionary<IBus, string> busTenantMap, IMultiTenantContextAccessor tenantContextAccessor)
    {
        _busTenantMap = busTenantMap;
        _tenantContextAccessor = tenantContextAccessor;
    }

    public async Task Send(ConsumeContext context, IPipe<ConsumeContext> next)
    {
        // 从当前消费上下文的总线实例，匹配对应的租户ID
        if (_busTenantMap.TryGetValue(context.Bus, out var tenantId))
        {
            // 设置Finbuckle租户上下文
            _tenantContextAccessor.MultiTenantContext = new MultiTenantContext<string>(tenantId);
        }

        try
        {
            // 继续执行后续消费逻辑
            await next.Send(context);
        }
        finally
        {
            // 清理上下文，避免污染后续消息处理
            _tenantContextAccessor.MultiTenantContext = null;
        }
    }

    public void Probe(ProbeContext context)
    {
        context.CreateFilterScope("tenant-resolution");
    }
}

// 扩展方法：快速注册中间件
public static class TenantMiddlewareExtensions
{
    public static void UseTenantResolution(this IBusFactoryConfigurator cfg, IServiceProvider serviceProvider)
    {
        cfg.ConsumePipeFilters.Add(new TenantConsumeMiddleware(
            serviceProvider.GetRequiredService<Dictionary<IBus, string>>(),
            serviceProvider.GetRequiredService<IMultiTenantContextAccessor>()));
    }
}

注册总线时，添加这个中间件：

var bus = Bus.Factory.CreateUsingRabbitMq(cfg =>
{
    var host = cfg.Host("rabbitmq://localhost", tenant.Vhost, h =>
    {
        h.Username("guest");
        h.Password("guest");
    });

    // 注入租户解析中间件
    cfg.UseTenantResolution(services.BuildServiceProvider());

    // 配置消费者...
});

步骤3：（可选）实现Finbuckle自定义租户解析策略 #

如果需要兼容HTTP请求和消息消费两种场景的租户识别，可以自定义ITenantResolutionStrategy，优先处理MassTransit上下文， fallback到原有的主机策略：

public class HybridTenantResolutionStrategy : ITenantResolutionStrategy
{
    private readonly Dictionary<IBus, string> _busTenantMap;
    private readonly IHttpContextAccessor _httpContextAccessor;
    // 用AsyncLocal传递当前MassTransit消费上下文
    private static readonly AsyncLocal<ConsumeContext> _currentConsumeContext = new();

    // 供中间件调用，设置当前消费上下文
    public static void SetCurrentConsumeContext(ConsumeContext context)
    {
        _currentConsumeContext.Value = context;
    }

    public HybridTenantResolutionStrategy(Dictionary<IBus, string> busTenantMap, IHttpContextAccessor httpContextAccessor)
    {
        _busTenantMap = busTenantMap;
        _httpContextAccessor = httpContextAccessor;
    }

    public async Task<string?> ResolveTenantIdAsync(object? context = null)
    {
        // 1. 优先处理MassTransit消息场景
        var consumeContext = _currentConsumeContext.Value;
        if (consumeContext != null && _busTenantMap.TryGetValue(consumeContext.Bus, out var tenantId))
        {
            return tenantId;
        }

        // 2. 处理HTTP请求场景，复用原有主机策略逻辑
        if (_httpContextAccessor.HttpContext != null)
        {
            var host = _httpContextAccessor.HttpContext.Request.Host.Host;
            // 替换为你原有的主机-租户映射逻辑
            return await MapHostToTenantId(host);
        }

        return null;
    }

    // 原有主机解析逻辑
    private Task<string?> MapHostToTenantId(string host)
    {
        // 示例：根据主机名匹配租户ID
        return Task.FromResult(host switch
        {
            "tenant1.example.com" => "tenant1",
            "tenant2.example.com" => "tenant2",
            _ => null
        });
    }
}

注册自定义策略：

services.AddMultiTenant<string>()
    .WithResolutionStrategy<HybridTenantResolutionStrategy>()
    .WithStore<ConfigurationTenantStore<string>>() // 替换为你的租户存储
    .WithDbContext<MyTenantDbContext>();

关键注意事项 #

• 上下文清理：必须在消费完成后清理租户上下文，避免不同租户的消息处理互相污染
• 总线生命周期：每个租户的总线是单例，确保映射字典的线程安全（如果动态添加租户，需加锁）
• 依赖注入：确保MassTransit消费者能正确注入IMultiTenantContextAccessor和多租户DbContext

内容的提问来源于stack exchange，提问作者Filip