NHibernate 连接多数据库怎么配置

在开发一些项目时，会使用到多个数据库。例如类A保存在数据库A，类B保存在数据库B。NHibernate在BuildSessionFactory之后，ISessionFactory就不能改变数据库的连接，即是说一个ISessionFactory只能对应一个数据库连接。但NHibernate可以在同一个应用中实例化多个ISessionFactory。实例化多个ISessionFactory，并让类A或类B找到自己所对应的ISessionFactory，获取ISession，即可实现多数据库连接。

如何通过类型获取ISessionFactory呢？ISessionFactory的Statistics.EntityNames中保存了所有映射了的实体类的类名。我们可以判断实体类的类名是否在EntityNames中，确定实体类所对应的ISessionFactory。

根据类型获取ISessionFactory：

public interface ISessionFactoryHolder
{
    ISessionFactory GetSessionFactoryForEntity() where TEntity : IEntity;
}

 public class SessionFactoryHolder : ISessionFactoryHolder
{
    private IDictionary entityDictionary;
    private IDictionary factoryDictionary;

    public SessionFactoryHolder()
    {
        this.entityDictionary = new Dictionary();
        this.factoryDictionary = new Dictionary();
    }

    #region ISessionFactoryHolder Members

    public ISessionFactory GetSessionFactoryForEntity() where TEntity : IEntity
    {
        int hashCode = 0;

        Asserts.Assert(
            this.EntityInDictionary(typeof(TEntity).FullName, out hashCode) == false
            , string.Format("No persister for:{0}", typeof(TEntity).FullName));

        return this.factoryDictionary[hashCode];
    }

    #endregion

    public void RegisterSessionFactory(ISessionFactory sessionFactory)
    {
        Asserts.IsNotNull(sessionFactory, "sessionFactory");

        this.factoryDictionary[sessionFactory.GetHashCode()] = sessionFactory;

        this.MapingEntityNameToSessionFactoryHashCode(sessionFactory.Statistics.EntityNames
            , sessionFactory.GetHashCode());
    }

    private bool EntityInDictionary(string entityName, out int sessionFactoryHashCode)
    {
        return this.entityDictionary.TryGetValue(entityName, out sessionFactoryHashCode);
    }

    private void MapingEntityNameToSessionFactoryHashCode(string[] entityNames, int sessionFactoryHashCode)
    {
        foreach (var entityName in entityNames)
        {
            this.entityDictionary[entityName] = sessionFactoryHashCode;
        }
    }
}

根据类型获取ISession：

public interface ISessionHolder : IDisposable
{
    ISession GetSessionForEntity() where TEntity : IEntity;
}
 public class SessionHolder : ISessionHolder, IUnitOfWork
{
    private readonly ISessionFactoryHolder factoryHolder;
    private IDictionary sessionDictionary;

    public SessionHolder(ISessionFactoryHolder factoryHolder)
    {
        Asserts.IsNotNull(factoryHolder, "factoryHolder");

        this.factoryHolder = factoryHolder;
        this.sessionDictionary = new Dictionary();
    }

    #region ISessionHolder Members

    public ISession GetSessionForEntity() where TEntity : IEntity
    {
        if (this.sessionDictionary.ContainsKey(this.GetFactoryHashCode()) == false)
        {
            this.sessionDictionary[this.GetFactoryHashCode()] = this.OpenNewSession();
        }

        return this.sessionDictionary[this.GetFactoryHashCode()];
    }

    #endregion

    #region IDisposable Members
    //Dispose Code
     #endregion

    #region IUnitOfWork
    //IUnitOfWork
    #endregion

    private ISessionFactory GetFactory() where TEntity : IEntity
    {
        return this.factoryHolder.GetSessionFactoryForEntity();
    }

    private int GetFactoryHashCode() where TEntity : IEntity
    {
        return this.GetFactory().GetHashCode();
    }

    private ISession OpenNewSession() where TEntity : IEntity
    {
        return this.GetFactory().OpenSession();
    }
}

Repository：

public interface IRepository where TEntity : IEntity
{
    void Save(TEntity entity);
    //......
}

public class NHibernateRepository : IRepository where TEntity : IEntity
{
    private readonly ISessionHolder sessionHolder;

    public NHibernateRepository(ISessionHolder sessionHolder)
    {
        Asserts.IsNotNull(sessionHolder, "sessionHolder");

        this.sessionHolder = sessionHolder;
    }

    protected virtual ISession Session
    {
        get
        {
            return this.sessionHolder.GetSessionForEntity();
        }
    }

    public override void Save(TEntity entity)
    {
        this.Session.Save(entity);
    }
    //......
}

NHibernate本身不支持多数据库支持，需要写SessionFactory扩展，不过一些项目已经写了这个扩展，例如Burrow项目，使用多个hibernate.cfg.xml，创建多个SessionFactory。。这是必须的。