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