hibernate 的一些笔记

1.持久化对象：
      用hibernate持久化对象也就是将它保存在Session实例中：
           Configuration cgf=new Configuration();
           SessionFactory factory=cfg.buildSessionFactory();
           Event event=new Event(); //实例化一个类的对象
           Session session=factory.openSession();
           session.saveOrUpdate(event);
           session.flush();
           session.close();
      hibernate在存储对象时，Session不会立即将其写入数据库；相反，Session将大量数据库写操作加入队列，心最大限度地提高性能！

2.新手常遇到的一个问题：
       将相同的对象的两个实例与同一个Session实例相关联，导致NonUniqueObjectException异常:
        Session session=factory.openSession();
        Event firstEvent=(Event)session.load(Event.class,myEventId); //根据指定的ID加载一个实例
        Event secondEvent=new Event();
        secondEvent.setId(myEventId);
        session.save(secondEvent);
       抛出的异常的意思是说在同一个session中存在不唯一的两个实例；以下的代码则可以避免这个问题：
        Session session=factory.openSession();
        Event firstEvent=(Event)session.load(Event.class,myEventId); //根据指定的ID加载一个实例
        if(session.contains(firstEvent))  //如果session中有这个对象则将其逐出，而用session.clear()方法则可以清除Session缓存中的所有对象；
             session.evict(firstEvent);
        Event secondEvent=new Event();
        secondEvent.setId(myEventId);
        session.save(secondEvent);

3.hibernate支持3种连接池服务：C3P0,Apache DBCP和Proxool,在配置文件中以connection.provider_class属性来声明。

4.事务将很多操作组成一个工作单元。如果批处理中的任何一个操作失败，之间的所有操作将撤销，整个工作单元停止。
  hiberbate中有两种事务，hibernate中默认使用JDBC事务，因为它们是最常用的；而如果要使用JTA事务则需要在配置文件中进行设置：
         <property name="transaction.factory_class">
             org.hibernate.transaction.JTATransactionFactory
         </property>
         <property name="jta.UserTransaction">
             java:comp/UserTransaction
         </property>
使用JTA事务有何好处？如果有多个事务性资源，如一个数据库和一个消息队列，JTA事务将很有用。JTA事务让你能够像对待单个事务一样对待多个事务。
如果试图通过一个Session实例创建多个事务，所有操作都将加入到第一个事务中，如下：
  Transaction tx1=session.beginTransaction();
  Event event=new Event();
  session.saveOrUpdate(event);
  Transaction tx2=session.beginTransaction();
  Event event2=new Event();
  session.saveOrUpdate(event2);
  tx1.commit();
  tx2.commit();
这个例子首先创建一个新的事务。第二次session.beginTransaction()时，将返回第一个事务实例。session.saveOrUpdate(event2)提交第一个事务，tx1.commit()重新提交一个事务。

   虽然可以创建两个事务，但实际上只使用一个事务。当然，这带来了一个问题：假设有两个应用线程使用一个Session对象。第一个用线程开始JTA事务，并添加对象，同时，使用同一个事务的第二个线程删除一个对象，然后提交事务。这对第一个线程有什么影响呢？ 答案是第一个线程不会被提交！ 这个答案可以猜到，不过这种问题难以调试，这也指出了一个要点：Session不应由多个应用线程同时使用。

5.hibernate有4种不同缓存服务，这在配置文件要用以下语句来声明： EHCache,OSCache,SwarmCache,TreeCache
   <property name="cache.provider_class">org.hibernate.cache.四种中的一种</property>

  6.hibernate中的继承
      hibernate为了解决层次结构持久化中的问题，Hibernate支持3种不同的继承持久化策略：
      a.每个类层次一个表；b.每个子类一个表；c.每个具体类一个表；

    (1)每个类层次一个表则是三种中最容易的使用的，类层次中的所有类都保存在一个表中。
   假设有一个基类Event和两个子类ConferrenceEvent和NetWorkingEvent,它们的层次的映射定义程序清单如下:
     <class name="Event" table="events" discriminator-value="EVENT">
        <id name="id" type="long">
           <generator class="native" />
        </id>
        <discriminator colum="event_type" type="string" length="15"/>
        <subclass name="ConferrenceEvent" discriminator-value="CONF_EVENT">
            <property name="" colum="" />
              ...
        </subclass>
        <subclass name="NetworkingEvent" discriminator-value="NET_EVNET">
            <property name="" colum="" />
        </subclass>
     </class>
    个人理解：也就是说它们在同一个表中是通过discriminator这一列的值来进行认定具体对象是属于哪一个类的！ discriminator是 辨别者 的意思！还有的就是subclass标签之间，可以包含如上等属性元素，但不能包含有id元素和嵌套的subclass元素！

  (2)每个子类一个表
     将每个子类放在一个独立的表中，这种方法不需要discriminator列，并建立了从子类表到基类表的一对一的映射；
     这种策略的映射定义如程序清单：
      <class name="Event" table="events">
          <id name="event_id" type="long">
              <generator class="native" />
          </id>
        <joined-subclass name="ConferrenceEvent" table="conf_events">
           <key column="event_id" />
        </joined-subclass>
         <joined-subclass name="NetworkingEvent" table="net_events">
           <key column="event_id" />
        </joined-subclass>
      </class>
     这种策略是通过在子类对应的表中定义与基类对应表的id列相同的列来进行关联的！