Hibernate【對映】知識要點

阿新 • • 發佈：2022-05-04

前言

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

集合對映

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

資料庫表

我們一般如下圖一樣設計資料庫表，一般我們不會在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();
    }
}