Hibernate【映射】知識要點

TesterHome 發布于2019-08-15 14:35 / 1774人閱讀

摘要：前言前面的我們使用的是一個表的操作，但我們實際的開發中不可能只使用一個表的因此，本博文主要講解關聯映射集合映射需求分析當用戶購買商品，用戶可能有多個地址。數據庫表我們一般如下圖一樣設計數據庫表，一般我們不會在表設計多個列來保存地址的。

前言

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

集合映射

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

數據庫表

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

創建兩張數據表，一張保存著用戶的信息，一張保存著地址的信息。地址表使用外鍵來引用用戶表

實體

由于地址只是使用String類型來保存著，那么我們直接使用一個User對象就可以了

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

    //各種setter和getter

映射文件

測試:

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集合是有序的，因此要多配置一個列來維護數據的有序性！

Map集合映射配置

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

一對多和多對一

上面我們講解了集合映射是怎么配置的，那集合裝載的元素有沒有可能是對象呢？？而不是簡單的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 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 getSet() {
        return set;
    }

    public void setSet(Set 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就可以找到對應類型的映射文件，從而得到對應的信息！】

部門映射配置文件

員工映射配置文件

在“一”的一方測試

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 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 getDevelopers() {
        return developers;
    }

    public void setDevelopers(Set 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 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 getProjects() {
        return projects;
    }

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

映射配置文件

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

配置映射集合的屬性(developers)

映射集合對應的中間表(developer_project)

中間表的外鍵字段(project_id)

集合元素的類型(Developer)

中間表另外的外鍵字段(developer_id)

Project和Developer的映射文件都需要這幾個關鍵步驟

Project映射文件

Developer映射文件

測試

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映射文件

idCard映射文件

測試

要使用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屬性值了

使用標簽來配置基于主鍵的映射

user映射文件

測試

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

映射表

使用了一個新標簽，組件映射標簽。

測試

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

映射文件

簡單繼承的映射文件很好寫，在屬性上，直接寫父類的屬性就可以了。

但是也有致命的缺點：如果子類有很多，就需要寫很多的配置文件

測試

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這個節點和鑒別器

測試

加載的是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

數據表設計

映射文件

使用到了這個節點

測試

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文件中使用了這個節點，由于有了這個節點，我們就不需要每個子類都寫一個配置文件了。

數據庫表設計

映射文件

想要父類不映射成數據庫表，只要在class中配置為abstract即可

使用了union-subclass節點，主鍵就不能采用自動增長策略了。我們改成UUID即可。當然啦，對應的實體id類型要改成String

測試

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

云服務器 GPU云服務器基礎要點要點 html要點 php要點

文章版權歸作者所有，未經允許請勿轉載,若此文章存在違規行為，您可以聯系管理員刪除。

轉載請注明本文地址：http://specialneedsforspecialkids.com/yun/68696.html

納稅服務系統【總結】

摘要：要是使用到日歷的話，我們想到使用這個日歷類上面僅僅是我個人總結的要點，如果有錯誤的地方還請大家給我指正。納稅服務系統總結納稅服務系統是我第一個做得比較大的項目(不同于javaWeb小項目),該項目系統來源于傳智Java32期，十天的視頻課程(想要視頻的同學關注我的公眾號就可以直接獲取了) 我跟著練習一步一步完成需求，才發覺原來Java是這樣用來做網站的，Java有那么多的類庫，頁面...

ispring 2019-08-15 14:48 評論0 收藏0
Java3y文章目錄導航

摘要：前言由于寫的文章已經是有點多了，為了自己和大家的檢索方便，于是我就做了這么一個博客導航。前言由于寫的文章已經是有點多了，為了自己和大家的檢索方便，于是我就做了這么一個博客導航。由于更新比較頻繁，因此隔一段時間才會更新目錄導航哦～想要獲取最新原創的技術文章歡迎關注我的公眾號：Java3y Java3y文章目錄導航 Java基礎泛型就這么簡單注解就這么簡單 Druid數據庫連接池...

KevinYan 2019-08-15 15:13 評論0 收藏0
Hibernate【緩存】知識要點

摘要：對象狀態中對象的狀態臨時瞬時狀態持久化狀態游離狀態學習的對象狀態是為了更清晰地知道的設計思想，以及是一級緩存的基礎當然啦，也就一點點知識臨時瞬時狀態當我們直接出來的對象就是臨時瞬時狀態的該對象還沒有被持久化沒有保存在數據庫中不受的管理持久化對象狀態 Hibernate中對象的狀態：臨時/瞬時狀態持久化狀態游離狀態學習Hibernate的對象狀態是為了更清晰地知道Hiber...

AlphaWallet 2019-08-15 14:37 評論0 收藏0
Mybatis【一對多、多對一、多對多】知識要點

摘要：我來看一下查詢結果我們的實體與映射表中，實體是沒有關聯其他的字段的，僅僅是寫出了該實體的自帶的屬性。 Mybatis【多表連接】我們在學習Hibernate的時候，如果表涉及到兩張的話，那么我們是在映射文件中使用..等標簽將其的映射屬性關聯起來的...那么在我們Mybatis中又怎么做呢？？？先來回顧一下我們SQL99的語法：一）內連接（等值連接）：查詢客戶姓名，訂單編號，訂單...

JerryWangSAP 2019-08-15 14:43 評論0 收藏0
Java項目經驗——程序員成長的鑰匙

摘要：當你真正到公司里面從事了幾年開發之后，你就會同意我的說法利用找工作，需要的就是項目經驗，項目經驗就是理解項目開發的基本過程，理解項目的分析方法，理解項目的設計思 Java就是用來做項目的！Java的主要應用領域就是企業級的項目開發！要想從事企業級的項目開發，你必須掌握如下要點： 1、掌握項目開發的基本步驟 2、具備極強的面向對象的分析與設計技巧 3、掌握用例驅動、以架構為核心的主流開發...

zhangfaliang 2019-08-16 10:37 評論0 收藏0