基于HotChocolate与EF Core整合多数据库构建单GraphQL Schema最优方案问询

无需进行Schema拼接的最优方式，核心是通过多DbContext独立管理不同数据库，并在GraphQL的Resolver层完成数据整合，以下是具体实现步骤：

1. 为每个数据库创建独立DbContext #

每个数据库对应一个专属的DbContext，分别配置对应的EF Core数据库提供器：

• 描述性数据（Azure SQL）：使用Microsoft.EntityFrameworkCore.SqlServer
• 供应商定价数据（PostgreSQL）：使用Npgsql.EntityFrameworkCore.PostgreSQL

示例DbContext定义：

// 描述性数据DbContext
public class DescriptiveDbContext : DbContext
{
    public DescriptiveDbContext(DbContextOptions<DescriptiveDbContext> options) : base(options) { }
    public DbSet<Product> Products { get; set; }
}

// 供应商1定价DbContext（PostgreSQL）
public class Supplier1PricingDbContext : DbContext
{
    public Supplier1PricingDbContext(DbContextOptions<Supplier1PricingDbContext> options) : base(options) { }
    public DbSet<PricingRecord> Supplier1Prices { get; set; }
}

// 供应商2定价DbContext（PostgreSQL）
public class Supplier2PricingDbContext : DbContext
{
    public Supplier2PricingDbContext(DbContextOptions<Supplier2PricingDbContext> options) : base(options) { }
    public DbSet<PricingRecord> Supplier2Prices { get; set; }
}

2. 注册多个DbContext到依赖注入容器 #

在Program.cs中，分别为每个DbContext配置连接字符串和对应提供器：

var builder = WebApplication.CreateBuilder(args);

// 注册描述性数据DbContext（Azure SQL）
builder.Services.AddDbContext<DescriptiveDbContext>(options =>
    options.UseSqlServer(builder.Configuration.GetConnectionString("DescriptiveDb")));

// 注册供应商1定价DbContext（PostgreSQL）
builder.Services.AddDbContext<Supplier1PricingDbContext>(options =>
    options.UseNpgsql(builder.Configuration.GetConnectionString("Supplier1PricingDb")));

// 注册供应商2定价DbContext（PostgreSQL）
builder.Services.AddDbContext<Supplier2PricingDbContext>(options =>
    options.UseNpgsql(builder.Configuration.GetConnectionString("Supplier2PricingDb")));

// 注册HotChocolate GraphQL服务
builder.Services.AddGraphQLServer()
    .AddQueryType<Query>()
    .AddProjections() // 启用投影优化
    .AddDataLoader<ProductPricingDataLoader>(); // 可选：添加DataLoader优化批量查询

3. 在GraphQL Resolver中整合多库数据 #

直接在Resolver类中注入多个DbContext，在字段解析逻辑中从不同数据库获取数据并组装，无需拆分或拼接Schema。

示例GraphQL类型与Resolver #

// 定义整合后的GraphQL类型
public class ProductDto
{
    public int Id { get; set; }
    public string Name { get; set; }
    public decimal? Supplier1Price { get; set; }
    public decimal? Supplier2Price { get; set; }
}

// Query类型Resolver
public class Query
{
    // 单个产品查询：整合描述数据与两个供应商定价
    public async Task<ProductDto> GetProduct(int id, 
        DescriptiveDbContext descDb,
        Supplier1PricingDbContext sup1Db,
        Supplier2PricingDbContext sup2Db)
    {
        // 从描述库获取基础信息
        var product = await descDb.Products.FindAsync(id);
        if (product == null) return null;

        // 从两个定价库获取对应价格
        var sup1Price = await sup1Db.Supplier1Prices.Where(p => p.ProductId == id).Select(p => p.Price).FirstOrDefaultAsync();
        var sup2Price = await sup2Db.Supplier2Prices.Where(p => p.ProductId == id).Select(p => p.Price).FirstOrDefaultAsync();

        return new ProductDto
        {
            Id = product.Id,
            Name = product.Name,
            Supplier1Price = sup1Price,
            Supplier2Price = sup2Price
        };
    }

    // 批量产品查询：推荐使用DataLoader避免N+1问题
    public async Task<IEnumerable<ProductDto>> GetProducts([Service] ProductPricingDataLoader pricingLoader,
        DescriptiveDbContext descDb)
    {
        var products = await descDb.Products.ToListAsync();
        var productIds = products.Select(p => p.Id).ToList();
        // 用DataLoader批量加载所有产品的定价数据
        var pricingMap = await pricingLoader.LoadAsync(productIds);

        return products.Select(p => new ProductDto
        {
            Id = p.Id,
            Name = p.Name,
            Supplier1Price = pricingMap[p.Id].Supplier1Price,
            Supplier2Price = pricingMap[p.Id].Supplier2Price
        });
    }
}

// 示例DataLoader：批量加载多供应商定价
public class ProductPricingDataLoader : BatchDataLoader<int, (decimal? Supplier1Price, decimal? Supplier2Price)>
{
    private readonly Supplier1PricingDbContext _sup1Db;
    private readonly Supplier2PricingDbContext _sup2Db;

    public ProductPricingDataLoader(
        Supplier1PricingDbContext sup1Db,
        Supplier2PricingDbContext sup2Db,
        IBatchScheduler batchScheduler,
        DataLoaderOptions? options = null) 
        : base(batchScheduler, options)
    {
        _sup1Db = sup1Db;
        _sup2Db = sup2Db;
    }

    protected override async Task<ILookup<int, (decimal? Supplier1Price, decimal? Supplier2Price)>> LoadBatchAsync(
        IReadOnlyList<int> productIds, CancellationToken cancellationToken)
    {
        // 批量查询两个供应商的定价
        var sup1Prices = await _sup1Db.Supplier1Prices
            .Where(p => productIds.Contains(p.ProductId))
            .ToDictionaryAsync(p => p.ProductId, p => p.Price, cancellationToken);
        
        var sup2Prices = await _sup2Db.Supplier2Prices
            .Where(p => productIds.Contains(p.ProductId))
            .ToDictionaryAsync(p => p.ProductId, p => p.Price, cancellationToken);

        // 组装结果
        var result = productIds.Select(id => new
        {
            Id = id,
            Pricing = (
                Supplier1Price: sup1Prices.TryGetValue(id, out var p1) ? p1 : null,
                Supplier2Price: sup2Prices.TryGetValue(id, out var p2) ? p2 : null
            )
        });

        return result.ToLookup(x => x.Id, x => x.Pricing);
    }
}

4. 关键优化要点 #

• 启用Projection：通过AddProjections()让HotChocolate自动生成只返回请求字段的SQL，减少不必要的数据读取。
• 使用DataLoader：批量加载关联数据，避免多数据库查询时出现N+1问题，提升批量查询性能。
• 连接字符串隔离：确保每个DbContext使用独立的连接字符串，避免数据库访问冲突。
• 事务控制（可选）：如果需要跨数据库的事务支持，可考虑使用分布式事务，但需注意云数据库的事务兼容性（如Azure SQL和PostgreSQL的分布式事务支持）。

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