Table

Table用来定义entity主表的name，catalog，schema等属性。

元数据属性说明：

• name: 表名
• catalog: 对应关系数据库中的catalog
• schema：对应关系数据库中的schema
• UniqueConstraints:定义一个UniqueConstraint数组，指定需要建唯一约束的列

								    

@Entity

@Table(name="CUST")

public class Customer { ... }

								                

@Entity

@Table(name="CUSTOMER")

@SecondaryTable(name="CUST_DETAIL",pkJoin=@PrimaryKeyJoinColumn(name="CUST_ID"))

public class Customer { ... }

								                

@Table(name = "CUSTOMER")

@SecondaryTables( value = {

@SecondaryTable(name = "CUST_NAME", pkJoin = { @PrimaryKeyJoinColumn(name = "STMO_ID", referencedColumnName = "id") }),

@SecondaryTable(name = "CUST_ADDRESS", pkJoin = { @PrimaryKeyJoinColumn(name = "STMO_ID", referencedColumnName = "id") }) })

public class Customer {}

								                

@Entity

@Table(name="EMPLOYEE",

uniqueConstraints={@UniqueConstraint(columnNames={"EMP_ID", "EMP_NAME"})}

)

public class Employee { ... }

								        

public class Person {

@Column(name = "PERSONNAME", unique = true, nullable = false, updatable = true)

private String name;



@Column(name = "PHOTO", columnDefinition = "BLOB NOT NULL", secondaryTable="PER_PHOTO")

private byte[] picture;

								                

public class Custom {



@OneToOne

@JoinColumn(

name="CUST_ID", referencedColumnName="ID", unique=true, nullable=true, updatable=true)

public Order getOrder() {

return order;

}

								                

public class Custom {

@OneToOne

@JoinColumns({

@JoinColumn(name="CUST_ID", referencedColumnName="ID"),

@JoinColumn(name="CUST_NAME", referencedColumnName="NAME")

})

public Order getOrder() {

return order;

}

								                

@Entity

@Table(name = "OTASK")

public class Task {

@Id(generate = GeneratorType.AUTO)

public Integer getId() {

return id;

}

}

								

                

@Table(name = "PERSON")

public class Person {



@OneToMany(targetEntity = Book.class, cascade = CascadeType.ALL, mappedBy = "person")

@MapKey(name = "isbn")

private Map books = new HashMap();

}

								

                

@Table(name = "MAPKEY_PERSON")

public class Person {



@OneToMany(targetEntity = Book.class, cascade = CascadeType.ALL, mappedBy = "person")

@OrderBy(name = "isbn ASC, name DESC")

private List books = new ArrayList();

}

								  @Entity

@Table(name="CUSTOMER")

@SecondaryTable(name="CUST_DETAIL",pkJoin=@PrimaryKeyJoinColumn(name="CUST_ID"，referencedColumnName="id"))

public class Customer { 

@Id(generate = GeneratorType.AUTO)

public Integer getId() {

return id;

}

}

								            

@Table(name = "Employee")

public class Employee {

@OneToOne

@PrimaryKeyJoinColumn(name = "id", referencedColumnName="INFO_ID")

EmployeeInfo info;

}

								            

@Entity

@IdClass(EmpPK.class)

@Table(name = "EMPLOYEE")

public class Employee {



private int id;



private String name;



private String address;



@OneToOne(cascade = CascadeType.ALL)

@PrimaryKeyJoinColumns({

@PrimaryKeyJoinColumn(name="id", referencedColumnName="INFO_ID"),

@PrimaryKeyJoinColumn(name="name" , referencedColumnName="INFO_NAME")})

EmployeeInfo info;

}



@Entity

@IdClass(EmpPK.class)

@Table(name = "EMPLOYEE_INFO")

public class EmployeeInfo {



@Id

@Column(name = "INFO_ID")

private int id;



@Id

@Column(name = "INFO_NAME")

private String name;

}

								    

@Transient

private String name;

								                

@Version

@Column("OPTLOCK")

protected int getVersionNum() { return versionNum; }

								                

@Lob

@Column(name="PHOTO" columnDefinition="BLOB NOT NULL")

protected JPEGImage picture;



@Lob(fetch=EAGER, type=CLOB)

@Column(name="REPORT")

protected String report;

								                

@JoinTable(

table=@Table(name=CUST_PHONE),

joinColumns=@JoinColumn(name="CUST_ID", referencedColumnName="ID"),

inverseJoinColumns=@JoinColumn(name="PHONE_ID", referencedColumnName="ID")

)

								                

@Entity public class Employee {

...

@TableGenerator(name="empGen",

table=@Table(name="ID_GEN"),

pkColumnName="GEN_KEY",

valueColumnName="GEN_VALUE",

pkColumnValue="EMP_ID",

allocationSize=1)

@Id(generate=TABLE, generator="empGen")

public int id;

...

}



@Entity public class Address {

...

@TableGenerator(name="addressGen",

table=@Table(name="ID_GEN"),

pkColumnValue="ADDR_ID")

@Id(generate=TABLE, generator="addressGen")

public int id;

...

}

								                

@SequenceGenerator(name="EMP_SEQ", allocationSize=25)	

								                

@Entity

@Table(name="CUST")

@Inheritance(strategy=SINGLE_TABLE,

discriminatorType=STRING,

discriminatorValue="CUSTOMER")

@DiscriminatorColumn(name="DISC", length=20)

public class Customer { ... }

1.尽量使用many-to-one，避免使用单项one-to-many
2.灵活使用单向one-to-many
3.不用一对一，使用多对一代替一对一
4.配置对象缓存，不使用集合缓存
5.一对多使用Bag 多对一使用Set
6.继承使用显示多态  HQL:from object  polymorphism="exlicit" 避免查处所有对象
7.消除大表，使用二级缓存
    对于上面这些，Robbin进行了详细的讲解。
one-to-many：
     使用inverse=false(default)，对象的关联关系是由parent对象来维护的
     而inverse=true的情况下，一般用户双向多对多关联，由子对象维护关联关系，增加子对象的时候需要显示：child.setParent(child)
     为了提高性能，应该尽量使用双向one-to-many inverse=true，在MVC结构中的DAO接口中应该直接用Session持久化对象，避免通过关联关系（这句话有点不理解），而在单项关系中正确使用二级缓存，则可以大幅提高以查询为主的应用。
     多对一性能问题比较少，但是要避免经典N+1问题。
     通过主键进行关联，相当于大表拆分小表。（这个是区分面向对象设计和面向过程设计的一个关键点）
list、bag、set的正确运用
     one-to-many：
     A、使用list 需要维护Index Column字段，不能被用于双向关联，而且必须使用inverse=false，需要谨慎使用在某些稀有场合（基本上是不予考虑使用）
     B、bag/set在one-to-many中语义基本相同，推荐使用bag
     many-to-one：
     A、bag和set不同，bag允许重复插入，建议使用set
在庞大的集合分页中应该使用session.createFilter
    session.createFilter(parent.getChildren(),""),setFirstResult(0),setMaxResult(10))
避免N+1 参考（http://www.javaeye.com/post/266972）
    在多对一的情况下，查询child对象，当在页面上显示每个子类的父类对象的时候会导致N+1次查询，需要采用下面的方法避免：many-to-one fetch="join|select"（该方法可能有问题）
inverse=true 无法维护集合缓存（还不是很理解集合缓存和对象缓存）
OLTP类型的web应用，可以群集水平扩展，不可避免的出现数据库瓶颈
    框架能降低访问数据库的压力，采用缓存是衡量一个框架是否优秀的重要标准，从缓存方面看Hibernate
    A、对象缓存，细颗粒度，是针对表的级别，透明化访问，因为有不改变代码的好处，所以是ORM提高性能的法宝
    B、Hibernate是目前ORM框架中缓存性能最好的框架
    C、查询缓存
最后Robbin还针对大家经常出现的Hibernate vs iBatis的讨论进行了一个总结：
   对于OLTP应用，使用ORM框架 而OLEB应用（不确定是什么应用）最好采用JDBC或者其他方法处理
   Hibernate倾向于细颗粒度设计，面向对象，将大表拆分为多个小表，消除冗余字段，通过二级缓存提升性能。
  iBatis倾向于粗颗粒度设计，面向关系，尽量把表合并，通过Column冗余，消除关联关系，但是iBatis没有有效的缓存手段。

出处：http://www.blogjava.net/rosen

    Hibernate 和 Spring 这两个突出的开源框架被越来越多的应用到 J2EE 中。尽管目标有着不同的问题空间，它们却共享一个关键特性：依赖注入。 在对象返回到客户端之前 Spring 协助挑选出这些对象间依赖关系，减少客户端代码量。而 Hibernate 专门挑选出在完整的对象模型返回客户端之前由数据模型表现的依赖关系。当使用 JDBC 直接从数据模型映射到对象模型时，我们通常需要书写大量的代码来构建对象模型。Hibernate 的出现淘汰了这种繁琐的编码工作。
   
    Hibernate 2.x 提供基本的表到对象的映射，标准关联映射（包括 one-to-one, one-to-many 以及 many-to-many 关系），多态映射，等等。Hibernate 3.x 沿着路线继续前进，formula、filter、subselect 等，使映射更加灵活，提供用细粒度的解释特性。
   
    在本文中，将阐述 formula 到底有哪些特性可帮助我们进行模型转换。Hibernate 3.x 之前，formula 属性只能出现在 property 元素中。但是到了现在，你可以在许多元素中使用 Hibernate 3.x 提供的 formula 属性或元素（formula 用法方面都是一样的），包括 discriminator、element、many-to-many、map-key、map-key-many-to-many、以及 property。它增加了 OR 映射的灵活性，因此允许对复杂数据模型更加细粒的解释。
   
    下面有两个 formula 应用场景：
   
    1. formula 用于评估结果的场合。在 discriminator、element、map-key、map-key-many-to-many以及 property 元素中注入 formula。
    2. formula 用于连接目的的场合。在 many-to-one、one-to-one 以及 many-to-many 元素中注入 formula。
   
范畴 1：从 formula 获得评估结果
   
    Discriminator
   
    在真实的数据 schema 中，经常出现一个表被用于描述其他表的情况。formula 可协助提供灵活的多态 OR 映射。
   
    在图 1 的范例中，有两个表：Product 和 ProductRelease。每条 product 记录都有一个 ProductReleaseID 参考相应的产品出厂记录，包括 product release name、type、release date 等等。

         
                       图 1. Product 和 product release
   
    ProductRelease 表中有个有趣的属性 SubProductAllowable，该属性的值为 1 或 0。值为 1 代表允许任何的次品出厂，但是 0 不允许次品出厂。
   
    图 2 展示了由数据模型解释的对象模型。Nested 接口定义了 getSubProducts 和 setSubProducts 方法。NestedProduct 类继承 Product 基类并实现 Nested 接口。无论产品数据记录是 Product 或 NestedProduct，都取决于产品出厂记录中 SubProductAllowable 的值。

       
                     图 2. Product 和产品出厂对象域模型
   
    为了完成模型转换，我们使用如下的 Hibernate 3.x 映射：
    

<hibernate-mapping>
  <class name="Product" 
        discriminator-value="0"  lazy="false">
    <id name="id" type="long"/>       
    <discriminator 
        formula="(select pr.SubProductAllowable 
                from ProductRelease pr 
                where pr.productReleaseID=
                        productReleaseID)"
        type="integer" />
    <subclass  name="NestedProduct"  
        discriminator-value="1"/>
  </class>
</hibernate-mapping>

    如果 formula 表达式评估结果为 0 时－－也就是不允许次品出厂－－那么对象将是 Product 类。如果结果是 1，那么对象将是 NestedProduct。在表 1 和 2 中，表 Product 的第一条记录（ProductID=10000001），已初始化的类将是 NestedProduct，因为它参考一条 SubProductAllowable=1 的 ProductRelease 记录。表 Product 的第二条记录（ProductID=20000001），已初始化的类将是 Product，因为它参考一条 SubProductAllowable=0 的 ProductRelease 记录。
   

S/N	ProductReleaseID	SubProductAllowable	...
1	11	1	¡­
2	601	0	¡­

        表 1. ProductRelease 表中的记录
   

S/N	ProductID	ProductReleaseID	...
1	10000001	11	¡­
2	20000001	601	...

        表 2. Product 表中的记录
   
    Property
   
    在 property 元素中的 formula 允许对象属性包含特定引伸值，比如对结果进行 sum、average、max 等等。

<property name="averagePrice" formula="(select avg(pc.price) from PriceCatalogue pc, SelectedItems si where si.priceRefID=pc.priceID)"/>

    此外，formula 也能协助从基于当前记录的特定值向其它表检索数据。例如：

<property name="currencyName" formula="(select cur.name from currency cur where cur.id= currencyID)"/>

    这将由助于从 currency 表检索 currency name。正如你所看到的，这样直接映射可消除许多转换编码。
   
    map-key
   
    formula 允许 map-key 持有任何可能的值。下列范例（图 3），我们想让 Role_roleID 成为对象模型的 map-key（图 4）。

                    
                          图 3. 用户角色数据 schema

  
                            图 4. 用户角色对象模型
   
    在前面的数据 schema 中，User 和 Role 由 User_has_Role 通过 many-to-many 关系关联调用。为了获取某个 User 所有的指派角色，我们进行如下映射：

<hibernate-mapping>
  <class name="User">
    <id name="userID"/>
    <map name="roles"  
        table="UserRole"/>
      <key column="User_userID"/>
      <map-key 
        formula="Role_RoleID" 
        type="string"/>
      <many-to-many 
        column="Role_RoleID"
        class="Role"/>
    </map>
  </class>
  <class name="Role">
    <id name="roleID"/>
  </class>
</hibernate-mapping>

    Role_RoleID 通常用于连接 many-to-many 元素的栏位值。Hibernate 通常不允许 Role_RoleID 出现在 map-key 和 many-to-many 的栏位属性中。但是有了 formula，Role_RoleID 也能用于 map-key。
   
    element、map-key-many-to-many 以及其他
   
    element 和 property 类似，能从任何有效的 formula 表达式赋予评估值。
   
    map-key-many-to-many 中 formula 的用法类似于 map-key。但是，map-key-many-to-many 通常用于三重关系，map key 是一个被自己参考的对象，而不是被参考的属性。
   
    那么，到底哪些情况下 formula 不支持呢？有些数据库（例如 Oracle 7）就不支持嵌入式 select 语句（也就是说一条 select SQL 内嵌在另外一条 select SQL 语句中），这种情况 formula 就不支持评估结果。因此，你应该首先检查嵌入式 select SQL 语句是否被支持。
   
    一旦 Hibernate 的映射拿 formula 表达式作为 select SQL 选取的一部分，请确认数据库 SQL 方言是否允许使用 formula，尽管这样将降低代码轻便性。
   
范畴 2：formula 用于连接

    many-to-one
   
    另一个普遍的场景是真实世界的数据模型是所有者关系映射，这意味着映射是不同于 one-to-one、one-to-many 以及 many-to-many 关系的，formula 是提供所有者关系管理元素中的一个。图 5 展示了某公司可有多个联系人，但是其中只有一个为默认联系人的范例。一个公司有多个联系人是典型的 one-to-many 关系。但是，为了标识默认联系人，ContactPerson 表使用了 defaultFlag 参数（1 是 yes, 0是 no）。

               
                        图 5. 用户角色数据 schema

             
                           图 6. 用户角色对象模型
   
    为了说明对象模型（图 6）中默认联系人关系，我们使用如下映射文件：

<hibernate-mapping>
  <class name="Company" table="Company">
    <id name="id" />
    <many-to-one 
      name="defaultContactPerson" 
      property-ref="defaultContactPerson">
        <column name="id"/>
        <formula>1</formula>
        </many-to-one>
  </class>
  <class name="Person" >
    <id name="id" />
    <properties name="defaultContactPerson">
        <property name="companyID" />
        <property name="defaultFlag" />
    </properties>
  </class>
</hibernate-mapping>

    如上，我们把 companyID 和 defaultFlag 组织到名为 defaultContactPerson 的 properties 元素中，做为 Person 表的 unique key。Company 类中的 many-to-one 元素连接 Person 表的 defaultContactPerson properties 元素。输出的 SQL 像这样：
   
    select c.id, p.id from Company c, Person p where p.companyID=c.id and p.defaultFlag=1
   
    one-to-one
   
    Hibernate 中，one-to-one 主要用于两张表共享同一主键的情况。对于外键关联，我们通常使用 many-to-one 来代替。但是，有了 formula，one-to-one 可以通过外键连接表。上面的 many-to-one 范例可以通过 one-to-one 来映射：

<hibernate-mapping>
  <class name="Company" table="Company" >
    <id name="id" />
    <one-to-one name="defaultContactPerson" 
        property-ref="defaultContactPerson" >
    <formula>id</formula>
    <formula>1</formula>
    </one-to-one>
  </class>
  <class name="Person" >
    <id name="id" />
    <properties name="defaultContactPerson">
      <property name="companyID" />
      <property name="defaultFlag" />
    </properties>
   </class>
</hibernate-mapping>

    many-to-many
   
    formula 用于当 many-to-many 元素为关系表和实体表连接的特殊关系，尽管通常没有必要这样用。
   
总结

1 Entity's relation

1.1 One to One

一个对象的一个实例对应另一个对象的一个实例从数据库角度描述，一个表中的一条记录对应另外一个表中唯一一条记录

public class Image{
private Long id;
private String imgName;
private Blog value; //to store binary of image
......
}
Image.hbm.xml
<class name="Image" dynamic-update="true">
<id...
<property...
</class>

public class Product{
private Long id;
private String name;
private double price;
private Image photo;
}
<class name=...dynamic-update="true" lazy="true"
<id...
<property...
<one-to-one name="photo" class="package.Image" cascade="all" outer-join="auto" constrained="false"/>
</class>

1.2 Many to One

一个对象对应另一个对象的多个实例，从数据库角度描述，是在一个数据表中的一条记录对应另外一个数据表中对条记录.

public class PersonalCompute{
private Long computerId;
private String cpu;
......
private Programmer owner;
}
<class name="Programmer" table="Programmer">
<id...
<property...
</class>

<class name="PersonalCompute" table="PCS">
<id....
<property...
<many-to-one name="owner" column="programmerId" class="Programmer">
</many-to-one>

1.3 One to Many

The same example as Many to One.But we stand at Programmer class's view point.
public class Programmer{
...
private Set computers = new HashSet();
}

<class name="Programmer" table="Programmer">
<id...
<property...
<set name="computers" inverse="true" cascade="all">
<key column="programmerId" />
<one-to-many class="PersonalComputers">
</one-to-many>
</set>

2 Collection

2.1 Map

<class name="Team">
...
<map name="members">
<key foreign-key="fk">
<column name="teamNumber">
</key>
<index column="teamRole" type="string"/>
<element column="name" ...
</map>

showcase:
Team team1 = new Team();
team1.setName(xx);
team1.getMembers.put("index","content");
......
sess.save...

2.1.1 many-to-any

2.1.2 One to many

单单使用Map做存储往往无法表达复杂的对象,如果要讲对象 map进行映射:
One Team,multi-members
Public class Member{
...
private Team team;
}
<class name="Team">
...
<map name="members" inverse="false">
<key column="team" foreign-key="fk"/>
<index type="string" column="teamRole"/>
<one-to-many class="Member"/>
</map>
<class name="member">
<id...
<property...
<many-to-one name="team" />

showcase:
Team team = new Team();
team.setName("xx");
Member mem1 = new Member();
mem1.setXX
mem1.setXX
Member mem2 = new Member();
mem2.setXX
mem2.setXX
team.getMembers().put("xx",mem1);
team.getMembers().put("xx2",mem2);

2.1.3 many to many

<class name="Team">
<id
<propery
<map name="members" inverse="false" table="teamHasMembers">
<key column="team" foreign-key="fk"/>
<index type="string" column="teamRole"/>
<many-to-many class="member" outer-join="auto">
<column name="member"/>
</many-to-many>
</map>

<class name="Member">
<id
<property
<map name="teams" table="memberAtTeams">
<key....

teamRole is their common key of Map.
Team

Member

memberAtTeams

teamHasMembers

2.1.4 Composite-index

复杂Index 可以是一个类。
public class Position{
private String role;
private String scene;
public Position()....
getter...
setter...
}
<class name="Team">
<id...
<property...
<map name="members" inverse="false">
<key column="team" foreign-key="fk"/>
<composite-index class="Position">
<key-property..
<key-property...
</composite-index>
<one-to-many class="Member"/>
</map>
...

<class name="Member">
<id...
<property...
<many-to-one name="team"/>
</class>

index-many-to-one

index-many-to-many

index-many-to-any

2.1.5 composite-element

<import class="Member"/>
<class name="Team">
<id...
<property...
<map name="members" table="teamMembers">
<key column="teamId"/>
<index...
<composite-element class="Member">
<parent name="parent"/>
<property...
<property...
</composite-element>
</map>

2.2 Set

<class name="Team">
<..
<set name="members" inverse="false">
<key column="team" foreign-key="fk"/>
<elemnet column="name" type="string"/>
</set>

2.2.1 one-to-many

<set name="xx" column="">
<key column="" foreign-key="fk"/>
<one-to-many class="BB"/>
</set>

2.2.2 many-to-many

<class name="Team">
<id..
<property...
<set name="members" inverse="false" table="teamHasMembers">
<key column="team" foreign-key="fk">
<many-to-many class="Member" outer-join="auto">
<column name="member"/>
</set>
</class>

<class name="Member">
<id..
<property...
<set name="members" inverse="true" table="memberAtTeams">
<key column="member" foreign-key="fk">
<many-to-many class="Member" outer-join="auto">
<column name="team"/>
</set>
</class>

2.2.3 many-to-any

2.2.4 composite-element

2.3 List

<list name="members" inverse="false">
<key column="team" foreign-key="fk"/>
<index column="teamMember"/>
<element column="name" type="string"/>
</list>

2.3.1 one-to-many

2.3.2 many-to-many

2.3.3 many-to-many

2.3.4 composite-element

2.4 Bag

It can contains JDK's Collection and List interface type's object.

2.5 idBag

与bag相比多出了collection-id属性

<ibdbag name="">
<collection-id column="mbid" type="long">
<generator class="hilo"/>
</collection-id>
<key..
<element..
</idbag>

2.6 array

public class Team{
//...
private String[] members;
}

<array name="members" inverse="false">
<key column="team" foreign-key="fk"/>
<index column="teamNumber"/>
<element column="name" type="string"/>
</array>

3 Component

<class name="Country">
<id..
<property...
<component name="position">
<property...
</component>
Public class Country{
//..
private Position position;
}

3.1 One-to-one

3.2 many-to-one

3.3 dynamic-component

4 Dynamic class

<dynamic-class entity-name="Country">
<id name="id" type="long">
<generator class="hilo"/>
</id>
<property name="name" column="NAME" type="string"/>
</..

4.1 One-to-one

4.2 many-to-one

5 Mapping type

5.1 Java type to SQL type

5.2 3.0 enmu

5.3 user defined data type

need implements org.hibernate.usertype.CompositeUserType or org.hibernate.usertype.UserType interface.

6 Class Hierarchy's mapping

6.1 Subclasses are saved in on Table

6.1.1 discriminator

Sapmle:

Class AbstractParent{
String id;
/*important*/
String discriminator
}
Class ChildA{
String childA;
}
Class ChildB{
String childB;
}

=========DB=========

========mapping config file====
<class name="AbstractParent" table="PARENT" abstract="true">
<id...
<discriminator column="CLASS_TYPE" type="string"/>
<property......
<subclass name="ChildA" discriminator-value="A">
<property name="childA"/>
</subclass>
<subclass......

id generator

· increment

· identity

· sequence

· hilo

· seqhilo

· uuid

· guid

· native

· assigned

· foreign

composite id

<composite-id>
<key-property name=""/>
<key-property name=""/>
</composite-id>

6.2 Subclasses are saved in separated Table

并不为父类Container建立映射文件 Box与Bottle的映射文件也如没有关系一样普通的建立 但是对Container取得操作

List pcs = sess.createQuery("from com.be.david.Container").list();
if(!cs.isEmpty()){
...
}
会将Box与Container数据都取出来 这是Hibernate默认隐式完成的

6.3 Parent Class and Subclasses are saved in separated Table

<class name="Container" table="CONTAINER">
<id...
<property...
<joined-subclass name="Box" table="CONTAINER_BOX">
<key column="ContainerId"/>
<property...
</joined-subclass>
<joined-subclass name="Bottle" table="CONTAINER_BOTTLE">
<key...
<property...
</joined-subclass>
</class>

6.4 One PO multi-table

public Class Person{
public String id;
public String name;
public String sex;
public String address;
public String city;
public String zipcode;
}
we wanna save address related attributes(blue ones).Use join
<class name="Person" table="PERSON">
<id...
<property ...
<join table="ADDRESS">
<key column="addressID"/>
 <property name="address"/>
 ...
 </join>
</class>

6.5 Class A Class B not inherited from Parent Class

6.5.1 subselect

We can use subselct to make ChildA and ChildB standalone.So how can we get all data including ChindA and ChildB?

<class name="ChildA" table="parent">
<id...
<property...
</class>
<class name="ChildB" table="parent">
<id...
<property...
</class>
<class name="Parent" mutable="false">
<subselect>
select * from ChildA
union
select * from ChildB
</subselect>
<sychronize table="ChildA"/>
<sychronize table="ChildB"/>
<id...
<property...
</class>

 <!-- ******  环境设置,可以根据自己的实际配置自行更改 ***** -->
 <!-- ******  http://blog.csdn.net/fasttalk    ***** -->
 <!-- ******  http://www.blogjava.net/asktalk  ***** -->
 <!-- 源文件目录, 可以通过 项目->属性->Java构建路径 更改 -->
 <property name="src.dir" value="./src" />
 <!-- 输出的class文件目录,可以通过 项目->属性->Java构建路径 更改 -->
 <property name="class.dir" value="./bin" />
 <!-- 库文件目录  -->
 <property name="lib.dir" value="E:/workspace/java/hibernate3" />

 <!-- 定义类路径 -->
 <path id="project.class.path">
  <fileset dir="${lib.dir}">
   <include name="*.jar"/>
  </fileset>
  <pathelement location="${class.dir}" />
 </path>

 <!-- ************************************************************** -->
 <!-- 使用说明 -->
 <!-- ************************************************************** -->
 <target name="help">
  <echo message="利用工具开发Hibernate" />
  <echo message="-----------------------------------" />
  <echo message="" />
  <echo message="提供以下任务：" />
  <echo message="" />
  <echo message="generate-hbm     --> 运行HibernateDoclet，生成 Hibernate 类的映射文件" />
  <echo message="schemaexport     --> 运行SchemaExport,利用 hbm.xml 文件生成数据表" />
  <echo message="" />
 </target>

 <!-- ************************************************************** -->
 <!-- Hbm2Java 任务 在hibernate3中无法实现 -->
 <!-- ************************************************************** -->
 <target name="generate-code" >
  <echo message="运行 Hbm2Java 任务， 利用 hbm.xml 文件生成Java类文件"/>

  <taskdef name="hbm2java"
       classname="org.hibernate.tool.instrument.InstrumentTask"
          classpathref="project.class.path">
  </taskdef>

  <hbm2java output="${src.dir}">
   <fileset dir="${src.dir}">
    <include name="**/*.hbm.xml"/>
   </fileset>
  </hbm2java>
 </target>

 <!-- ************************************************************** -->
 <!-- HibernateDoclet 任务 -->
 <!-- ************************************************************** -->
 <target name="generate-hbm" >
  <echo message="运行HibernateDoclet，生成 Hibernate 类的映射文件"/>

  <taskdef name="hibernatedoclet"
   classname="xdoclet.modules.hibernate.HibernateDocletTask"
   classpathref="project.class.path">
  </taskdef>
        <!--
        destdir         输出目录；
        force,          每次都强行执行，覆盖原有文件；
        -->
  <hibernatedoclet destdir="${src.dir}"
   excludedtags="@version,@author,@todo" force="true" encoding="GBK"
   verbose="true">

   <fileset dir="${src.dir}">
    <include name="**/*.java"/>
   </fileset>

   <hibernate version="3.0" xmlencoding="utf-8" />
  </hibernatedoclet>
 </target>

 <!-- ************************************************************** -->
 <!-- SchemaExport 任务 -->
 <!-- ************************************************************** -->
 <target name="schemaexport">
  <echo message="运行SchemaExport,利用 hbm.xml 文件生成数据表"/>

  <taskdef name="schemaexport"
   classname="org.hibernate.tool.hbm2ddl.SchemaExportTask"
   classpathref="project.class.path">
  </taskdef>
      <!--
      quiet=true                       不要把脚本输出到stdout;
      drop=true                        只进行drop tables的步骤 ;
      text=true                        不执行在数据库中运行的步骤 ;
      output=my_schema.ddl             把输出的ddl脚本输出到一个文件 ;
      config=hibernate.cfg.xml         从XML文件读入Hibernate配置 ;
      properties=hibernate.properties  从文件读入数据库属性 ;
      format=true                      把脚本中的SQL语句对齐和美化 ;
      delimiter=x                      为脚本设置行结束符
      -->
  <schemaexport properties="src/hibernate.properties"
  quiet="no" text="no" drop="no"  output="schema-export.sql" >
         <fileset dir="${src.dir}">
             <include name="**/*.hbm.xml"/> 
         </fileset>
  </schemaexport>
 </target>

</project>

1.1 Hibernate API 变化
1.1.1 包名
1.1.2 org.hibernate.classic包
1.1.3 Hibernate所依赖的第三方软件包
1.1.4 异常模型
1.1.5 Session接口
1.1.6 createSQLQuery()
1.1.7 Lifecycle 和 Validatable 接口
1.1.8 Interceptor接口
1.1.9 UserType和CompositeUserType接口
1.1.10 FetchMode类
1.1.11 PersistentEnum类
1.1.12 对Blob 和Clob的支持
1.1.13 Hibernate中供扩展的API的变化
1.2 元数据的变化
1.2.1 检索策略
1.2.2 对象标识符的映射
1.2.3 集合映射
1.2.4 DTD
1.3 查询语句的变化
1.3.1 indices()和elements()函数

尽管Hibernate 3.0 与Hibernate2.1的源代码是不兼容的，但是当Hibernate开发小组在设计Hibernate3.0时，为简化升级Hibernate版本 作了周到的考虑。对于现有的基于Hibernate2.1的Java项目，可以很方便的把它升级到Hibernate3.0。

本文描述了Hibernate3.0版本的新变化，Hibernate3.0版本的变化包括三个方面：
（1）API的变化，它将影响到Java程序代码。
（2）元数据，它将影响到对象-关系映射文件。
（3）HQL查询语句。

值得注意的是， Hibernate3.0并不会完全取代Hibernate2.1。在同一个应用程序中，允许Hibernate3.0和Hibernate2.1并存。

1.1 Hibernate API 变化

1.1.1 包名

Hibernate3.0的包的根路径为: “org.hibernate” ，而在Hibernate2.1中为“net.sf.hibernate”。这一命名变化使得Hibernate2.1和Hibernate3.0能够同 时在同一个应用程序中运行。

如果希望把已有的应用升级到Hibernate3.0，那么升级的第一步是把Java源程序中的所有“net.sf.hibernate”替换为“org.hibernate”。

Hibernate2.1中的“net.sf.hibernate.expression”包被改名为“org.hibernate.criterion”。假如应用程序使用了Criteria API，那么在升级的过程中，必须把Java源程序中的所有“net.sf.hibernate.expression”替换为“org.hibernate.criterion”。

如果应用使用了除Hibernate以外的其他外部软件，而这个外部软件又引用了Hibernate的接口，那么在升级时必须十分小心。例如EHCache拥有自己的CacheProvider： net.sf.ehcache.hibernate.Provider，在这个类中引用了Hibernate2.1中的接口，在升级应用时，可以采用以下办法之一来升级EHCache:

（1）手工修改net.sf.ehcache.hibernate.Provider类，使它引用Hibernate3.0中的接口。
（2）等到EHCache软件本身升级为使用Hibernate3.0后，使用新的EHCache软件。
（3）使用Hibernate3.0中内置的CacheProvider：org.hibernate.cache.EhCacheProvider。

1.1.2 org.hibernate.classic包

Hibernate3.0把一些被废弃的接口都转移到org.hibernate.classic中。

1.1.3 Hibernate所依赖的第三方软件包

在Hibernate3.0的软件包的lib目录下的README.txt文件中，描述了Hibernate3.0所依赖的第三方软件包的变化。

1.1.4 异常模型

在Hibernate3.0中，HibernateException异常以及它的所有子类都继承了java.lang.RuntimeException。因此在编译时，编译器不会再检查HibernateException。

1.1.5 Session接口

在Hibernate3.0中，原来Hibernate2.1的Session接口中的有些基本方法也被废弃，但为了简化升级，这些方法依然是可用的，可以通过org.hibernate.classic.Session子接口来访问它们，例如：

org.hibernate.classic.Session session=sessionFactory.openSession();
session.delete("delete from Customer ");

在Hibernate3.0 中，org.hibernate.classic.Session接口继承了org.hibernate.Session接口，在 org.hibernate.classic.Session接口中包含了一系列被废弃的方法，如find()、interate()等。 SessionFactory接口的openSession()方法返回org.hibernate.classic.Session类型的实例。如果希 望在程序中完全使用Hibernate3.0，可以采用以下方式创建Session实例：

org.hibernate.Session session=sessionFactory.openSession();

如果是对已有的程序进行简单的升级，并且希望仍然调用Hibernate2.1中Session的一些接口，可以采用以下方式创建Session实例：

org.hibernate.classic.Session session=sessionFactory.openSession();

在Hibernate3.0中，Session接口中被废弃的方法包括：
* 执行查询的方法：find()、iterate()、filter()和delete(String hqlSelectQuery)
* saveOrUpdateCopy()

Hibernate3.0一律采用createQuery()方法来执行所有的查询语句，采用DELETE 查询语句来执行批量删除，采用merge()方法来替代 saveOrUpdateCopy()方法。

提 示：在Hibernate2.1中，Session的delete()方法有几种重载形式，其中参数为HQL查询语句的delete()方法在 Hibernate3.0中被废弃，而参数为Ojbect类型的的delete()方法依然被支持。delete(Object o)方法用于删除参数指定的对象，该方法支持级联删除。

Hibernate2.1没有对批量更 新和批量删除提供很好的支持，参见<<精通Hibernate>>一书的第13章的13.1.1节（批量更新和批量删除），而 Hibernate3.0对批量更新和批量删除提供了支持，能够直接执行批量更新或批量删除语句，无需把被更新或删除的对象先加载到内存中。以下是通过 Hibernate3.0执行批量更新的程序代码：

Session session = sessionFactory.openSession();
Transaction tx = session.beginTransaction();

String hqlUpdate = "update Customer set name = :newName where name = :oldName";
int updatedEntities = s.createQuery( hqlUpdate )
.setString( "newName", newName )
.setString( "oldName", oldName )
.executeUpdate();
tx.commit();
session.close();

以下是通过Hibernate3.0执行批量删除的程序代码：

Session session = sessionFactory.openSession();
Transaction tx = session.beginTransaction();

String hqlDelete = "delete Customer where name = :oldName";
int deletedEntities = s.createQuery( hqlDelete )
.setString( "oldName", oldName )
.executeUpdate();
tx.commit();
session.close();

1.1.6 createSQLQuery()

在Hibernate3.0中，Session接口的createSQLQuery()方法被废弃，被移到org.hibernate.classic.Session接口中。Hibernate3.0采用新的SQLQuery接口来完成相同的功能。

1.1.7 Lifecycle 和 Validatable 接口

Lifecycle和Validatable 接口被废弃，并且被移到org.hibernate.classic包中。

1.1.8 Interceptor接口

在Interceptor 接口中加入了两个新的方法。 用户创建的Interceptor实现类在升级的过程中，需要为这两个新方法提供方法体为空的实现。此外，instantiate()方法的参数作了修 改，isUnsaved()方法被改名为isTransient()。

1.1.9 UserType和CompositeUserType接口

在UserType和CompositeUserType接口中都加入了一些新的方法，这两个接口被移到org.hibernate.usertype包中，用户定义的UserType和CompositeUserType实现类必须实现这些新方法。

Hibernate3.0提供了ParameterizedType接口，用于更好的重用用户自定义的类型。

1.1.10 FetchMode类

FetchMode.LAZY 和 FetchMode.EAGER被废弃。取而代之的分别为FetchMode.SELECT 和FetchMode.JOIN。

1.1.11 PersistentEnum类

PersistentEnum被废弃并删除。已经存在的应用应该采用UserType来处理枚举类型。

1.1.12 对Blob 和Clob的支持

Hibernate对Blob和Clob实例进行了包装，使得那些拥有Blob或Clob类型的属性的类的实例可以被游离、序列化或反序列化，以及传递到merge()方法中。

1.1.13 Hibernate中供扩展的API的变化

org.hibernate.criterion、 org.hibernate.mapping、 org.hibernate.persister和org.hibernate.collection 包的结构和实现发生了重大的变化。多数基于Hibernate
2.1 的应用不依赖于这些包，因此不会被影响。如果你的应用扩展了这些包中的类，那么必须非常小心的对受影响的程序代码进行升级。

1.2 元数据的变化

1.2.1 检索策略

在Hibernate2.1中，lazy属性的默认值为“false”，而在Hibernate3.0中，lazy属性的默认值为“true”。在升级映 射文件时，如果原来的映射文件中的有关元素，如<set>、<class>等没有显式设置lazy属性，那么必须把它们都显式的 设置为lazy=“true”。如果觉得这种升级方式很麻烦，可以采取另一简单的升级方式：在<hibernate-mapping>元素中 设置: default-lazy=“false”。

1.2.2 对象标识符的映射

unsaved-value属性是可选的，在多数情况下，Hibernate3.0将把unsaved-value="0" 作为默认值。

在Hibernate3.0中，当使用自然主键和游离对象时，不再强迫实现Interceptor.isUnsaved()方法。 如果没有设置这个方法，当Hibernate3.0无法区分对象的状态时，会查询数据库，来判断这个对象到底是临时对象，还是游离对象。不过，显式的使用 Interceptor.isUnsaved()方法会获得更好的性能，因为这可以减少Hibernate直接访问数据库的次数。

1.2.3 集合映射

<index>元素在某些情况下被<list-index>和<map-key>元素替代。此外，Hibernate3.0用<map-key-many-to-many> 元素来替代原来的<key-many-to-many>.元素，用<composite-map-key>元素来替代原来的<composite-index>元素。

1.2.4 DTD

对象-关系映射文件中的DTD文档，由原来的：
http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd
改为：
http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd

1.3 查询语句的变化

Hibernate3.0 采用新的基于ANTLR的HQL/SQL查询翻译器，不过，Hibernate2.1的查询翻译器也依然存在。在Hibernate的配置文件中， hibernate.query.factory_class属性用来选择查询翻译器。例如：
（1）选择Hibernate3.0的查询翻译器：
hibernate.query.factory_class= org.hibernate.hql.ast.ASTQueryTranslatorFactory
（2）选择Hibernate2.1的查询翻译器
hibernate.query.factory_class= org.hibernate.hql.classic.ClassicQueryTranslatorFactory

提示：ANTLR是用纯Java语言编写出来的一个编译工具，它可生成Java语言或者是C++的词法和语法分析器，并可产生语法分析树并对该树进行遍历。ANTLR由于是纯Java的，因此可以安装在任意平台上，但是需要JDK的支持。