怎样用Hibernate配置多个数据源？

如果用xml配置的话，那就写两个配置文件，可以不再用“hibernate.cfg.xml”做文件名，随便什么都可以，像“mysql.cfg.xml”或“sqlserver.xml”都行。用Configuration类获取SessionFactory的代码：

SessionFactory mysqlFactory = new Configuration().configure("mysql.cfg.xml").buildSessionFactory()

SessionFactory sqlserverFactory = new Configuration().configure("sqlserver.xml").buildSessionFactory()

如果你用spring，多数据库就更简单了，像这段代码可以完成所有配置：

<beans>

<bean id="mysqlDS" class="org.springframework.jdbc.datasource.DriverManagerDataSource">

<property name="url">

<value>jdbc:mysql://localhost:3306/test</value>

</property>

<property name="driverClassName">

<value>org.gjt.mm.mysql.Driver</value>

</property>

<property name="username">

<value>root</value>

</property>

<property name="password">

<value>123456</value>

</property>

</bean>

<bean id="mysqlFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">

<property name="dataSource">

<ref local="mysqlDS"/>

</property>

<property name="hibernateProperties">

<props>

<prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>

</props>

</property>

<property name="mappingResources">

<list>

<value>test.hbm.xml</value>

</list>

</property>

</bean>

<bean id="sqlserverDS" class="org.springframework.jdbc.datasource.DriverManagerDataSource">

<property name="url">

<value>jdbc:odbc:test</value>

</property>

<property name="driverClassName">

<value>sun.jdbc.odbc.JdbcOdbcDriver</value>

</property>

<property name="username">

<value>root</value>

</property>

<property name="password">

<value>123456</value>

</property>

</bean>

<bean id="sqlserverFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">

<property name="dataSource">

<ref local="sqlserverDS"/>

</property>

<property name="hibernateProperties">

<props>

<prop key="hibernate.dialect">org.hibernate.dialect.SQLServerDialect</prop>

</props>

</property>

<property name="mappingResources">

<list>

<value>test.hbm.xml</value>

</list>

</property>

</bean>

.......

</beans>

hibernate和spring还有很多可行的配置，可以参考他们的references，有很详细地说明的。

在进行软件开发的过程中，了解软件开发的主流框架是非常重要的，主流框架主要有哪些呢？Hibernate、Struts和Spring是现在使用最主流的三种框架，很多人对软件开发框架的了解非常少，在开发过程中不知道应该选择哪种框架进行使用，这三种框架有哪些优缺点呢？下面电脑培训为大家介绍这三种主流框架的优缺点。

一、Hibernate

Hibernate书属于一种开放源代码的对象关系映射框架，在使用过程中，它能够对JDBC进行对象封装，让程序员在开发过程中进行随心所欲的使用对象编程。

优点：Hibernate使用能够起到Java的反射机制，并不是使用字节码程序进行使用的。在使用过程中具有很好的性能，并且还是一个轻量级的框架程序，有很好的灵活性。Hibernate能支持很多种关系数据库，能够处理一对一和多对多的各种关系。

缺点：Hibernate在使用过程中受限于所使用的对象模型，它所独有的界面和市场范围是非常不稳定的，并且在使用过程中，IT培训认为它所具有的强大发展动力能够减少这些风险。一般情况下，它所具有的开源持久性框架只有一些，市场冲击力并不大。

二、Struts

Struts框架具有很好的组件模块性，在使用过程中有很好的灵活性和重用性，在使用过程中主要基于MVC的web程序开发。

优点：像许多Apache项目一样，如Tomcat和Turbine，Struts是一个开源软件，这是一个很大的优势。很多开发人员能够更深入地了解其内部实现机制。如果是考虑页面导航，那么昭通北大青鸟认为这是一种以后的发展方向，这样的方法对于后期的维护有着非常大的好处。

缺点：在进行学习的过程中，很多人都知道Taglib是Struts使用中的一大优势，对于初学者来说，这并不是最好的选择，因为在学习开发的时候，这是一个持续学习的过程。如果是没有经验的初学者，在使用过程中会被打乱自己编写代码的习惯，要是能够熟悉这种编程方法，对后续的学习有很大的帮助。

三、Spring

这是一个很好的开源项目，在使用过程中非常的活跃，能够和IoC、AOP的框架结构结合使用，这种框架不需要在每一层进行使用，它的模块化是非常好的，使用的时候可以选择任何一个模块进行使用，并且能够实现MVC，对于数据能够提供统一的接口。

优点：无论您是否选择使用EJB，Spring都可以有效地组织您的中间层对象。Spring消除了在许多项目中常见的Singleton的过度使用。北大青鸟昭通计算机学院认为这是一个非常严重的问题，会降低系统的可测试性和面向对象的程度。

缺点：这种框架的使用并不是很多，很多人不会选择，在使用在JSP中需要写很多的代码，并且控制器过于灵活，在使用过程中缺少公用控制器。

在开发一些项目时，会使用到多个数据库。例如类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<TEntity>() where TEntity : IEntity

}

 public class SessionFactoryHolder : ISessionFactoryHolder

{

    private IDictionary<string, int> entityDictionary

    private IDictionary<int, ISessionFactory> factoryDictionary

    public SessionFactoryHolder()

    {

        this.entityDictionary = new Dictionary<string, int>()

        this.factoryDictionary = new Dictionary<int, ISessionFactory>()

    }

    #region ISessionFactoryHolder Members

    public ISessionFactory GetSessionFactoryForEntity<TEntity>() where TEntity : IEntity

    {

        int hashCode = 0

        Asserts.Assert<MappingException>(

            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<TEntity>() where TEntity : IEntity

}

 public class SessionHolder : ISessionHolder, IUnitOfWork

{

    private readonly ISessionFactoryHolder factoryHolder

    private IDictionary<int, ISession> sessionDictionary

    public SessionHolder(ISessionFactoryHolder factoryHolder)

    {

        Asserts.IsNotNull(factoryHolder, "factoryHolder")

        this.factoryHolder = factoryHolder

        this.sessionDictionary = new Dictionary<int, ISession>()

    }

    #region ISessionHolder Members

    public ISession GetSessionForEntity<TEntity>() where TEntity : IEntity

    {

        if (this.sessionDictionary.ContainsKey(this.GetFactoryHashCode<TEntity>()) == false)

        {

            this.sessionDictionary[this.GetFactoryHashCode<TEntity>()] = this.OpenNewSession<TEntity>()

        }

        return this.sessionDictionary[this.GetFactoryHashCode<TEntity>()]

    }

    #endregion

    #region IDisposable Members

    //Dispose Code

     #endregion

    #region IUnitOfWork

    //IUnitOfWork

    #endregion

    private ISessionFactory GetFactory<TEntity>() where TEntity : IEntity

    {

        return this.factoryHolder.GetSessionFactoryForEntity<TEntity>()

    }

    private int GetFactoryHashCode<TEntity>() where TEntity : IEntity

    {

        return this.GetFactory<TEntity>().GetHashCode()

    }

    private ISession OpenNewSession<TEntity>() where TEntity : IEntity

    {

        return this.GetFactory<TEntity>().OpenSession()

    }

}

Repository：

public interface IRepository<TEntity> where TEntity : IEntity

{

    void Save(TEntity entity)

    //......

}

public class NHibernateRepository<TEntity> : IRepository<TEntity> 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<TEntity>()

        }

    }

    public override void Save(TEntity entity)

    {

        this.Session.Save(entity)

    }

    //......

}

---