Hibernate 3.6.10.Final ²Î¿¼ÊÖ²á ÖÐÎÄ°æ

On the database level collection instances are distinguished by the foreign key of the entity that owns the collection. This foreign key is referred to as the collection key column, or columns, of the collection table. The collection key column is mapped by the @JoinColumn annotation respectively the <key> XML element.

There can be a nullability constraint on the foreign key column. For most collections, this is implied. For unidirectional one-to-many associations, the foreign key column is nullable by default, so you may need to specify

@JoinColumn(nullable=false)

or

<key column="productSerialNumber" not-null="true"/>

The foreign key constraint can use ON DELETE CASCADE. In XML this can be expressed via:

<key column="productSerialNumber" on-delete="cascade"/>

In annotations the Hibernate specific annotation @OnDelete has to be used.

@OnDelete(action=OnDeleteAction.CASCADE)

See 第 5.1.11.3 节 “Key” for more information about the <key> element.

In the following paragraphs we have a closer at the indexed collections List and Map how the their index can be mapped in Hibernate.

@Entity

public class Customer {

   @Id @GeneratedValue public Integer getId() { return id; }

   public void setId(Integer id) { this.id = id; }

   private Integer id;


   @OneToMany(mappedBy="customer")

   @OrderBy("number")

   public List<Order> getOrders() { return orders; }

   public void setOrders(List<Order> orders) { this.orders = orders; }

   private List<Order> orders;

}


@Entity

public class Order {

   @Id @GeneratedValue public Integer getId() { return id; }

   public void setId(Integer id) { this.id = id; }

   private Integer id;


   public String getNumber() { return number; }

   public void setNumber(String number) { this.number = number; }

   private String number;


   @ManyToOne

   public Customer getCustomer() { return customer; }

   public void setCustomer(Customer customer) { this.customer = customer; }

   private Customer number;

}


-- Table schema

|-------------| |----------|

| Order       | | Customer |

|-------------| |----------|

| id          | | id       |

| number      | |----------| 

| customer_id |

|-------------|

@Entity

public class Customer {

   @Id @GeneratedValue public Integer getId() { return id; }

   public void setId(Integer id) { this.id = id; }

   private Integer id;


   @OneToMany(mappedBy="customer")

   @OrderColumn(name="orders_index")

   public List<Order> getOrders() { return orders; }

   public void setOrders(List<Order> orders) { this.orders = orders; }

   private List<Order> orders;

}


@Entity

public class Order {

   @Id @GeneratedValue public Integer getId() { return id; }

   public void setId(Integer id) { this.id = id; }

   private Integer id;


   public String getNumber() { return number; }

   public void setNumber(String number) { this.number = number; }

   private String number;


   @ManyToOne

   public Customer getCustomer() { return customer; }

   public void setCustomer(Customer customer) { this.customer = customer; }

   private Customer number;

}


-- Table schema

|--------------| |----------|

| Order        | | Customer |

|--------------| |----------|

| id           | | id       |

| number       | |----------| 

| customer_id  |

| orders_order |

|--------------|

<list-index
        column="column_name"
        base="0|1|..."/>

@Entity

public class Customer {

   @Id @GeneratedValue public Integer getId() { return id; }

   public void setId(Integer id) { this.id = id; }

   private Integer id;


   @OneToMany(mappedBy="customer")

   @MapKey(name="number")

   public Map<String,Order> getOrders() { return orders; }

   public void setOrders(Map<String,Order> order) { this.orders = orders; }

   private Map<String,Order> orders;

}


@Entity

public class Order {

   @Id @GeneratedValue public Integer getId() { return id; }

   public void setId(Integer id) { this.id = id; }

   private Integer id;


   public String getNumber() { return number; }

   public void setNumber(String number) { this.number = number; }

   private String number;


   @ManyToOne

   public Customer getCustomer() { return customer; }

   public void setCustomer(Customer customer) { this.customer = customer; }

   private Customer number;

}


-- Table schema

|-------------| |----------|

| Order       | | Customer |

|-------------| |----------|

| id          | | id       |

| number      | |----------| 

| customer_id |

|-------------|

@Entity

public class Customer {

   @Id @GeneratedValue public Integer getId() { return id; }

   public void setId(Integer id) { this.id = id; }

   private Integer id;


   @OneToMany @JoinTable(name="Cust_Order")

   @MapKeyColumn(name="orders_number")

   public Map<String,Order> getOrders() { return orders; }

   public void setOrders(Map<String,Order> orders) { this.orders = orders; }

   private Map<String,Order> orders;

}


@Entity

public class Order {

   @Id @GeneratedValue public Integer getId() { return id; }

   public void setId(Integer id) { this.id = id; }

   private Integer id;


   public String getNumber() { return number; }

   public void setNumber(String number) { this.number = number; }

   private String number;


   @ManyToOne

   public Customer getCustomer() { return customer; }

   public void setCustomer(Customer customer) { this.customer = customer; }

   private Customer number;

}


-- Table schema

|-------------| |----------| |---------------|

| Order       | | Customer | | Cust_Order    |

|-------------| |----------| |---------------|

| id          | | id       | | customer_id   |

| number      | |----------| | order_id      |

| customer_id |              | orders_number |

|-------------|              |---------------|

<map-key
        column="column_name"
        formula="any SQL expression"
        type="type_name"
        node="@attribute-name"
        length="N"/>

<map-key-many-to-many
        column="column_name"
        formula="any SQL expression"
        class="ClassName"
/>

In some situations you don't need to associate two entities but simply create a collection of basic types or embeddable objects. Use the @ElementCollection for this case.

@Entity

public class User {

   [...]

   public String getLastname() { ...}


   @ElementCollection

   @CollectionTable(name="Nicknames", joinColumns=@JoinColumn(name="user_id"))

   @Column(name="nickname")

   public Set<String> getNicknames() { ... } 

}

The collection table holding the collection data is set using the @CollectionTable annotation. If omitted the collection table name defaults to the concatenation of the name of the containing entity and the name of the collection attribute, separated by an underscore. In our example, it would be User_nicknames.

The column holding the basic type is set using the @Column annotation. If omitted, the column name defaults to the property name: in our example, it would be nicknames.

But you are not limited to basic types, the collection type can be any embeddable object. To override the columns of the embeddable object in the collection table, use the @AttributeOverride annotation.

@Entity

public class User {

   [...]

   public String getLastname() { ...}


   @ElementCollection

   @CollectionTable(name="Addresses", joinColumns=@JoinColumn(name="user_id"))

   @AttributeOverrides({

      @AttributeOverride(name="street1", column=@Column(name="fld_street"))

   })

   public Set<Address> getAddresses() { ... } 

}


@Embeddable

public class Address {

   public String getStreet1() {...}

   [...]

}

Such an embeddable object cannot contains a collection itself.

@Entity

public class User {

   @ElementCollection

   @AttributeOverrides({

      @AttributeOverride(name="key.street1", column=@Column(name="fld_street")),

      @AttributeOverride(name="value.stars", column=@Column(name="fld_note"))

   })

   public Map<Address,Rating> getFavHomes() { ... }

Using the mapping file approach a collection of values is mapped using the <element> tag. For example:

<element
        column="column_name"
        formula="any SQL expression"
        type="typename"
        length="L"
        precision="P"
        scale="S"
        not-null="true|false"
        unique="true|false"
        node="element-name"
/>

Hibernate supports collections implementing java.util.SortedMap and java.util.SortedSet. With annotations you declare a sort comparator using @Sort. You chose between the comparator types unsorted, natural or custom. If you want to use your own comparator implementation, you'll also have to specify the implementation class using the comparator attribute. Note that you need to use either a SortedSet or a SortedMap interface.

@OneToMany(cascade=CascadeType.ALL, fetch=FetchType.EAGER)

@JoinColumn(name="CUST_ID")

@Sort(type = SortType.COMPARATOR, comparator = TicketComparator.class)

public SortedSet<Ticket> getTickets() {

    return tickets;

}

Using Hibernate mapping files you specify a comparator in the mapping file with <sort>:

<set name="aliases"

            table="person_aliases" 

            sort="natural">

    <key column="person"/>

    <element column="name" type="string"/>

</set>



<map name="holidays" sort="my.custom.HolidayComparator">

    <key column="year_id"/>

    <map-key column="hol_name" type="string"/>

    <element column="hol_date" type="date"/>

</map>

sort 属性中允许的值包括 unsorted，natural 和某个实现了 java.util.Comparator 的类的名称。

If you want the database itself to order the collection elements, use the order-by attribute of set, bag or map mappings. This solution is implemented using LinkedHashSet or LinkedHashMap and performs the ordering in the SQL query and not in the memory.

<set name="aliases" table="person_aliases" order-by="lower(name) asc">

    <key column="person"/>

    <element column="name" type="string"/>

</set>



<map name="holidays" order-by="hol_date, hol_name">

    <key column="year_id"/>

    <map-key column="hol_name" type="string"/>

    <element column="hol_date type="date"/>

</map>

关联还可以在运行时使用集合 filter() 根据任意的条件来排序：

              
              sortedUsers 
              
              =
              
               s
              
              .
              
              createFilter
              
              (
              
               group
              
              .
              
              getUsers
              
              (),
              
               
              
              "order by this.name"
              
               
              
              ).
              
              list
              
              ();
            

双向关联允许通过关联的任一端访问另外一端。在 Hibernate 中，支持两种类型的双向关联：

Often there exists a many to one association which is the owner side of a bidirectional relationship. The corresponding one to many association is in this case annotated by @OneToMany(mappedBy=...)

@Entity

public class Troop {

    @OneToMany(mappedBy="troop")

    public Set<Soldier> getSoldiers() {

    ...

}


@Entity

public class Soldier {

    @ManyToOne

    @JoinColumn(name="troop_fk")

    public Troop getTroop() {

    ...

}           

Troop has a bidirectional one to many relationship with Soldier through the troop property. You don't have to (must not) define any physical mapping in the mappedBy side.

To map a bidirectional one to many, with the one-to-many side as the owning side, you have to remove the mappedBy element and set the many to one @JoinColumn as insertable and updatable to false. This solution is not optimized and will produce additional UPDATE statements.

@Entity

public class Troop {

    @OneToMany

    @JoinColumn(name="troop_fk") //we need to duplicate the physical information

    public Set<Soldier> getSoldiers() {

    ...

}


@Entity

public class Soldier {

    @ManyToOne

    @JoinColumn(name="troop_fk", insertable=false, updatable=false)

    public Troop getTroop() {

    ...

}

How does the mappping of a bidirectional mapping look like in Hibernate mapping xml? There you define a bidirectional one-to-many association by mapping a one-to-many association to the same table column(s) as a many-to-one association and declaring the many-valued end inverse="true".

<class name="Parent">

    <id name="id" column="parent_id"/>

    ....

    <set name="children" inverse="true">

        <key column="parent_id"/>

        <one-to-many class="Child"/>

    </set>

</class>



<class name="Child">

    <id name="id" column="child_id"/>

    ....

    <many-to-one name="parent" 

        class="Parent" 

        column="parent_id"

        not-null="true"/>

</class>

在“一”这一端定义 inverse="true" 不会影响级联操作，二者是正交的概念。

A many-to-many association is defined logically using the @ManyToMany annotation. You also have to describe the association table and the join conditions using the @JoinTable annotation. If the association is bidirectional, one side has to be the owner and one side has to be the inverse end (ie. it will be ignored when updating the relationship values in the association table):

@Entity

public class Employer implements Serializable {

    @ManyToMany(

        targetEntity=org.hibernate.test.metadata.manytomany.Employee.class,

        cascade={CascadeType.PERSIST, CascadeType.MERGE}

    )

    @JoinTable(

        name="EMPLOYER_EMPLOYEE",

        joinColumns=@JoinColumn(name="EMPER_ID"),

        inverseJoinColumns=@JoinColumn(name="EMPEE_ID")

    )

    public Collection getEmployees() {

        return employees;

    }

    ...

}              

@Entity

public class Employee implements Serializable {

    @ManyToMany(

        cascade = {CascadeType.PERSIST, CascadeType.MERGE},

        mappedBy = "employees",

        targetEntity = Employer.class

    )

    public Collection getEmployers() {

        return employers;

    }

}                

In this example @JoinTable defines a name, an array of join columns, and an array of inverse join columns. The latter ones are the columns of the association table which refer to the Employee primary key (the "other side"). As seen previously, the other side don't have to (must not) describe the physical mapping: a simple mappedBy argument containing the owner side property name bind the two.

As any other annotations, most values are guessed in a many to many relationship. Without describing any physical mapping in a unidirectional many to many the following rules applied. The table name is the concatenation of the owner table name, _ and the other side table name. The foreign key name(s) referencing the owner table is the concatenation of the owner table name, _ and the owner primary key column(s). The foreign key name(s) referencing the other side is the concatenation of the owner property name, _, and the other side primary key column(s). These are the same rules used for a unidirectional one to many relationship.

@Entity

public class Store {

    @ManyToMany(cascade = CascadeType.PERSIST)

    public Set<City> getImplantedIn() {

        ...

    }

}


@Entity

public class City {

    ... //no bidirectional relationship

}             

A Store_City is used as the join table. The Store_id column is a foreign key to the Store table. The implantedIn_id column is a foreign key to the City table.

Without describing any physical mapping in a bidirectional many to many the following rules applied. The table name is the concatenation of the owner table name, _ and the other side table name. The foreign key name(s) referencing the owner table is the concatenation of the other side property name, _, and the owner primary key column(s). The foreign key name(s) referencing the other side is the concatenation of the owner property name, _, and the other side primary key column(s). These are the same rules used for a unidirectional one to many relationship.

@Entity

public class Store {

    @ManyToMany(cascade = {CascadeType.PERSIST, CascadeType.MERGE})

    public Set<Customer> getCustomers() {

        ...

    }

}


@Entity

public class Customer {

    @ManyToMany(mappedBy="customers")

    public Set<Store> getStores() {

        ...

    }

}             

A Store_Customer is used as the join table. The stores_id column is a foreign key to the Store table. The customers_id column is a foreign key to the Customer table.

Using Hibernate mapping files you can map a bidirectional many-to-many association by mapping two many-to-many associations to the same database table and declaring one end as inverse.

例 7.27 “Many to many association using Hibernate mapping files” shows a bidirectional many-to-many association that illustrates how each category can have many items and each item can be in many categories:

<class name="Category">

    <id name="id" column="CATEGORY_ID"/>

    ...

    <bag name="items" table="CATEGORY_ITEM">

        <key column="CATEGORY_ID"/>

        <many-to-many class="Item" column="ITEM_ID"/>

    </bag>

</class>



<class name="Item">

    <id name="id" column="ITEM_ID"/>

    ...



    <!-- inverse end -->

    <bag name="categories" table="CATEGORY_ITEM" inverse="true">

        <key column="ITEM_ID"/>

        <many-to-many class="Category" column="CATEGORY_ID"/>

    </bag>

</class>

如果只对关联的反向端进行了改变，这个改变不会被持久化。 这表示 Hibernate 为每个双向关联在内存中存在两次表现，一个从 A 连接到 B，另一个从 B 连接到 A。如果你回想一下 Java 对象模型，我们是如何在 Java 中创建多对多关系的，这可以让你更容易理解：

category.getItems().add(item);           // The category now "knows" about the relationship

item.getCategories().add(category);      // The item now "knows" about the relationship


session.persist(item);                   // The relationship won't be saved!

session.persist(category);               // The relationship will be saved

非反向端用于把内存中的表示保存到数据库中。

There are some additional considerations for bidirectional mappings with indexed collections (where one end is represented as a <list> or <map>) when using Hibernate mapping files. If there is a property of the child class that maps to the index column you can use inverse="true" on the collection mapping:

<class name="Parent">

    <id name="id" column="parent_id"/>

    ....

    <map name="children" inverse="true">

        <key column="parent_id"/>

        <map-key column="name" 

            type="string"/>

        <one-to-many class="Child"/>

    </map>

</class>



<class name="Child">

    <id name="id" column="child_id"/>

    ....

    <property name="name" 

        not-null="true"/>

    <many-to-one name="parent" 

        class="Parent" 

        column="parent_id"

        not-null="true"/>

</class>

但是，假若子类中没有这样的属性存在，我们不能认为这个关联是真正的双向关联（信息不对称，在关联的一端有一些另外一端没有的信息）。在这种情况下，我们不能使用 inverse="true"。我们需要这样用：

<class name="Parent">

    <id name="id" column="parent_id"/>

    ....

    <map name="children">

        <key column="parent_id"

            not-null="true"/>

        <map-key column="name" 

            type="string"/>

        <one-to-many class="Child"/>

    </map>

</class>



<class name="Child">

    <id name="id" column="child_id"/>

    ....

    <many-to-one name="parent" 

        class="Parent" 

        column="parent_id"

        insert="false"

        update="false"

        not-null="true"/>

</class>

注意在这个映射中，关联中集合类"值"一端负责来更新外键。

有三种可能的途径来映射一个三重关联。第一种是使用一个 Map，把一个关联作为其索引：

@Entity

public class Company {

   @Id 

   int id;

   ...

   @OneToMany // unidirectional

   @MapKeyJoinColumn(name="employee_id")

   Map<Employee, Contract> contracts;

}



// or



<map name="contracts">

    <key column="employer_id" not-null="true"/>

    <map-key-many-to-many column="employee_id" class="Employee"/>

    <one-to-many class="Contract"/>

</map>

A second approach is to remodel the association as an entity class. This is the most common approach. A final alternative is to use composite elements, which will be discussed later.

The majority of the many-to-many associations and collections of values shown previously all map to tables with composite keys, even though it has been suggested that entities should have synthetic identifiers (surrogate keys). A pure association table does not seem to benefit much from a surrogate key, although a collection of composite values might. For this reason Hibernate provides a feature that allows you to map many-to-many associations and collections of values to a table with a surrogate key.

<idbag> 属性让你使用 bag 语义来映射一个 List （或 Collection）。

<idbag name="lovers" table="LOVERS">

    <collection-id column="ID" type="long">

        <generator class="sequence"/>

    </collection-id>

    <key column="PERSON1"/>

    <many-to-many column="PERSON2" class="Person" fetch="join"/>

</idbag>

你可以理解，<idbag> 人工的 id 生成器，就好像是实体类一样！集合的每一行都有一个不同的人造关键字。但是，Hibernate 没有提供任何机制来让你取得某个特定行的人造关键字。

注意 <idbag> 的更新性能要比普通的 <bag> 高得多！Hibernate 可以有效的定位到不同的行，分别进行更新或删除工作，就如同处理一个 list，map 或者 set 一样。

在目前的实现中，还不支持使用 identity 标识符生成器策略来生成 <idbag> 集合的标识符。