由new命令开辟内存空间的java对象，

       eg. Person person = new Person("amigo", "女");

        如果没有变量对该对象进行引用，它将被java虚拟机回收。

        瞬时对象在内存孤立存在，它是携带信息的载体，不和数据库的数据有任何关联关系，在Hibernate中，可通过session的save()或saveOrUpdate()方法将瞬时对象与数据库相关联，并将数据对应的插入数据库中，此时该瞬时对象转变成持久化对象。

•        持久态

        处于该状态的对象在数据库中具有对应的记录，并拥有一个持久化标识。如果是用hibernate的delete()方法，对应的持久对象就变成瞬时对象，因数据库中的对应数据已被删除，该对象不再与数据库的记录关联。

       当一个session执行close()或clear()、evict()之后，持久对象变成脱管对象，此时持久对象会变成脱管对象，此时该对象虽然具有数据库识别值，但它已不在HIbernate持久层的管理之下。

       持久对象具有如下特点：

       1. 和session实例关联；

       2. 在数据库中有与之关联的记录。

•  脱管态

        当与某持久对象关联的session被关闭后，该持久对象转变为脱管对象。当脱管对象被重新关联到session上时，并再次转变成持久对象。

       脱管对象拥有数据库的识别值，可通过update()、saveOrUpdate()等方法，转变成持久对象。

       脱管对象具有如下特点：

       1.  本质上与瞬时对象相同，在没有任何变量引用它时，JVM会在适当的时候将它回收；

       2.  比瞬时对象多了一个数据库记录标识值。

• Configuration接口：该对象用于配置并且根启动Hibernate。Hibernate应用通过Configuration实例来指定对象-关系映射文件的位置或动态配置Hibernate的属性，然后创建SessionFactory实例。
• SessionFactory接口：一个SessionFactory实例对应一个数据存储源，应用从SessionFactory中获得Session实例。它具有如下特点：

              1）它是线程安全的，这意味着它的同一个实例可以被应用的各个线程共享。

              2）它是重量级的，这意味着不能随意创建或销毁它的实例。如果应用只访问一个数据库，只需创建一个SessionFactory实例，在应用初始化的时候创建该实例。如果应用同时访问多个数据库，则需要为每个数据库创建一个单独的SessionFactory实例。

              之所以说SessionFactory是重量级的，是因为它需要一个很大的缓存，用来存放预定义的SQL语句以及映射元数据等。用户还可以为SessionFactory配置一个缓存插件，这个缓存插件被称为Hibernate的第二级缓存，该缓存用来存放被工作单元读过的数据，将来其它工作单元可能会重用这些数据，因此这个缓存中的数据能够被所有工作单元共享，一个工作单元通常对应一个数据库事务。

• Session接口：该接口是Hibernate应用使用最广泛的接口。Session也被称为持久化管理器，提供了和持久化相关的操作，如添加、更新、删除、加载和查询对象。Session具有一下特点：

             1）不是线程安全的，因此在设计软件架构时，应该避免多个线程共享同一个Session实例；

             2）Session实例是轻量级的，所谓轻量级，是指它的创建和销毁不需要消耗太多的资源。这意味着在程序中可以经常创建和销毁Session对象，例如为每个客户请求分配单独的Session实例，或者为每个工作单元分配单独的Session实例。

             Session有一个缓存，被称为Hibernate的第一级缓存，它存放被当前工作单元加载的对象。每个Session实例都有自己的缓存，这个Session实例的缓存，这个Session实例的缓存只能被当前工作单元访问。

•  Transaction：该接口是Hibernate的数据库事务接口，它对底层的事务接口做了封装，底层事务接口包括：JDBC API、JTA（Java Transaction API）、CORBA（Common Object Requet Broker Architecture) API.

             Hibernate应用可通过一致的Transaction接口来声明事务边界，这有助于应用在不同环境或容器中移植。

•  Query和Criteria接口：它们是Hibernate的查询接口，用于向数据库查询对象，以及控制执行查询的过程。Query实例封装了一个HQL（Hibernate Query Language）查询语句，HQL是面向对象的，它引用类名及类的属性名，而不是表名及表的字段名。Criteria接口完全封装了基于字符串形式的查询语句，比Query接口更加面向对象，Criteria接口更擅长于执行动态查询。

       在Hibernate.cfg.xml中既可以配置JDBC，也可以配置JNDI。在本小节中讲述数据源如何配置。

hibernate.cfg.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>

<session-factory>

<!-- 各属性的配置-->

<!—为true表示将Hibernate发送给数据库的sql显示出来 -->

<property name="show_sql">true</property>

<!-- SQL方言，这边设定的是MySQL -->

<property name="dialect">net.sf.hibernate.dialect.MySQLDialect</property>

<!-- 一次读的数据库记录数 -->

<property name="jdbc.fetch_size">50</property>

<!-- 设定对数据库进行批量删除 -->
        <property name="jdbc.batch_size">30</property>

<!—下面为JNDI的配置 -->

<!-- 数据源的名称 -->

<property name="connection.datasource">java:comp/env/jdbc/datasourcename</property>

<!-- Hibernate的连接加载类 -->

<property name="connection.provider_class">net.sf.hibernate.connection.DatasourceConnectionProvider</property>

<property name="dialect">net.sf.hibernate.dialect.SQLServerDialect</property>

<!—映射文件 -->

<mapping resource="com/amigo/pojo/User.hbm.xml"/>

<mapping resource="com/amigo/pojo/Org.hbm.xml"/>
    </session-factory>
</hibernate-configuration>

2. c3p0连接池

       c3p0连接池是Hibernate推荐使用的连接池，若需要使用该连接池时，需要将c3p0的jar包加入到classpath中。c3p0连接池的配置示例如下：

hibernate.cfg.xml

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE hibernate-configuration PUBLIC

"-//Hibernate/Hibernate Configuration DTD 3.0//EN"

"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>

<session-factory>

        <!-- 显示实际操作数据库时的SQL -->

        <property name="show_sql">true</property>

        <!-- SQL方言，这边设定的是MySQL -->

        <property name="dialect">net.sf.hibernate.dialect.MySQLDialect</property>

        <!--驱动程序，在后续的章节中将讲述mysql、sqlserver和Oracle数据库的配置 -->

        <property name="connection.driver_class">……</property>

        <!-- JDBC URL -->

        <property name="connection.url">……</property>

        <!-- 数据库用户名 -->

        <property name="connection.username">user</property>

        <!-- 数据库密码 -->

        <property name="connection.password">pass</property>

        <property name="c3p0.min_size">5</property>

        <property name="c3p0.max_size">20</property>

        <property name="c3p0.timeout">1800</property>

        <property name="c3p0.max_statements">50</property>

        <!-- 对象与数据库表格映像文件 -->

       <mapping resource="com/amigo/pojo/User.hbm.xml"/>

<mapping resource="com/amigo/pojo/Org.hbm.xml"/>

    </session-factory>

</hibernate-configuration>

在上述配置中，Hibernate根据配置文件生成连接，再交给c3p0管理。

3. proxool连接池

       proxool跟c3p0以及dbcp不一样，它是自己生成连接的，因此连接信息放在proxool配置文件中。使用它时，需要将proxool-0.8.3.jar加入到classespath中。配置举例如下：

hibernate.cfg.xml

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE hibernate-configuration PUBLIC

"-//Hibernate/Hibernate Configuration DTD 3.0//EN"

"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>

<session-factory>

        <!-- 显示实际操作数据库时的SQL -->

        <property name="show_sql">true</property>

        <!-- SQL方言，这边设定的是MySQL -->

        <property name="dialect">net.sf.hibernate.dialect.MySQLDialect</property>

<!—proxool的配置 -->

       <property name="proxool.pool_alias">pool1</property>

<property name="proxool.xml">ProxoolConf.xml</property>

<property name="connection.provider_class">net.sf.hibernate.connection.ProxoolConnectionProvider</property>

       <!-- 对象与数据库表格映像文件 -->

       <mapping resource="com/amigo/pojo/User.hbm.xml"/>

<mapping resource="com/amigo/pojo/Org.hbm.xml"/>

  </session-factory>

</hibernate-configuration>

在hibernate.cfg.xml的同目录下编写proxool的配置文件：ProxoolConf.xml，该文件的配置实例如下：

ProxoolConf.xml

<?xml version="1.0" encoding="utf-8"?>
<!-- the proxool configuration can be embedded within your own application's.
Anything outside the "proxool" tag is ignored. -->
<something-else-entirely>
<proxool>
<alias>pool1</alias>
<!--proxool只能管理由自己产生的连接-->

<!-- 驱动的url-->

<!-- jdbc:mysql://localhost:3306/dbname?useUnicode=true&characterEncoding=GBK-->

<driver-url>… </driver-url>

<!-- 驱动类，eg. com.mysql.jdbc.Driver-->

<driver-class>… </driver-class>
<driver-properties>

<!-- 数据库用户名，eg. value为root-->

<property name="user" value="…"/>

<!-- 数据库密码，eg. value为root-->

<property name="password" value="…."/>
</driver-properties>
<!-- proxool自动侦察各个连接状态的时间间隔(毫秒),侦察到空闲的连接就马上回收,超时的销毁-->
<house-keeping-sleep-time>90000</house-keeping-sleep-time>
<!-- 指因未有空闲连接可以分配而在队列中等候的最大请求数,超过这个请求数的用户连接就不会被接受-->
<maximum-new-connections>20</maximum-new-connections>
<!-- 最少保持的空闲连接数-->
<prototype-count>5</prototype-count>
<!-- 允许最大连接数,超过了这个连接，再有请求时，就排在队列中等候，最大的等待请求数由maximum-new-connections决定-->
<maximum-connection-count>100</maximum-connection-count>
<!-- 最小连接数-->
<minimum-connection-count>10</minimum-connection-count>
</proxool>
</something-else-entirely>

4. dbcp连接池

       在hibernate3.0中，已经不再支持dbcp了，hibernate的作者在hibernate.org中，明确指出在实践中发现dbcp有 BUG,在某些种情会产生很多空连接不能释放，所以抛弃了对dbcp的支持。若需要使用dbcp，开发人员还需要将commons-pool-1.2.jar 和commons-dbcp-1.2.1.jar两个jar包加入到classpath中。dbcp与c3p0一样，都是由hibernate建立连接的。

在hibernate2.0中的配置建立如下：

hibernate.cfg.xml

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE hibernate-configuration PUBLIC

"-//Hibernate/Hibernate Configuration DTD 2.0//EN"

"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>

<session-factory>

        <!-- 显示实际操作数据库时的SQL -->

        <property name="show_sql">true</property>

        <!-- SQL方言，这边设定的是MySQL -->

        <property name="dialect">net.sf.hibernate.dialect.MySQLDialect</property>

        <!--驱动程序，在后续的章节中将讲述mysql、sqlserver和Oracle数据库的配置 -->

        <property name="connection.driver_class">……</property>

        <!-- JDBC URL -->

        <property name="connection.url">……</property>

        <!-- 数据库用户名,eg. root -->

        <property name="connection.username">…</property>

        <!-- 数据库密码, eg. root-->

        <property name="connection.password">…</property>

       <property name="dbcp.maxActive">100</property>

<property name="dbcp.whenExhaustedAction">1</property>

<property name="dbcp.maxWait">60000</property>

<property name="dbcp.maxIdle">10</property>

<property name="dbcp.ps.maxActive">100</property>

<property name="dbcp.ps.whenExhaustedAction">1</property>

<property name="dbcp.ps.maxWait">60000</property>

<property name="dbcp.ps.maxIdle">10</property>

        <!-- 对象与数据库表格映像文件 -->

       <mapping resource="com/amigo/pojo/User.hbm.xml"/>

<mapping resource="com/amigo/pojo/Org.hbm.xml"/>

    </session-factory>

</hibernate-configuration>

5. MySql连接配置

在hibernate中，可以配置很多种数据库，例如MySql、Sql Server和Oracle，MySql的配置举例如下：

hibernate.cfg.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>

<session-factory>

<!-- 各属性的配置-->

<!—为true表示将Hibernate发送给数据库的sql显示出来 -->

<property name="show_sql">true</property>

<!-- SQL方言，这边设定的是MySQL -->

<property name="dialect">net.sf.hibernate.dialect.MySQLDialect</property>

<!-- 一次读的数据库记录数 -->

<property name="jdbc.fetch_size">50</property>

<!-- 设定对数据库进行批量删除 -->
        <property name="jdbc.batch_size">30</property>

<!--驱动程序-->

<property name="connection.driver_class">com.mysql.jdbc.Driver</property>

<!-- JDBC URL -->

<property name="connection.url">jdbc:mysql://localhost/dbname?characterEncoding=gb2312</property>

<!-- 数据库用户名-->

<property name="connection.username">root</property>

<!-- 数据库密码-->

<property name="connection.password">root</property>

<!—映射文件 -->

<mapping resource="com/amigo/pojo/User.hbm.xml"/>

<mapping resource="com/amigo/pojo/Org.hbm.xml"/>
    </session-factory>
</hibernate-configuration>

上面使用的驱动类是com.mysql.jdbc.Driver。需要将MySql的连接器jar包(eg. mysql-connector-java-5.0.4-bin.jar)加入到classpath中。

6. Sql Server连接配置

       本小节讲述一下Sql Server数据库的hibernate连接设置，在此只给出连接部分的内容，其余部分与2.2.1.5一样，在此不再赘述。内容如下：

<!--驱动程序-->

<property name="connection.driver_class">net.sourceforge.jtds.jdbc.Driver</property>

<!-- JDBC URL -->

<property name="connection.url">jdbc:jtds:sqlserver://localhost:1433;DatabaseName=dbname</property>

<!-- 数据库用户名-->

<property name="connection.username">sa</property>

<!-- 数据库密码-->

<property name="connection.password"></property>

上例的驱动类使用的是jtds的驱动类，因此读者需要将jtds的jar包(eg. jtds-1.2.jar)加入到classpath中。

7. Oracle连接配置

本小节讲述一下Sql Server数据库的hibernate连接设置，在此只给出连接部分的内容，其余部分与2.2.1.5一样，在此不再赘述。内容如下：

<!--驱动程序-->

<property name="connection.driver_class">oracle.jdbc.driver.OracleDriver</property>

<!-- JDBC URL -->

<property name="connection.url">jdbc:oracle:thin:@localhost:1521:dbname</property>

<!-- 数据库用户名-->

<property name="connection.username">test</property>

<!-- 数据库密码-->

<property name="connection.password">test</property>

上例使用的驱动类为：oracle.jdbc.driver.OracleDriver，开发人员需要将相关的jar包（ojdbc14.jar）加入到classpath中。

http://www.blogjava.net/amigoxie/archive/2007/12/29/171395.html

本节讲述如何使用Hibernate实现记录的增、删、改和查功能。

1 查询

       在Hibernate中使用查询时，一般使用Hql查询语句。

HQL（Hibernate Query Language），即Hibernate的查询语言跟SQL非常相像。不过HQL与SQL的最根本的区别，就是它是面向对象的。

使用HQL时需要注意以下几点：

l         大小写敏感

因为HQL是面向对象的，而对象类的名称和属性都是大小写敏感的，所以HQL是大小写敏感的。

Eg.

HQL语句：from Cat as cat where cat.id > 1;与from Cat as cat where cat.ID > 1;是不一样的，这点与SQL不同。

l         from子句

Eg. from Cat，该句返回Cat对象实例，开发人员也可以给其加上别名，eg. from Cat as cat，对于多表查询的情况，可参考如下：

from Cat as cat, Dog as dog

其它方面都与SQL类似，在此不再赘述。

接下来讲一个在Hibernate中查询的例子。

1.1简单查询

List list = session.createQuery("from User as user order by user.loginName").list();

1.2带单个参数的查询

List list = session.find("from User as user where user.loginName=?",

                                                          loginName,

                                                          Hibernate.STRING);

1.3多个参数的查询

Eg1. 此例采用“?”占位符的方式

String hql = "from User as user where user.loginName=? and user.orgId=? ";

Query query = session.createQuery(hql);

query.setParameter(1, 'amigo');

query.setParameter(2, new Long(1)) ;

List list = query .list();

Eg2. 此例采用“:paramName”的方式

String hql = "from User as user where user.loginName=:loginName and user.orgId=:orgId ";

Query query = session.createQuery(hql);

query.setParameter('loginName', 'amigo');

query.setParameter('orgId', new Long(1)) ;

List list = query .list();

1.4查询数量

int count  = (Integer) session.createQuery("select count(*) from User").uniqueResult().intValue();

1.5限制查询起始值和数量的查询

这种一般是在记录需要分页的时候需要用到，例如，在如下的代码中，限制查询的开始记录的位置为50，最大查询条数为50。

String hql = "from User as user order by user.loginName";

int firstResult= 50;

int maxResults = 50;

Query query = session.createQuery(hql);

query = query.setFirstResult(firstResult);

query.setMaxResults(maxResults);

1.6子查询

在某些情况下，也需要用到子查询，例如在下面的例子中，User为用户对象，UserRole为用户与角色关联对象。如下HQL语句将没有分配角色的用户对象查找出来。

String hql = "from User user where user.loginName"

+ " not in(select ur.user.loginName from UserRole ur) ";

List list = (session.createQuery(hql)).list();

1.7原生SQL查询

对于某些复杂的查询语句，需要调用某种特定的数据库的特定函数才能解决，Hibernate虽然不推荐使用原生SQL语句来查询，因为这将破坏数据库的易移植性，但是Hibernate中也提供了使用原生SQL进行查询的方法，只需要获得连接即可。

Eg. 在下面的例子中，用到了Sql Server数据库中的原生sql语句，如下所示：

String timeUnit = "13";

String sql = "select count(*) count, CONVERT(VARCHAR(" + timeUnit +"),  log.gen_datetime,121) timeUnit " + "from Log log";

SQLQuery query = session.createSQLQuery(sql)

.addScalar("count", Hibernate.INTEGER)

.addScalar("timeUnit", Hibernate.STRING);

List list = query.list();

2 新增

       在数据库中新增记录在Hibernate中不需要使用insert命令，只需要构造新增的对象后，调用Session对象的save(…)方法即可。

2.1新增单个对象

       新增单个对象的实例如下，该实例将在用户表中新增一条记录。

Session session = HibernateSessionFactory.getSession();

         Transaction ts = null;

try {

ts = session.beginTransaction();

                  User user = new User();

                  user.setLoginName("amigo");

                  user.setFullName("阿蜜果");

                  ……

                  session.save(user) ;

                   ts.commit();

} catch (Exception e) {

                  if (ts != null) {

ts.rollback();

}

} finally {

                   HibernateSessionFactory.closeSession();

}

2.2批量新增对象

对于批量新增对象的情况，需要在新增一部分对象后flush和clear一次，例如，没批量新增20个对象时手动的flush一次，假设在list为一个用户列表，里面包含很多User对象，那么要将实现这些对象的批量新增，可采用如下方法：

Session session = HibernateSessionFactory.getSession();

Transaction ts = null;

try {

ts = session.beginTransaction();

for (int i = 0; i < list.size(); i++) {

                            User user = (User) list.get(i);

                            session.save(user) ;

                            if (i % 20 == 0) {

         session.flush();

         session.clear();

}

                   }

                   ts.commit();

} catch (Exception e) {

                   if (ts != null) {

ts.rollback();

}

} finally {

                   HibernateSessionFactory.closeSession();

}

3 更新

       在hibernate中，更新对象前不需要使用查询语句：update…，一般需要在取得需要更新的持久化对象后，执行Session对象的update(…)方法。例如：

Session session = HibernateSessionFactory.getSession();

Transaction ts = null;

try {

ts = session.beginTransaction();

//取得持久化对象

                   User user = session.get(User.class, "amigo");

                   //对需要修改的属性进行修改

                   user.setFullName("阿蜜果");

                   ……

                   session.update(user) ;

                   ts.commit();

} catch (Exception e) {

                   if (ts != null) {

ts.rollback();

}

} finally {

                  HibernateSessionFactory.closeSession();

}

4 删除

4.1删除单个对象

       一般在取得某对象后，开发人员可以调用Session对象的delete(…)方法删除该对象。

Eg. 下面的实例中取得loginName（主键）为“amigo”的User对象后，将它删除。

Session session = HibernateSessionFactory.getSession();

Transaction ts = null;

try {

ts = session.beginTransaction();

//取得持久化对象

                   User user = session.get(User.class, "amigo");

                   session.delete(user) ;

                   ts.commit();

} catch (Exception e) {

                   if (ts != null) {

ts.rollback();

}

} finally {

                   HibernateSessionFactory.closeSession();

}

4.2批量删除对象

对于批量删除对象的情况，开发人员可以在取得待删除的对象列表后，一个一个的将对象删除，对于每个对象的删除方法，见3.4.1小节。开发人员还可以hql语句来做批量删除。

Eg. 该实例通过delete语句来删除记录，除了loginName为“amigo”的对象为，其余都删除，代码如下所示：

Session session = HibernateSessionFactory.getSession();

Transaction ts = null;

try {

ts = session.beginTransaction();

String hql = "delete User as user where user.loginName != 'amigo'";

Query query = session.createQuery(hql);

int count  = query.executeUpdate();

 ts.commit();

System.out.println("delete count : " + count); //删除条数

} catch (Exception e) {

                   if (ts != null) {

ts.rollback();

}

} finally {

                   HibernateSessionFactory.closeSession();

}

1. net.sf.hibernate.MappingException

       当出现net.sf.hibernate.MappingException: Error reading resource:…异常时一般是因为映射文件出现错误。

       当出现net.sf.hibernate.MappingException: Resource: … not found是因为XML配置文件没找到所致，有可能是放置目录不正确，或者没将其加入hibernate.cfg.xml中。

2. net.sf.hibernate.PropertyNotFoundException

       当出现net.sf.hibernate.PropertyNotFoundException: Could not find a setter for property name in class …时，原因一般是因为XML映射文件中的属性与对应的Java类中的属性的getter或setter方法不一致。

3. org.hibernate.id.IdentifierGenerationException

       当出现org.hibernate.id.IdentifierGenerationException: ids for this class must be manually assigned before calling save():异常时，一般是因为<id>元素配置不正确，<id>元素缺少其子元素<generator></generator>的配置引起。

       解决方案：<id>元素映射了相应数据库表的主键字段，对其子元素<generator class="">,其中class的取值可以为increment、identity、sequence、hilo、native……等，更多的可参考hibernate参考文档，一般取其值为native 。具体可参考2.2.2.1小节。

4. a different object with the same identifier value was already associated with the session

       当出现a different object with the same identifier value was already associated with the session时，一般是因为在hibernate中同一个session里面有了两个相同标识但是是不同实体。

       有如下几种解决方案：

（1）使用session.clean()，如果在clean操作后面又进行了saveOrUpdate(object)等改变数据状态的操作，有可能会报出"Found two representations of same collection"异常。

（2）使用session.refresh(object)，当object不是数据库中已有数据的对象的时候，不能使用session.refresh(object)因为该方法是从hibernate的session中去重新取object，如果session中没有这个对象，则会报错所以当你使用saveOrUpdate(object)之前还需要判断一下。

（3）session.merge(object)，Hibernate里面自带的方法，推荐使用。

5. SQL Grammer Exception,Could not execute JDBC batch update

       当出现SQL Grammer Exception,Could not execute JDBC batch update异常时，一般是由如下问题引起：

（1）SQL语句中存在语法错误或是传入的数据有误;

（2）数据库的配置不合法，或者说是配置有误。较容易出现的有数据表的映射文件(,hbm.xml文件)配置有误；Hibernate.cfg.xml文件配置有误;

（3） 当前的数据库用户权限不足，不能操作数据库。以是以Oracle 数据库为例，这种情况下在错误提示中会显示java.sql.BatchUpdateException: ORA-01031: insufficient privileges这样的信息。

       针对上面的各种原因，开发人员可以找出对应的解决方案。

       配置文件的基本结构如下：

<?xml version="1.0" encoding='UTF-8'?>

<!DOCTYPE hibernate-mapping PUBLIC

                            "-//Hibernate/Hibernate Mapping DTD 3.0//EN"

                            "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" >

<hibernate-mapping package="包名">

<class name="类名" table="表名">

                  <id name="主键在java类中的字段名" column="对应表中字段" type="类型 ">

                    <generator class="主键生成策略"/>

</id>

         ……

    </class>

</hibernate-mapping>

1. 主键（id）

       Hibernate的主键生成策略有如下几种：

1)  assigned

主键由外部程序负责生成，在 save() 之前指定。

2)  hilo

通过hi/lo 算法实现的主键生成机制，需要额外的数据库表或字段提供高位值来源。

3)  seqhilo

与hilo 类似，通过hi/lo 算法实现的主键生成机制，需要数据库中的 Sequence，适用于支持 Sequence 的数据库，如Oracle。

4)  increment

主键按数值顺序递增。此方式的实现机制为在当前应用实例中维持一个变量，以保存着当前的最大值，之后每次需要生成主键的时候将此值加1作为主键。这种方式可能产生的问题是：不能在集群下使用。

5)  identity

采用数据库提供的主键生成机制。如DB2、SQL Server、MySQL 中的主键生成机制。

6)  sequence

采用数据库提供的 sequence 机制生成主键。如 Oralce 中的Sequence。

7)  native

由 Hibernate 根据使用的数据库自行判断采用 identity、hilo、sequence 其中一种作为主键生成方式。

8)  uuid.hex

由 Hibernate 基于128 位 UUID 算法 生成16 进制数值（编码后以长度32 的字符串表示）作为主键。

9)  uuid.string

与uuid.hex 类似，只是生成的主键未进行编码（长度16），不能应用在 PostgreSQL 数据库中。

10) foreign

使用另外一个相关联的对象的标识符作为主键。

主键配置举例如下：

<id name="id" column="id" type="java.lang.Integer">

             <generator class="native"/>

</id>

另外还可以扩展Hibernate的类来做自己的主键生成策略，具体例子见：http://www.javaeye.com/topic/93391。

2. 普通属性（property）

       开发人员可以打开网址：http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd

来查看hibernate3.0的dtd信息，可看到property的定义如下：

<!ELEMENT property (meta*,(column|formula)*,type?)>

                    <!ATTLIST property name CDATA #REQUIRED>

                    <!ATTLIST property node CDATA #IMPLIED>

                    <!ATTLIST property access CDATA #IMPLIED>

                    <!ATTLIST property type CDATA #IMPLIED>

                    <!ATTLIST property column CDATA #IMPLIED>

                    <!ATTLIST property length CDATA #IMPLIED>

                    <!ATTLIST property precision CDATA #IMPLIED>

                    <!ATTLIST property scale CDATA #IMPLIED>

                    <!ATTLIST property not-null (true|false) #IMPLIED>

                    <!ATTLIST property unique (true|false) "false">

                    <!ATTLIST property unique-key CDATA #IMPLIED>

                    <!ATTLIST property index CDATA #IMPLIED>                                                                                  <!-- include the columns spanned by this property in an index -->

                    <!ATTLIST property update (true|false) #IMPLIED>

                    <!ATTLIST property insert (true|false) #IMPLIED>

                    <!ATTLIST property optimistic-lock (true|false) "true">          <!-- only supported for properties of a class (not component) -->

                    <!ATTLIST property formula CDATA #IMPLIED>

                    <!ATTLIST property lazy (true|false) "false">

    <!ATTLIST property generated (never|insert|always) "never">

       它的各属性中比较常用的有：name（对应的java类的属性名称）、column（对应的表中的字段）、tyope（属性的类型，eg.java.lang.String）、not-null（设置该属性是否为空，为true时表示非空，默认为false）和length(字段的长度限制)。

         Eg1. <property name="accessname" column="accessName" type="java.lang.String" not-null="true" />

         Eg2. <property name="state" column="state" type="java.lang.Byte" not-null="true" />

Eg3. <property name="description" column="description" type="java.lang.String" />

3. 一对多关系（<many-to-one…/>和<set…></set>）

       一对多关系一般是用在一个表与另一个表存在外键关联的时候，例如用户表的组织id与组织表存在外键关联，则“一”方为组织表，“多”方为用户表，因为一个组织可以包含多个用户，而一个用户只能隶属于一个组织。

对于存在一对多关系和多对一关系的双方，需要在…hbm.xml中进行相应配置，这时在“一”方（例如：组织）需要在映射文件中添加<set…></set>元素，因为它包含多个“多”方的对象，一般的格式如下：

<set name="java映射类中对应的属性" inverse="true" lazy="true">

<key column="表中对应字段"/>

              <one-to-many class="多方的类"/>

</set>

       Eg.

<set name="userSet" inverse="true" lazy="true">

                  <key column="orgId"/>

<one-to-many class="User"/>

</set>

“多”方（例如：用户）隶属于一个“一”方对象，一般的格式如下：

<many-to-one name="java映射类中对应的属性" column="表中对应字段" class="类名" not-null="true" />

Eg.

<many-to-one name="org" column="orgId" class="Organization" not-null="true" />

4. 一对一关系（<one-to-one…/>）

一对一关系相对一对多关系来说比较少见，但也在某些情况下要用到，例如有一个用户的基本信息表（USER）和一个用户的密码表（PASSWD）就存在一对一的关系。下面来看一下一对一关系在Hibernate的配置。

其中主表（eg. 用户的基本信息表）的配置如下：

<one-to-one name="主表对象中子表对象的属性名" class="子表对象的类名" cascade="save-update"/>

Eg. <one-to-one name="password" class="com.amigo.dao.pojo.Passwd" cascade="save-update"/>

子表（eg. 用户的密码表）的配置如下：

<one-to-one name="子表对象中主表对象的属性名" class="主表对象的类名" constrained="true" />

Eg. <one-to-one name="user" class="com.amigo.dao.pojo.User " constrained="true" />

5. 多对多关系（<many-to-many…/>）

在数据库设计时，一般将多对多关系转换为两个一对多（或多对一）关系，例如在基于角色的权限系统中，用户和角色存在的关系就是典型的多对多关系，即一个用户可以具有多个角色，而一个角色又可以为多个用户所有，一般在设计时，都会加一个用户与角色的关联表，该表与用户表以及角色表都存在外键关联。

在本小节中讲述的是没有分解的多对多关系在Hibernate中如何配置。设置格式如下：

<set name="java对象的属性名" table="表名" cascade="all" outer-join="false">  

<key column="表的对应字段"/>  

<many-to-many class="另一个表的对象类" column="另一个表的字段"/>  

</set>  

Eg. 上述的多对多关系可以表示为：

t_user方：

<set name="roleSet" table="t_user" cascade="all" outer-join="false">  

<key column="roleId"/>  

<many-to-many class="com.amigo.dao.pojo.Role" column="roleId"/>  

</set>  

t_role方：

<set name="userSet" table="t_role" cascade="all" outer-join="false">  

<key column="roleId"/>  

<many-to-many class="com.amigo.dao.pojo.User" column="roleId"/>  

</set>

6. 完整实例

在本小节中举一些.hbm.xml映射文件的例子，让开发人员对其有一个感性的认识。接下来讲述一个用户表（tbl_user）、用户与角色关联表（tbl_user_role）、角色表（tbl_role）以及组织表（tbl_organization）的例子。

（1）tbl_user

<?xml version="1.0" encoding='UTF-8'?>

<!DOCTYPE hibernate-mapping PUBLIC

                            "-//Hibernate/Hibernate Mapping DTD 3.0//EN"

                            "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" >

<hibernate-mapping package="com.amigo.dao.pojo">

    <class name="User" table="tbl_user">

        <id name="loginname" column="loginName" type="java.lang.String">

            <generator class="assigned"/>

        </id>

        <property name="name" column="name" type="java.lang.String" not-null="true" />

        <property name="password" column="password" type="java.lang.String" not-null="true" />

        <property name="mobile" column="mobile" type="java.lang.String" />

        <property name="telephone" column="telephone" type="java.lang.String" />

        <property name="email" column="email" type="java.lang.String" />

        <property name="createtime" column="createTime" type="java.util.Date" not-null="true" />

        <property name="lastlogintime" column="lastLoginTime" type="java.util.Date" />

        <property name="logintimes" column="loginTimes" type="java.lang.Long" not-null="true" />

        <property name="state" column="state" type="java.lang.Byte" not-null="true" />

        <property name="description" column="description" type="java.lang.String" />

        <many-to-one name="organization" column="orgId" class="Organization" not-null="true" />

        <set name="userRoleSet" inverse="true" cascade="all-delete-orphan" lazy="true">

            <key column="loginName"/>

            <one-to-many class="UserRole"/>

        </set>

</hibernate-mapping>

（2）tbl_organization

<?xml version="1.0" encoding='UTF-8'?>

<!DOCTYPE hibernate-mapping PUBLIC

                            "-//Hibernate/Hibernate Mapping DTD 3.0//EN"

                            "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" >

<hibernate-mapping package="com.amigo.dao.pojo">

    <class name="Organization" table="tbl_organization">

        <id name="orgid" column="orgId" type="java.lang.Long">

            <generator class="native"/>

        </id>

        <property name="parentorgid" column="parentOrgId" type="java.lang.Long" not-null="true" />

        <property name="orgname" column="orgName" type="java.lang.String" not-null="true" />

        <property name="orgfullname" column="orgFullName" type="java.lang.String" />

        <property name="orglevel" column="orgLevel" type="java.lang.Integer" not-null="true" />

        <property name="state" column="state" type="java.lang.Byte" not-null="true" />

        <property name="description" column="description" type="java.lang.String" />

        <property name="creator" column="creator" type="java.lang.String" />

        <property name="createtime" column="createTime" type="java.util.Date" />

        <set name="userSet" inverse="true" lazy="true">

            <key column="orgId"/>

            <one-to-many class="User"/>

        </set>

    </class>

</hibernate-mapping>

（3）tbl_user_role

<?xml version="1.0" encoding='UTF-8'?>

<!DOCTYPE hibernate-mapping PUBLIC

                            "-//Hibernate/Hibernate Mapping DTD 3.0//EN"

                            "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" >

<hibernate-mapping package="com.cotel.netvote.dao.model">

    <class name="UserRole" table="tbl_user_role">

        <id name="urid" column="urId" type="java.lang.Integer">

            <generator class="native"/>

        </id>

        <many-to-one name="role" column="roleId" class="Role" not-null="true" />

        <many-to-one name="user" column="loginName" class="User" not-null="true" />

    </class>

</hibernate-mapping>

（4）tbl_ role

<?xml version="1.0" encoding='UTF-8'?>

<!DOCTYPE hibernate-mapping PUBLIC

                            "-//Hibernate/Hibernate Mapping DTD 3.0//EN"

                            "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" >

<hibernate-mapping package="com.cotel.netvote.dao.model">

    <class name="Role" table="tbl_role">

        <id name="roleid" column="roleId" type="java.lang.Integer">

            <generator class="native"/>

        </id>

        <property name="rolename" column="roleName" type="java.lang.String" not-null="true" />

        <property name="createdate" column="createDate" type="java.util.Date" not-null="true" />

        <property name="description" column="description" type="java.lang.String" />

        <set name="userRoleSet" inverse="true" lazy="true" cascade="all">

            <key column="roleId"/>

            <one-to-many class="UserRole"/>

        </set>

    </class>

</hibernate-mapping>