通过设置hibernate映射文件的class处 dynamic-insert="true" dynamic-update="true" 和property 里面的insert="false" update="false" 实现 .

两处都要配置！

<property></property>标签属性：update=”true|false”

如果设置为false,则在hibernate的update语句里面没有<property>标签所指明的属性所对应的字段。

同理，insert=”true|false”

如果设置为false,则在hibernate的insert语句里面没有<property>标签所指明的属性所对应的字段。

这样的弊端是无法从表单上填写信息了。

http://sourceforge.net/projects/hibernate/files/

先决条件：

已经安装了ant和MySQL数据库，数据库表已经建立。

1、  从Hibernate官方网站下载Middlegen-Hibernate和hibernate-extensions，并解压。

2、  配置Middlegen-Hibernate:

2.1 配置数据库连接

假设连接的数据库是MySQL，在Middlegen-Hibernate-r5\config\database目录中有一个mysql.xml文件，是用来配置MySQL数据库的连接的。内容为：

   <property name="database.script.file" value="${src.dir}/sql/${name}-mysql.sql"/>

   <property name="database.driver.file" value="${lib.dir}/mysql-connector-java-3.0.15-ga-bin.jar"/>

   <property name="database.driver.classpath"      value="${database.driver.file}"/>

   <property name="database.driver"                value="org.gjt.mm.mysql.Driver"/>

   <property name="database.url"                   value="jdbc:mysql://localhost/jboss"/>

   <property name="database.userid"                value="jboss"/>

   <property name="database.password"              value="jboss"/>

   <property name="database.schema"                value=""/>

   <property name="database.catalog"               value=""/>

   <property name="jboss.datasource.mapping"       value="mySQL"/>

将mysql-connector-java-3.0.15-ga-bin.jar拷贝到${lib.dir}，也就是Middlegen-Hibernate-r5\lib目录。

修改配置文件中的数据库连接项目database.url、database.userid、database.userid 使Middlegen-Hibernate可以找到数据库。

2.2 配置Middlegen-Hibernate-r5的ant运行文件build.xml

<!DOCTYPE project [

    <!ENTITY database SYSTEM "file:./config/database/mysql.xml">

]>

指出使用的数据库配置文件。

<project name="Middlegen Hibernate" default="all" basedir=".">

   <property file="${basedir}/build.properties"/>

   <property name="name" value="hibernatesample"/>

指出你的应用名称。

   <property name="build.gen-src.dir"              value="C:/sample"/>

指出hbm的输出路径。

         <hibernate

            destination="${build.gen-src.dir}"

            package="org.hibernate.sample"

            genXDocletTags="false"

            genIntergratedCompositeKeys="false"

            javaTypeMapper="middlegen.plugins.hibernate.HibernateJavaTypeMapper"

         />

指出hbm所在的包的位置。

指出hbm.xml中是否需要XDoclet Tags。

3、  运行Middlegen-Hibernate:

在Middlegen-Hibernate目录下运行ant，进入Middlegen-Hibernate的图形界面。可以设置表，和字段的特性。然后按Genarate，产生hbm.xml文件。

4、  配置hibernate-extensions

在hibernate-extensions-2.1.2\tools\bin目录有一个setenv.bat文件，改变其内容为：

set JDBC_DRIVER=C:\java\Middlegen-Hibernate-r5\lib\mysql-connector-java-3.0.15-ga-bin.jar

set HIBERNATE_HOME=C:\java\hibernate-2.1.6

set CORELIB=%HIBERNATE_HOME%\lib

set LIB=..\lib

set PROPS=%HIBERNATE_HOME%\src

set CP=%JDBC_DRIVER%;%PROPS%;%HIBERNATE_HOME%\hibernate2.jar;%CORELIB%\commons-logging-1.0.4.jar;%CORELIB%\commons-collections-2.1.1.jar;%CORELIB%\commons-lang-1.0.1.jar;%CORELIB%\cglib-full-2.0.2.jar;%CORELIB%\dom4j-1.4.jar;%CORELIB%\odmg-3.0.jar;%CORELIB%\xml-apis.jar;%CORELIB%\xerces-2.4.0.jar;%CORELIB%\xalan-2.4.0.jar;%LIB%\jdom.jar;%LIB%\..\hibernate-tools.jar

注意红色字体提示的均是路径和JAR文件名，一定要正确。

5、运行hibernate-extensions，根据hbm.xml产生POJO文件

Student.hbm.xml
...
<hibernate-mapping>
 <class name="model.Student" table="student">
  <id name="id" unsaved-value="null">
   <generator class="uuid.hex"/>
  </id>
  <property name="name" type="string"/>
  <set name="courses"
    table="student_course"
    cascade="save-update"
  >
    <key column="stu_id"/>
    <many-to-many class="model.Course
      column="course_id"/>
  </set>
 <class>
</hibernate-mapping>
多对多关系需要配置的属性比较多一些。初学者经常会把<key column=""/>和<column="">的值
弄反了，其实只要记住一个原则：<key column="">总是和本身类的主键id对应，而<column="">
总是与关联类的主键id相对应。对于上面的Student.hbm.xml,关联类是Course,本身类则是Student

Course.hbm.xml
...
<hibernate-mapping>
 <class name="model.Course" table="course">
  <id name="id" unsaved-value="null">
   <generator class="uuid.hex"/>
  </id>
  <propery name="name" type="string"/>
  <set name="students"
    table="student_course"
    cascade="save-update"
    >
    <key columm="course_id"/>
    <many-to-many class="model.Student"
      column="stu_id"/>
  </set>
 </class>
</hibernate-mapping>
注意：Student与Course的cascade都设置为save-update，在多对多的关系中，all,delete等
cascade是没有意义的，因为多对多关系中，并不能因为父对象被删除，而造成被包括的子对象
被删除，因为可能还有其他的父对象参考了这个子对象。

另外，在多对多关系中，如果双方都有控制权（也就是双方都没有设置inverse="true"），则
双方都要把关联关系反映到数据库。必须在某一方设置inverse="true"，然后在执行语句时使用
主控方进行操作（也就是没有设置inverse="true"的那一方）。

单向关联

双向关联

  本节中使用到两个类，分别是班级(Team)和学生(Student)，学生和班级之间是多对一
关系。
具体的关联实现源代码如下：
Student.hbm.xml
...
<hibernate-mapping>
 <class name="model.Student" table="student">
  <id name="id" unsaved-value="null">
   <generator class="uuid.hex"/>
  </id>
  <property name="name" type="string'/>
  <many-to-one name="team"
    class="model.Team"
    column="team_id" <!--和team发生关联的列名-->
    cascade="none"
    fetch="join"
  />
 </class>
</hibernate-mapping>

<many-to-one>标签具有column属性，column属性总是和关联类（对于Student来说，关联类
是Team）的主键id 相对应，因此Hibernate会根据student表中的team_id，根据Team表中设置
的id列（一般情况列名也叫id），取出team.id=student.team_id的记录，构造成Team对象返
回给Student类。

Team.hbm.xml
...
<hibernate-mapping>
 <class name="model.Team" table="team" lazy="true">
  <id name="id" unsaved-value="null">
   <generator class="uuid.hex"/>
  </id>
  <property name="teamName" type="string"/>
  <set name="students" cascade="save-update" lazy="true" inverse="true">
   <key column="team_id"/>
   <one-to-many class="model.Student"/>
  </set>
 </class>
</hibernate-mapping>

Team对Student是一对多关系，一对多具有<key column=""/>属性，key标签总是和本身类的主键
相对应。在取得Team对象时，通过Team的主键id与Student表中的team_id进行匹配，如果
team.id=student.team_id，则认为此学生是本班级的，于是加载学生，把学生对象加入Team
对象的学生集合。

设置inverse标签
  由于在Team.hbm.xml中设置了inverse="true",Team和Student之间的关系转由Student来维护
因此，当Team掌握维护权时(inverse="false"或者默认状态），它负责将自己的id告诉Student
，然后Hibernate发送update语句去更新记录。但现在设置了inverse="true"之后，维护权在
Student手中，于是Hibernate不再发送update语句，而由Student自动去取得team_id，而这个
动作其实就是完成一个“学生添加班级”动作，也就是语句newStu.setTeam(team)。

以主键关联

  主键关系的重点是：关联的两个实体共享一个主键值。
Student.hbm.xml
...
<hibernate-mapping>
 <class name="model.Student" table="student" lazy="true"><!--把类和表关联起来-->
  <id name="id" unsaved-value="null"><!--id的产生方式是uuid.hex-->
   <generator class="uuid.hex"/>
  </id>
  <property name="name" type="sring"/>
  <one-to-one name="cer"
    class="model.Certificate"
    fetch="join"
    cascade="all"
  /><!--映射对应的身份证对象-->
 </class>
</hibernate-mapping>

Certificate.hbm.xml
...
<hibernate-mapping>
 <class name="model.Certificate" table="certificate" lazy="true">
  <id name="id">
  <!--外键生成机制，引用stu对象的主键作为certificate数据表的主键和外键-->
   <generator class="foreign">
    <param name="property">stu</param>
   </generator>
  </id>
  <one-to-one name="stu"
    class="model.Student"
    constrained="true" <!--表示Certificate引用了stu的主键作为外键-->
  />
 </class>
</hibernate-mapping>

上述的两个配置文件在<one-to-one>标签中都没有设置column属性
（实际上<one-to-one>标签本身就没有column属性）。

以外键关联

  以外键关联的重点是：两个实体各自有不同的主键，但其中一个实体有一个外键引用
了另一个表的主键。

Student.hbm.xml
...
<hibernate-mapping>
 <class name="model.Student" table="student" lazy="true">
  <id name="id" nusaved-value="null">
   <generator class="uuid.hex"/>
  </id>
  <property name="name" type="sring"/>
  <one-to-one name="cer"
    class="model.Certificate"
    fetch="join"
    cascade="all"
  /><!--映射对应的身份证对象-->
 </class>
</hibernate-mapping>
可以看到Student.hbm.xml和以主键关联时的代码是一样的，并没有改变。

Certificate.hbm.xml
...
<hibernate-mapping>
 <class name="model.Certificate" table="certificate" lazy="true">
  <id name="id">
   <generator class="uuid.hex"/> <!--不再是foreign了-->
  </id>
  <many-to-one name="stu"
    class="model.Student"
    unique="true" <!--唯一的多对一，其实也就变成了一对一关系-->
    column="stu_id" 
  />
 </class>
</hibernate-mapping>
以外键关联的一对一，其实本质上变成了一对多的双向关联了，编写时直接
按照一对多和多对一的要求编写，最后在many-to-one这一边上加上一个
unique="true"即可。

一对多、多对多（末端为多）的情况：在集合的配置中设置，以 set 为例，如下所示： 

        <set name="students" inverse="true" cascade="all" lazy="false" batch-size="2" ><!-- 一对多的延迟加载设置 -->

            <key>

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

            </key>

            <one-to-many class="edu.dgut.ke.model.Student" />

        </set>

 一对一、多对一（末端为一）的情况：如果要对末端为一的关联设置批量加载，要在“一”这端的配置文件中进行设置，比如学生对身份证，要实现对班级的批量加载，应设置如下
                <class name="edu.dgut.ke.model.Certificate" table="CERTIFICATE" lazy="true" batch-size="10" >

测试例子

1.不管A类对property1在配置文件里是什么策略(可能是预先抓取,立即或延迟检索,它们都失效),这时都采用HQL指定的左外连接;左外连接必定会初始化property1属性(或对象),但是如果配置文件里对property1的检索策略是延迟加载,A类得 到对properyt1的引用,为了得到这个引用,需要再次发送一条SQL语句来确立这种引用关系,这种情况在property1为集合时经常出现.

2.A类在配置文件中设置的对property2的预先抓取策略将被忽略(不管这个策略是fetch或是select),对property2有影响的设置是立即和延迟加载,hibernate只看得到这两种策略,所以在使用语句"from A as a left outer join a.property1"时,property2的加载策略将仅由lazy="true"或者是lazy="false"来决定 


Team.hbm.xml 
...    ...
       <set name="students" inverse="true" cascade="all" lazy="true" fetch="join"><!-- 一对多的延迟加载设置 -->
            <key>
                <column name="TEAMID" length="32" not-null="true" />
            </key>
            <one-to-many class="edu.dgut.ke.model.Student" />
        </set>
...    ...
Student.hbm.xml
...    ...
        <many-to-one name="certificate"
         class="edu.dgut.ke.model.Certificate"
         unique="true"
         column="cardId"
         cascade="all"
         lazy="false"
         fetch="join">
        </many-to-one>
        <many-to-one name="team" class="edu.dgut.ke.model.Team" fetch="join">
            <column name="TEAMID" length="32" not-null="true" />
        </many-to-one>
...    ...
测试代码
  Session session = HibernateSessionFactory.getSession();
  List list = session.createQuery("from Student as s left join s.team").list();
  HibernateSessionFactory.closeSession();
  //list 包括两个长度为2的数组,每一个数组中包括一个学生对象和一个班级对象
  Object[] stuAndTeam1 = (Object[]) list.get(0);
  Student stu = (Student) stuAndTeam1[0];
  System.out.println(stu.getStudentname());
  System.out.println(stu.getTeam().getTeamname());
  System.out.println(stu.getTeam().getStudents().size());

取值. full.classname.of.Dialect

取值. SCHEMA_NAME

取值. jndi/composite/name

取值. true | false

取值. 建议设置为0到3之间

取值. 建议值在 5 和 30之间。

取值. true | false

取值. true | false

取值. true | false

取值. 1, 2, 4, 8

取值. classname.of.ConnectionProvider

取值. classname.of.CacheProvider

取值. classname.of.TransactionFactory

取值. jndi/composite/name

取值. classname.of.TransactionManagerLookup

取值. hqlLiteral=SQL_LITERAL, hqlFunction=SQLFUNC

取值. true | false

取值. update | create | create-drop

public class Query {

 public static void main(String[] args) {

  //打开Session取得Student对象,后关闭Session
  Student student = getStudent();
  //打开另一个Session.调用update()方法,因为在上面的Session关闭后,
  //student对象成了脱管状态,在另一个Session中无法初始化一个脱管对象,必须重新关联
  HibernateSessionFactory.getSession().update(student.getTeam());
  //使用initialize方法初始化一个代理对象或者集合(此代理并不能保证内部嵌套的对象或者集合被初始化)
  Hibernate.initialize(student.getTeam());
  System.out.println(student.getTeam().getTeamname());
  HibernateSessionFactory.closeSession();
 }

... 
 public static Student getStudent() {
  StudentDAO studentDAO = new StudentDAO();
  
  Session session = studentDAO.getSession();
  Student student = (Student) session.get(Student.class, "2c9ab2d516056609011605660e7e0001");
  session.close();
  return student;
 }
... 
}

很多程序需要在某个事务中获取对象，然后将对象发送到界面层去操作，最后在一个新的事务保存所做的修改。 在高并发访问的环境中使用这种方式，通常使用附带版本信息的数据来保证这些“长“工作单元之间的隔离。

Hibernate通过提供使用Session.update()或Session.merge()方法 重新关联脱管实例的办法来支持这种模型。

// in the first session
Cat cat = (Cat) firstSession.load(Cat.class, catId);
Cat potentialMate = new Cat();
firstSession.save(potentialMate);
// in a higher layer of the application
cat.setMate(potentialMate);
// later, in a new session
secondSession.update(cat);  // update cat
secondSession.update(mate); // update mate

如果具有catId持久化标识的Cat之前已经被另一Session(secondSession)装载了， 应用程序进行重关联操作(reattach)的时候会抛出一个异常。

如果你确定当前session没有包含与之具有相同持久化标识的持久实例，使用update()。 如果想随时合并你的的改动而不考虑session的状态，使用merge()。 换句话说，在一个新session中通常第一个调用的是update()方法，以便保证重新关联脱管(detached)对象的操作首先被执行。

希望相关联的脱管对象（通过引用“可到达”的脱管对象）的数据也要更新到数据库时（并且也仅仅在这种情况）， 应用程序需要对该相关联的脱管对象单独调用update() 当然这些可以自动完成，即通过使用传播性持久化(transitive persistence)，请看第 11.11 节 “传播性持久化(transitive persistence)”。

lock()方法也允许程序重新关联某个对象到一个新session上。不过，该脱管(detached)的对象必须是没有修改过的！

//just reassociate:
sess.lock(fritz, LockMode.NONE);
//do a version check, then reassociate:
sess.lock(izi, LockMode.READ);
//do a version check, using SELECT ... FOR UPDATE, then reassociate:
sess.lock(pk, LockMode.UPGRADE);

请注意，lock()可以搭配多种LockMode， 更多信息请阅读API文档以及关于事务处理(transaction handling)的章节。重新关联不是lock()的唯一用途。

其他用于长时间工作单元的模型会在第 12.3 节 “乐观并发控制(Optimistic concurrency control)”中讨论。

分页支持类：

抽象业务类

用户在web层构造查询条件detachedCriteria，和可选的startIndex，调用业务bean的相应findByCriteria方法，返回一个PaginationSupport的实例ps。

ps.getItems()得到已分页好的结果集
ps.getIndexes()得到分页索引的数组
ps.getTotalCount()得到总结果数
ps.getStartIndex()当前分页索引
ps.getNextIndex()下一页索引
ps.getPreviousIndex()上一页索引

文章出处:http://www.javaeye.com/topic/14657

q      void delete(Object entity)：删除指定持久化实例

q      deleteAll(Collection entities)：删除集合内全部持久化类实例

q      find(String queryString)：根据HQL查询字符串来返回实例集合

q      findByNamedQuery(String queryName)：根据命名查询返回实例集合

q      get(Class entityClass, Serializable id)：根据主键加载特定持久化类的实例

q      save(Object entity)：保存新的实例

q      saveOrUpdate(Object entity)：根据实例状态，选择保存或者更新

q      update(Object entity)：更新实例的状态，要求entity是持久状态

q      setMaxResults(int maxResults)：设置分页的大小

下面是一个完整DAO类的源代码：

public class PersonDAOHibernate implements PersonDAO

{

    //采用log4j来完成调试时的日志功能

private static Log log = LogFactory.getLog(NewsDAOHibernate.class);

    //以私有的成员变量来保存SessionFactory。

private SessionFactory sessionFactory;

//以私有变量的方式保存HibernateTemplate

private HibernateTemplate hibernateTemplate = null;

         //设值注入SessionFactory必需的setter方法

    public void setSessionFactory(SessionFactory sessionFactory)

{

           this.sessionFactory = sessionFactory;

    }

         //初始化本DAO所需的HibernateTemplate

public HIbernateTemplate getHibernateTemplate()

{

         //首先，检查原来的hibernateTemplate实例是否还存在

         if ( hibernateTemplate == null)

         {

                   //如果不存在，新建一个HibernateTemplate实例

                   hibernateTemplate = new HibernateTemplate(sessionFactory);

         }

         return hibernateTemplate;

}

         //返回全部的人的实例

    public List getPersons()

         {       

                   //通过HibernateTemplate的find方法返回Person的全部实例

           return getHibernateTemplate().find("from Person");

    }

         /**

          * 根据主键返回特定实例

          * @ return 特定主键对应的Person实例

          * @ param 主键值

    public News getNews(int personid)

         {

           return (Person)getHibernateTemplate().get(Person.class, new Integer(personid));

    }

         /**

          * @ person 需要保存的Person实例

          */

    public void savePerson(Person person)

         {                

                   getHibernateTemplate().saveOrUpdate(person);

    }

         /**

          * @ param personid 需要删除Person实例的主键

          * /

    public void removePerson(int personid)

         {

                   //先加载特定实例

           Object p = getHibernateTemplate().load(Person.class, new Integer(personid));

                   //删除特定实例

           getHibernateTemplate().delete(p);

    }

}

q      Object execute(HibernateCallback action)

q      List execute(HibernateCallback action)

这两个方法都需要一个HibernateCallback的实例，HibernateCallback实例可在任何有效的Hibernate数据访问中使用。程序开发者通过HibernateCallback，可以完全使用Hibernate灵活的方式来访问数据库，解决Spring封装Hibernate后灵活性不足的缺陷。HibernateCallback是一个接口，该接口只有一个方法doInHibernate(org.hibernate.Session session)，该方法只有一个参数Session。

通常，程序中采用实现HibernateCallback的匿名内部类来获取HibernateCallback的实例，方法doInHibernate的方法体就是Spring执行的持久化操作。具体代码如下：

public class PersonDaoImpl implements PersonDao

{

    //私有实例变量保存SessionFactory

         private SessionFactory sessionFactory;

         //依赖注入必须的setter方法

    public void setSessionFactory(SessionFactory sessionFactory)

         {

           this.sessionFactory = sessionFactory;

    }

         /**

          * 通过人名查找所有匹配该名的Person实例

          * @param name 匹配的人名

          * @return 匹配该任命的全部Person集合

          */

    public List findPersonsByName(final String name)

         {

           //创建HibernateTemplate实例

                   HibernateTemplate hibernateTemplate =

                         new HibernateTemplate(this.sessionFactory);

           //返回HibernateTemplate的execute的结果

                   return (List) hibernateTemplate.execute(

                //创建匿名内部类

                   new HibernateCallback()

                   {

              public Object doInHibernate(Session session) throws HibernateException

                            {

                   //使用条件查询的方法返回

                                     List result = session.createCriteria(Person.class)

                                                                     .add(Restrictions.like(“name”, name+”%”)

                                                                           .list();

                                    return result;

                     }

                });

    }

}

注意：方法doInHibernate方法内可以访问Session，该Session对象是绑定到该线程的Session实例。该方法内的持久层操作，与不使用Spring时的持久层操作完全相同。这保证对于复杂的持久层访问，依然可以使用Hibernate的访问方式。

一、           数据库事务概念

数据库事务的特征： ACID

Atomic （原子性）、 Consistency （一致性）、 Isolation （隔离性）和 Durability （持久性）。 DBMS 用日志来保证数据的原子性、一致性和持久性；用锁的机制来保证数据的隔离性。

二、           事务的边界

数据库支持 2 种事务模式：自动提交和手动提交。

JDBC API 的事务边界

try
{
    Connection conn  =  java.sql.DriverManager,.getConnection(dbUrl,dbUser,dbPwd);
    conn.setAutoCommit( false );  // 设置成手动模式
    stmt  =  conn.createStatement();
    stmt.executeUpdate( " . " );  // 数据库更新1
    stmt.executeUpdate( " . " );  // 数据库更新2
    
    conn.commit();
}
catch (Exception e)
{
    conn.rollback();
}
finally
{
    stmt.close();
    conn.close();
}

Hibernate API 声明事务边界

Session session  =  factory.openSession();
Transaction tx;
try  
{
    tx  =  session.beginTransaction();  // 开始事务
     // 执行操作
    。。。。。
    
    tx.commit();
}
catch  (Exception e)
{
     if  (tx != null )
     {
        tx.rollback();
    }
}
finally
{
    session.close();
}

注：一个 session 可以对应多个事务，但是推荐的做法是一个 session 对应一个事务。

三、            多事务的并发问题

当多个事务同时访问相同的数据的时候，程序如果没有采取适当的隔离措施，就会发生数据库的并发问题。常见的并发问题有：

第一类丢失更新：撤消事务的时候，把其他的事务已经提交的数据给覆盖了；

脏读；读了没有提交的数据；

虚读：一个事务读到另外一个事务已经提交的新插入的数据；

不可重复读：一个事务读到另外一个事务已经提交的更新的数据；

第二类丢失更新：一个事务覆盖另外一个事务已经提交的更新数据。 
四、           锁

一般地，大型的 DBMS 都会自动的管理锁定机制，但是在对数据的安全性、完整性和一致性有特殊要求的地方，可以由事务本身来管理琐的机制。

有一点要关注的是：锁的粒度越大，隔离性越好，并发性越差。

按照锁的程度来分有：

共享锁：用读操作，非独占的，其他事务可以读，但是不能更新，并发性好；

独占锁：用与 insert update 和 delete 等语句，其他事务不能读，也不能改，并发性差；

更新锁：执行 update 的时候，加锁。

死琐：多是事务分别锁定了一个资源，又请求锁定对方已经锁定的资源，就造成了请求环。

降低死锁的最好办法是使用短事务。

五、            数据库的事务隔离级别

数据库提供 4 种事务隔离级别：

Serializable ：串行化；（隔离级别最高） 1

Repeatable Read ：可重复读； 2

Read Commited ：读已提交数据； 4

Read Uncommited ：读未提交数据；（隔离级别最低） 8

Hiberate 中的隔离级别的设置

在 Hibernate 的配置文件中 hibernate.connection.isolation=2

六、            悲观锁和乐观琐

从应用程序的角度来看，锁分为悲观锁和乐观锁。

悲观锁：显示的为程序加锁，但是降低并发性。

Select ……. For update;

在 Hibernate 中的代码

Session.get(Account.class,net Long(1),LockMode.UPGRADE) ； // 程序采用悲观锁

乐观锁：依靠 DBMS 来管理锁，程序依靠版本控制来避免并发问题。

在对象 - 关系映射的文件中，用 <version> 或者 <timestamp> 可以管理并发。乐观琐比悲观琐有更好的并发性，优先考虑乐观琐。  

http://www.blogjava.net/sodmewuhan/archive/2006/04/22/42505.html

Hibernate 提供了 3 种检索策略：

l        延迟检索；

l        立即检索；

l        迫切左外连接；

Hibernate 提供 2 种方式来确定检索策略，一中是在配置文件当中，另外一种是在程序种设置。当然，如果你在程序中设置了检索策略，那么你在配置文件中的设置也就无效了。另外的一种情况是 HQL 会忽略配置文件的设置，而总是采用迫切左外连接。

一、 类级别的检索

可以选择的检索策略是立即检索和延迟检索，默认的是立即检索。用配置文件中的 <class> 节点的 lazy 来控制。

注意：不管你在配置 class 的 lazy 是 true 还是 false ，对 get() 和 create Criteria () 方法都不起作用，只有对 load() 方法起作用。

当你使用的检索策略是 lazy 的时候，当你执行

Customer customer = (Customer)session.load(Customer.class,new Long(1));

的时候， Hibernate 不从数据库检索数据，而只是产生一个代理类，只有当你执行

Customer.getName();

的时候， Hibernate 才到数据库取数据。所以，如下的代码是会被抛出异常的：

Session session  =  sessionFactory.openSession();
transaction tx  =   null ;
tx  =  session.beginTransaction();
  Customer customer  =  (Customer)session.load(Customer. class , new  Long( 1 ));
tx.commit();
  session.close();
customer.getName();

import java.io.IOException;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hibernate.SessionFactory;

import cn.hxex.blog.hibernate.HibernateUtil;

public class HibernateFilter implements Filter {

    private static Log log = LogFactory.getLog(HibernateFilter.class);

    /**
     * 过滤器的主要方法
     * 用于实现Hibernate事务的开始和提交
     */
    public void doFilter(ServletRequest request,
                         ServletResponse response,
                         FilterChain chain)
            throws IOException, ServletException
    {
     // 得到SessionFactory对象的实例
     SessionFactory sf = HibernateUtil.getSessionFactory();

        try
        {
         // 开始一个新的事务
            log.debug("Starting a database transaction");
            sf.getCurrentSession().beginTransaction();

            log.debug( "Request Path:\t" + ((HttpServletRequest)request).getServletPath() );
            // Call the next filter (continue request processing)
            chain.doFilter(request, response);

            // 提交事务
            log.debug("Committing the database transaction");
            sf.getCurrentSession().getTransaction().commit();

        }
        catch (Throwable ex)
        {
         ex.printStackTrace();
            try
            {
             // 回滚事务
                log.debug("Trying to rollback database transaction after exception");
                sf.getCurrentSession().getTransaction().rollback();
            }
            catch (Throwable rbEx)
            {
                log.error("Could not rollback transaction after exception!", rbEx);
            }

            // 抛出异常
            throw new ServletException(ex);
        }
    }

    /**
     * Servlet过滤器的初始化方法
     * 可以读取配置文件中设置的配置参数
     */
    public void init(FilterConfig filterConfig) throws ServletException {}

    /**
     * Servlet的销毁方法
     * 用于释放过滤器所申请的资源
     */
    public void destroy() {}

}

import java.io.Serializable;

import org.apache.commons.lang.builder.EqualsBuilder;
import org.apache.commons.lang.builder.HashCodeBuilder;
import org.apache.commons.lang.builder.ReflectionToStringBuilder;

public class BaseModel implements Serializable{

 /**
  * The Generated SerialVersionUID
  */
 private static final long serialVersionUID = 7766184319541530720L;
 
 /**
  * The identify of the object
  */
 private String id;

 public String getId() {
  return id;
 }

 public void setId(String id) {
  this.id = id;
 }
 
 /**
  * Common implement equals method
  */
 public boolean equals( Object obj )
 {
  if( this==obj ) return true;
  
  if( !( obj instanceof BaseModel ) )
   return false;
  
  BaseModel target = (BaseModel)obj;
  
  if( this.getId()!=null && this.getId().length()>0 )
  {
   return this.getId().equals( target.getId() );
  }
  
  if( target.getId()!=null && target.getId().length()>0 )
  {
   return false;
  }
  
  return EqualsBuilder.reflectionEquals(this, obj);
 }

 /**
  * Generate the hash code
  */
 public int hashCode()
 {
  if( this.getId()!=null && this.getId().length()>0 )
  {
   return this.getId().hashCode();
  }
   
  return HashCodeBuilder.reflectionHashCode(this);
 }

 /**
  * Common implement toString method
  */
 public String toString()
 {
  return ReflectionToStringBuilder.toString( this );
 }
}
         equals()方法,用于判断两个对象是否相等,但并不是在使用"=="进行两个对象是否相等的判断时调用.因为使用"=="所判断的是两个对象的引用是否相等,也可以简单理解为两个实例所引用的是否为内存中的同一个对象.equals()方法可以理解为两个对象在"含义"上是否相等,也就是说这两个对象所表达的意思是否相同.equals()方法在对象保存到集合容器类(Collection)中时被调用.因为集合容器类不允许其中存在两个相同对象实例,其判断的依据就是通过调用该实体对象的equals()方法来进行判断的.
         如果修改了equals()方法,就必须修改hashCode()方法.如果不这样的话,就违反java.lang.Object的通用的hashCode的约定,从而导致该类无法与基于散列值的集合类一起正常工作.
         toString()方法,用于将当前Java对象的实例转换为可以描述其内容的字符串.这个方法的作用是在程序调试的过程可以方便地得到实体对象中令人感兴趣的信息,有利于更准确及时地发现程序中的问题.

  对于Hibernate 3.1 以前的的版本在实现Hibernate工具类时,需要通过两个线程
局部变量来保存与当前进行相对应的Session和事务对象的实例.
  而对于Hibernate 3.1 以后的版本,使用线程局部变量保存Session和事务对象的
工作就完全不需要自己去实现了,只需在Hibernate.cfg.xml配置文件中增加一个名为
Current_session_context_class的属性,并且设置该属性的值为thread.这样Hibernate
就可以自动地使用线程局部变量来保存当前的进程的Session和事务对象了.
  相应地,Hibernate也为其Session对象增加了getTransaction()方法,以便可以随时
得到当前的事务并进行提交或者回滚操作.这个方法在以前版本的hibernate中是不存在
的.
Hibernate工具类主要包括以下功能:
(1)Hibernate的初始化操作
  这个功能不放在任何方法中,采用静态编码的处理方式,在对象的初始化的时候被
  调用一次就可以了.
(2)得到当前的配置信息
  这个方法可以得到当前的配置信息,以便于动态进行配置参数的修改.hibernate
  的配置信息只在Hibernate初始化的时候使用一次,在完成初始化之后对配置文件
  或者Configuration对象所做的修改将不会生效.
(3)得到SessionFactory对象的实例
  这个方法用于得到当前系统运行时的SessionFactory对象的实例,这个对象的实例
  对于整个系统而言是全局唯一的.
(4)释放各种资源
  这个方法用于终止Hibernate的报务后,释放各种Hibernate所使用的资源.虽然这个
  方法几乎不会用到,但对于申请资源的及时释放是每个程序应该掌握的基本原则.
(5)重建SessionFactory
  由于SessionFactory对于整个Hibernate应用是唯一的.并且是在Hibernate初始化
  之后建立好的,而且对于配置文件的修改也不会影响到已经初始化的SessionFactory
  对象.那么如何才能使修改的配置信息对Hibernate起作用呢.这就需要重建SessionFactory
  对象实例.
(6)拦截器注册
  用于注册拦截器并重建SessionFactory.
HibenateUtil.java
import javax.naming.InitialContext;
import javax.naming.NamingException;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hibernate.Interceptor;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.cfg.Environment;

/**
 * 基础的Hibernate辅助类，用于Hibernate的配置和启动。
 * <p>
 * 通过静态的初始化代码来读取Hibernate启动参数，并初始化
 * <tt>Configuration</tt>和<tt>SessionFactory</tt>对象。
 * <p>
 *
 * @author galaxy
 */
public class HibernateUtil
{

    private static Log log = LogFactory.getLog(HibernateUtil.class);

    // 指定定义拦截器属性名
    private static final String INTERCEPTOR_CLASS = "hibernate.util.interceptor_class";

    // 静态Configuration和SessionFactory对象的实例（全局唯一的）
    private static Configuration configuration;
    private static SessionFactory sessionFactory;

    static
    {
        // 从缺省的配置文件创建SessionFactory
        try
        {
         // 创建默认的Configuration对象的实例
         // 如果你不使用JDK 5.0或者注释请使用new Configuration()
         // 来创建Configuration()对象的实例
            configuration = new Configuration();

            // 读取hibernate.properties或者hibernate.cfg.xml文件
            configuration.configure();

            // 如果在配置文件中配置了拦截器，那么将其设置到configuration对象中
            String interceptorName = configuration.getProperty(INTERCEPTOR_CLASS);
            if (interceptorName != null)
            {
                Class interceptorClass =
                        HibernateUtil.class.getClassLoader().loadClass(interceptorName);
                Interceptor interceptor = (Interceptor)interceptorClass.newInstance();
                configuration.setInterceptor(interceptor);
            }

            if (configuration.getProperty(Environment.SESSION_FACTORY_NAME) != null)
            {
                // 让Hibernate将SessionFacory绑定到JNDI
                configuration.buildSessionFactory();
            }
            else
            {
                // 使用静态变量来保持SessioFactory对象的实例
                sessionFactory = configuration.buildSessionFactory();
            }

        }
        catch (Throwable ex)
        {
            // 输出异常信息
            log.error("Building SessionFactory failed.", ex);
            ex.printStackTrace();
            throw new ExceptionInInitializerError(ex);
        }
    }

    /**
     * 返回原始的Configuration对象的实例
     *
     * @return Configuration
     */
    public static Configuration getConfiguration()
    {
        return configuration;
    }

    /**
     * 返回全局的SessionFactory对象的实例
     *
     * @return SessionFactory
     */
    public static SessionFactory getSessionFactory()
    {
        SessionFactory sf = null;
        String sfName = configuration.getProperty(Environment.SESSION_FACTORY_NAME);
        if ( sfName != null)
        {
            log.debug("Looking up SessionFactory in JNDI.");
            try
            {
                sf = (SessionFactory) new InitialContext().lookup(sfName);
            }
            catch (NamingException ex)
            {
                throw new RuntimeException(ex);
            }
        }
        else
        {
            sf = sessionFactory;
        }
        if (sf == null)
            throw new IllegalStateException( "SessionFactory not available." );
        return sf;
    }

    /**
     * 关闭当前的SessionFactory并且释放所有的资源
     */
    public static void shutdown()
    {
        log.debug("Shutting down Hibernate.");
        // Close caches and connection pools
        getSessionFactory().close();

        // Clear static variables
        configuration = null;
        sessionFactory = null;
    }

    /**
     * 使用静态的Configuration对象来重新构建SessionFactory。
     */
     public static void rebuildSessionFactory()
     {
        log.debug("Using current Configuration for rebuild.");
        rebuildSessionFactory(configuration);
     }

    /**
     * 使用指定的Configuration对象来重新构建SessionFactory对象。
     *
     * @param cfg
     */
     public static void rebuildSessionFactory(Configuration cfg)
     {
        log.debug("Rebuilding the SessionFactory from given Configuration.");
        synchronized(sessionFactory)
        {
            if (sessionFactory != null && !sessionFactory.isClosed())
                sessionFactory.close();
            if (cfg.getProperty(Environment.SESSION_FACTORY_NAME) != null)
                cfg.buildSessionFactory();
            else
                sessionFactory = cfg.buildSessionFactory();
            configuration = cfg;
        }
     }

    /**
     * 在当前SessionFactory中注册一个拦截器
     */
    public static SessionFactory registerInterceptorAndRebuild(Interceptor interceptor)
    {
        log.debug("Setting new global Hibernate interceptor and restarting.");
        configuration.setInterceptor(interceptor);
        rebuildSessionFactory();
        return getSessionFactory();
    }

    /**
     * 获得拦截器对象
     *
     * @return Interceptor
     */
    public static Interceptor getInterceptor()
    {
        return configuration.getInterceptor();
    }

    /**
     * 提交当前事务，并开始一个新的事务
     */
    public static void commitAndBeginTransaction()
    {
     sessionFactory.getCurrentSession().getTransaction().commit();
     sessionFactory.getCurrentSession().beginTransaction();
    }
}