前言

前面的我們使用的是一個表的操作，但我們實際的開發(fā)中不可能只使用一個表的...因此，本博文主要講解關(guān)聯(lián)映射

集合映射

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

數(shù)據(jù)庫表

我們一般如下圖一樣設(shè)計數(shù)據(jù)庫表，一般我們不會在User表設(shè)計多個列來保存地址的。因為每個用戶的地址個數(shù)都不一的，會造成數(shù)據(jù)冗余

創(chuàng)建兩張數(shù)據(jù)表，一張保存著用戶的信息，一張保存著地址的信息。地址表使用外鍵來引用用戶表

這里寫圖片描述

實體

由于地址只是使用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) {

        //創(chuàng)建對象

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

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

        //加載User的映射文件！
        configuration.configure().addClass(User.class);

        //創(chuàng)建Session工廠對象
        SessionFactory factory = configuration.buildSessionFactory();

        //得到Session對象
        Session session = factory.openSession();

        //使用Hibernate操作數(shù)據(jù)庫，都要開啟事務(wù),得到事務(wù)對象
        Transaction transaction = session.getTransaction();

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

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

        //關(guān)閉Session
        session.close();
    }
}

這里寫圖片描述

List集合映射配置

既然我們現(xiàn)在已經(jīng)會了如何配置Set集合了，List集合又怎么配置呢？？

想一下，List集合和Set集合有什么區(qū)別...List集合是有序的，因此要多配置一個列來維護(hù)數(shù)據(jù)的有序性！

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

            <!--index是關(guān)鍵字，不能使用！?。?！-->
            <list-index column="indexNum"></list-index>
            <element column="addr" type="string"></element>
        </list>

Map集合映射配置

Map集合和Collection集合的區(qū)別就是鍵值對模型，那么在配置的時候多一個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，如果我們的裝載在集合的數(shù)據(jù)有很多類型，那么String就不能用了！...

需求：部門與員工之間的關(guān)系

一個部門有多個員工; 【一對多】
多個員工，屬于一個部門【多對一】

設(shè)計數(shù)據(jù)庫表

員工表應(yīng)該使用一個外鍵來記住部門表。這樣才可以維護(hù)員工和部門之間的關(guān)系

這里寫圖片描述

設(shè)計實體

部門實體要使用一個集合來記住所有的員工，員工要使用一個對象引用著部門

這里寫圖片描述

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;
    }
}

映射分析

我們在寫映射配置文件之前，分析一下怎么寫。以部門映射配置文件為例...

現(xiàn)在使用了一個Set集合來維護(hù)與員工的關(guān)系，Set集合的類型是員工對象...因此在映射文件中需要以下幾點

映射集合屬性的名稱(employees)
映射集合對應(yīng)的數(shù)據(jù)表(employee)
對應(yīng)的數(shù)據(jù)表的外鍵字段(dept_id)
集合中的元素類型(Employee)【通過這個類型，Hibernate就可以找到對應(yīng)類型的映射文件，從而得到對應(yīng)的信息！】

這里寫圖片描述

部門映射配置文件


<?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>

        <!--維護(hù)關(guān)系的是Set集合，對應(yīng)employee表-->
        <set  cascade="save-update" name="set" table="employee">

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

            <!--一個部門對應(yīng)多個員工，集合的類型是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>

        <!--普通字段數(shù)據(jù)-->
        <property name="empName" column="empName"></property>
        <property name="salary" column="salary"></property>

        <!--Hibernate這個標(biāo)簽可看成在當(dāng)前表中設(shè)置一個外鍵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) {

        //創(chuàng)建對象
        Dept dept = new Dept();
        dept.setDeptName("開發(fā)部");

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

        //添加關(guān)系
        dept.getSet().add(zs);
        dept.getSet().add(ls);

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

        //加載User的映射文件！
        configuration.configure().addClass(Dept.class).addClass(Employee.class);

        //創(chuàng)建Session工廠對象
        SessionFactory factory = configuration.buildSessionFactory();

        //得到Session對象
        Session session = factory.openSession();

        //使用Hibernate操作數(shù)據(jù)庫，都要開啟事務(wù),得到事務(wù)對象
        Transaction transaction = session.getTransaction();

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

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

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

        //關(guān)閉Session
        session.close();
    }
}

Hibernate執(zhí)行了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) {

        //創(chuàng)建對象
        Dept dept = new Dept();
        dept.setDeptName("開發(fā)部");

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

        //維護(hù)關(guān)系
        zs.setDept(dept);
        ls.setDept(dept);

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

        //加載User的映射文件！
        configuration.configure().addClass(Dept.class).addClass(Employee.class);

        //創(chuàng)建Session工廠對象
        SessionFactory factory = configuration.buildSessionFactory();

        //得到Session對象
        Session session = factory.openSession();

        //使用Hibernate操作數(shù)據(jù)庫，都要開啟事務(wù),得到事務(wù)對象
        Transaction transaction = session.getTransaction();

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

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

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

        //關(guān)閉Session
        session.close();
    }
}

Hibernate執(zhí)行了3條SQL

這里寫圖片描述

一對多和多對一總結(jié)

在一對多與多對一的關(guān)聯(lián)關(guān)系中，保存數(shù)據(jù)最好的通過多的一方來維護(hù)關(guān)系，這樣可以減少update語句的生成，從而提高h(yuǎn)ibernate的執(zhí)行效率！

配置一對多與多對一，這種叫“雙向關(guān)聯(lián)”
只配置一對多，叫“單項一對多”
只配置多對一，叫“單項多對一”

值得注意是：配置了哪一方，哪一方才有維護(hù)關(guān)聯(lián)關(guān)系的權(quán)限！

當(dāng)我在部門中不配置員工的關(guān)聯(lián)關(guān)系了，那么在操作部門的時候就不能得到員工的數(shù)據(jù)了【也就是：在保存部門時，不能同時保存員工的數(shù)據(jù)】

多對多映射

需求：一個項目由多個員工開發(fā)，一個員工開發(fā)多個項目

設(shè)計數(shù)據(jù)庫表

一般地，如果是多對多的映射，我們都會使用一張中間表來保存它們的關(guān)聯(lián)關(guān)系....

這里寫圖片描述

設(shè)計實體

我們在設(shè)計實體的時候，一般是核心數(shù)據(jù)表對應(yīng)一個JavaBean實體【中間表并不是核心數(shù)據(jù)表】，那么我們將會設(shè)計兩個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實體維護(hù)關(guān)系
    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集合來維護(hù)與Project關(guān)系
    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;
    }
}

映射配置文件

以項目映射文件為例：我們不急著寫，首先來分析一下關(guān)鍵點......想要在多對多映射中產(chǎn)生正確的關(guān)聯(lián)關(guān)系，下面幾步必不可少：

配置映射集合的屬性(developers)
映射集合對應(yīng)的中間表(developer_project)
中間表的外鍵字段(project_id)
集合元素的類型(Developer)
中間表另外的外鍵字段(developer_id)

Project和Developer的映射文件都需要這幾個關(guān)鍵步驟

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>

        <!--映射多對多的關(guān)系-->
        <!--Set的屬性名稱為developers，對應(yīng)developer_project表-->
        <set name="developers" table="developer_project">
            <!--對應(yīng)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>

        <!--映射多對多的關(guān)系-->
        <!--Set的屬性名稱為developers，對應(yīng)developer_project表-->
        <set name="projects" table="developer_project">
            <!--對應(yīng)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
              電商系統(tǒng)
                             曹吉
                             王春
               OA系統(tǒng)
                             王春
                             老張

            */
        //創(chuàng)建對象
        Developer cj = new Developer();
        Developer wc = new Developer();
        Developer lz = new Developer();
        Project ds = new Project();
        Project oa = new Project();

        //設(shè)置對象的數(shù)據(jù)
        cj.setDeveloperName("曹吉");
        wc.setDeveloperName("王春");
        lz.setDeveloperName("老張");

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

        //使用Project來關(guān)聯(lián)數(shù)據(jù)【在多對多中，一樣的】
        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);

        //創(chuàng)建Session工廠對象
        SessionFactory factory = configuration.buildSessionFactory();

        //得到Session對象
        Session session = factory.openSession();

        //使用Hibernate操作數(shù)據(jù)庫，都要開啟事務(wù),得到事務(wù)對象
        Transaction transaction = session.getTransaction();

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

        //在Project映射文件中設(shè)置級聯(lián)保存了
        session.save(oa);
        session.save(ds);

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

        //關(guān)閉Session
        session.close();
    }
}

執(zhí)行了9條SQL語句，數(shù)據(jù)庫中的記錄也是正確的。

這里寫圖片描述

一對一的映射

需求：用戶與身份證信息..一個用戶對應(yīng)一個身份證

數(shù)據(jù)庫表設(shè)計

對于數(shù)據(jù)庫表設(shè)計我們有兩種方式

第一種：在身份證的數(shù)據(jù)表中設(shè)置一個外鍵來維護(hù)用戶的關(guān)系，這個外鍵也應(yīng)該是唯一的【一個用戶對應(yīng)一張身份證】
第二種：在身份證的數(shù)據(jù)表中使用主鍵+外鍵的方式來維護(hù)用戶的關(guān)系。

這里寫圖片描述

設(shè)計實體

idCard.java

package zhongfucheng.one2one;

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

    private int idCardId;
    private String idCardName;

    //維護(hù)與用戶之間的關(guān)系
    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;

    //維護(hù)與身份證一對一的關(guān)系
    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;
    }
}

第一種方式映射文件

我們有兩種方式來設(shè)計數(shù)據(jù)庫中的表實現(xiàn)一對一的關(guān)系，首先我們來挑比較熟悉的外鍵方式來寫映射文件

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是沒有外鍵字段的表
                一對一的關(guān)系的屬性名稱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
            對應(yīng)表的字段是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來維護(hù)User的關(guān)聯(lián)關(guān)系。

如果使用User來維護(hù)idCart的關(guān)聯(lián)關(guān)系，idCart的外鍵列是為NULL的，因為重頭到尾我們都沒有給它賦值
而使用IdCart來維護(hù)User，是外鍵值是根據(jù)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) {

        //創(chuàng)建對象
        User user = new User();
        IdCard idCard = new IdCard();

        //設(shè)置對象的數(shù)據(jù)
        user.setUserName("你好");
        idCard.setIdCardName("身份證001");

        //一對一關(guān)聯(lián)數(shù)據(jù)
        idCard.setUser(user);

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

        //加載User的映射文件！
        configuration.configure().addClass(User.class).addClass(IdCard.class);

        //創(chuàng)建Session工廠對象
        SessionFactory factory = configuration.buildSessionFactory();

        //得到Session對象
        Session session = factory.openSession();

        //使用Hibernate操作數(shù)據(jù)庫，都要開啟事務(wù),得到事務(wù)對象
        Transaction transaction = session.getTransaction();

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

        //保存對象的數(shù)據(jù),idCard配置文件使用級聯(lián)保存
        session.save(idCard);

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

        //關(guān)閉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節(jié)點下還有一個屬性沒有講解，也就是foreign屬性...現(xiàn)在來填坑了..

這里寫圖片描述

idCard映射文件

idCart的映射文件主要在于:將主鍵也映射成外鍵來使用，這就需要用到foreign屬性值了

使用<one-to-one>標(biāo)簽來配置基于主鍵的映射


<?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是沒有外鍵字段的表
            一對一的關(guān)系的屬性名稱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) {

        //創(chuàng)建對象
        User user = new User();
        IdCard idCard = new IdCard();

        //設(shè)置對象的數(shù)據(jù)
        user.setUserName("你好3");
        idCard.setIdCardName("身份證003");
        idCard.setIdCardId(4235);

        //一對一關(guān)聯(lián)數(shù)據(jù)
        idCard.setUser(user);

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

        //加載User的映射文件！
        configuration.configure().addClass(User.class).addClass(IdCard.class);

        //創(chuàng)建Session工廠對象
        SessionFactory factory = configuration.buildSessionFactory();

        //得到Session對象
        Session session = factory.openSession();

        //使用Hibernate操作數(shù)據(jù)庫，都要開啟事務(wù),得到事務(wù)對象
        Transaction transaction = session.getTransaction();

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

        //保存對象的數(shù)據(jù),idCard配置文件使用級聯(lián)保存
        session.save(idCard);

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

        //關(guān)閉Session
        session.close();
    }
}

這里寫圖片描述

組件映射

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

組合關(guān)系，組合關(guān)系對應(yīng)的就是組件映射
繼承關(guān)系，繼承關(guān)系對應(yīng)的就是繼承映射

組件映射實際上就是將組合關(guān)系的數(shù)據(jù)映射成一張表，組件類和被包含的組件類映射成一張表

有的時候，兩個類的關(guān)系明顯不是繼承關(guān)系，但兩個類的親密程度很高，在一個類里邊需要用到另外一個類...那么就在類中定義一個變量來維護(hù)另一個類的關(guān)系，這種就叫組合關(guān)系！

需求：汽車和輪子。汽車需要用到輪子，但是輪子的爸爸不可能是汽車吧？

設(shè)計數(shù)據(jù)庫

這里寫圖片描述

設(shè)計實體

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，使用變量維護(hù)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;
    }
}

映射表

使用了一個新標(biāo)簽<component>，組件映射標(biāo)簽。


<?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) {

        //創(chuàng)建對象
        Wheel wheel = new Wheel();
        Car car = new Car();

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

        //維護(hù)關(guān)系
        car.setWheel(wheel);
        //獲取加載配置管理類
        Configuration configuration = new Configuration();

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

        //創(chuàng)建Session工廠對象
        SessionFactory factory = configuration.buildSessionFactory();

        //得到Session對象
        Session session = factory.openSession();

        //使用Hibernate操作數(shù)據(jù)庫，都要開啟事務(wù),得到事務(wù)對象
        Transaction transaction = session.getTransaction();

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

        session.save(car);

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

        //關(guān)閉Session
        session.close();

    }
}

這里寫圖片描述

傳統(tǒng)方式繼承

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

傳統(tǒng)方式繼承的特點就是：有多少個子類就寫多少個配置文件.

表結(jié)構(gòu)

我們的表應(yīng)該是這樣的：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) {

        //創(chuàng)建對象
        Cat cat = new Cat();

        //設(shè)置屬性

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

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

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

        //創(chuàng)建Session工廠對象
        SessionFactory factory = configuration.buildSessionFactory();

        //得到Session對象
        Session session = factory.openSession();

        //使用Hibernate操作數(shù)據(jù)庫，都要開啟事務(wù),得到事務(wù)對象
        Transaction transaction = session.getTransaction();

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

        session.save(cat);

        //如果取數(shù)據(jù)時候Animal父類接收的話，需要給出Anmail的全名

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

        //關(guān)閉Session
        session.close();

    }
}

這里寫圖片描述

把所有子類映射成一張表

前面我們采用的是：每個子類都需要寫成一個配置文件，映射成一張表...

如果子類的結(jié)構(gòu)很簡單，只比父類多幾個屬性。就像上面的例子...我們可以將所有的子類都映射成一張表中

但是呢，這樣是不符合數(shù)據(jù)庫設(shè)計規(guī)范的.....因為表中的數(shù)據(jù)可能是貓，可能是猴子...這明顯是不合適的...

由于表中可能存在貓，存在猴子，為了區(qū)分是什么類型的。我們需要使用鑒別器

我們了解一下...

數(shù)據(jù)表

這里寫圖片描述

實體

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

Monkey.java


public class Monkey extends Animal {

    // 吃香蕉
    private String eatBanana;

    public String getEatBanana() {
        return eatBanana;
    }

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

}

映射文件

使用了subClass這個節(jié)點和鑒別器

<?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>
        <!-- 指定鑒別器字段(區(qū)分不同的子類) -->
        <discriminator column="type_"></discriminator>

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

        <!-- 
            子類：貓
                每個子類都用subclass節(jié)點映射
                注意：一定要指定鑒別器字段，否則報錯！
                鑒別器字段：作用是在數(shù)據(jù)庫中區(qū)別每一個子類的信息， 就是一個列
            discriminator-value="cat_"
                指定鑒別器字段,即type_字段的值
                如果不指定，默認(rèn)為當(dāng)前子類的全名
         -->
         <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) {

        //創(chuàng)建對象
        Cat cat = new Cat();
        Monkey monkey = new Monkey();

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

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

        //加載Animal的映射文件！
        configuration.configure().addClass(Animal.class);

        //創(chuàng)建Session工廠對象
        SessionFactory factory = configuration.buildSessionFactory();

        //得到Session對象
        Session session = factory.openSession();

        //使用Hibernate操作數(shù)據(jù)庫，都要開啟事務(wù),得到事務(wù)對象
        Transaction transaction = session.getTransaction();

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

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

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

        //關(guān)閉Session
        session.close();

    }
}

這里寫圖片描述

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

父類和子類都各對應(yīng)一張表。那么就有三張表了

這種結(jié)構(gòu)看起來是完全面向?qū)ο?，但?strong>表之間的結(jié)構(gòu)會很復(fù)雜，插入一條子類的信息，需要兩條SQL

數(shù)據(jù)表設(shè)計

這里寫圖片描述

映射文件

使用到了<joined-subclass >這個節(jié)點

<?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下的子類映射成一張表
                指定子類的類型，對應(yīng)的表
                指定子類的外鍵字段【需要對應(yīng)Animal】
                指定子類的普通屬性
        -->
        <joined-subclass name="Cat" table="cat_">
            <!--key對應(yīng)的是外鍵字段-->
            <key column="animal_id"></key>
            <property name="catchMouse"></property>
        </joined-subclass>

        <joined-subclass name="Monkey" table="monkey_">
            <!--key對應(yīng)的是外鍵字段-->
            <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) {

        //創(chuàng)建對象
        Cat cat = new Cat();
        Monkey monkey = new Monkey();

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

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

        //加載類對應(yīng)的映射文件！
        configuration.configure().addClass(Animal.class);

        //創(chuàng)建Session工廠對象
        SessionFactory factory = configuration.buildSessionFactory();

        //得到Session對象
        Session session = factory.openSession();

        //使用Hibernate操作數(shù)據(jù)庫，都要開啟事務(wù),得到事務(wù)對象
        Transaction transaction = session.getTransaction();

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

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

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

        //關(guān)閉Session
        session.close();

    }
}

每保存一個子類對象需要兩條SQL語句！

這里寫圖片描述

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

使用過了一張表保存所有子類的數(shù)據(jù)，這不符合數(shù)據(jù)庫設(shè)計規(guī)范
每個子類、父類都擁有一張表..表結(jié)構(gòu)太過于繁瑣..添加信息時，過多的SQL

我們即將使用的是：每個子類映射成一張表，父類不對應(yīng)表...這和我們傳統(tǒng)方式繼承是一樣的。只不過在hbm.xml文件中使用了<union-subclass>這個節(jié)點，由于有了這個節(jié)點，我們就不需要每個子類都寫一個配置文件了。

數(shù)據(jù)庫表設(shè)計

這里寫圖片描述

映射文件

想要父類不映射成數(shù)據(jù)庫表，只要在class中配置為abstract即可
使用了union-subclass節(jié)點，主鍵就不能采用自動增長策略了。我們改成UUID即可。當(dāng)然啦，對應(yīng)的實體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">

    <!--
        想要父類不映射成表，設(shè)置成abstract
    -->
    <class name="Animal" abstract="true">

        <!--
            如果使用了union-subclass節(jié)點，那么主鍵生成策略不能是自增長，我們改成uuid即可
        -->
        <id name="id">
            <generator class="uuid"></generator>
        </id>

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

        <!--
            將子類的信息都映射成一張表
                給出屬性的名稱
                屬性對應(yīng)的數(shù)據(jù)庫表
                普通字段
        -->
        <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) {

        //創(chuàng)建對象
        Cat cat = new Cat();
        Monkey monkey = new Monkey();

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

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

        //加載類對應(yīng)的映射文件！
        configuration.configure().addClass(Animal.class);

        //創(chuàng)建Session工廠對象
        SessionFactory factory = configuration.buildSessionFactory();

        //得到Session對象
        Session session = factory.openSession();

        //使用Hibernate操作數(shù)據(jù)庫，都要開啟事務(wù),得到事務(wù)對象
        Transaction transaction = session.getTransaction();

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

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

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

        //關(guān)閉Session
        session.close();

    }
}

這里寫圖片描述

組件映射和繼承映射總結(jié)

由于我們的傳統(tǒng)繼承映射每個子類都對應(yīng)一個配置文件，這樣十分麻煩。因此.hbm.xml就給出了幾個節(jié)點供我們使用，分別有以下的情況：

子類父類共有一張表subclass
- 不符合數(shù)據(jù)庫設(shè)計規(guī)范
- 需要使用鑒別器
子類、父類都有自己的表joined-subclass，那么就是三張表
- 表的結(jié)構(gòu)太過繁瑣
- 插入數(shù)據(jù)時要生成SQL至少就要兩條
子類擁有自己的表、父類不對應(yīng)表【推薦】union-subclass
- 父類不對應(yīng)表要使用abstract來修飾
- 主鍵的id不能使用自增長策略，修改成UUID就好了。對應(yīng)的JavaBean的id設(shè)置成String就好

如果文章有錯的地方歡迎指正，大家互相交流。習(xí)慣在微信看技術(shù)文章，想要獲取更多的Java資源的同學(xué)，可以關(guān)注微信公眾號:Java3y

色偷偷精品伊人,欧洲久久精品,欧美综合婷婷骚逼,国产AV主播,国产最新探花在线,九色在线视频一区,伊人大交九 欧美,1769亚洲,黄色成人av

Hibernate【映射】知識要點

前言

集合映射

數(shù)據(jù)庫表

實體

映射文件

List集合映射配置

Map集合映射配置

一對多和多對一

設(shè)計數(shù)據(jù)庫表

設(shè)計實體

映射分析

部門映射配置文件

員工映射配置文件

在“一”的一方測試

在“多”的一方測試

一對多和多對一總結(jié)

多對多映射

設(shè)計數(shù)據(jù)庫表

設(shè)計實體

映射配置文件

Project映射文件

Developer映射文件

測試

一對一的映射

數(shù)據(jù)庫表設(shè)計

設(shè)計實體

第一種方式映射文件

user映射文件

idCard映射文件

測試

第二種方式映射文件

idCard映射文件

user映射文件

測試

組件映射

設(shè)計數(shù)據(jù)庫

設(shè)計實體

映射表

測試

傳統(tǒng)方式繼承

表結(jié)構(gòu)

實體

映射文件

測試

把所有子類映射成一張表

數(shù)據(jù)表

實體

映射文件

測試

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

數(shù)據(jù)表設(shè)計

映射文件

測試

(推薦)每個子類映射一張表， 父類不對應(yīng)表(2張表)

數(shù)據(jù)庫表設(shè)計

映射文件

測試

組件映射和繼承映射總結(jié)

相關(guān)閱讀更多精彩內(nèi)容

友情鏈接更多精彩內(nèi)容

色偷偷精品伊人,欧洲久久精品,欧美综合婷婷骚逼,国产AV主播,国产最新探花在线,九色在线视频一区,伊人大交九欧美,1769亚洲,黄色成人av

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