实体与实体之间的多对1、一对多、一对1、多对多如何与Java对象之间进行映像

 

上一篇: 用 Spring 更好地处理 Struts 动做三种整合 Struts 应用程序与 Spring 的方式

 |  下一篇: HQL（Hibernate Query Language)

  实体与实体之间的多对1、一对多、一对1、多对多如何与Java对象之间进行映像   

10．1多对一

一个实体简单的说就是在数据库中拥有一个表格，并拥有自已的数据库识别（Database identity）。

一个简单的实体与实体间之关系为多对一的关系，例如在学校宿舍中，使用者与房间的关系就是多对一的关系，多个使用者能够居住于一个房间。

如上图所示的，能够藉由room_id让使用者与房间产生关联，您能够以下创建user与room表格：

CREATE TABLE user (

    id INT(11) NOT NULL auto_increment PRIMARY KEY,

    name VARCHAR(100) NOT NULL default '',

    room_id INT(11)

);

 

CREATE TABLE room (

    id INT(11) NOT NULL auto_increment PRIMARY KEY,

    address VARCHAR(100) NOT NULL default ''

);

用程序来表示的话，首先看看User类别：

User.java

package onlyfun.caterpillar;

 

public class User {

    private Integer id;

    private String name;

    private Room room;

 

    public User() {

    }

 

    public Integer getId() {

        return id;

    }

 

    public void setId(Integer id) {

        this.id = id;

    }

 

    public String getName() {

        return name;

    }

 

    public void setName(String name) {

        this.name = name;

    }

 

    public Room getRoom() {

        return room;

    }

 

    public void setRoom(Room room) {

        this.room = room;

    }  

}

User类别中有一room属性，将参考至Room实例，多个User实例可共同参考一个Room实例，Room类别设计以下：

Room.java

package onlyfun.caterpillar;

 

public class Room {

    private Integer id;

    private String address;

   

    public Room() {

    }

   

    public Integer getId() {

        return id;

    }

    public void setId(Integer id) {

        this.id = id;

    }   

   

    public String getAddress() {

        return address;

    }

   

    public void setAddress(String address) {

        this.address = address;

    }

}

在映射文件方面，先来看看Room.hbm.xml：

Room.hbm.xml

<?xml version="1.0" encoding="utf-8"?>

<!DOCTYPE hibernate-mapping

    PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"

    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

 

<hibernate-mapping>

 

    <class name="onlyfun.caterpillar.Room" table="room">

        <id name="id" column="id">

            <generator class="native"/>

        </id>

 

        <property name="address"

                  column="address"

                  type="java.lang.String"/>

    </class>

 

</hibernate-mapping>

没什么，很简单的一个映射文件，而在User.hbm.xml中，使用<many-to-one>标签来映像多对一关系：

User.hbm.xml

<?xml version="1.0" encoding="utf-8"?>

<!DOCTYPE hibernate-mapping

    PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"

    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

 

<hibernate-mapping>

 

    <class name="onlyfun.caterpillar.User" table="user">

        <id name="id" column="id" type="java.lang.Integer">

            <generator class="native"/>

        </id>

 

        <property name="name" column="name" type="java.lang.String"/>

       

        <many-to-one name="room"

                     column="room_id"

                     class="onlyfun.caterpillar.Room"

                     cascade="all"

                     outer-join="true"/>        

    </class>

 

</hibernate-mapping>

在<many-to-one>的设定中，cascade表示主控方（User）进行save-update、delete等相关操做时，被控方（Room）是否也一并进行相关操做，简单的说，也就是您储存或更新User实例时，当中的Room实例是否一并对数据库发生储存或操做，设定为 all，表示主控方任何操做，被控方也进行对应操做。

注意到room_id 与 onlyfun.caterpillar.Room 对应 那么room_id的值为 Room的id；

一个储存的例子以下：

Room room1 = new Room();

room1.setAddress("NTU-M8-419");

Room room2 = new Room();

room2.setAddress("NTU-G3-302");

       

User user1 = new User();

user1.setName("bush");

user1.setRoom(room1);

       

User user2 = new User();

user2.setName("caterpillar");

user2.setRoom(room1);

       

User user3 = new User();

user3.setName("momor");

user3.setRoom(room2);

 

Session session = sessionFactory.openSession();

Transaction tx = session.beginTransaction();

       

session.save(user1); // 主控方操做，被控方也会对应操做

session.save(user2);

session.save(user3);

       

tx.commit();

session.close();

 

数据库中将储存如下的内容：

mysql> select * from user;

+-------+-------------+-----------+

| id    | name    | room_id |

+-------+-------------+-----------+

|  1   | bush     |      1 |

|  2   | caterpillar |      1 |

|  3   | momor   |      2 |

+-------+-------------+-----------+

3 rows in set (0.00 sec)

 

mysql> select * from room;

+----+-------------------+

| id | address        |

+----+-------------------+

|  1 | NTU-M8-419  |

|  2 | NTU-G3-302  |

+----+-------------------+

2 rows in set (0.00 sec)

 

在查询时的例子以下：

Session session = sessionFactory.openSession();

User user = (User) session.load(User.class, new Integer(1));

System.out.println(user.getName());

System.out.println(user.getRoom().getAddress());

session.close();

 

在设定outer-join为true的状况下，Hibernate将使用如下的SQL一次查询全部的数据：

Hibernate:

select user0_.id as id1_, user0_.name as name0_1_, user0_.room_id as room3_0_1_,

room1_.id as id0_, room1_.address as address1_0_ from user user0_

left outer join room room1_ on user0_.room_id=room1_.id where user0_.id=?

在不设定outer-join为true的状况下，Hibernate则使用如下的SQL分别查询user与room表格：

Hibernate:

select user0_.id as id0_, user0_.name as name0_0_, user0_.room_id as room3_0_0_

from user user0_ where user0_.id=?

Hibernate:

select room0_.id as id0_, room0_.address as address1_0_

from room room0_ where room0_.id=?

10．2 cascade 的意义

在Java程序中，对象与对象之间会透过某些关系互相参考，若是有一个对象已是持久化对象，被它参考的对象直觉上也应该要持久化，以维持对象之间关联的完整性，这是藉由可达性完成持久化（Persistence by reachability）的基本概念。

若是将对象之间的关联想象为一个树形图，从某一个持久化物件为树根出发，父节点如果持久化对象，则被父节点参考到的子节点应自动持久化，而另外一方面，若是有一子节点没办法藉由任何的父节点来参考至它，则它没有被持久化的需求，它应从数据库中加以删除。

Hibernate并无彻底实现以上的概念，它让使用者自行决定自动持久化的方式，当对象之间被指定关联（例如多对1、一对多等），您能够决定被持久化对象关联的暂存对象是否进行自动持久化与如何自动持久化。

在Hibernate中是以映像文件中卷标上的cascade属性来设定，预设上是none，以多对一中的范例来讲，若是不设定cascade为true，则您必须分别对User实例与Room实例进行储存：

Room room1 = new Room();

room1.setAddress("NTU-M8-419");

Room room2 = new Room();

room2.setAddress("NTU-G3-302");

       

User user1 = new User();

user1.setName("bush");

user1.setRoom(room1);

       

User user2 = new User();

user2.setName("caterpillar");

user2.setRoom(room1);

       

User user3 = new User();

user3.setName("momor");

user3.setRoom(room2);

 

Session session = sessionFactory.openSession();

Transaction tx = session.beginTransaction();

 

// 储存Room实例

session.save(room1);

session.save(room2);        

// 储存User实例

session.save(user1);

session.save(user2);

session.save(user3);

       

tx.commit();

session.close();

使用cascade自动持久化时，会先检查被关联对象的id属性，未被持久化的对象是否储存是藉由id属性的unsaved-value决定，预设是 null，也就是没有参考至任何值时储存对象，若是您使用int、long这样的原生型态（Primitive type）时，因为数据成员的初始会被设定为0，因此您必须自行指定默认值，例如（若是id的数据型态是long的话）：

....

        <id name="id" column="id" unsaved-value="0">

            <generator class="native"/>

        </id>

....

10．3一对多

在多对一中，User对Room是多对一的关系，User实例维护着对Room实例的参考，若是将这个关系反过来，由Room实例维护对多个User实例的数据，就是一对多的关系。

具体来讲，能够设计User类别以下：

User.java

package onlyfun.caterpillar;

 

public class User {

    private Integer id;

    private String name;

   

    public User() {

    }

 

    public Integer getId() {

        return id;

    }

 

    public void setId(Integer id) {

        this.id = id;

    }

 

    public String getName() {

        return name;

    }

 

    public void setName(String name) {

        this.name = name;

    }

}

而在Room类别中，使用Set来记录多个User：

Room.java

package onlyfun.caterpillar;

 

import java.util.Set;

 

public class Room {

    private Integer id;

    private String address;

    private Set users;

   

    public Room() {

    }

   

    public Integer getId() {

        return id;

    }

    public void setId(Integer id) {

        this.id = id;

    }   

   

    public String getAddress() {

        return address;

    }

   

    public void setAddress(String address) {

        this.address = address;

    }

 

    public Set getUsers() {

        return users;

    }

 

    public void setUsers(Set users) {

        this.users = users;

    }

   

    public void addUser(User user) {

        users.add(user);       

    }

   

    public void removeUser(User user) {

        users.remove(user);

    }

}

这种方式即所谓单向一对多关系，也就是Room实例知道User实例的存在，而User实例则没有意识到Room实例。
（在多对一中，则是单向多对一关系，即User知道Room的存在，但Room不知道User的存在。）

在映射文件上，先来看看User.hbm.xml：

User.hbm.xml

<?xml version="1.0" encoding="utf-8"?>

<!DOCTYPE hibernate-mapping

    PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"

    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

 

<hibernate-mapping>

 

    <class name="onlyfun.caterpillar.User" table="user">

        <id name="id" column="id" type="java.lang.Integer">

            <generator class="native"/>

        </id>

 

        <property name="name" column="name" type="java.lang.String"/>

       

    </class>

 

</hibernate-mapping>

在单向关系中，被参考的对象其映像文件就如单一实体同样的配置，接下来看看Room.hbm.xml，使用<one-to-many>卷标配置一对多：

Room.hbm.xml

<?xml version="1.0" encoding="utf-8"?>

<!DOCTYPE hibernate-mapping

    PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"

    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

 

<hibernate-mapping>

    <class name="onlyfun.caterpillar.Room" table="room">

        <id name="id" column="id">

            <generator class="native"/>

        </id>

        <property name="address"

                  column="address"

                  type="java.lang.String"/>

                 

        <set name="users" table="user" cascade="all">

            <key column="room_id"/>

            <one-to-many class="onlyfun.caterpillar.User"/>

        </set>

    </class>

</hibernate-mapping>

接着您能够以下储存对象：

User user1 = new User();

user1.setName("bush");

       

User user2 = new User();

user2.setName("caterpillar");

       

User user3 = new User();

user3.setName("momor");

 

Room room1 = new Room();

room1.setUsers(new HashSet());

room1.setAddress("NTU-M8-419");

room1.addUser(user1);

room1.addUser(user2);

       

Room room2 = new Room();

room2.setUsers(new HashSet());

room2.setAddress("NTU-G3-302");

room2.addUser(user3);

        

Session session = sessionFactory.openSession();

Transaction tx = session.beginTransaction();

       

session.save(room1);  // cascade 操做

session.save(room2);

       

tx.commit();

session.close();

数据库中将储存如下的表格：

mysql> select * from user;

+----+-------------+-----------+

| id | name      | room_id   |

+----+-------------+------------+

|  1 | bush     |         1 |

|  2 | caterpillar |         1 |

|  3 | momor   |         2 |

+----+-------------+------------+

3 rows in set (0.01 sec)

 

mysql> select * from room;

+----+------------------+

| id | address       |

+----+------------------+

|  1 | NTU-M8-419 |

|  2 | NTU-G3-302 |

+----+------------------+

2 rows in set (0.00 sec)

10．4双向关联（inverse 的意义

在多对1、一对多中都是单向关联，也就是其中一方关联到另外一方，而另外一方不知道本身被关联。

若是让双方都意识到另外一方的存在，这就造成了双向关联，在多对1、一对多的例子能够改写一下，从新设计User类别以下：

User.java

package onlyfun.caterpillar;

 

public class User {

    private Integer id;

    private String name;

    private Room room;

   

    public User() {

    }

 

    public Integer getId() {

        return id;

    }

 

    public void setId(Integer id) {

        this.id = id;

    }

 

    public String getName() {

        return name;

    }

 

    public void setName(String name) {

        this.name = name;

    }

 

    public Room getRoom() {

        return room;

    }

 

    public void setRoom(Room room) {

        this.room = room;

    }

}

Room类别以下：

Room.java

package onlyfun.caterpillar;

 

import java.util.Set;

 

public class Room {

    private Integer id;

    private String address;

    private Set users;

   

    public Room() {

    }

   

    public Integer getId() {

        return id;

    }

    public void setId(Integer id) {

        this.id = id;

    }   

   

    public String getAddress() {

        return address;

    }

   

    public void setAddress(String address) {

        this.address = address;

    }

 

    public Set getUsers() {

        return users;

    }

 

    public void setUsers(Set users) {

        this.users = users;

    }

   

    public void addUser(User user) {

        users.add(user);        

    }

   

    public void removeUser(User user) {

        users.remove(user);

    }

}

如此，User实例可参考至Room实例而维持多对一关系，而Room实例记得User实例而维持一对多关系。

在映射文件方面，能够以下撰写：

User.hbm.xml

<?xml version="1.0" encoding="utf-8"?>

<!DOCTYPE hibernate-mapping

    PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"

    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

 

<hibernate-mapping>

 

    <class name="onlyfun.caterpillar.User" table="user">

        <id name="id" column="id" type="java.lang.Integer">

            <generator class="native"/>

        </id>

        <property name="name" column="name" type="java.lang.String"/>        

        <many-to-one name="room"

                     column="room_id"

                     class="onlyfun.caterpillar.Room"

                     cascade="save-update"

                     outer-join="true"/>   

    </class>

 

</hibernate-mapping>

 

Room.hbm.xml

<?xml version="1.0" encoding="utf-8"?>

<!DOCTYPE hibernate-mapping

    PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"

    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

 

<hibernate-mapping>

 

    <class name="onlyfun.caterpillar.Room" table="room">

        <id name="id" column="id">

            <generator class="native"/>

        </id>

 

        <property name="address"

                  column="address"

                  type="java.lang.String"/>

                 

        <set name="users" table="user" cascade="save-update">

            <key column="room_id"/>

            <one-to-many class="onlyfun.caterpillar.User"/>

        </set>

    </class>

 

</hibernate-mapping>

映像文件双方都设定了cascade为save-update，因此您能够用多对一的方式来维持关联：

User user1 = new User();

user1.setName("bush");

       

User user2 = new User();

user2.setName("caterpillar");

 

Room room1 = new Room();

room1.setAddress("NTU-M8-419");

 

user1.setRoom(room1);

user2.setRoom(room1);

       

Session session = sessionFactory.openSession();

Transaction tx = session.beginTransaction();

       

session.save(user1);

session.save(user2);

 

tx.commit();

session.close();

或是反过来由一对多的方式来维持关联：

User user1 = new User();

user1.setName("bush");

       

User user2 = new User();

user2.setName("caterpillar");

 

Room room1 = new Room();

room1.setUsers(new HashSet());

room1.setAddress("NTU-M8-419");

room1.addUser(user1);

room1.addUser(user2);

       

Session session = sessionFactory.openSession();

Transaction tx = session.beginTransaction();

       

session.save(room1);

 

tx.commit();

session.close();

这边有个效率议题能够探讨，上面的程序片断Hibernate将使用如下的SQL进行储存：

Hibernate: insert into room (address) values (?)

Hibernate: insert into user (name, room_id) values (?, ?)

Hibernate: insert into user (name, room_id) values (?, ?)

Hibernate: update user set room_id=? where id=?

Hibernate: update user set room_id=? where id=?

上面的程序写法表示关联由Room单方面维持，而主控方也是Room，User不知道Room的room_id是多少，因此必须分别储存Room与User以后，再更新user的room_id。

在一对多、多对一造成双向关联的状况下，能够将关联维持的控制权交给多的一方，这样会比较有效率，理由不难理解，就像是在公司中，老板要记住多个员工的姓名快，仍是每个员工都记得老板的姓名快。

因此在一对多、多对一造成双向关联的状况下，能够在「一」的一方设定控制权反转，也就是当储存「一」的一方时，将关联维持的控制权交给「多」的一方，以上面的例子来讲，能够设定Room.hbm.xml以下：

Room.hbm.xml

<?xml version="1.0" encoding="utf-8"?>

<!DOCTYPE hibernate-mapping

    PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"

    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

 

<hibernate-mapping>

 

    <class name="onlyfun.caterpillar.Room" table="room">

        <id name="id" column="id">

            <generator class="native"/>

        </id>

 

        <property name="address"

                  column="address"

                  type="java.lang.String"/>

                 

        <set name="users" table="user" cascade="save-update" inverse="true">

            <key column="room_id"/>

            <one-to-many class="onlyfun.caterpillar.User"/>

        </set>

    </class>

 

</hibernate-mapping>

因为关联的控制权交给「多」的一方了，因此直接储存「一」方前，「多」的一方必须意识到「一」的存在，因此程序片断必须改成以下：

User user1 = new User();

user1.setName("bush");

       

User user2 = new User();

user2.setName("caterpillar");

 

Room room1 = new Room();

room1.setUsers(new HashSet());

room1.setAddress("NTU-M8-419");

room1.addUser(user1);

room1.addUser(user2);

 

// 多方必须意识到单方的存在

user1.setRoom(room1);

user2.setRoom(room1);

       

Session session = sessionFactory.openSession();

Transaction tx = session.beginTransaction();

       

session.save(room1);

 

tx.commit();

session.close();

上面的程序片断Hibernate将使用如下的SQL：

Hibernate: insert into room (address) values (?)

Hibernate: insert into user (name, room_id) values (?, ?)

Hibernate: insert into user (name, room_id) values (?, ?)

若是控制权交给另外一方了，而另外一方没有意识到对方的存在的话会如何？试着将上面的程序片断中user1.setRoom(room1);与user2.setRoom(room1);移去，执行以后，您会发现数据库中room_id会出现null值，这种结果就比如在多对一中，您没有分配给User一个Room，理所固然的，room_id会出现null。

10．5 一对一（惟一外键关联）

如今考虑每个User配给一间Room，造成一对一，user表格透过room_id做为外键参考至room：

在表格创建方面，使用多对一中的表格创建语句就能够了：

CREATE TABLE user (

    id INT(11) NOT NULL auto_increment PRIMARY KEY,

    name VARCHAR(100) NOT NULL default '',

    room_id INT(11)

);

 

CREATE TABLE room (

    id INT(11) NOT NULL auto_increment PRIMARY KEY,

    address VARCHAR(100) NOT NULL default ''

);

对象方面，User的实例会参考至Room实例，而Room实例也参考至User实例：

User.java

package onlyfun.caterpillar;

 

public class User {

    private Integer id;

    private String name;

    private Room room;

   

    public User() {

    }

 

    public Integer getId() {

        return id;

    }

 

    public void setId(Integer id) {

        this.id = id;

    }

 

    public String getName() {

        return name;

    }

 

    public void setName(String name) {

        this.name = name;

    }

 

    public Room getRoom() {

        return room;

    }

 

    public void setRoom(Room room) {

        this.room = room;

    }

}

Room.java

package onlyfun.caterpillar;

 

public class Room {

    private Integer id;

    private String address;

    private User user;

   

    public Room() {

    }

   

    public Integer getId() {

        return id;

    }

    public void setId(Integer id) {

        this.id = id;

    }   

   

    public String getAddress() {

        return address;

    }

   

    public void setAddress(String address) {

        this.address = address;

    }

 

    public User getUser() {

        return user;

    }

 

    public void setUser(User user) {

        this.user = user;

    }

}

使用外键来完成一对一，其实就是限制多对一关系中，「多」的一方只能有一个参考至「一」的一方，也就是多对一关系的一个特例，这能够在映像文件中使用<many-to-one>标签时，加上"unique"属性来设定，例如：

User.hbm.xml

<?xml version="1.0" encoding="utf-8"?>

<!DOCTYPE hibernate-mapping

    PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"

    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

 

<hibernate-mapping>

 

    <class name="onlyfun.caterpillar.User" table="user">

        <id name="id" column="id" type="java.lang.Integer">

            <generator class="native"/>

        </id>

 

        <property name="name" column="name" type="java.lang.String"/>

       

        <many-to-one name="room"

                     column="room_id"

                     class="onlyfun.caterpillar.Room"

                     cascade="all"

                     outer-join="true"

                     unique="true"/>   

    </class>

 

</hibernate-mapping>

到这边为止，单向一对一的映像已经完成，若是要再完成双向一对一的关系，则能够在Room.hbm.xml中使用<one-to-one>标签来定义：

Room.hbm.xml

<?xml version="1.0" encoding="utf-8"?>

<!DOCTYPE hibernate-mapping

    PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"

    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

 

<hibernate-mapping>

 

    <class name="onlyfun.caterpillar.Room" table="room">

        <id name="id" column="id">

            <generator class="native"/>

        </id>

 

        <property name="address"

                  column="address"

                  type="java.lang.String"/>

                 

        <one-to-one name="user"

                    class="onlyfun.caterpillar.User"

                    property-ref="room"/>

    </class>

 

</hibernate-mapping>

在<one-to-one>中，property-ref告诉Hibernate，查询出user并将其参考至room。

一个储存的例子以下：

User user1 = new User();

user1.setName("bush");

Room room1 = new Room();

room1.setAddress("NTU-M8-419");

user1.setRoom(room1);

       

User user2 = new User();

user2.setName("caterpillar");

Room room2 = new Room();

room2.setAddress("NTU-M8-418");

user2.setRoom(room2);

       

Session session = sessionFactory.openSession();

Transaction tx = session.beginTransaction();

 

session.save(user1);

session.save(user2);

       

tx.commit();

session.close();

 

在查询Room时，User也会一加载，例如：

Session session = sessionFactory.openSession();

Room room = (Room) session.load(Room.class, new Integer(23));

System.out.println(room.getUser().getName());

session.close();

 

上面的查询程序，Hibernate将使用如下的SQL：

Hibernate:

select

  room0_.id as id1_, room0_.address as address1_1_, user1_.id as id0_, user1_.name as name0_0_,

  user1_.room_id as room3_0_0_

from room room0_ left outer join user user1_ on room0_.id=user1_.room_id where room0_.id=?

10．6一对一（主键关联）

一对一关联的另外一种方式，是限制两个实体的主键必须一致，如此直接透过两个表格的主键就可肯定一对一关联，而不用额外的外键参考。

例如user与room表格，能够以下创建：

CREATE TABLE user (

    id INT(11) NOT NULL auto_increment PRIMARY KEY,

    name VARCHAR(100) NOT NULL default ''

);

 

CREATE TABLE room (

    id INT(11) NOT NULL auto_increment PRIMARY KEY,

    address VARCHAR(100) NOT NULL default ''

);

User类别与Room类别的设计使用一对一（惟一外键关联）中的设计便可，接着在User.hbm.xml方面以下设计：

User.hbm.xml

<?xml version="1.0" encoding="utf-8"?>

<!DOCTYPE hibernate-mapping

    PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"

    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

 

<hibernate-mapping>

 

    <class name="onlyfun.caterpillar.User" table="user">

        <id name="id" column="id" type="java.lang.Integer">

            <generator class="native"/>

        </id>

 

        <property name="name" column="name" type="java.lang.String"/>

       

        <one-to-one name="room"

                    class="onlyfun.caterpillar.Room"

                    cascade="all"/>

    </class>

 

</hibernate-mapping>

在Room.hbm.xml的设计方面以下：

Room.hbm.xml

<?xml version="1.0" encoding="utf-8"?>

<!DOCTYPE hibernate-mapping

    PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"

    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

 

<hibernate-mapping>

 

    <class name="onlyfun.caterpillar.Room" table="room">

        <id name="id" column="id">

            <generator class="foreign">

                <param name="property">user</param>

            </generator>

        </id>

 

        <property name="address"

                  column="address"

                  type="java.lang.String"/>

                 

        <one-to-one name="user"

                    class="onlyfun.caterpillar.User"

                    constrained="true"/>

    </class>

 

</hibernate-mapping>

在Room的id主键上，使用foreign表示与外键共享主键，也就是与User实体共享主键，而constrained设定为true，表示约束room的主键必须与user中对应数据的主键相同。

一个储存的实例以下：

User user1 = new User();

user1.setName("bush");

Room room1 = new Room();

room1.setAddress("NTU-M8-419");

       

// 互相设定关联

user1.setRoom(room1);

room1.setUser(user1);

       

User user2 = new User();

user2.setName("caterpillar");

Room room2 = new Room();

room2.setAddress("NTU-M8-418");

       

// 互相设定关联

user2.setRoom(room2);

room2.setUser(user2);

       

Session session = sessionFactory.openSession();

Transaction tx = session.beginTransaction();

 

session.save(user1);

session.save(user2);

       

tx.commit();

session.close();

数据库中将有如下的储存结果：

mysql> select * from user;

+----+-------------+

| id | name      |

+----+-------------+

|  1 | bush     |

|  2 | caterpillar |

+----+-------------+

2 rows in set (0.00 sec)

 

mysql> select * from room;

+----+------------------+

| id | address       |

+----+------------------+

|  1 | NTU-M8-419 |

|  2 | NTU-M8-418 |

+----+------------------+

2 rows in set (0.00 sec)

10．7多对多

在数据库表格上要进行多对多对应，能够藉由一个中介表格来完成，也就是藉由多对1、一对多来完成多对多关联。

多对多因为使用了中介表格，在查询效率不彰，且在程序的对象模式上，多对多会使得对象与对象之间彼此依赖，并非一个很好的设计方式，在设计上应避免使用多对多关系。

若是必定要使用多对多关系的话，在表格上先以下创建：

CREATE TABLE user (

    id INT(11) NOT NULL auto_increment PRIMARY KEY,

    name VARCHAR(100) NOT NULL default ''

);

 

CREATE TABLE user_server (

    user_id INT(11),

    server_id INT(11)

);

 

CREATE TABLE server (

    id INT(11) NOT NULL auto_increment PRIMARY KEY,

    address VARCHAR(100) NOT NULL default ''

);

先设计User类别以下：

User.java

package onlyfun.caterpillar;

 

import java.util.Set;

 

public class User {

    private Integer id;

    private String name;

    private Set servers;

   

    public User() {

    }

 

    public Integer getId() {

        return id;

    }

 

    public void setId(Integer id) {

        this.id = id;

    }

 

    public String getName() {

        return name;

    }

 

    public void setName(String name) {

        this.name = name;

    }

 

    public Set getServers() {

        return servers;

    }

 

    public void setServers(Set servers) {

        this.servers = servers;

    }

}

再来设计Server类别以下：

Server.java

package onlyfun.caterpillar;

 

import java.util.Set;

 

public class Server {

    private Integer id;

    private String address;

    private Set users;

   

    public String getAddress() {

        return address;

    }

   

    public void setAddress(String address) {

        this.address = address;

    }

   

    public Integer getId() {

        return id;

    }

   

    public void setId(Integer id) {

        this.id = id;

    }

   

    public Set getUsers() {

        return users;

    }

   

    public void setUsers(Set users) {

        this.users = users;

    }

}

在映像文件上，使用<many-to-many>标签来完成映像关系：

User.hbm.xml

<?xml version="1.0" encoding="utf-8"?>

<!DOCTYPE hibernate-mapping

    PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"

    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

 

<hibernate-mapping>

 

    <class name="onlyfun.caterpillar.User" table="user">

        <id name="id" column="id" type="java.lang.Integer">

            <generator class="native"/>

        </id>

 

        <property name="name" column="name" type="java.lang.String"/>

 

        <set name="servers"

             table="user_server"

             cascade="save-update">

            

            <key column="user_id"/>

            <many-to-many class="onlyfun.caterpillar.Server"

                          column="server_id"/>           

        </set>

    </class>

 

</hibernate-mapping>

注意到cascade是设定为save-update，由于在多对多的关系中，不多由于删除其中之一，而所关联的实体都要一并删除的，因此设定save-update，表示在save或update时，一并对关联的对象进行对应的save或update。

Server.hbm.xml的定义以下：

Server.hbm.xml

<?xml version="1.0" encoding="utf-8"?>

<!DOCTYPE hibernate-mapping

    PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"

    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

 

<hibernate-mapping>

 

    <class name="onlyfun.caterpillar.Server" table="server">

 

        <id name="id" column="id">

            <generator class="native"/>

        </id>

 

        <property name="address" type="java.lang.String"/>

       

        <set name="users"

             table="user_server"

             inverse="true"

             cascade="save-update">

             

             <key column="server_id"/>

             <many-to-many class="onlyfun.caterpillar.User"

                           column="user_id"/>

        </set>

    </class>

 

</hibernate-mapping>

一个储存时的例子以下：

Server server1 = new Server();

server1.setAddress("PC-219");

server1.setUsers(new HashSet());

       

Server server2 = new Server();

server2.setAddress("PC-220");

server2.setUsers(new HashSet());

       

Server server3 = new Server();

server3.setAddress("PC-221");

server3.setUsers(new HashSet());

       

User user1 = new User();

user1.setName("caterpillar");

user1.setServers(new HashSet());

       

User user2 = new User();

user2.setName("momor");

user2.setServers(new HashSet());

 

// 多对多，互相参考

user1.getServers().add(server1);

user1.getServers().add(server2);

user1.getServers().add(server3);

server1.getUsers().add(user1);

server2.getUsers().add(user1);

server3.getUsers().add(user1);

       

user2.getServers().add(server1);

user2.getServers().add(server3);

server1.getUsers().add(user2);

server3.getUsers().add(user2);

       

Session session = sessionFactory.openSession();

Transaction tx= session.beginTransaction();

session.save(user1);

session.save(user2);

       

tx.commit();

session.close();

执行后数据库的内容以下：

mysql> select * from user;

+----+--------------+

| id | name         |

+----+--------------+

|  1 | caterpillar  |

|  2 | momor        |

+----+--------------+

2 rows in set (0.00 sec)

 

mysql> select * from user_serv

+----------+-------------+

| user_id  | server_id   |

+----------+-------------+

|       1  |           1 |

|       1  |           2 |

|       1  |           3 |

|       2  |           1 |

|       2  |           2 |

+----------+-------------+

5 rows in set (0.00 sec)

 

mysql> select * from server;

+----+-----------+

| id | address   |

+----+-----------+

|  1 | PC-219    |

|  2 | PC-221    |

|  3 | PC-220    |

+----+-----------+

3 rows in set (0.00 sec)

 

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=1351899