Hibernate【映射】知識要點

前言

前面的咱們使用的是一個表的操做，但咱們實際的開發中不可能只使用一個表的...所以，本博文主要講解關聯映射

集合映射

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

數據庫表

咱們通常以下圖同樣設計數據庫表，通常咱們不會在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