多對一

 

一個實體簡單的說就是在資料庫中擁有一個表格，並擁有自已的資料庫識別（Database identity）。

一個簡單的實體與實體間之關係為多對一的關係，例如在學校宿舍中，使用者與房間的關係就是多對一的關係，多個使用者可以居住於一個房間。

如上圖所示的，可以藉由room_id讓使用者與房間產生關聯，您可以如下建立user與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;
    }   
}

 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：

<?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 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=?