使用 Fluent nHibernate 和 Ninject 实现多租户。每个租户一个数据库

我正在构建一个多租户 Web 应用程序，出于安全考虑，我们需要为每个租户拥有一个数据库实例。所以我有一个用于身份验证的 MainDB 和许多用于应用程序数据的 ClientDB。

我正在使用 Asp.net MVC 与 Ninject 和 Fluent nHibernate。我已经在应用程序开始时在 Ninject 模块中使用 Ninject 和 Fluent nHibernate 设置了 SessionFactory/Session/Repositories。我的会话是 PerRequestScope，存储库也是如此。

我的问题是现在我需要为每个租户实例化一个 SessionFactory (SingletonScope) 实例，只要其中一个租户连接到应用程序，并为每个 Web 请求创建一个新会话和必要的存储库。我对如何做到这一点感到困惑，并且需要一个具体的例子。

情况是这样的。

申请开始：TenantX 的用户输入他的登录信息。 MainDB 的 SessionFactory 被创建并打开到 MainDB 的会话以对用户进行身份验证。然后应用程序创建身份验证 cookie。

租户访问应用程序：租户名称 + ConnectionString 是从 MainDB 中提取的，Ninject 必须为该租户构造一个特定于租户的 SessionFactory (SingletonScope)。 Web 请求的其余部分，所有需要存储库的控制器都将根据该租户的 SessionFactory 注入特定于租户的会话/存储库。

如何使用 Ninject 设置该动态？当我有多个数据库时，我最初使用命名实例，但现在数据库是特定于租户的，我迷失了......

经过进一步研究，我可以给你一个更好的答案。

虽然可以将连接字符串传递给ISession.OpenSession更好的方法是创建自定义ConnectionProvider。最简单的方法是从DriverConnectionProvider并覆盖ConnectionString财产：

public class TenantConnectionProvider : DriverConnectionProvider
{
    protected override string ConnectionString
    {
        get
        {
            // load the tenant connection string
            return "";
        }
    }

    public override void Configure(IDictionary<string, string> settings)
    {
        ConfigureDriver(settings);
    }
}

使用 FluentNHibernate 您可以像这样设置提供程序：

var config = Fluently.Configure()
    .Database(
        MsSqlConfiguration.MsSql2008
            .Provider<TenantConnectionProvider>()
    )

每次打开会话时都会评估 ConnectionProvider，以便您连接到应用程序中的租户特定数据库。

上述方法的一个问题是 SessionFactory 是共享的。如果您仅使用一级缓存（因为它与会话相关），那么这并不是真正的问题，但如果您决定启用二级缓存（与 SessionFactory 相关），那么这实际上并不是问题。

因此，推荐的方法是为每个租户设置一个 SessionFactory（这适用于每个租户模式和每个租户数据库策略）。

另一个经常被忽视的问题是，虽然二级缓存与 SessionFactory 绑定在一起，但在某些情况下缓存空间本身是共享的（参考）。这可以通过设置提供者的“regionName”属性来解决。

下面是根据您的要求的 SessionFactory-per-tenant 的工作实现。

The Tenant类包含我们为租户设置 NHibernate 所需的信息：

public class Tenant : IEquatable<Tenant>
{
    public string Name { get; set; }
    public string ConnectionString { get; set; }

    public bool Equals(Tenant other)
    {
        if (other == null)
            return false;

        return other.Name.Equals(Name) && other.ConnectionString.Equals(ConnectionString);
    }

    public override bool Equals(object obj)
    {
        return Equals(obj as Tenant);
    }

    public override int GetHashCode()
    {
        return string.Concat(Name, ConnectionString).GetHashCode();
    }
}

因为我们将存储一个Dictionary<Tenant, ISessionFactory>我们实施IEquatable接口，以便我们可以评估租户密钥。

获取当前租户的过程抽象如下：

public interface ITenantAccessor
{
    Tenant GetCurrentTenant();
}

public class DefaultTenantAccessor : ITenantAccessor
{
    public Tenant GetCurrentTenant()
    {
        // your implementation here

        return null;
    }
}

最后NHibernateSessionSource它管理会话：

public interface ISessionSource
{
    ISession CreateSession();
}

public class NHibernateSessionSource : ISessionSource
{
    private Dictionary<Tenant, ISessionFactory> sessionFactories = 
        new Dictionary<Tenant, ISessionFactory>();

    private static readonly object factorySyncRoot = new object();

    private string defaultConnectionString = 
        @"Server=(local)\sqlexpress;Database=NHibernateMultiTenancy;integrated security=true;";

    private readonly ISessionFactory defaultSessionFactory;
    private readonly ITenantAccessor tenantAccessor;

    public NHibernateSessionSource(ITenantAccessor tenantAccessor)
    {
        if (tenantAccessor == null)
            throw new ArgumentNullException("tenantAccessor");

        this.tenantAccessor = tenantAccessor;

        lock (factorySyncRoot)
        {
            if (defaultSessionFactory != null) return;

            var configuration = AssembleConfiguration("default", defaultConnectionString);
            defaultSessionFactory = configuration.BuildSessionFactory();
        }
    }

    private Configuration AssembleConfiguration(string name, string connectionString)
    {
        return Fluently.Configure()
            .Database(
                MsSqlConfiguration.MsSql2008.ConnectionString(connectionString)
            )
            .Mappings(cfg =>
            {
                cfg.FluentMappings.AddFromAssemblyOf<NHibernateSessionSource>();
            })
            .Cache(c =>
                c.UseSecondLevelCache()
                .ProviderClass<HashtableCacheProvider>()
                .RegionPrefix(name)
            )
            .ExposeConfiguration(
                c => c.SetProperty(NHibernate.Cfg.Environment.SessionFactoryName, name)
            )
            .BuildConfiguration();
    }

    private ISessionFactory GetSessionFactory(Tenant currentTenant)
    {
        ISessionFactory tenantSessionFactory;

        sessionFactories.TryGetValue(currentTenant, out tenantSessionFactory);

        if (tenantSessionFactory == null)
        {
            var configuration = AssembleConfiguration(currentTenant.Name, currentTenant.ConnectionString);
            tenantSessionFactory = configuration.BuildSessionFactory();

            lock (factorySyncRoot)
            {
                sessionFactories.Add(currentTenant, tenantSessionFactory);
            }
        }

        return tenantSessionFactory;
    }

    public ISession CreateSession()
    {
        var tenant = tenantAccessor.GetCurrentTenant();

        if (tenant == null)
        {
            return defaultSessionFactory.OpenSession();
        }

        return GetSessionFactory(tenant).OpenSession();
    }
}

当我们创建一个实例时NHibernateSessionSource我们为我们的“默认”数据库设置了一个默认的 SessionFactory。

When CreateSession()被称为我们得到一个ISessionFactory实例。这将是默认会话工厂（如果当前租户为空）或特定于租户的会话工厂。定位租户特定会话工厂的任务由GetSessionFactory method.

最后我们打电话OpenSession on the ISessionFactory我们获得的实例。

请注意，当我们创建会话工厂时，我们设置 SessionFactory 名称（用于调试/分析目的）和缓存区域前缀（出于上述原因）。

我们的 IoC 工具（在我的例子中为 StructureMap）将所有内容连接起来：

    x.For<ISessionSource>().Singleton().Use<NHibernateSessionSource>();
    x.For<ISession>().HttpContextScoped().Use(ctx => 
        ctx.GetInstance<ISessionSource>().CreateSession());
    x.For<ITenantAccessor>().Use<DefaultTenantAccessor>();

这里 NHibernate Session Source 的作用域是单例和每个请求的 Session。

希望这可以帮助。