<union-subclass
        name="ClassName"                    (1)
        table="tablename"                   (2)
        proxy="ProxyInterface"              (3)
        lazy="true|false"                   (4)
        dynamic-update="true|false"
        dynamic-insert="true|false"
        schema="schema"
        catalog="catalog"
        extends="SuperclassName"
        abstract="true|false"
        persister="ClassName"
        subselect="SQL expression"
        entity-name="EntityName"
        node="element-name">

        <property .... />
        .....
</union-subclass>

这种映射策略不需要指定辨别标志(discriminator)字段。

更多关于继承映射的信息，参考第 10 章 继承映射(Inheritance Mappings)。

好了。。看 一个例子
看这个配置文件

<? 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 ="com.test.Dog"  table ="dog" >   

         < id  name ="aid"  type ="string"  unsaved-value ="null"   >
             < column  name ="aid"  sql-type ="char(32)"  not-null ="true" />
             < generator  class ="uuid.hex" />
         </ id >

         < property  name ="dname" >
             < column  name ="dname"  sql-type ="varchar(16)" />
         </ property >

     </ class >

     < class  name ="com.test.Cat"  table ="cat" >   

         < id  name ="aid"  type ="string"  unsaved-value ="null"   >
             < column  name ="aid"  sql-type ="char(32)"  not-null ="true" />
             < generator  class ="uuid.hex" />
         </ id >

         < property  name ="cname" >
             < column  name ="cname"  sql-type ="varchar(16)" />
         </ property >

     </ class >

</ hibernate-mapping >

表结构:

create   table  dog
(aid  varchar ( 32 )  not   null   primary   key ,
 dname  varchar ( 16 )
)

create   table  cat
(aid  varchar ( 32 )  not   null   primary   key ,
 cname  varchar ( 16 )
)

写VO
Amimal.java

package  com.test;

public   class  Animal
{
     private  String aid;
    // get set

Dog.java

package  com.test;

public   class  Dog  extends  Animal
{
     private  String dname;
   // get set

package com.test;

public class Cat extends Animal
{
    private String cname;
  //get set

//插入
    public void doCreate()
    {
        try
        {
            session = sf.openSession();

            Dog dog = new Dog();
            dog.setDname("small dog");
            Cat cat = new Cat();
            cat.setCname("small cat");
            session.save(dog);
            session.save(cat);
            session.flush();
            session.connection().commit();

        }
        catch(HibernateException ex)
        {
            ex.printStackTrace();
        }
        catch(SQLException ex1)
        {
            ex1.printStackTrace();
        }
        finally
        {
                try{
                    session.close();
                }
                catch(HibernateException ex2){
                }
        }

    }
    //查询
    public void doQuery()
    {
        try{
            session = sf.openSession();
            Query q = session.createQuery("select d from Dog as d");
            List l = q.list();
            Dog dog = null;
            Cat cat = null;
            for(int i=0;i<l.size();i++)
            {
                dog = (Dog)l.get(i);
                System.out.println(dog.getDname());
            }
        }
        catch(HibernateException ex){
            ex.printStackTrace();
        }
        finally{
            try{
                session.close();
            }
            catch(HibernateException ex2){
            }
        }
    }

  A中可含映射文件的配置，而B中hard codes加映射文件。

  A。Configuration config=new Configuration().config();
  B. Configuration config=new Configuration();
     config.addClass(TUser.class);

2.你不必一定用hibernate.cfg.xml或hibernate.properties这两文件名，
   你也不一定非得把配置文件放在Classes下，
   File file=new File("c:\\sample\\myhibernate.xml");
   Configuration config=new Configuration().config(file);

3. session.Flush()
   强制数据库立即同步，当用事务时，不必用flush,事务提交自动调用flush
   在session关闭时也会调用flush

4. Hibernate总是使用对象类型作为字段类型

5. XDoclet专门建立了hibernate doclet,就是在java代码上加上一些
   java docTag，后来再让XDoclet分析该java代码，生成映射文件;

6.HQL子句本身大小写无关，但是其中出现的类名和属性名必须注意大小写区分。

7.关系：
  Constrained : 约束，表明主控表的主键上是否存在一个外键（foreigh key）
   对其进行约束。

  property-ref:关联类中用于与主控类相关联的属性名，默认为关联类的主键属性名

  单向一对多需在一方配置，双向一对多需在双方进行配置

8.lazy=false:被动方的记录由hibernate负责记取，之后存放在主控方指定的
  Collection类型属性中

9. java.util.Set或net.sof.hibernate.collecton.Bag类型的Collection

10.重要：inverse:用于标识双向关联中的被动方一端。
         inverse=false的一方（主控方）负责维护关联关系.默认值：false

11.batch-size:采用延迟加载特征时，一次读入的数据数昨。

12.一对多通过主控方更新（主控方为一方时）

   user.getAddresses().add(addr);
   session.save(user);//通过主控对象级联更新  

13.在one-to-many 关系中，将many 一方设为主动方（inverse=false）将有助性能
   的改善。在一方设置关系时，inverse=true,即将主控权交给多方，
   这样多方可主动从一方获得foreign key,然后一次insert即可完工。

   addr.setUser(user);//设置关联的TUser对象
   user.getAddresses().add(addr);
   session.save(user);//级联更新 

14.只有设为主控方的一方才关心（访问）对方的属性，被动方是不关心对方的属性的。

15.one-to-many与many-to-one节点的配置属性不同：
   一对多关系多了lazy和inverse两个属性
   多对多节点属性：column:中间映射表中，关联目标表的关联字段
                   class:类名，关联目标类
                   outer-join:是否使用外联接    

   注意:access是设置属性值的读取方式。

        column是设置关联字段。

16.多对多，注意两方都要设置inverse和lazy,cascade只能设为insert-update
   多对多关系中，由于关联关系是两张表相互引用，因此在保存关系状态时必须对双方同时保存。

   group1.getRoles().add(role1);
   role1.getGroups().add(group1);

   session.save(role1);
   session.save(group1);

17.关于vo和po
   vo经过hibernate容量处理，就变成了po(该vo的引用将被容器保存，并且在session关闭时flush,因此po如果再传到其它地方改变了，就危险了)
 
   vo和po相互转换：BeanUtils.copyProperties(anotherUser,user);

18.对于save操作而言，如果对象已经与Session相关联（即已经被加入Session的实体容器中），则无需进行具体的操作。因为之后的Session.flush过程中，Hibernate
会对此实体容器中的对象进行遍历，查找出发生变化的实体，生成并执行相应的update
语句。

19.如果我们采用了延迟加载机制，但希望在一些情况下，实现非延迟加
载时的功能，也就是说，我们希望在Session关闭后，依然允许操作user的addresses
属性
Hibernate.initialize方法可以通过强制加载关联对象实现这一功能：
这也正是我们为什么在编写POJO时，必须用JDK Collection接口（如Set,Map）,
而非特定的JDK Collection实现类（如HashSet、HashMap）申明Collection属性的
原因。

20.事务：从sessionFactory获得session,其自动提交属性就已经关闭(AutoCommit=false),此时若执行了jdbc操作，如果不显式调用session.BeginTransaction(),是不会执行事务操作的。

   jdbc transaction:基于同一个session(就是同一个connection)的事务;
   jta  transaction:跨session（跨connection）事务.

   对于jta事务，有三种实现方法：
     A。UserTransaction tx=new InitialContext().lookup("...");
        tx.commit();
     B. 使用hibernate封装的方法：(不推荐)
        Transaction tx=session.beginTransaction();
        tx.commit();
     C. 使用ejb之sessionBean的事务技持方法，你只要在把需要在发布描述符中，把需要jta事务的方法声明为require即可

21.悲观锁，乐观锁：
   乐观锁一般通过version来实现，注意version节点必须出现在id后。

22.Hibernate中，可以通过Criteria.setFirstResult和Criteria.setFetchSize方法设定分页范围。
   Query接口中也提供了与其一致的方法，hibernate主要在dialect类中实现在这个功能。

23.cache
   <hibernate-configuration>
 <session-factory>
 ……
  <property name="hibernate.cache.provider_class">
   net.sf.ehcache.hibernate.Provider
  </property> 

  还需对ecache本身进配置
  <ehcache>
 <diskStore path="java.io.tmpdir"/>
 <defaultCache
 maxElementsInMemory="10000" //Cache中最大允许保存的数据数量
 eternal="false" //Cache中数据是否为常量
 timeToIdleSeconds="120" //缓存数据钝化时间
 timeToLiveSeconds="120" //缓存数据的生存时间
 overflowToDisk="true" //内存不足时，是否启用磁盘缓存
 />
  </ehcache>

  之后在映射文件中指定各个映射实体的cache策略
  <class name=" org.hibernate.sample.TUser" .... >
 <cache usage="read-write"/>
 ....
 <set name="addresses" .... >
  <cache usage="read-only"/>
 ....
 </set>
 </class>

 *****************************************************
 Query.list()跟Query.iterate()的不同：
 对于query.list()总是通过一条sql语句获取所有记录,然后将其读出，填入pojo返回;
 但是query.iterate()，则是首先通过一条Select SQL 获取所有符合查询条件的记录的
id，再对这个id 集合进行循环操作，通过单独的Select SQL 取出每个id 所对应的记
录，之后填入POJO中返回。

 也就是说，对于list 操作，需要一条SQL 完成。而对于iterate 操作，需要n+1
条SQL。，list方法将不会从Cache中读取数据。iterator却会。

24.ThreadLocal:它会为每个线程维护一个私有的变量空间。实际上，
其实现原理是在JVM 中维护一个Map，这个Map的key 就是当前的线程对象，而value则是
线程通过ThreadLocal.set方法保存的对象实例。当线程调用ThreadLocal.get方法时，
ThreadLocal会根据当前线程对象的引用，取出Map中对应的对象返回。

 这样，ThreadLocal通过以各个线程对象的引用作为区分，从而将不同线程的变量隔离开
来。

25.Hibernate官方开发手册标准示例:
  public class HibernateUtil {
private static SessionFactory sessionFactory;
static {
try {
// Create the SessionFactory
sessionFactory = new
Configuration().configure().buildSessionFactory();
} catch (HibernateException ex) {
throw new RuntimeException(
"Configuration problem: " + ex.getMessage(),
ex
);
}
}
public static final ThreadLocal session = new ThreadLocal();
public static Session currentSession() throws HibernateException
{
Session s = (Session) session.get();
// Open a new Session, if this Thread has none yet
if (s == null) {
s = sessionFactory.openSession();
session.set(s);
}
return s;
}
public static void closeSession() throws HibernateException {
Session s = (Session) session.get();
session.set(null);
if (s != null)
s.close();
}
} 

    
26.通过filter实现session的重用：
   public class PersistenceFilter implements Filter
{
protected static ThreadLocal hibernateHolder = new ThreadLocal();
public void doFilter(ServletRequest request, ServletResponse
response, FilterChain chain)
throws IOException, ServletException
{
hibernateHolder.set(getSession());
try
{
……
chain.doFilter(request, response);
……
}
finally
{
Session sess = (Session)hibernateHolder.get();
if (sess != null)
{
hibernateHolder.set(null);
try
{
sess.close();
}
catch (HibernateException ex) {
throw new ServletException(ex);
}
}
}
}
……}

27.Spring的参数化事务管理功能相当强大，笔者建议在基于Spring Framework的应用
开发中，尽量使用容器管理事务，以获得数据逻辑代码的最佳可读性。
 
public class UserDAO extends HibernateDaoSupport implements IUserDAO
{
public void insertUser(User user) {
getHibernateTemplate().saveOrUpdate(user);
}
}

  上面的UserDAO实现了自定义的IUserDAO接口，并扩展了抽象类：
HibernateDaoSupport
HibernateSupport实现了HibernateTemplate和SessionFactory实例的关联。
HibernateTemplate对Hibernate Session操作进行了封装，而
HibernateTemplate.execute方法则是一封装机制的核心

  *在spring的配置文件里，移植了整个hibernate.cfg.xml的内容。