十五滴水：Hibernate（六）之Hibernate關聯對映註解

阿新 • • 發佈：2019-02-07

這裡寫圖片描述
如上是我們本篇部落格裡要一起學習的內容
在學習具體的關係對映註解之前呢，我們先來回顧一下資料庫當中實體與實體之間究竟有哪些對映關係：
實體與實體之間的對映關係大體分為三種情況：
1.一對一：一個公民對應一個身份證號碼，反過來也是成立的；
2.一對多（多對一）：一個公民有多個銀行賬號；
3.多對多：一個學生有多個老師同時一個老師有多個學生；
一對一的單項外來鍵關聯首先要用到兩個註解：
[email protected]（cascade=cascadeType.All）：
[email protected]（name=“pid”，unique=true）：
這兩個註解都是寫在我們的主表類當中，onetoone後面的 Cascade表示的是一種級聯關係，cascadeType.All表示的是一種全級聯關係，包括級聯刪除，級聯更新，級聯新增等等。JoinColumn表示把我們的外來鍵要寫到我們的主控類當中,比如說這個pid表示的是身份證這個類裡的主鍵，unique=true 表示它是唯一的，也就是說這個pid在我們的主表當中充當的是一個外來鍵，外來鍵顯然也是唯一的；
值得注意的是，在儲存我們的主表物件之前，應該先儲存我們的外來鍵物件，才能再儲存我們的主表物件。
接下來我們去實際的運用一下一對一單項外來鍵關聯：
新建一個Students實體類作為主控方:

package onetoone;

import java.io.Serializable;
import java.util.Date;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.EmbeddedId;
import javax.persistence.Entity;/*JPA註解*/
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import 
 javax.persistence.JoinColumn;
import javax.persistence.OneToOne;
import javax.persistence.Table;
import javax.persistence.Transient;

//學生實體類 有了這個註解就可以保證我們的實體類將來會對映成資料庫當中的一張表
//@Entity(name="t_students")
@Entity
public class Students implements Serializable {

    private IdCard card;
    private int sid;//學生的學號 

    private String sname;//學生的姓名
    private String gender;//學生的性別
    private Date birthday;//學生的生日
    private String major;//學生的專業

    public Students(){

    }
    public Students( IdCard card,String sname, String gender, Date birthday,
            String major) {
        //super();
        this.card=card;
        this.sname = sname;
        this.gender = gender;
        this.birthday = birthday;
        this.major = major;
        //this.address = address;

    }

    @Id
    @GeneratedValue
    public int getSid() {
        return sid;
    }
    public void setSid(int sid) {
        this.sid = sid;
    }
    @OneToOne(cascade=CascadeType.ALL)
    @JoinColumn(name="pid",unique=true)
    public IdCard getCard() {
        return card;
    }
    public void setCard(IdCard card) {
        this.card = card;
    }
    public String getSname() {
        return sname;
    }
    public void setSname(String sname) {
        this.sname = sname;
    }
    public String getGender() {
        return gender;
    }
    public void setGender(String gender) {
        this.gender = gender;
    }
    public Date getBirthday() {
        return birthday;
    }
    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }
    public String getMajor() {
        return major;
    }
    public void setMajor(String major) {
        this.major = major;
    }


}

新建一個IdCard實體類作為被控方:

package onetoone;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;

import org.hibernate.annotations.GenericGenerator;

//身份證類
@Entity
public class IdCard {
    @Id
    @GeneratedValue(generator="pid")
    @GenericGenerator(name="pid",strategy="assigned")
    @Column(length=18)
    private String pid;//身份證號碼
    private String sname;//學生姓名
    public IdCard(){

    }

    public IdCard(String pid, String sname) {
        super();
        this.pid = pid;
        this.sname = sname;
    }

    public String getPid() {
        return pid;
    }
    public void setPid(String pid) {
        this.pid = pid;
    }
    public String getSname() {
        return sname;
    }
    public void setSname(String sname) {
        this.sname = sname;
    }

}

被控方的主鍵是pid 再新建一個測試類：

package onetoone;

import java.util.Date;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.service.ServiceRegistryBuilder;
import org.hibernate.tool.hbm2ddl.SchemaExport;
import org.junit.Test;

public class TestStudents {
    @Test
    public void testSchemaExport(){
        //建立hibernate配置物件
        Configuration config = new Configuration().configure();
        //建立服務註冊物件
        ServiceRegistry serviceRegistry=new ServiceRegistryBuilder().applySettings(config.getProperties()).buildServiceRegistry();
        //生成sessionFactory
        SessionFactory sessionFactory=config.buildSessionFactory(serviceRegistry);

        SchemaExport export = new SchemaExport(config);
        export.create(true, true);
    }


}

執行結果如下：
這裡寫圖片描述

控制檯輸出顯示我們新建了兩個表：IDCard和Students表
我們再到資料庫中看一下：
這裡寫圖片描述

如圖所示，關聯表是idCard ，外聯欄位是pid。
接下來我們插入進去一條資料來測試一下：

@Test
    public void addStudents(){
        //建立hibernate配置物件
        Configuration config=new Configuration().configure();
        //建立服務註冊物件
        ServiceRegistry serviceRegistry=new ServiceRegistryBuilder().applySettings(config.getProperties()).buildServiceRegistry();
        //生成sessionFactory
        SessionFactory sessionFactory=config.buildSessionFactory(serviceRegistry);
        //建立會話
        Session session=sessionFactory.getCurrentSession();
        //建立事務
        Transaction tx=session.beginTransaction();
        //身份證類的物件
        IdCard card=new IdCard("123456789012345678","張馨");
        //再生成學生物件
        Students s = new Students(card,"女","張馨", new Date(),"軟體工程");
        //先儲存身份證類的物件
        session.save(card);
        //再儲存學生物件
        session.save(s);
        tx.commit();

    }

執行結果：
這裡寫圖片描述

接下來我們來學習一下一對一的雙向外來鍵的關聯關係：
什麼叫做雙向外來鍵呢？就是雙方都持有對方的引用，通俗點來說，就是你中有我，我中有你。
舉例來說就是學生方持有一個身份證的引用，那麼身份證類也持有一個學生的引用，那麼這兩個引用同時都是充當各自表裡的外來鍵；
主控方的配置同一對一的單項外來鍵關聯完全相同，變化主要體現在被控方，被控方在持有對方的引用上面要加上一個@OneToOne(mappedBy=”card”)；mappedBy指定了把我們的控制權交給我們的主控方，這裡要指定主控方所對應的外來鍵屬性；
需要注意的是，我們在實現一對一的雙向外來鍵關聯的時候，被控方必須要設定mappedBy屬性，這是因為雙向外來鍵關聯關係只能交給一方去控制，不可能雙方同時來控制，如果雙方同時來控制，那麼就會造成雙方誰也無法儲存；
我們不妨來設想這樣一種情況：如果是學生持有身份證類的引用，同時身份證持有學生的引用，那麼我們在儲存學生的時候，它會要求我們先儲存身份證，那麼反過來想，如果我們先儲存身份證，它又要求你先儲存一個學生物件，那麼這樣雙方都無法去儲存，所以這就是我們為什麼在做雙向外來鍵關聯關係的時候，最後要把主控權利交給其中的一方，接下來我們來一起了解一下一對一雙向外來鍵關聯的實現過程：
首先我們的主控方Students類不用改，需要改動的是我們的被控方IDCard類：

@OneToOne(mappedBy="card")
    private Students stu;

mappedBy表示的是把控制權交給了我們的主控方card屬性，也就是我們Students的外來鍵card屬性，並更改相應的cfg.xml裡面的配置，剩下其他的都不用改變，執行生成表測試方法的結果如下：
這裡寫圖片描述

接下來我們執行新增資料方法：

emmm發現好像gender和sname的資料寫篡了都是String型別，意會就好~~
一對一單項外來鍵關聯和雙向外來鍵關聯在資料庫上看起來並無區別，所以理解起來稍微有一點抽象，這篇文章的理解思路清晰易懂：
https://www.cnblogs.com/printN/p/6405269.html
接下來我們來學習一下一對一雙向外來鍵聯合主鍵：
這個聯合主鍵我們要藉助一個主鍵類來實現，首先我們來建立一個主鍵類，這個主鍵類它要新增@Embeddble這樣一個註解，同時這個主鍵類有一定的要求，這個主鍵類要實現一個Serializable這樣的一個宣告式介面，同時還必須重寫從父類繼承過來的hashcode（）和equals（）方法；
就是建立完主鍵類之後，我們給這個主鍵類添加了一個類註解叫做@Embeddble，然後我們建立一個對應的實體類，在實體類對應的主鍵聯合主鍵屬性上面我們可以新增@EmbeddedId這樣一個屬性級別的註解，這樣就實現了一個一對一的雙向外來鍵聯合主鍵，這篇的具體實現上一篇部落格有寫就不再寫了（博主已經吐血）
下面我們來學習一下多對一單項外來鍵關聯：
所謂的多對一，就是多方持有一方的引用，比如說多個學生屬於一個班級，在多方我們需要新增下面兩種註解：
這裡寫圖片描述
fetch指的是一種抓取策略，eager表示的是積極的
joincolumn表示多方持有一方的引用一方的外來鍵用name來表示referenceColumnName表示的是對應的外來鍵對映成資料庫中表裡的欄位，我們可以給他起的名稱；
下面我們來具體的操作一下：
新建一個叫做manytoone的包實體類students類複製過來刪掉多餘的屬性，另外新增一個ClassRoom實體類，

package manyToone;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;

import org.hibernate.annotations.GenericGenerator;



//班級實體類
@Entity
public class ClassRoom {
    @Id
    @GeneratedValue(generator="cid")
    @GenericGenerator(name="cid",strategy="assigned")
    @Column(length=4)
    private String cid;//班級的編號
    private String cname;//班級的名字

    public ClassRoom(){

    }
    public String getCid() {
        return cid;
    }
    public void setCid(String cid) {
        this.cid = cid;
    }
    public String getCname() {
        return cname;
    }
    public void setCname(String cname) {
        this.cname = cname;
    }


}

在Students實體類中新增ClassRoom屬性封裝後標註上註解

@ManyToOne(cascade={CascadeType.ALL},fetch=FetchType.EAGER)
    @JoinColumn(name="cid",referencedColumnName="CID")
    public ClassRoom getClassRoom() {
        return classRoom;
    }

新增執行類建立表，得到的結果如下圖所示：
這裡寫圖片描述

我們現在來向其中插入資料：

@Test
    public void addStudents(){
        //建立hibernate配置物件
        Configuration config=new Configuration().configure();
        //建立服務註冊物件
        ServiceRegistry serviceRegistry=new ServiceRegistryBuilder().applySettings(config.getProperties()).buildServiceRegistry();
        //生成sessionFactory
        SessionFactory sessionFactory=config.buildSessionFactory(serviceRegistry);
        //建立會話
        Session session=sessionFactory.getCurrentSession();
        //建立事務
        Transaction tx=session.beginTransaction();
        //建立班級物件
        ClassRoom c1=new ClassRoom("0101","軟體工程");
        ClassRoom c2=new ClassRoom("0202","電腦科學");
        //建立四個學生
        Students s1=new Students("遲人華","男",new Date(),"計算機");
        Students s2=new Students("張馨","女",new Date(),"計算機");
        Students s3=new Students("李四","男",new Date(),"計算機");
        Students s4=new Students("王五","男",new Date(),"計算機");

        s1.setClassRoom(c1);
        s2.setClassRoom(c1);
        s3.setClassRoom(c2);
        s4.setClassRoom(c2);
        //先儲存班級
        session.save(c1);
        session.save(c2);
        //再儲存學生
        session.save(s1);
        session.save(s2);
        session.save(s3);
        session.save(s4);
        tx.commit();

    }

執行結果如下：
這裡寫圖片描述

OK了
下面我們來學習一對多的單項外來鍵關聯關係：
一對多顧名思義就是一方持有多方的集合，比如說一個班級有多個學生，我們需要在一的一方新增以下的註解：

作為一的一方它的抓取策略一般是懶載入，column同時用來表示它的外來鍵的名稱，
通過上面一對多和多對一的學習我們可以總結出來，當一對多的時候我們一的一方是lazy 多對一的時候我們多的一方是eager；
接下來我們來看下具體的實現步驟：
ClassRoom實體類：

package oneTomany;

import java.util.Set;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToMany;

import org.hibernate.annotations.GenericGenerator;



//班級實體類
@Entity
public class ClassRoom {
    @Id
    @GeneratedValue(generator="cid")
    @GenericGenerator(name="cid",strategy="assigned")
    @Column(length=4)
    private String cid;//班級的編號
    private String cname;//班級的名字
    @OneToMany(cascade={CascadeType.ALL},fetch=FetchType.LAZY)
    @JoinColumn(name="cid")
    private Set<Students> stus;//一方持有多方的集合

    public ClassRoom(){

    }

    public ClassRoom(String cid, String cname) {
        super();
        this.cid = cid;
        this.cname = cname;
    }

    public String getCid() {
        return cid;
    }
    public void setCid(String cid) {
        this.cid = cid;
    }
    public String getCname() {
        return cname;
    }
    public void setCname(String cname) {
        this.cname = cname;
    }

    public Set<Students> getStus() {
        return stus;
    }

    public void setStus(Set<Students> stus) {
        this.stus = stus;
    }


}

執行test生成表方法得到下面：
這裡寫圖片描述

插入資料：

@Test
    public void addStudents(){
        //建立hibernate配置物件
        Configuration config=new Configuration().configure();
        //建立服務註冊物件
        ServiceRegistry serviceRegistry=new ServiceRegistryBuilder().applySettings(config.getProperties()).buildServiceRegistry();
        //生成sessionFactory
        SessionFactory sessionFactory=config.buildSessionFactory(serviceRegistry);
        //建立會話
        Session session=sessionFactory.getCurrentSession();
        //建立事務
        Transaction tx=session.beginTransaction();
        //建立班級物件
        ClassRoom c1=new ClassRoom("0101","軟體工程");
        ClassRoom c2=new ClassRoom("0202","電腦科學");
        //建立四個學生
        Students s1=new Students("遲人華","男",new Date(),"計算機");
        Students s2=new Students("張馨","女",new Date(),"計算機");
        Students s3=new Students("李四","男",new Date(),"計算機");
        Students s4=new Students("王五","男",new Date(),"計算機");
        //建立集合
        Set<Students> set1=new HashSet<Students>();
        set1.add(s1);
        set1.add(s2);

        Set<Students> set2=new HashSet<Students>();
        set2.add(s3);
        set2.add(s4);

        c1.setStus(set1);
        c2.setStus(set2);
        //再儲存學生
        session.save(s1);
        session.save(s2);
        session.save(s3);
        session.save(s4);
        //先儲存班級
        session.save(c1);
        session.save(c2);

        tx.commit();

    }

執行結果：
這裡寫圖片描述

接下來我們來學習一對多（多對一）的雙向外來鍵關聯關係
多方：多方持有一方的引用
新增的註解：

一方：一方持有多方的集合

我們只需要把剛剛一對多單向中的 Students類中改動一下即可：

@ManyToOne(cascade={CascadeType.ALL},fetch=FetchType.EAGER)
    @JoinColumn(name="cid")
    public ClassRoom getClassRoom() {
        return classRoom;
    }
    public void setClassRoom(ClassRoom classRoom) {
        this.classRoom = classRoom;
    }

執行結果：
這裡寫圖片描述

接下來我們來學習多對多的單向外來鍵關聯：
比如說學生和教師就是典型的多對多的關聯關係，既然是單向外來鍵關聯，也就是說其中一個多方持有另一個多方的集合物件（學生持有教師的集合），學生和教師這兩個表之間的這種外來鍵關係的維護要依靠中間表，中間表是可以通過註解自動實現的：
這裡寫圖片描述
joinTable 就表示中間表，下面我們實際來做一下

@ManyToMany
    @JoinTable(name="teachers_students",joinColumns={@JoinColumn(name="sid")},inverseJoinColumns={@JoinColumn(name="tid")})
    public Set<Teachers> getTeachers() {
        return teachers;
    }
    public void setTeachers(Set<Teachers> teachers) {
        this.teachers = teachers;
    }

新建教師類作為被控方：

package manyTomany;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
//教師實體類
import javax.persistence.Id;

import org.hibernate.annotations.GenericGenerator;

@Entity
public class Teachers {
    private String tid;//教師的編號
    private String tname;//教師的姓名

    public Teachers(){

    }

    public Teachers(String tid, String tname) {
        super();
        this.tid = tid;
        this.tname = tname;
    }
@Id
@GeneratedValue(generator="tid")
@GenericGenerator(name="tid",strategy="assigned")
@Column(length=4)
    public String getTid() {
        return tid;
    }
    public void setTid(String tid) {
        this.tid = tid;
    }
    public String getTname() {
        return tname;
    }
    public void setTname(String tname) {
        this.tname = tname;
    }


}

執行結果：
這裡寫圖片描述
建立了三張表：學生表教師表和一張中間表
我們來向其中新增幾條資料：

@Test
    public void addStudents(){
        //建立hibernate配置物件
        Configuration config=new Configuration().configure();
        //建立服務註冊物件
        ServiceRegistry serviceRegistry=new ServiceRegistryBuilder().applySettings(config.getProperties()).buildServiceRegistry();
        //生成sessionFactory
        SessionFactory sessionFactory=config.buildSessionFactory(serviceRegistry);
        //建立會話
        Session session=sessionFactory.getCurrentSession();
        //建立事務
        Transaction tx=session.beginTransaction();
        //先建立幾個教師物件
        Teachers t1=new Teachers("0001","張老師");
        Teachers t2=new Teachers("0002","李老師");
        Teachers t3=new Teachers("0003","王老師");
        Teachers t4=new Teachers("0004","劉老師");

        //再建立四個學生物件
        Students s1=new Students("遲人華","男",new Date(),"軟體");
        Students s2=new Students("張馨","女",new Date(),"軟體");
        Students s3=new Students("林玲","女",new Date(),"計算機");
        Students s4=new Students("榴蓮","男",new Date(),"整合");
        //建立教師的集合
        Set<Teachers> set1=new HashSet<Teachers>();
        set1.add(t1);
        set1.add(t2);
        Set<Teachers> set2=new HashSet<Teachers>();
        set2.add(t3);
        set2.add(t4);
        Set<Teachers> set3=new HashSet<Teachers>();
        set3.add(t1);
        set3.add(t3);
        set3.add(t4);
        Set<Teachers> set4=new HashSet<Teachers>();
        set4.add(t2);
        set4.add(t3);
        set4.add(t4);
        s1.setTeachers(set1);
        s2.setTeachers(set2);
        s3.setTeachers(set3);
        s4.setTeachers(set4);
        //先儲存教師
        session.save(t1);
        session.save(t2);
        session.save(t3);
        session.save(t4);
        //再儲存學生
        session.save(s1);
        session.save(s2);
        session.save(s3);
        session.save(s4);
        tx.commit();

    }

執行結果：
這裡寫圖片描述

接下來我們來看一下多對多的雙向外來鍵關聯關係
也就是雙方都持有對方的集合，就是要把主控方交給另外一方，

我們來實際的操作一下需要改的地方只有兩處：在teachers實體類當中新增學生的集合並加上@manyTomany標籤即可，另外需要更改相應的hibernate.cfg.xml裡的配置對映到我們新建的包：

@ManyToMany(mappedBy="teachers")
    private Set<Students> stus;//教師持有學生的集合

執行結果：
這裡寫圖片描述

十五滴水：Hibernate（六）之Hibernate關聯對映註解

十五滴水：Hibernate（六）之Hibernate關聯對映註解

十三滴水：Hibernate（四）之Hibernate註解學習

Oracle PL/SQL進階程式設計（第十五彈：動態SQL語句）

javaweb學習總結(十五)——JSP基礎語法（轉）

斯坦福大學-自然語言處理入門筆記第十五課詞彙化（Lexicalization）的PCFGs

FairyGUI:筆記：Text （六）

《人類簡史》十五、開啟未來（下）——智慧之心

《生命》第五集：Birds （鳥類）

轉：神奇的python（六）之python的串列埠操作（pyserial）

C for Graphic：語言（六）

hibernate（六）多對多關係維護

Scala入門到精通——第二十五節提取器（Extractor）

【SpringCloud Greenwich版本】第五章：斷路器（hystrix）

第二十一章：變換（一）

第二十一章：變換（四）

演算法工程師修仙之路：TensorFlow（六）

第十五週內部排序（2）專案2---大資料集上排序演算法效能的體驗

Hibernate（六）實現一對多、多對一對映關聯關係

第二十五節提取器（Extractor）

小白學 Python 資料分析（7）：Pandas （六）資料匯入

十五滴水：Hibernate（六）之Hibernate關聯對映註解

相關推薦