ITEEDU

Hibernate Gossip: 双向关联（inverse 的意义）

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

如果让双方都意识到另一方的存在，这就形成了双向关联，在多对一、一对多的例子可以改写一下，重新设计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。