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

Hibernate【快取】知識要點
2019-03-04
快取
Hibernate【inverse和cascade屬性】知識要點
2018-03-08
Hibernate知識點總結
2015-06-29
MongoDB知識要點
2019-12-09
MongoDB
hibernate 元件對映
2013-12-17
元件
Mybatis【一對多、多對一、多對多】知識要點
2018-03-13
MyBatis
Hibernate--繼承對映
2017-09-13
繼承
【API知識】MongoTemplate非對映方式操作Document
2018-12-09
APIGo
java框架之Hibernate框架知識點整理。
2018-07-21
Java框架
Spring【AOP模組】知識要點
2021-09-09
Spring
索引的知識要點與操作
2024-04-28
索引
hibernate(五) hibernate一對一關係對映詳解
2016-12-03
hibernate(三) 一對多對映關係
2016-11-29
ROS知識（22）----USB口對映固定名字
2017-08-23
ROS
linux-gcc簡要知識點 **
2020-11-09
LinuxGC
Hibernate--單表對映總結
2018-08-08
Hibernate 的關聯關係對映
2018-03-06
hibernate 繼承對映關係（ JOINED)
2013-12-20
繼承
hibernate對映合成模式的問題
2009-03-03
模式
Mybatis【逆向工程，快取，代理】知識要點
2018-03-12
MyBatis快取
44個路由器知識要點(轉)
2007-08-11
路由器
hibernate(四) 雙向多對多對映關係
2016-12-01
Hibernate對映檔案一對多關係薦
2012-05-31
Hibernate （開源物件關係對映框架）
2018-06-09
物件框架
hibernate物件對映的一個問題。
2007-05-14
物件
Hibernate的入門知識
2020-04-06
【學習】MySQL基礎知識要點-001
2018-03-28
MySql
關於Hibernate和hql語句的相關知識點
2021-09-09
Hibernate配置檔案中對映元素詳解
2022-05-10
Hibernate繼承對映多型的詳解
2012-06-05
繼承多型
Hibernate 對映xml中的屬性型別
2016-03-23
XML型別
hibernate 關係對映之主鍵關聯一對一
2013-12-17
hibernate常用知識書目錄
2017-02-26
Hibernate常見知識彙總
2017-11-10
學習運維技術要掌握哪些知識點？
2020-11-19
運維
電腦“前端匯流排”的基本知識要點
2014-11-14
前端
java之Hibernate面試要點總結
2021-09-11
Java面試
學習Hibernate原始碼二_Hibernate物件對映檔案hbm學習
2013-08-29
原始碼物件

Hibernate【對映】知識要點

前言

集合對映

資料庫表

實體

對映檔案

List集合對映配置

Map集合對映配置

一對多和多對一

設計資料庫表

設計實體

對映分析

部門對映配置檔案

員工對映配置檔案

在“一”的一方測試

在“多”的一方測試

一對多和多對一總結

多對多對映

設計資料庫表

設計實體

對映配置檔案

Project對映檔案

Developer對映檔案

測試

一對一的對映

資料庫表設計

設計實體

第一種方式對映檔案

user對映檔案

idCard對映檔案

測試

第二種方式對映檔案

idCard對映檔案

user對映檔案

測試

元件對映

設計資料庫

設計實體

對映表

測試

傳統方式繼承

表結構

實體

對映檔案

測試

把所有子類對映成一張表

資料表

實體

對映檔案

測試

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

資料表設計

對映檔案

測試

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

資料庫表設計

對映檔案

測試

元件對映和繼承對映總結

相關文章

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