我们要为查询限定条件，可以通过net.sf.hibernate.expression.Expression设置Expression有很多的条件查询方法下面举一些例子：

ge（）表示大于等于，即age大于等于25的user。

between表示weight在60和80之间。

crit.add(Expression.or(
                   Expression.eq("age", new Integer(20)),
                   Expression.isNull("age")
               ));
List users = crit.list();

eq表示age为20的user。

setMaxResult（）设置返回的信息条数，setFirstResult（）设置查询结果的初始位置，上面的程序段可以实现分页。

在hibernate的Session里面使用createCriteria可以创建一个Criteria实例帮助我们进行条件查询，不用自己串hql语句，很方便。
用法很简单，首先传Class实例创建Criteria，Class实例对应你想要查询的那个实体:

然后调用Criteria的add方法加入条件（Restrictions）。常用的条件有：
 
方法说明： Restrictions.eq 等于 
                     Restrictions.allEq 使用Map，使用key/value进行多个等于的对比
                     Restrictions.gt 大于 >
                     Restrictions.ge 大于等于 >=
                     Restrictions.lt 小于 <
                    Restrictions.le 小于等于 <=
                    Restrictions.between 对应SQL的BETWEEN子句
                    Restrictions.like 对应SQL的LIKE子句
                    Restrictions.in 对应SQL的in子句
                    Restrictions.and   and关系
                     Restrictions.or   or关系
                   Restrictions.sqlRestriction    SQL限定查詢 


例如，我想返回Person实体里面年龄(age)大于20的记录，那么就为Criteria加入Restrictions.gt条件：

 
Restrictions.and和Restrictions.or很有用，表示and查询还是or查询，例如我要查询Person实体里面年龄(age)大于20，或者性别 (sex)为man
的记录，那么就为Criteria加入:

如果需要关联查询的话，可以使用Criteria的createCriteria方法创建一个Criteria，例如部门(Department)和人员(Person)是一对多的关系，我要查询Person实体里面年龄(age)大于20，性别 (sex)为man，
备注包含应届生，
且所在部门(department)是开发部的记录:

 
其他条件的用法也很简单，就不列举了。
 
另外，Hibernate3出了一个org.hibernate.criterion.DetachedCriteria，即离线Criteria，它允许你可以先创建DetachedCriteria，然后传到Session里面才真正返回一个Criteria，用法如下：

 
 
最后，需要注意，Criteria还提供了setFirstResult和setMaxResults方法进行分页查询。
 

从一个最基本的对象关系映像自动化程序，了解Hibernate组成的基本元素，并进一步了解Hibernate的基础语义、配置等概念。

1．O/R映像入门第一个Hibernate程序很简单，将一个对象映像至一个数据表

1．1配置Hibernate
Hibernate是ORM的解决方案，其底层对数据库的操作依赖于JDBC，所以您必须先取得JDBC驱动程序，在这边所使用的是MySQL，所以您必须至MySQL®Connector/J取得MySQL的JDBC驱动程序。

接下来至Hibernate官方网站取得hibernate 3.0。

解开zip档案后，当中的hibernate3.jar是必要的，而在lib目录中还包括了许多jar档案，您可以在Hibernate 3.0官方的参考手册上找到这些jar的相关说明，其中必要的是antlr、dom4j、CGLIB、asm、Commons Collections、Commons Logging、 EHCache，Hibernate底层还需要Java Transaction API，所以您还需要jta.jar，到这边为止，总共需要以下的jar档案：

Hibernate可以运行于单机之上，也可以运行于Web应用程序之中，如果是运行于单机，则将所有用到的jar档案（包括JDBC驱动程序）设定至CLASSPATH中，如果是运行于Web应用程序中，则将jar档案置放于WEB-INF/lib中。

如果您还需要额外的Library，再依需求加入，例如JUnit、Proxool等等，接下来可以将etc目录下的log4j.properties复制至Hibernate项目的Classpath下，并修改一下当中的log4j.logger.org.hibernate为error，也就是只在错误发生时显示必要的讯息。

接着设置基本的Hibernate配置文件，可以使用XML或Properties档案，这边先使用XML，档名预设为hibernate.cfg.xml：

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">org.hibernate.dialect.MySQLDialect</property>

            <!-- JDBC 驱动程序 -->

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

            <!-- JDBC URL -->

            <property name="connection.url">jdbc:mysql://localhost/demo</property>

            <!-- 数据库使用者 -->

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

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

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

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

            </session-factory>

            </hibernate-configuration>
            

配置文件中已经加上批注为每一个项目作了说明，其中对象与数据库表格映像文件还有待加入。

1．2第一个Hibernate
这边以一个简单的单机程序来示范Hibernate的配置与功能，首先作数据库的准备工作，在MySQL中新增一个demo数据库，并建立user表格：

CreateUser2MySQL.sql

            
CREATE TABLE user (

            id INT(11) NOT NULL auto_increment PRIMARY KEY,

            name VARCHAR(100) NOT NULL default '',

            age INT

            );
            

对于这个表格，您有一个User类别与之对应，表格中的每一个字段将对应至User实例上的Field成员。

User.java

            
package onlyfun.caterpillar;

            public class User {

            private Integer id;

            private String name;

            private Integer age;

            // 必须要有一个预设的建构方法

            // 以使得Hibernate 可以使用Constructor.newInstance()建立对象

            public User() {

            }

            public Integer getId() {

            return id;

            }

            public void setId(Integer id) {

            this.id = id;

            }

            public String getName() {

            return name;

            }

            public void setName(String name) {

            this.name = name;

            }

            public Integer getAge() {

            return age;

            }

            public void setAge(Integer age) {

            this.age = age;

            }

            }
            

其中id是个特殊的属性，Hibernate会使用它来作为主键识别，您可以定义主键产生的方式，这是在XML映像文件中完成，为了告诉Hibernate您所定义的User实例如何映像至数据库表格，您撰写一个XML映射文件档名是User.hbm.xml，如下所示：

User.hbm.xml

            
<?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>

            <class name="onlyfun.caterpillar.User" table="user">

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

            <generator class="native" />

            </id>

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

            <property name="age" column="age" type="java.lang.Integer" />

            </class>

            </hibernate-mapping>
            

<class>卷标的name属性为所映像的对象，而table为所映像的表格；<id>中column属性指定了表格字段，而type属性指定了User实例的中的id之型态，这边type中所设定的是直接指定Java中的对象型态，Hibernate也定义有自己的映像型态，作为Java对象与SQL型态的标准对应型态（因为语言所提供的类型并不一定与数据库的类型对应），这之后会再说明。

#p#

<id>中主键的产生方式在这边设定为"native"，表示主键的生成方式由Hibernate根据数据库Dialect的定义来决定，之后还会介绍其它主键的生成方式。

同样的，<property>标签中的column与type都各自指明了表格中字段与对象中属性的对应。

接着必须在Hibernate配置文件hibernate.cfg.xml中指明映像文件的位置，如下加入映像文件位置：

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-factor>

            ....

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

            <mapping resource="onlyfun/caterpillar/User.hbm.xml"/>

            </session-factory>

            </hibernate-configuration>
            

接下来撰写一个测试的程序，这个程序直接以Java 程序设计人员熟悉的语法方式来操作对象，而实际上也直接完成对数据库的操作，程序将会将一笔数据存入表格之中：

FirstHibernate.java

            
package onlyfun.caterpillar;

            import org.hibernate.Session;

            import org.hibernate.SessionFactory;

            import org.hibernate.Transaction;

            import org.hibernate.cfg.Configuration;

            public class FirstHibernate {

            public static void main(String[] args) {

            // Configuration 负责管理 Hibernate 配置讯息

            Configuration config = new Configuration().configure();

            // 根据 config 建立 SessionFactory

            // SessionFactory 将用于建立 Session

            SessionFactory sessionFactory = config.buildSessionFactory();

            //将持久化的物件

            User user = new User();

            user.setName("caterpillar");

            user.setAge(new Integer(30));

            //开启Session，相当于开启JDBC 的Connection

            Session session = sessionFactory.openSession();

            //Transaction 表示一组对DB 的交易

            Transaction tx = session.beginTransaction();

            //将对象映像至数据库表格中储存

            session.save(user);

            tx.commit();

            session.close();

            sessionFactory.close();

            System.out.println("新增资料OK!请先用MySQL 观看结果！");

            }

            }
            

如您所看到的，程序中只需要直接操作User 对象，并进行Session 与Transaction 的相关操作，Hibernate 就会自动完成对数据库的操作，您看不到任何一行JDBC 或SQL 的陈述，撰写好以上的各个档案之后，各档案的放置位置如下：

接着可以开始运行程序，结果如下：

FirstHibernate执行结果

            
Hibernate: insert into user (name, age) values (?, ?)
            

新增资料OK!请先用MySQL 观看结果！

执行结果中显示了Hibernate 所实际使用的SQL，由于这个程序还没有查询功能，所以要
进入MySQL 中看看新增的数据，如下：

MySQL 中查询结果

            
mysql> select * from user;

            +----+-------------+------+

            | id | name | age |

            +----+-------------+------+

            | 1 | caterpillar | 30 |

            +----+-------------+------+

            1 row in set (0.03 sec)
            

Comments

第四段代码的标题应该是hibernate.cfg.xml

1．3 第二个 Hibernate
在 第一个 Hibernate 中介绍如何使用Hibernate 在不使用SQL 的情况下，以Java 中操作对象的习惯来插入数据至数据库中，当然储存数据之后，更重要的是如何将资料读出，Hibernate 中也可以让您不写一句SQL，而以Java 中操作对象的习惯来查询数据。

直接来看个范例：

SecondHibernate.java

            
package onlyfun.caterpillar;

            import org.hibernate.Criteria;

            import org.hibernate.Session;

            import org.hibernate.SessionFactory;

            import org.hibernate.cfg.Configuration;

            import org.hibernate.criterion.Expression;

            import java.util.Iterator;

            import java.util.List;

            public class SecondHibernate {

            public static void main(String[] args) {

            Configuration config = new Configuration().configure();

            SessionFactory sessionFactory = config.buildSessionFactory();

            Session session = sessionFactory.openSession();

            Criteria criteria = session.createCriteria(User.class);

            // 查询user 所有字段

            List users = criteria.list();

            Iterator iterator = users.iterator();

            System.out.println("id \t name/age");

            while (iterator.hasNext()) {

            User user = (User) iterator.next();

            System.out.println(user.getId() + " \t " + user.getName() + "/" +

            user.getAge());

            }

            // 查询user 中符合条件的字段

            criteria.add(Expression.eq("name", "caterpillar"));

            users = criteria.list();

            iterator = users.iterator();

            System.out.println("id \t name/age");

            while (iterator.hasNext()) {

            User user = (User) iterator.next();

            System.out.println(user.getId() + " \t " + user.getName() + "/" +

            user.getAge());

            }

            session.close();

            sessionFactory.close();

            }

            }
            

#p#

Criteria 对SQL 进行封装，对于不甚了解SQL 的开发人员来说，使用Criteria 也可以轻易的进行各种数据的检索，您也可以使用 Expression 设定查询条件，并将之加入Criteria中对查询结果作限制，Expression.eq()表示设定符合条件的查询，例如Expression.eq("name", "caterpillar")表示设定查询条件为"name"字段中为"caterpillar"的数据。

先来看一下执行结果：
SecondHibernate 执行结果

            
Hibernate: select this_.id as id0_, this_.name as name0_0_, 
            
this_.age as age0_0_ from user 
            
this_id

            id name/age

            1 caterpillar/30

            3 bush/5

            2 momor/26

            Hibernate: select this_.id as id0_, this_.name as name0_0_, 
            
this_.age as age0_0_ from user 
            
this_

            where this_.name=?

            id name/age

            1 caterpillar/30
            

Criteria 是对象导向式的查询方式，让不了解SQL 的开发人员也可以轻易进行各项查询，但Criteria 的API 目前还不是很完善，而Hibernate 鼓励的查询方式，是透过HQL（Hibernate Query Language）来进行，直接来看个实例：

SecondHibernateUsingHQ.java

            
package onlyfun.caterpillar;

            import org.hibernate.Query;

            import org.hibernate.Session;

            import org.hibernate.SessionFactory;

            import org.hibernate.cfg.Configuration;

            import java.util.Iterator;

            import java.util.List;

            public class SecondHibernateUsingHQ {

            public static void main(String[] args) {

            Configuration config = new Configuration().configure();

            SessionFactory sessionFactory = config.buildSessionFactory();

            Session session = sessionFactory.openSession();

            // 使用HQL 建立查询

            Query query = session.createQuery("from User");

            List users = query.list();

            Iterator iterator = users.iterator();

            System.out.println("id \t name/age");

            while (iterator.hasNext()) {

            User user = (User) iterator.next();

            System.out.println(user.getId() + " \t " + user.getName() + "/" +

            user.getAge());

            }

            System.out.println();

            // 使用HQL 建立查询

            query = session.createQuery("from User user where user.name like ?");

            // 设定查询参数

            query.setParameter(0, "caterpillar");

            users = query.list();

            iterator = users.iterator();

            System.out.println("id \t name/age");

            while (iterator.hasNext()) {

            User user = (User) iterator.next();

            System.out.println(user.getId() + " \t " + user.getName() + "/" +

            user.getAge());

            }

            session.close();

            sessionFactory.close();

            }

            }
            

执行结果：

SecondHibernateUsingHQ 执行结果

            
Hibernate: select this_.id as id0_, this_.name as name0_0_, 
            
  this_.age as age0_0_ from user 
            
this_id

            id name/age

            1 caterpillar/30

            3 bush/5

            2 momor/26

            Hibernate: select this_.id as id0_, this_.name as name0_0_,  
            
  this_.age as age0_0_ from user 
            
this_

            where this_.name=?

            id name/age

            1 caterpillar/30
            

透过Query 接口，您可以先设定查询参数，之后透过setXXX()等方法，将指定的参数值填入，而不用每次都撰写完整的HQL，Query 的setParameter()方法第一个参数是指定?出现的位置，从 0 开始，第二个参数则是设定查询条件。

#p#

二、简单的Hibernate 程序

这边以一个简单的单机程序来示范Hibernate的配置与功能，在这个例子中的一些操作，实际上会使用一些自动化工具来完成，而不一定亲自手动操作设定，这边完全手动的原因，在于让您可以知道Hibernate实际上会作那些动作，在进行范例之前，请先确定前一个主题中的相关jar档案都已经设定在CLASSPATH中。
　
我们先作数据库的准备工作，在MySQL中新增一个HibernateTest数据库，并建立USER表格：

            
CREATE TABLE USER (

                user_id CHAR(32) NOT NULL PRIMARY KEY,

                name VARCHAR(16) NOT NULL,

                sex CHAR(1),

                age INT

            );
            

我们先撰写一个纯Java对象，它纯綷表示一个数据集合，待会我们会将之映像至数据库的表格上，程序如下：

User.java

            
package onlyfun.caterpillar;

             public class User {

                private String id;

                private String name;

                private char sex;

                private int age;

                public int getAge() {

                    return age;

                }

                public String getId() {

                    return id;

                }

                public String getName() {

                    return name;

                }

                public char getSex() {

                    return sex;

                }

                public void setAge(int i) {

                    age = i;

                }

                public void setId(String string) {

                    id = string;

                }

                public void setName(String string) {

                    name = string;

                }

                public void setSex(char c) {

                    sex = c;

                }

            }
            

其中id是个特殊的属性，Hibernate会使用它来作为主键识别，我们可以定义主键产生的方式，这是在XML映像文件中完成，为了告诉Hibernate对象如何映像至数据库表格，我们撰写一个XML映射文件档名是User.hbm.xml，如下所示：

User.hbm.xml

            
<?xml version="1.0"?>

            <!DOCTYPE hibernate-mapping

                PUBLIC "-//Hibernate/Hibernate Mapping DTD//EN"

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

            <hibernate-mapping>

                <class name="onlyfun.caterpillar.User" table="USER">

                    <id name="id" type="string" unsaved-value="null">

                        <column name="user_id" sql-type="char(32)" />

                        <generator class="uuid.hex"/>

                    </id>

                    <property name="name" type="string" not-null="true">

                        <column name="name" length="16" not-null="true"/>

                    </property>

                    <property name="sex" type="char"/>

                    <property name="age" type="int"/>

                </class>

            </hibernate-mapping>
            

这个XML文件定义了对象属性映像至数据库表格的关系，您可以很简单的了解对映的方法，像是User对象对应至USER表格，其中我们使用 uuid.hex来定义主键的产生算法，UUID算法使用IP地址、JVM的启动时间、系统时间和一个计数值来产生主键。除了使用uuid.hex之外，我们还可以使用其它的方式来产生主键，像是increment等，这可以在Hibernate参考手册中找到相关资料。

<property>卷标用于定义Java对象的属性，而当中的<column/>卷标用于定义与数据库的对应，如果您是手工建立Java对象与数据库表格，则在最简单的情况下，可以只定义<property name="sex"/>这样的方式，而由Hibernate自动判断Java对象属性与数据库表格名称对应关系，在< property/>与<column/>标签上的额外设定（像是not null、sql-type等），则可以用于自动产生Java对象与数据库表格的工具上。

接下来我们定义Hibernate配置文件，主要是进行SessionFactory配置，Hibernate可以使用XML或属性文件来进行配置，我 们这边先介绍如何使用XML配置，这也是Hibernate所建议的配置方式，我们的文件名是hibernate.cfg.xml，如下：

hibernate.cfg.xml

            
<?xml version='1.0' encoding='big5'?>

            <!DOCTYPE hibernate-configuration

                PUBLIC "-//Hibernate/Hibernate Configuration DTD//EN"

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

            <hibernate-configuration>

                <session-factory>

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

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

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

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

                    <!-- JDBC驱动程序 -->

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

                    <!-- JDBC URL -->

                    <property name="connection.url">jdbc:mysql://localhost/HibernateTest</property>

                    <!-- 数据库使用者 -->

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

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

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

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

                    <mapping resource="User.hbm.xml"/>

                </session-factory>

            </hibernate-configuration>
            

接下来我们撰写一个测试的程序，这个程序将直接以Java程序设计人员熟悉的语法方式来操作对象，而实际上也直接完成对数据库的操作，程序将会将一笔数据存入表格之中：

HibernateTest.java

            
import onlyfun.caterpillar.*;

            import net.sf.hibernate.*;

            import net.sf.hibernate.cfg.*;

            public class HibernateTest {

                public static void main(String[] args) throws HibernateException {

                    SessionFactory sessionFactory = 

                      new Configuration().configure().buildSessionFactory();

                    User user = new User();

                    user.setName("caterpillar");

                    user.setSex('M');

                    user.setAge(28);

                    Session session = sessionFactory.openSession();

                    Transaction tx= session.beginTransaction();

                    session.save(user);

                    tx.commit();

                    session.close();

                    sessionFactory.close();          

                    System.out.println("新增资料OK!请先用MySQL观看结果！");

                }

            }
            

#p#

Configuration代表了Java对象至数据库的映像设定，这个设定是从我们上面的XML而来，接下来我们从Configuration取得SessionFactory对象，并由它来开启一个Session，它代表对象与表格的一次会话操作，而 Transaction则表示一组会话操作，我们只需要直接操作User对象，并进行Session与Transaction的相关操作， Hibernate就会自动完成对数据库的操作。这边对程序先只作简单的介绍，之后再详加说明。

将所有的.java档案编译，并将两个XML档案放置在与HibernateTest相同的目录中，也就是档案位置如下：

            
/

            |--HibernateTest.class

            |--User.hbm.xml

            |--hibernate.cfg.xml

                /onlyfun

                    /caterpillar

                    |--User.class
            

OK!现在您可以执行HibernateTest，程序将会出现以下的讯息：

            
log4j:WARN No appenders could be found for logger (net.sf.hibernate.cfg.Environment).

            log4j:WARN Please initialize the log4j system properly.

            Hibernate: insert into USER (name, sex, age, user_id) values (?, ?, ?, ?)
            

新增资料OK!请先用MySQL观看结果！

这边只先进行数据的存入，要观看数据存入的结果的话，请进入MySQL观看，以下是数据库存入的结果：

            
mysql> SELECT * FROM USER;

            +----------------------------------+-------------+------+------+

            | user_id                          | name        | sex  | age  |

            +----------------------------------+-------------+------+------+

            | 297e3dbdfea6023d00fea60241000001 | caterpillar | M    |   28 |

            +----------------------------------+-------------+------+------+

            1 rows in set (0.00 sec) 
            

<? 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 >

         <!--  Database connection settings  -->
         < property name = " connection.driver_class " > com.mysql.jdbc.Driver </ property >
         < property name = " connection.url " > jdbc:mysql: // localhost:3306/eg</property>
         < property name = " connection.username " > root </ property >
         < property name = " connection.password " > 4864452 </ property >

         <!--  JDBC connection pool (use the built - in)  -->
         < property name = " connection.pool_size " > 1 </ property >

         <!--  SQL dialect  -->
         < property name = " dialect " > org.hibernate.dialect.MySQLInnoDBDialect </ property >

         <!--  Enable Hibernate ' s automatic session context management -->
         < property name = " current_session_context_class " > thread </ property >

         <!--  Disable the second - level cache   -->
         < property name = " cache.provider_class " > org.hibernate.cache.NoCacheProvider </ property >

         <!--  Echo all executed SQL to stdout  -->
         < property name = " show_sql " > true </ property >

         <!--  Drop and re - create the database schema on startup 
         < property name = " hbm2ddl.auto " > create </ property >
          -->
    
         < mapping resource = " eg/Message.hbm.xml " />
        
        
     </ session - factory >

</ hibernate - configuration >

2、源文件：

package  eg;

public   class  Message  {
     private  Long id;
     private  String text;
             
     private  Message nextMessage;

     public  Message()  {}
     public  Message(String text) {
         this .text = text;
    }
    
     public   void  setId(Long id)  {
         this .id  =  id; 
    }

     public   void  setText(String text)  {
         this .text  =  text; 
    }

     public   void  setNextMessage(Message nextMessage)  {
         this .nextMessage  =  nextMessage; 
    }
        public  Long getId()  {
         return  ( this .id); 
    }
        public  String getText()  {
         return  ( this .text); 
    }
        public  Message getNextMessage()  {
         return  ( this .nextMessage); 
    }  
}

3、配置文件：Messsage.hbm.xml

<? 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 >
     < class
        name =" eg.Message "
        table = " MESSAGE "
     >

         < id
            name = " id "
            column = " MESSAGE_ID "
            type = " java.lang.Long "
         >
             < generator  class = " native " />
                         
         </ id >
         < property
            name = " text "
            type = " java.lang.String "
            update = " true "
            insert = " true "
            column = " MESSAGE_TEXT "
         />

         < many - to - one
            name = " nextMessage "
             class = " jmuse.eg.Message "
            cascade = " all "
            outer - join = " auto "
            update = " true "
            insert = " true "
            column = " NEXT_MESSAGE_ID "
         />

       </ class >

</ hibernate - mapping >

4、最后的包结构：

+ lib 
     antlr.jar 
     cglib.jar 
     asm.jar 
     asm - attrs.jars 
     commons - collections.jar 
     commons - logging.jar 
     hibernate3.jar 
     jta.jar 
     dom4j.jar 
     log4j.jar 
＋src 
     + eg
       Message.java
       Message.hbm.xml
       TestMessage.java
     hibernate.cfg.ml
     log4j.properties

5、测试：

 session.beginTransaction();
        Message m = new  Message( " hello,world " );
        session.save(m);
        session.getTransaction().commit();
        session.close();

 你会发现在数据库中有一条信息了，id=1
Hibernate的对象识别是通过对象的Id 来识别的：
如：

我们刚才在数据库中保存了一个Id为1的Message对象。
如果：
session.beginTraction();
Message m = new  Message();
m.setId( new  Long( 1 ));
m.setText( " This is another greeting " );
session.saveOrUpdate(m);
sesion.getTraction.commit();

Hibernate有很多值得学习的地方,这里我们简单介绍一个Hibernate，重点介绍Hibernate部署，希望读者看后受益匪浅。

一. 什么是hibernate？

答：Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序使用，也可以在Servlet/JSP的Web应用中使用，最具革命意义的是，Hibernate可以在应用EJB的J2EE架构中取代CMP，完成数据持久化的重任。

二. 快速构建。

在此先要说明一下。由于本人懒惰，记不住hibernate的配置选项，所以，此系列的实例都是使用myeclipse进行快速开发。各位对myeclipse不齿的，就请见谅。然后，数据库都是mysql。
下面开始利用hibernate进行数据库的访问。
需求：实现对用户的增、删、改、查。为了方便，用户就2个属性 用户ID和用户名。实体模型如下：



建立工程:HibernateQuickUse，并且建立包。如下：



根据实体，创建类User，代码如下：

 
        
        

            
package org.py.hib.quickstart;  
            
 
            
/**  
            
 * User entity.  
            
 * @author MyEclipse Persistence Tools  
            
 */  
            
 
            
@SuppressWarnings("serial")  
            
public class User implements java.io.Serializable  
            
{  
            
 private String id;  
            
 private String name;  
            
 
            
 public User()  
            
 {  
            
 }  
            
 
            
 public String getId()  
            
 {  
            
  return this.id;  
            
 }  
            
 
            
 public void setId(String id)  
            
 {  
            
  this.id = id;  
            
 }  
            
 
            
 public String getName()  
            
 {  
            
  return this.name;  
            
 }  
            
 
            
 public void setName(String name)  
            
 {  
            
  this.name = name;  
            
 }  
            
}  
        
        
        

根据hibernate实体，创建数据表。sql如下：

        

            
use HibernateQuickUse;  
            
drop table if exists User;  
            
 
            
create table user (  
            
 id varchar(32) primary key,  
            
 name varchar(32)  
            
);  
        
        

这里的id，我没有采用Integer auto_increment, 原因是为了数据库的数据能方便的导入到另外一种数据库里面，比方说：oracle。当然，这个是以牺牲部分效率为前提的。因为id是integer的，能更加快速查询。不过，从数据库会自动为 primary key 建立 index来看，效率也不会相差太多。
要想通过hibernate访问数据库。首先要建立描述数据库的文件：hibernate.cfg.xml。放到src下面。内容如下：

        

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

            
          "-//Hibernate/Hibernate Configuration DTD 3.0//EN"  
            
          "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd"> 
            
 
            
<hibernate-configuration> 
            
 
            
 <session-factory> 
            
  <property name="dialect">org.hibernate.dialect.MySQLDialectproperty> 
            
  <property name="connection.url">jdbc:mysql://localhost:3306/hibernatequickUseproperty> 
            
  <property name="connection.username">rootproperty> 
            
  <property name="connection.password">rootproperty> 
            
  <property name="connection.driver_class">com.mysql.jdbc.Driverproperty> 
            
    
            
  <property name="show_sql">trueproperty> 
            
  <mapping resource="org/py/hib/quickstart/User.hbm.xml" /> 
            
 
            
   
            
 session-factory> 
            
 
            
hibernate-configuration> 
            
 
        
        

说说上面的 "dialect", 这个对应着hibernate生成哪种数据库的sql。然后是："show_sql", 这个是为了调试时候输出sql语句到屏幕用的。

注意"mapping resource"部分。这个部分表示你的 实体- 数据库 映射文件的位置。（什么是实体-数据库 映射文件，看下面。）

实体-数据库映射文件 -- 主要是告诉hibernate，这个User类，对应着哪个table，User类里面的那个属性对应着table里面的哪个字段。我们可以建立 实体-数据库 的xml映射文件，也可以采用Annotations映射，但是目前只说xml映射方式。如下：

        

            
xml version="1.0" encoding="utf-8"?> >  <hibernate-mapping>  <class name="org.py.hib.quickstart.User" table="user">                 <id name="id" type="java.lang.String" column="id" length="32">    <generator class="uuid" />   id>    <property name="name"  type="java.lang.String" column="name" length="32" />  class> hibernate-mapping>    
        
        

上面的xml还是很好理解的。注意一个generator中的class，他可以有很多。我们这用的是uuid。什么是uuid。这个可以google一下。呵呵。google是最好的教科书。还能有很多其他的，比方说：native。具体的同样请教google。有了上面的准备，那么我们开始来测试一下。这里我们用junit。具体怎么使用junit，呵呵。答案我想大家都知道了，也不用我说了。其实我对test 和 使用它也不熟练。

我把测试用力放到了test/org.py.hib.quickstart下面。代码如下：

        

            
package org.py.hib.quickstart;  
            
 
            
import junit.framework.Assert;  
            
import junit.framework.TestCase;  
            
 
            
import org.hibernate.Session;  
            
import org.hibernate.SessionFactory;  
            
import org.hibernate.Transaction;  
            
import org.hibernate.cfg.Configuration;  
            
import org.junit.After;  
            
import org.junit.Before;  
            
 
            
public class QuickStartTest extends TestCase  
            
{  
            
 SessionFactory factory;  
            
 
            
 String m_name = "ryanpoy";  
            
 
            
 String m_name2 = "ryanpoy2";  
            
 
            
 @Before  
            
 public void setUp() throws Exception  
            
 {  
            
  Configuration conf = new Configuration().configure();  
            
  factory = conf.buildSessionFactory();  
            
 }  
            
 
            
 /**  
            
  * 测试添加  
            
  * @throws Exception  
            
  */  
            
 public void testSave() throws Exception  
            
 {  
            
  System.out.println("\n=== test save ===");  
            
  User u = new User();  
            
  u.setName(m_name); // 设置用户名 = m_name  
            
 
            
  Session session = null;  
            
  Transaction tran = null;  
            
  try  
            
  {  
            
   session = factory.openSession();  
            
   tran = session.beginTransaction();  
            
   session.save(u);  
            
   tran.commit();  
            
 
            
   Assert.assertEquals(u.getId() != null, true);  
            
  } catch (Exception ex)  
            
  {  
            
   tran.rollback();  
            
   throw ex;  
            
  } finally  
            
  {  
            
   if (session != null)  
            
   {  
            
    try  
            
    {  
            
     session.close();  
            
    } catch (Exception ex)  
            
    {  
            
     // nothing to do  
            
    } finally  
            
    {  
            
     if (session != null)  
            
      session = null;  
            
    }  
            
   }  
            
  }  
            
 }  
            
 
            
 /**  
            
  * 测试查询  
            
  * @throws Exception  
            
  */  
            
 public void testFind() throws Exception  
            
 {  
            
  System.out.println("\n=== test find ===");  
            
  Session session = null;  
            
  try  
            
  {  
            
   session = factory.openSession();  
            
   User u = (User) session.createQuery("from User").list().get(0);  
            
 
            
   Assert.assertEquals(true, u.getId() != null);  
            
   Assert.assertEquals(m_name, u.getName());  
            
  } catch (Exception ex)  
            
  {  
            
   throw ex;  
            
  } finally  
            
  {  
            
   if (session != null)  
            
   {  
            
    try  
            
    {  
            
     session.close();  
            
    } catch (Exception ex)  
            
    {  
            
     // nothing to do  
            
    } finally  
            
    {  
            
     if (session != null)  
            
      session = null;  
            
    }  
            
   }  
            
  }  
            
 }  
            
 
            
 /**  
            
  * 测试修改  
            
  * @throws Exception  
            
  */  
            
 public void testModify() throws Exception  
            
 {  
            
  System.out.println("\n=== test modify ===");  
            
  Session session = null;  
            
  Transaction tran = null;  
            
  try  
            
  {  
            
   session = factory.openSession();  
            
   tran = session.beginTransaction();  
            
 
            
   User u = (User) session.createQuery("from User").list().get(0);  
            
   u.setName(m_name2);  // 修改用户名 = m_name2.（原来用户名= m_name）  
            
   tran.commit();  
            
 
            
  } catch (Exception ex)  
            
  {  
            
   throw ex;  
            
  } finally  
            
  {  
            
   if (session != null)  
            
   {  
            
    try  
            
    {  
            
     session.close();  
            
    } catch (Exception ex)  
            
    {  
            
     // nothing to do  
            
    } finally  
            
    {  
            
     if (session != null)  
            
      session = null;  
            
    }  
            
   }  
            
  }  
            
 
            
  /*  
            
   * 修改后再查询  
            
   */  
            
  System.out.println("\n=== test find after modify ===");  
            
  try  
            
  {  
            
   session = factory.openSession();  
            
   User u = (User) session.createQuery("from User").list().get(0);  
            
 
            
   Assert.assertEquals(true, u.getId() != null);  
            
   Assert.assertEquals(m_name2, u.getName());  
            
  } catch (Exception ex)  
            
  {  
            
   throw ex;  
            
  } finally  
            
  {  
            
   if (session != null)  
            
   {  
            
    try  
            
    {  
            
     session.close();  
            
    } catch (Exception ex)  
            
    {  
            
     // nothing to do  
            
    } finally  
            
    {  
            
     if (session != null)  
            
      session = null;  
            
    }  
            
   }  
            
  }  
            
 }  
            
 
            
 /**  
            
  * 测试删除  
            
  * @throws Exception  
            
  */  
            
 public void testDelete() throws Exception  
            
 {  
            
  System.out.println("\n=== test delete ===");  
            
  Session session = null;  
            
  Transaction tran = null;  
            
  try  
            
  {  
            
   session = factory.openSession();  
            
   tran = session.beginTransaction();  
            
 
            
   User u = (User) session.createQuery("from User").list().get(0);  
            
   session.delete(u);  
            
   tran.commit();  
            
 
            
  } catch (Exception ex)  
            
  {  
            
   throw ex;  
            
  } finally  
            
  {  
            
   if (session != null)  
            
   {  
            
    try  
            
    {  
            
     session.close();  
            
    } catch (Exception ex)  
            
    {  
            
     // nothing to do  
            
    } finally  
            
    {  
            
     if (session != null)  
            
      session = null;  
            
    }  
            
   }  
            
  }  
            
 
            
  /*  
            
   * 删除后再查询  
            
   */  
            
  System.out.println("\n=== test find after delete ===");  
            
  try  
            
  {  
            
   session = factory.openSession();  
            
   Integer num = (Integer) session.createQuery("from User").list().size();  
            
 
            
   Assert.assertEquals(0, num.intValue());  
            
  } catch (Exception ex)  
            
  {  
            
   throw ex;  
            
  } finally  
            
  {  
            
   if (session != null)  
            
   {  
            
    try  
            
    {  
            
     session.close();  
            
    } catch (Exception ex)  
            
    {  
            
     // nothing to do  
            
    } finally  
            
    {  
            
     if (session != null)  
            
      session = null;  
            
    }  
            
   }  
            
  }  
            
 }  
            
 
            
 /**  
            
  *   
            
  */  
            
 @After  
            
 public void tearDown() throws Exception  
            
 {  
            
  factory.close();  
            
 }  
            
 
            
}  
        
        

运行后，我们很欣慰的看到一路绿灯，全部通过了。那么测试没有问题。呵呵(这里的测试可能还不完善。请大家指出。前面说过，我对测试这块也不熟)。
看控制台，会输出如下信息：

        

            
=== test save ===  
            
Hibernate: insert into hibernatequickuse.user (name, id) values (?, ?)  
            
 
            
=== test find ===  
            
Hibernate: select user0_.id as id2_, user0_.name as name2_ from hibernatequickuse.user user0_ 
            
 
            
=== test modify ===  
            
Hibernate: select user0_.id as id4_, user0_.name as name4_ from hibernatequickuse.user user0_  
            
Hibernate: update hibernatequickuse.user set name=? where id=?  
            
 
            
=== test find after modify ===  
            
Hibernate: select user0_.id as id4_, user0_.name as name4_ from hibernatequickuse.user user0_ 
            
 
            
=== test delete ===  
            
Hibernate: select user0_.id as id6_, user0_.name as name6_ from hibernatequickuse.user user0_  
            
Hibernate: delete from hibernatequickuse.user where id=?  
            
 
            
=== test find after delete ===  
            
Hibernate: select user0_.id as id6_, user0_.name as name6_ from hibernatequickuse.user user0_  
            
 
        
        

Hibernate有很多值得学习的地方，这里我们主要介绍Hibernate Sequence，包括介绍Oracle sequence等方面。

一、为表创建自增长自段有两种

一种是不同的表使用各自的Hibernate Sequence，方法如下：
1、在Oracle sequence首先创建sequence create sequence seq_idminvalue 1start with 1increment by 1cache 20；
2.在你的hbm.xml中的配置seq_id

这样再插入数据的时候，Hibernate会自动生成如下语句：

hibernate： select seq_id.nextval from dual hibernate： insert into YXJK.T_YXJK_WHRYTXL （XM0000， ZW0000， LXDH00， SJHM00， DZYJ00，IP0000， ID0000） values （？， ？， ？， ？， ？， ？， ？）

自动生成下一个序列值，然后将对象插入表中。在使用的时候需要注意，Hibernate对于sequence的主键的要求是一定要是shor，long，或者integer.

二 还有一种方式是使用公共的sequence

这各时候可以不指定表使用的sequence，那么相应的hbm.xml中内容是：

然后创建公用的Hibernate sequence对象，命名为 hibernate_sequence
◆create sequence hibernate_sequence
◆minvalue 0
◆maxvalue 99999999
◆start with 10000
◆increment by 1；

三 注意事项

如果数据库是从sqlserver等其他数据库移植而来的，那么创建sequence时的起始值应该比当前表中最大的ID值大，否则会出现错误，因为sequence 不会维护是否和导库前现有的值重复。
1、sequence：用于Oracle数据库
2、native：跨数据库时使用，由底层方言产生。

Default.sequence为hibernate_sequence

注：使用native时Hibernate默认会去查找Oracle中的hibernate_sequence序列。如果Oracle中没有该序列，连Oracle数据库时会报错。