Hibernate 多對一關聯查詢

 版權聲明：本文為博主原創文章，如需轉載請標注轉載地址。

 博客地址：http://www.cnblogs.com/caoyc/p/5598269.html 

一、單向多對一和雙向多對一的區別

　　如果只需要從一方獲取另一方數據，就用單向多對一；如果需要從雙方都獲取對方數據，就用雙向多對一。

　　如果有兩個對象，一個為User對象，一個為Department對象，一個用戶只能屬於一個部門，而一個部門可以包含多個用戶。這樣就是多對一關系。如下圖

　　

　　　　假設：我們需要通過用戶找到所對應的部門，不需要通過部門查詢該部門有哪些用戶，就采用單向多對一關系

　　　　如果：我們不僅需要通過用戶獲取所對應的部門，還需要通過部門對象獲取該部門下的用戶，那么就采用雙向多對一

 

二、單向多對一關系

　　Department.java

package com.proc.pojo;

import java.io.Serializable;

public class Department implements Serializable {

    private Integer id;
    private String deptname;
    
    //提供構造方法
    public Department() {
    }
    
    public Department(String deptname) {
        this.deptname = deptname;
    }

    //getter和setter實現
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getDeptname() {
        return deptname;
    }
    public void setDeptname(String deptname) {
        this.deptname = deptname;
    }
}

　　User.java

package com.proc.pojo;

import java.io.Serializable;

public class User implements Serializable {

    private Integer id;
    private String name;
    private Department dept;
    
    //提供構造方法
    public User() {
    }
    public User(String name) {
        this.name = name;
    }
    //getter和setter實現
    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 Department getDept() {
        return dept;
    }
    public void setDept(Department dept) {
        this.dept = dept;
    }
}

　　Department.hbm.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.proc.pojo">
    <class name="Department" table="department">
        <id name="id" type="int">
            <generator class="native"></generator>
        </id>
        <property name="deptname" length="20" not-null="true"></property>
    </class>
</hibernate-mapping>

　　User.hbm.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.proc.pojo">
    <class name="User">
        <id name="id" type="int">
            <generator class="native"></generator>
        </id>
        <property name="name" length="20" not-null="true"></property>
        <many-to-one name="dept" column="deptid" class="Department" ></many-to-one>
    </class>
</hibernate-mapping>

 　  代碼講解：在配置User（多）->Department(一)時，采用外鍵映射，其中

　　name="dept"：User對象dept屬性

　　class="Department"：表示該dept屬性的類型是Department類型，因為User和Department在同一個包中，所以直接使用了類名稱

　　column="deptid"：指定在用user表中，對應department表的中主鍵的列為deptid

　　這里並沒有指出user表中deptid對應的值department表中哪一列，默認為主鍵，這里也會自動給deptid列添加一個外鍵約束

　　foreign-key="none"：不創建外鍵約束，如果將none改成其他的，即為指定外鍵名稱

　　測試代碼：

package com.proc.test;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.junit.Test;

import com.proc.pojo.Department;
import com.proc.pojo.User;

public class TestOneToMany {

    private static SessionFactory factory=new Configuration()
                                .configure()
                                .addClass(User.class)
                                .addClass(Department.class)
                                .buildSessionFactory();
    @Test
    public void set(){
        
        Session session=factory.openSession();
        Transaction tran=session.beginTransaction();
        Department dept1=new Department("IT部");
        
        User user1=new User("caoyc");
        User user2=new User("zhh");
        
        user1.setDept(dept1);
        user2.setDept(dept1);
        
        session.save(dept1);
        session.save(user1);
        session.save(user2);
        
        tran.commit();
        session.close();
    }
}

　　 在控制台輸出SQL語句：

Hibernate: create table department (id integer not null auto_increment, deptname varchar(20) not null, primary key (id))
Hibernate: create table User (id integer not null auto_increment, name varchar(20) not null, deptid integer, primary key (id))
Hibernate: alter table User add constraint FK66lqw6kl2gcxhs44gamc91fbd foreign key (deptid) references department (id)

Hibernate: insert into department (deptname) values (?)
Hibernate: insert into User (name, deptid) values (?, ?)
Hibernate: insert into User (name, deptid) values (?, ?)

 

測試：如果將測試代碼中32-34行代碼改成

session.save(user1);
session.save(user2);
session.save(dept1);

 　　在控制台輸出SQL語句：

Hibernate: create table department (id integer not null auto_increment, deptname varchar(20) not null, primary key (id))
Hibernate: create table User (id integer not null auto_increment, name varchar(20) not null, deptid integer, primary key (id))
Hibernate: alter table User add constraint FK66lqw6kl2gcxhs44gamc91fbd foreign key (deptid) references department (id)

Hibernate: insert into User (name, deptid) values (?, ?)
Hibernate: insert into User (name, deptid) values (?, ?)
Hibernate: insert into department (deptname) values (?)
Hibernate: update User set name=?, deptid=? where id=?
Hibernate: update User set name=?, deptid=? where id=?

　　這里多出了兩行update User代碼，也就是在我們先添加向user表中插入數據時，而還在department總還沒有數據，當插入department數據后，在通過update的方式來修改user表

　　總結：在我們插入多對一關系時，需要先保存（一）的一方，然后在保存（多）的一方，這樣可以減少SQL執行語句，如果是單向多對一關系，在添加多對一關系，只需要在（多）的一方的映射文件（.hbm.xml）中添加many-to-one就可以了

 

單向多對一刪除操作：

　　a、刪除（多）的一方（User），刪除成功

　　b、刪除（一）的一方（Department），如果user表中沒有該部門的用戶，則刪除成功

　　c、刪除（一）的一方（Department），如果user表中還有改部門的用戶，則刪除失敗，因為有外鍵約束

 

三、雙向多對一操作

　　第一步：在Department.java中添加一個users屬性，並提供get和set方法

private Set<User> users;
public Set<User> getUsers() {
    return users;
}
public void setUsers(Set<User> users) {
    this.users = users;
}

　　第二步：在Department.hbm.xml中添加關聯映射

 

既可以通過User的到Department，也可以通過Department得到Set<User>

 

雙向多對一刪除：

　　a、刪除（多）的一方，總是成功

　　b、刪除（少）的一方，如果inverse=“false”，成功

　　c、刪除（少）的一方，如果inverse=“true”，失敗