Hibernate【對映】知識要點

Java3y發表於2018-03-08

前言

前面的我們使用的是一個表的操作,但我們實際的開發中不可能只使用一個表的...因此,本博文主要講解關聯對映

集合對映

需求分析:當使用者購買商品,使用者可能有多個地址。

資料庫表

我們一般如下圖一樣設計資料庫表,一般我們不會在User表設計多個列來儲存地址的。因為每個使用者的地址個數都不一的,會造成資料冗餘

  • 建立兩張資料表,一張儲存著使用者的資訊,一張儲存著地址的資訊。地址表使用外來鍵來引用使用者表

這裡寫圖片描述

實體

由於地址只是使用String型別來儲存著,那麼我們直接使用一個User物件就可以了


public class User {
    
    private String id;
    private String username;
    private String password;
    private Set<String> address;

	//各種setter和getter
複製程式碼

對映檔案


<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<!--在domain包下-->
<hibernate-mapping package="zhongfucheng.domain">

    <class name="User" table="user">

        <!--主鍵對映-->
        <id name="id" column="id" >
            <generator class="native"/>
        </id>

        <!--普通欄位對映-->
        <property name="username" column="username"></property>
        <property name="password" column="password"></property>

        <!--
             Set:
                name: 對映集合的名稱
                table:集合的屬性要對映到哪張表(address)
             key:
                column:指定要對映的表(address)中的外來鍵列
                element:要對映的表的其他欄位
                    型別一定要指定!
        -->
        <set name="address" table="address">
            <key column="user_id"></key>
            <element column="addr" type="string"></element>
        </set>


    </class>
</hibernate-mapping>

複製程式碼

測試:


package zhongfucheng.domain;

import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.classic.Session;

/**
 * Created by ozc on 2017/5/6.
 */
public class App {
    public static void main(String[] args) {

        //建立物件

        User user = new User();
        user.setUsername("123");
        user.setPassword("1234");
        user.getAddress().add("廣州");


        //獲取載入配置管理類
        Configuration configuration = new Configuration();

        //載入User的對映檔案!
        configuration.configure().addClass(User.class);

        //建立Session工廠物件
        SessionFactory factory = configuration.buildSessionFactory();

        //得到Session物件
        Session session = factory.openSession();

        //使用Hibernate運算元據庫,都要開啟事務,得到事務物件
        Transaction transaction = session.getTransaction();

        //開啟事務
        transaction.begin();

        session.save(user);
        //提交事務
        transaction.commit();

        //關閉Session
        session.close();
    }
}

複製程式碼

這裡寫圖片描述


List集合對映配置

既然我們現在已經會了如何配置Set集合了,List集合又怎麼配置呢??

想一下,List集合和Set集合有什麼區別...List集合是有序的,因此要多配置一個列來維護資料的有序性!

        <list name="address" table="address">
            <key column="user_id"></key>

            <!--index是關鍵字,不能使用!!!!-->
            <list-index column="indexNum"></list-index>
            <element column="addr" type="string"></element>
        </list>
複製程式碼

Map集合對映配置

Map集合和Collection集合的區別就是鍵值對模型,那麼在配置的時候多一個key即可!


        <map name="address" table="address">
            <key column="user_id"  ></key>
            <map-key type="string" column="short"></map-key>
            <element type="string" column="addr"></element>
        </map>
複製程式碼

這裡寫圖片描述


一對多和多對一

上面我們講解了集合對映是怎麼配置的,那集合裝載的元素有沒有可能是物件呢??而不是簡單的String型別..那個就太多了!一般地,我們集合裝載的都是物件,而不是簡單的String,如果我們的裝載在集合的資料有很多型別,那麼String就不能用了!...

需求:部門與員工之間的關係

  • 一個部門有多個員工; 【一對多】
  • 多個員工,屬於一個部門 【多對一】

設計資料庫表

員工表應該使用一個外來鍵來記住部門表。這樣才可以維護員工和部門之間的關係

這裡寫圖片描述

設計實體

部門實體要使用一個集合來記住所有的員工,員工要使用一個物件引用著部門

這裡寫圖片描述

  • Dept.java
package zhongfucheng.domain;

import java.util.HashSet;
import java.util.Set;

/**
 * Created by ozc on 2017/5/6.
 */
public class Dept {
    private int id ;

    private Set<Employee> set = new HashSet<>();

    private String deptName;

    public String getDeptName() {
        return deptName;
    }

    public void setDeptName(String deptName) {
        this.deptName = deptName;
    }


    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public Set<Employee> getSet() {
        return set;
    }

    public void setSet(Set<Employee> set) {
        this.set = set;
    }
}


複製程式碼
  • Employee.java

package zhongfucheng.domain;

/**
 * Created by ozc on 2017/5/6.
 */
public class Employee {


    private int id;
    private String empName;
    private double salary;
    private Dept dept;

    public Dept getDept() {
        return dept;
    }

    public void setDept(Dept dept) {
        this.dept = dept;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getEmpName() {
        return empName;
    }

    public void setEmpName(String empName) {
        this.empName = empName;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }
}

複製程式碼

對映分析

我們在寫對映配置檔案之前,分析一下怎麼寫。以部門對映配置檔案為例...

現在使用了一個Set集合來維護與員工的關係,Set集合的型別是員工物件...因此在對映檔案中需要以下幾點

  • 對映集合屬性的名稱(employees)
  • 對映集合對應的資料表(employee)
  • 對應的資料表的外來鍵欄位(dept_id)
  • 集合中的元素型別(Employee)【通過這個型別,Hibernate就可以找到對應型別的對映檔案,從而得到對應的資訊!】

這裡寫圖片描述

部門對映配置檔案


<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<!--在domain包下-->
<hibernate-mapping package="zhongfucheng.domain">

    <class name="Dept" table="dept">
        <id column="id" name="id">
            <generator class="native">

            </generator>
        </id>
        
        <!--普通欄位對映-->
        <property name="deptName" column="deptname"></property>

        <!--維護關係的是Set集合,對應employee表-->
        <set  cascade="save-update" name="set" table="employee">

            <!--employee的外來鍵列是dept_no-->
            <key column="dept_no"></key>

            <!--一個部門對應多個員工,集合的型別是Employee-->
            <one-to-many class="Employee" ></one-to-many>
        </set>
    </class>

</hibernate-mapping>

複製程式碼

員工對映配置檔案


<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<!--在domain包下-->
<hibernate-mapping package="zhongfucheng.domain">

    <class name="Employee" table="employee">
        <id column="id" name="id">
            <generator class="native">

            </generator>
        </id>

        <!--普通欄位資料-->
        <property name="empName" column="empName"></property>
        <property name="salary" column="salary"></property>

        <!--Hibernate這個標籤可看成在當前表中設定一個外來鍵dept_no-->
        <many-to-one name="dept" class="Dept" column="dept_no"></many-to-one>
    </class>

</hibernate-mapping>

複製程式碼

在“一”的一方測試


package zhongfucheng.domain;

import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.classic.Session;

/**
 * Created by ozc on 2017/5/6.
 */
public class App {
    public static void main(String[] args) {

        //建立物件
        Dept dept = new Dept();
        dept.setDeptName("開發部");

        Employee zs = new Employee();
        zs.setEmpName("張珊");
        zs.setSalary(1111);
        Employee ls = new Employee();
        ls.setEmpName("李四");
        ls.setSalary(2222);

        //新增關係
        dept.getSet().add(zs);
        dept.getSet().add(ls);

        //獲取載入配置管理類
        Configuration configuration = new Configuration();

        //載入User的對映檔案!
        configuration.configure().addClass(Dept.class).addClass(Employee.class);

        //建立Session工廠物件
        SessionFactory factory = configuration.buildSessionFactory();

        //得到Session物件
        Session session = factory.openSession();

        //使用Hibernate運算元據庫,都要開啟事務,得到事務物件
        Transaction transaction = session.getTransaction();

        //開啟事務
        transaction.begin();


        session.save(dept);
        session.save(zs);
        session.save(ls);

        //提交事務
        transaction.commit();

        //關閉Session
        session.close();
    }
}

複製程式碼

Hibernate執行了5條SQL語句

這裡寫圖片描述


在“多”的一方測試


package zhongfucheng.domain;

import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.classic.Session;

/**
 * Created by ozc on 2017/5/6.
 */
public class App {
    public static void main(String[] args) {

        //建立物件
        Dept dept = new Dept();
        dept.setDeptName("開發部");

        Employee zs = new Employee();
        zs.setEmpName("張珊");
        zs.setSalary(1111);
        Employee ls = new Employee();
        ls.setEmpName("李四");
        ls.setSalary(2222);

        //維護關係
        zs.setDept(dept);
        ls.setDept(dept);



        //獲取載入配置管理類
        Configuration configuration = new Configuration();

        //載入User的對映檔案!
        configuration.configure().addClass(Dept.class).addClass(Employee.class);

        //建立Session工廠物件
        SessionFactory factory = configuration.buildSessionFactory();

        //得到Session物件
        Session session = factory.openSession();

        //使用Hibernate運算元據庫,都要開啟事務,得到事務物件
        Transaction transaction = session.getTransaction();

        //開啟事務
        transaction.begin();


        session.save(dept);
        session.save(zs);
        session.save(ls);



        //提交事務
        transaction.commit();

        //關閉Session
        session.close();
    }
}

複製程式碼

Hibernate執行了3條SQL

這裡寫圖片描述

一對多和多對一總結

在一對多與多對一的關聯關係中,儲存資料最好的通過多的一方來維護關係,這樣可以減少update語句的生成,從而提高hibernate的執行效率!

  • 配置一對多與多對一, 這種叫“雙向關聯”
  • 只配置一對多, 叫“單項一對多”
  • 只配置多對一, 叫“單項多對一”

值得注意是:配置了哪一方,哪一方才有維護關聯關係的許可權!

  • 當我在部門中不配置員工的關聯關係了,那麼在操作部門的時候就不能得到員工的資料了【也就是:在儲存部門時,不能同時儲存員工的資料】

多對多對映

需求:一個專案由多個員工開發,一個員工開發多個專案

設計資料庫表

一般地,如果是多對多的對映,我們都會使用一張中間表來儲存它們的關聯關係....

這裡寫圖片描述

設計實體

我們在設計實體的時候,一般是核心資料表對應一個JavaBean實體【中間表並不是核心資料表】,那麼我們將會設計兩個JavaBean物件

這裡寫圖片描述

project.java


package zhongfucheng.many2many;

import java.util.HashSet;
import java.util.Set;

/**
 * Created by ozc on 2017/5/7.
 */


public class Project {
    
    private int projectId;
    private String projectName;

    //使用Set集合與developer實體維護關係
    private Set<Developer> developers = new HashSet<>();

    public int getProjectId() {
        return projectId;
    }

    public void setProjectId(int projectId) {
        this.projectId = projectId;
    }

    public String getProjectName() {
        return projectName;
    }

    public void setProjectName(String projectName) {
        this.projectName = projectName;
    }

    public Set<Developer> getDevelopers() {
        return developers;
    }

    public void setDevelopers(Set<Developer> developers) {
        this.developers = developers;
    }
}

複製程式碼

developer.java



package zhongfucheng.many2many;

import java.util.HashSet;
import java.util.Set;

/**
 * Created by ozc on 2017/5/7.
 */
public class Developer {

    private int developerId;
    private String developerName;

    //使用Set集合來維護與Project關係
    private Set<Project> projects = new HashSet<>();


    public int getDeveloperId() {
        return developerId;
    }

    public void setDeveloperId(int developerId) {
        this.developerId = developerId;
    }

    public String getDeveloperName() {
        return developerName;
    }

    public void setDeveloperName(String developerName) {
        this.developerName = developerName;
    }

    public Set<Project> getProjects() {
        return projects;
    }

    public void setProjects(Set<Project> projects) {
        this.projects = projects;
    }
}

複製程式碼

對映配置檔案

以專案對映檔案為例:我們不急著寫,首先來分析一下關鍵點......想要在多對多對映中產生正確的關聯關係,下面幾步必不可少:

  • 配置對映集合的屬性(developers)
  • 對映集合對應的中間表(developer_project)
  • 中間表的外來鍵欄位(project_id)
  • 集合元素的型別(Developer)
  • 中間表另外的外來鍵欄位(developer_id)

Project和Developer的對映檔案都需要這幾個關鍵步驟

Project對映檔案

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<!--在domain包下-->
<hibernate-mapping package="zhongfucheng.many2many">

    <class name="Project" table="Project">

        <!--對映主鍵-->
        <id name="projectId" column="projectId">
            <generator class="native"></generator>
        </id>

        <!--對映普通欄位-->
        <property name="projectName" column="projectName"></property>


        <!--對映多對多的關係-->
        <!--Set的屬性名稱為developers,對應developer_project表-->
        <set name="developers" table="developer_project">
            <!--對應developer_project表的外來鍵列-->
            <key column="project_id"></key>

            <!--集合的型別和developer_project表的另一個外來鍵列-->
            <many-to-many column="developer_id" class="Developer"></many-to-many>
        </set>

    </class>

</hibernate-mapping>


複製程式碼

Developer對映檔案


<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<!--在domain包下-->
<hibernate-mapping package="zhongfucheng.many2many">

    <class name="Developer" table="Developer">

        <!--對映主鍵-->
        <id name="developerId" column="developerId">
            <generator class="native"></generator>
        </id>

        <!--對映普通欄位-->
        <property name="developerName" column="developerName"></property>


        <!--對映多對多的關係-->
        <!--Set的屬性名稱為developers,對應developer_project表-->
        <set name="projects" table="developer_project">
            <!--對應developer_project表的外來鍵列-->
            <key column="developer_id"></key>

            <!--集合的型別和developer_project表的另一個外來鍵列-->
            <many-to-many column="project_id" class="Project"></many-to-many>
        </set>

    </class>

</hibernate-mapping>

複製程式碼

測試


package zhongfucheng.many2many;

import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.classic.Session;

/**
 * Created by ozc on 2017/5/6.
 */
public class App2 {
    public static void main(String[] args) {


        /*
        *
        *
        * 	  Project   Developer
              電商系統
                             曹吉
                             王春
               OA系統
                             王春
                             老張

			*/
        //建立物件
        Developer cj = new Developer();
        Developer wc = new Developer();
        Developer lz = new Developer();
        Project ds = new Project();
        Project oa = new Project();

        //設定物件的資料
        cj.setDeveloperName("曹吉");
        wc.setDeveloperName("王春");
        lz.setDeveloperName("老張");

        oa.setProjectName("OA系統");
        ds.setProjectName("電商系統");

        //使用Project來關聯資料【在多對多中,一樣的】
        oa.getDevelopers().add(wc);
        oa.getDevelopers().add(lz);

        ds.getDevelopers().add(cj);
        ds.getDevelopers().add(wc);


        //獲取載入配置管理類
        Configuration configuration = new Configuration();

        //載入User的對映檔案!
        configuration.configure().addClass(Developer.class).addClass(Project.class);

        //建立Session工廠物件
        SessionFactory factory = configuration.buildSessionFactory();

        //得到Session物件
        Session session = factory.openSession();

        //使用Hibernate運算元據庫,都要開啟事務,得到事務物件
        Transaction transaction = session.getTransaction();

        //開啟事務
        transaction.begin();


        //在Project對映檔案中設定級聯儲存了
        session.save(oa);
        session.save(ds);


        //提交事務
        transaction.commit();

        //關閉Session
        session.close();
    }
}
複製程式碼

執行了9條SQL語句,資料庫中的記錄也是正確的。

這裡寫圖片描述


一對一的對映

需求:使用者與身份證資訊..一個使用者對應一個身份證

資料庫表設計

對於資料庫表設計我們有兩種方式

  • 第一種:在身份證的資料表中設定一個外來鍵來維護使用者的關係,這個外來鍵也應該是唯一的【一個使用者對應一張身份證】
  • 第二種:在身份證的資料表中使用主鍵+外來鍵的方式來維護使用者的關係。

這裡寫圖片描述

設計實體

idCard.java

package zhongfucheng.one2one;

/**
 * Created by ozc on 2017/5/7.
 */
public class IdCard {

    private int idCardId;
    private String idCardName;

    //維護與使用者之間的關係
    private User user ;

    public int getIdCardId() {
        return idCardId;
    }

    public void setIdCardId(int idCardId) {
        this.idCardId = idCardId;
    }

    public String getIdCardName() {
        return idCardName;
    }

    public void setIdCardName(String idCardName) {
        this.idCardName = idCardName;
    }

    public User getUser() {
        return user;
    }

    public void setUser(User user) {
        this.user = user;
    }
}

複製程式碼

User.java

package zhongfucheng.one2one;

/**
 * Created by ozc on 2017/5/7.
 */
public class User {

    private int userId;
    private String userName;

    //維護與身份證一對一的關係
    private IdCard idCard ;

    public int getUserId() {
        return userId;
    }

    public void setUserId(int userId) {
        this.userId = userId;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public IdCard getIdCard() {
        return idCard;
    }

    public void setIdCard(IdCard idCard) {
        this.idCard = idCard;
    }
}

複製程式碼

第一種方式對映檔案

我們有兩種方式來設計資料庫中的表實現一對一的關係,首先我們來挑比較熟悉的外來鍵方式來寫對映檔案

user對映檔案


<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="zhongfucheng.one2one">

    <class name="User" table="User">

        <!--對映主鍵-->
        <id name="userId" column="userId">
            <generator class="native"></generator>
        </id>

        <!--對映普通欄位-->
        <property name="userName" column="userName"></property>

        <!--
            User是沒有外來鍵欄位的表
            	一對一的關係的屬性名稱name是idCard
            	型別是IdCard
        -->
        <one-to-one name="idCard" class="IdCard"></one-to-one>

    </class>

</hibernate-mapping>

複製程式碼

idCard對映檔案


<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="zhongfucheng.one2one">

    <class name="IdCard" table="IdCard">

        <!--對映主鍵-->
        <id name="idCardId" column="idCardId">
            <generator class="native"></generator>
        </id>

        <!--對映普通欄位-->
        <property name="idCardName" column="idCardName"></property>

        <!--idCart是有外來鍵的表,要把欄位對映成外來鍵,用的是manyToOne-->

        <!--
            外來鍵的屬性name是user
            對應表的欄位是userId
            屬性的型別是User
            該欄位需要唯一性 unique
        -->
        <many-to-one name="user" column="user_id" class="User" unique="true" cascade="save-update"></many-to-one>

    </class>

</hibernate-mapping>

複製程式碼

測試

要使用IdCart來維護User的關聯關係。

  • 如果使用User來維護idCart的關聯關係,idCart的外來鍵列是為NULL的,因為重頭到尾我們都沒有給它賦值
  • 而使用IdCart來維護User,是外來鍵值是根據User的主鍵id來生成的


package zhongfucheng.one2one;

import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.classic.Session;

/**
 * Created by ozc on 2017/5/6.
 */
public class App3 {
    public static void main(String[] args) {

        //建立物件
        User user = new User();
        IdCard idCard = new IdCard();

        //設定物件的資料
        user.setUserName("你好");
        idCard.setIdCardName("身份證001");

        //一對一關聯資料
        idCard.setUser(user);

        //獲取載入配置管理類
        Configuration configuration = new Configuration();

        //載入User的對映檔案!
        configuration.configure().addClass(User.class).addClass(IdCard.class);

        //建立Session工廠物件
        SessionFactory factory = configuration.buildSessionFactory();

        //得到Session物件
        Session session = factory.openSession();

        //使用Hibernate運算元據庫,都要開啟事務,得到事務物件
        Transaction transaction = session.getTransaction();

        //開啟事務
        transaction.begin();

        //儲存物件的資料,idCard配置檔案使用級聯儲存
        session.save(idCard);

        //提交事務
        transaction.commit();

        //關閉Session
        session.close();
    }
}
複製程式碼

這裡寫圖片描述


第二種方式對映檔案

因為IdCart使用userId作為了主鍵,因此需要在JavaBean中配置多一個屬性UserId...其他的都不用變


    private int userId;
    public int getUserId() {
        return userId;
    }

    public void setUserId(int userId) {
        this.userId = userId;
    }
複製程式碼

在Hibernate入門篇講解配置的時候,在generator節點下還有一個屬性沒有講解,也就是foreign屬性...現在來填坑了..

這裡寫圖片描述

idCard對映檔案

idCart的對映檔案主要在於:將主鍵也對映成外來鍵來使用,這就需要用到foreign屬性值了

使用<one-to-one>標籤來配置基於主鍵的對映


<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="zhongfucheng.one2one2.one2one">

    <class name="IdCard" table="IdCard">

        <!--對映主鍵-->
        <id name="userId" column="userId">
            <!--
                做主鍵的同時也做外來鍵
                外來鍵的型別名稱為user
            -->
            <generator class="foreign">
                <param name="property">user</param>
            </generator>
        </id>

        <!--對映普通欄位-->
        <property name="idCardName" column="idCardName"></property>
        <property name="idCardId" column="idCartId"></property>



        <!--
            有外來鍵的一方:
                基於主鍵對映,使用oneToOne
                constrained="true"  指定在主鍵上新增外來鍵約束
        -->
        <one-to-one name="user" class="User" constrained="true"></one-to-one>




    </class>

</hibernate-mapping>

複製程式碼

user對映檔案


<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="zhongfucheng.one2one2.one2one">

    <class name="User" table="User">

        <!--對映主鍵-->
        <id name="userId" column="userId">
            <generator class="native"></generator>
        </id>

        <!--對映普通欄位-->
        <property name="userName" column="userName"></property>

        <!--
            User是沒有外來鍵欄位的表
            一對一的關係的屬性名稱name是idCard
            型別是IdCard
        -->
        <one-to-one name="idCard" class="IdCard"></one-to-one>

    </class>

</hibernate-mapping>

複製程式碼

測試


package zhongfucheng.one2one2.one2one;

import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.classic.Session;

/**
 * Created by ozc on 2017/5/6.
 */
public class App4 {
    public static void main(String[] args) {

        //建立物件
        User user = new User();
        IdCard idCard = new IdCard();

        //設定物件的資料
        user.setUserName("你好3");
        idCard.setIdCardName("身份證003");
        idCard.setIdCardId(4235);

        //一對一關聯資料
        idCard.setUser(user);

        //獲取載入配置管理類
        Configuration configuration = new Configuration();

        //載入User的對映檔案!
        configuration.configure().addClass(User.class).addClass(IdCard.class);

        //建立Session工廠物件
        SessionFactory factory = configuration.buildSessionFactory();

        //得到Session物件
        Session session = factory.openSession();

        //使用Hibernate運算元據庫,都要開啟事務,得到事務物件
        Transaction transaction = session.getTransaction();

        //開啟事務
        transaction.begin();

        //儲存物件的資料,idCard配置檔案使用級聯儲存
        session.save(idCard);

        //提交事務
        transaction.commit();

        //關閉Session
        session.close();
    }
}
複製程式碼

這裡寫圖片描述

元件對映

Java主要的類主要有兩種方式

  • 組合關係,組合關係對應的就是元件對映
  • 繼承關係,繼承關係對應的就是繼承對映

元件對映實際上就是將組合關係的資料對映成一張表,元件類和被包含的元件類對映成一張表

有的時候,兩個類的關係明顯不是繼承關係,但兩個類的親密程度很高,在一個類裡邊需要用到另外一個類...那麼就在類中定義一個變數來維護另一個類的關係,這種就叫組合關係!

需求:汽車和輪子。汽車需要用到輪子,但是輪子的爸爸不可能是汽車吧?

設計資料庫

這裡寫圖片描述

設計實體

Wheel.java


public class Wheel {
    
    private int  count;
    private int size;

    public int getCount() {
        return count;
    }

    public void setCount(int count) {
        this.count = count;
    }

    public int getSize() {
        return size;
    }

    public void setSize(int size) {
        this.size = size;
    }
}


複製程式碼

Car.java,使用變數維護Wheel

package zhongfucheng.aa;

/**
 * Created by ozc on 2017/5/7.
 */
public class Car {

    private int id;
    private String name;
    private Wheel wheel;

    public Wheel getWheel() {
        return wheel;
    }

    public void setWheel(Wheel wheel) {
        this.wheel = wheel;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

複製程式碼

對映表

使用了一個新標籤<component>,元件對映標籤。


<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="zhongfucheng.aa" >

    <class name="Car" table="Car" >

        <!--對映主鍵-->
        <id name="id" column="id">
            <generator class="native"></generator>
        </id>

        <!--對映普通欄位-->
        <property name="name" column="name" ></property>


        <!--
            對映元件欄位
        -->
        <component name="wheel">
            <property name="count"></property>
            <property name="size"></property>
        </component>

    </class>

</hibernate-mapping>

複製程式碼

測試

package zhongfucheng.aa;

import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.classic.Session;

/**
 * Created by ozc on 2017/5/6.
 */
public class App5 {
    public static void main(String[] args) {


        //建立物件
        Wheel wheel = new Wheel();
        Car car = new Car();

        //設定屬性
        wheel.setCount(43);
        wheel.setSize(22);
        car.setName("寶馬");

        //維護關係
        car.setWheel(wheel);
        //獲取載入配置管理類
        Configuration configuration = new Configuration();

 
        configuration.configure().addClass(Car.class);

        //建立Session工廠物件
        SessionFactory factory = configuration.buildSessionFactory();

        //得到Session物件
        Session session = factory.openSession();

        //使用Hibernate運算元據庫,都要開啟事務,得到事務物件
        Transaction transaction = session.getTransaction();

        //開啟事務
        transaction.begin();

        session.save(car);

        //提交事務
        transaction.commit();

        //關閉Session
        session.close();


    }
}
複製程式碼

這裡寫圖片描述

傳統方式繼承

需求:動物、貓、猴子。貓繼承著動物

傳統方式繼承的特點就是:有多少個子類就寫多少個配置檔案.

表結構

我們的表應該是這樣的:id和name從Animal中繼承,catchMouse是子類的具體行為。

這裡寫圖片描述

實體

Animal.java


package zhongfucheng.aa;

// 動物類
public abstract class Animal {

	private int id;
	private String name;
	
	
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
}

複製程式碼

Cat.java繼承著Animail


package zhongfucheng.aa;

public class Cat extends Animal{

	// 抓老鼠
	private String catchMouse;

	public String getCatchMouse() {
		return catchMouse;
	}

	public void setCatchMouse(String catchMouse) {
		this.catchMouse = catchMouse;
	}
}
複製程式碼

對映檔案

簡單繼承的對映檔案很好寫,在屬性上,直接寫父類的屬性就可以了。

但是也有致命的缺點:如果子類有很多,就需要寫很多的配置檔案


<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="zhongfucheng.aa" >

    <class name="Cat" table="cat" >

        <!--對映主鍵-->
        <id name="id" column="id">
            <generator class="native"></generator>
        </id>

        <!--
            對映普通欄位
            父類的屬性直接引用就行了,比如name屬性,直接寫就行了!
        -->
        <property name="name" column="name" ></property>
        <property name="catchMouse" column="catchMouse" ></property>


    </class>

</hibernate-mapping>

複製程式碼

測試


package zhongfucheng.aa;

import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.classic.Session;

public class App5 {
    public static void main(String[] args) {


        //建立物件
        Cat cat = new Cat();

        //設定屬性

        cat.setName("大花貓");
        cat.setCatchMouse("捉大老鼠");

        //獲取載入配置管理類
        Configuration configuration = new Configuration();

    
        configuration.configure().addClass(Cat.class);

        //建立Session工廠物件
        SessionFactory factory = configuration.buildSessionFactory();

        //得到Session物件
        Session session = factory.openSession();

        //使用Hibernate運算元據庫,都要開啟事務,得到事務物件
        Transaction transaction = session.getTransaction();

        //開啟事務
        transaction.begin();

        session.save(cat);
		
		//如果取資料時候Animal父類接收的話,需要給出Anmail的全名


        //提交事務
        transaction.commit();

        //關閉Session
        session.close();


    }
}
複製程式碼

這裡寫圖片描述


把所有子類對映成一張表

前面我們採用的是:每個子類都需要寫成一個配置檔案,對映成一張表...

如果子類的結構很簡單,只比父類多幾個屬性。就像上面的例子...我們可以將所有的子類都對映成一張表中

但是呢,這樣是不符合資料庫設計規範的.....因為表中的資料**可能是貓,可能是猴子...**這明顯是不合適的...

由於表中可能存在貓,存在猴子,為了區分是什麼型別的。我們需要使用鑑別器

我們瞭解一下...

資料表

這裡寫圖片描述

實體

實體和上面雷同,只多了一個猴子的實體表

Monkey.java


public class Monkey extends Animal {
	
	// 吃香蕉
	private String eatBanana;

	public String getEatBanana() {
		return eatBanana;
	}

	public void setEatBanana(String eatBanana) {
		this.eatBanana = eatBanana;
	}
	
}


複製程式碼

對映檔案

使用了subClass這個節點和鑑別器

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
	"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
	"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<!-- 
	繼承對映, 所有的子類都對映到一張表
 -->
<hibernate-mapping package="cn.itcast.e_extends2">
	
	<class name="Animal" table="t_animal">
		<id name="id">
			<generator class="native"></generator>
		</id>
		<!-- 指定鑑別器欄位(區分不同的子類) -->
		<discriminator column="type_"></discriminator>
		
		<property name="name"></property>
		
		<!-- 
			子類:貓
				每個子類都用subclass節點對映
				注意:一定要指定鑑別器欄位,否則報錯!
				鑑別器欄位:作用是在資料庫中區別每一個子類的資訊, 就是一個列
			discriminator-value="cat_"
				指定鑑別器欄位,即type_欄位的值
				如果不指定,預設為當前子類的全名
		 -->
		 <subclass name="Cat" discriminator-value="cat_">
		 	<property name="catchMouse"></property>
		 </subclass>
		 
		 <!-- 
		 	子類:猴子
		  -->
		  <subclass name="Monkey" discriminator-value="monkey_">
		  	<property name="eatBanana"></property>
		  </subclass>
		
	</class>
	

</hibernate-mapping>

複製程式碼

測試

載入的是Animal父類的對映檔案。儲存的是cat和monkey。


package zhongfucheng.aa;

import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.classic.Session;

public class App5 {
    public static void main(String[] args) {


        //建立物件
        Cat cat = new Cat();
        Monkey monkey = new Monkey();

        //設定屬性
        cat.setName("大花貓");
        cat.setCatchMouse("小老鼠");
        monkey.setEatBanana("吃香蕉");
        monkey.setName("大猴子");

        //獲取載入配置管理類
        Configuration configuration = new Configuration();

        //載入Animal的對映檔案!
        configuration.configure().addClass(Animal.class);

        //建立Session工廠物件
        SessionFactory factory = configuration.buildSessionFactory();

        //得到Session物件
        Session session = factory.openSession();

        //使用Hibernate運算元據庫,都要開啟事務,得到事務物件
        Transaction transaction = session.getTransaction();

        //開啟事務
        transaction.begin();

        session.save(cat);
        session.save(monkey);

        //提交事務
        transaction.commit();

        //關閉Session
        session.close();


    }
}
複製程式碼

這裡寫圖片描述


每個類對映一張表(3張表)

父類和子類都各對應一張表。那麼就有三張表了

這種結構看起來是完全物件導向,但是表之間的結構會很複雜,插入一條子類的資訊,需要兩條SQL

資料表設計

這裡寫圖片描述

對映檔案

使用到了<joined-subclass >這個節點

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">


<hibernate-mapping package="zhongfucheng.aa">

    <class name="Animal" table="t_animal">
        <id name="id">
            <generator class="native"></generator>
        </id>

        <property name="name"></property>


        <!--
            Animal下的子類對映成一張表
                指定子類的型別,對應的表
                指定子類的外來鍵欄位【需要對應Animal】
                指定子類的普通屬性
        -->
        <joined-subclass name="Cat" table="cat_">
            <!--key對應的是外來鍵欄位-->
            <key column="animal_id"></key>
            <property name="catchMouse"></property>
        </joined-subclass>

        <joined-subclass name="Monkey" table="monkey_">
            <!--key對應的是外來鍵欄位-->
            <key column="animal_id"></key>
            <property name="eatBanana"></property>
        </joined-subclass>


    </class>


</hibernate-mapping>



複製程式碼

測試

package zhongfucheng.aa;

import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.classic.Session;

public class App5 {
    public static void main(String[] args) {


        //建立物件
        Cat cat = new Cat();
        Monkey monkey = new Monkey();

        //設定屬性
        cat.setName("大花貓");
        cat.setCatchMouse("小老鼠");
        monkey.setEatBanana("吃香蕉");
        monkey.setName("大猴子");

        //獲取載入配置管理類
        Configuration configuration = new Configuration();

        //載入類對應的對映檔案!
        configuration.configure().addClass(Animal.class);

        //建立Session工廠物件
        SessionFactory factory = configuration.buildSessionFactory();

        //得到Session物件
        Session session = factory.openSession();

        //使用Hibernate運算元據庫,都要開啟事務,得到事務物件
        Transaction transaction = session.getTransaction();

        //開啟事務
        transaction.begin();

        session.save(cat);
        session.save(monkey);

        //提交事務
        transaction.commit();

        //關閉Session
        session.close();


    }
}
複製程式碼

每儲存一個子類物件需要兩條SQL語句!

這裡寫圖片描述


(推薦)每個子類對映一張表, 父類不對應表(2張表)

  • 使用過了一張表儲存所有子類的資料,這不符合資料庫設計規範
  • 每個子類、父類都擁有一張表..表結構太過於繁瑣..新增資訊時,過多的SQL

我們即將使用的是:每個子類對映成一張表,父類不對應表...這和我們傳統方式繼承是一樣的。只不過在hbm.xml檔案中使用了<union-subclass>這個節點,由於有了這個節點,我們就不需要每個子類都寫一個配置檔案了。

資料庫表設計

這裡寫圖片描述

對映檔案

  • 想要父類不對映成資料庫表,只要在class中配置為abstract即可
  • 使用了union-subclass節點,主鍵就不能採用自動增長策略了。我們改成UUID即可。當然啦,對應的實體id型別要改成String

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">


<hibernate-mapping package="zhongfucheng.aa">

    
    <!--
        想要父類不對映成表,設定成abstract
    -->
    <class name="Animal" abstract="true">
        
        <!--
            如果使用了union-subclass節點,那麼主鍵生成策略不能是自增長,我們改成uuid即可
        -->
        <id name="id">
            <generator class="uuid"></generator>
        </id>

        <property name="name"></property>


        <!--
            將子類的資訊都對映成一張表
                給出屬性的名稱
                屬性對應的資料庫表
                普通欄位
        -->
        <union-subclass name="Cat" table="cat_">
            <property name="catchMouse"></property>
        </union-subclass>
        
        <union-subclass name="Monkey" table="monkey_">
            <property name="eatBanana"></property>
        </union-subclass>


    </class>


</hibernate-mapping>

複製程式碼

測試


package zhongfucheng.aa;

import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.classic.Session;

public class App5 {
    public static void main(String[] args) {


        //建立物件
        Cat cat = new Cat();
        Monkey monkey = new Monkey();

        //設定屬性
        cat.setName("大花貓");
        cat.setCatchMouse("小老鼠");
        monkey.setEatBanana("吃香蕉");
        monkey.setName("大猴子");

        //獲取載入配置管理類
        Configuration configuration = new Configuration();

        //載入類對應的對映檔案!
        configuration.configure().addClass(Animal.class);

        //建立Session工廠物件
        SessionFactory factory = configuration.buildSessionFactory();

        //得到Session物件
        Session session = factory.openSession();

        //使用Hibernate運算元據庫,都要開啟事務,得到事務物件
        Transaction transaction = session.getTransaction();

        //開啟事務
        transaction.begin();

        session.save(cat);
        session.save(monkey);

        //提交事務
        transaction.commit();

        //關閉Session
        session.close();


    }
}
複製程式碼

這裡寫圖片描述

元件對映和繼承對映總結

由於我們的傳統繼承對映每個子類都對應一個配置檔案,這樣十分麻煩。因此**.hbm.xml就給出了幾個節點供我們使用**,分別有以下的情況:

  • 子類父類共有一張表subclass
    • 不符合資料庫設計規範
    • 需要使用鑑別器
  • 子類、父類都有自己的表joined-subclass,那麼就是三張表
    • 表的結構太過繁瑣
    • 插入資料時要生成SQL至少就要兩條
  • 子類擁有自己的表、父類不對應表【推薦】union-subclass
    • 父類不對應表要使用abstract來修飾
    • 主鍵的id不能使用自增長策略,修改成UUID就好了。對應的JavaBean的id設定成String就好

如果文章有錯的地方歡迎指正,大家互相交流。習慣在微信看技術文章,想要獲取更多的Java資源的同學,可以關注微信公眾號:Java3y

相關文章