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