Hibernate学习-7-关联映射

关联映射

需求分析

eg 1-

部门与员工的例子

一个部门有多个员工[一对多]

多个员工，属于一个部门[多对一]

eg 2-

       一个项目多个开发人员

一个开发人员参与多个项目 [多对多]

一对多与多对一映射

一.需求分析

二.数据库

t_dept

字段：deptId  deptName

t_employee

字段：empId empName salary dept_id

三.javabean

设计关键：通过一方维护到另一方

class Dept{

    private int deptId;

    private String deptName;

    //部门对应多个员工
    private Set<Employee> emps;

}

class Employee{

   private int empId;

   private String empName;

   private double salary;

   //多个员工对应一个部门
   private Dept dept;
}

四.映射

Dept映射关键点

1.映射的集合属性:"emps"

2.指定集合属性对应的集合表:"t_employee"

3.指定集合表的外键字段

4.指定集合元素的类型

Employee映射的关键点

1.映射的部门属性: dept

2.映射的部门对象，对应的外键字段:dept_id

3.部门的类型

实例-保存数据-查询数据

总配置文件

<!DOCTYPE hibernate-configuration PUBLIC
    "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
    <session-factory>
         <!--1.数据库连接配置-->
        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="hibernate.connection.url">jdbc:mysql:///learnHibernate</property>
        <property name="hibernate.connection.username">root</property>
        <property name="hibernate.connection.password">33269456.cx</property>
        <!--
          数据库方言配置，hibernate会根据不同的方言生成符合当前数据库语法的sql
        -->
        <property name="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</property>

        <!--2.其他相关配置-->
        <!--2.1显示运行时的sql语句-->
        <property name="hibernate.show_sql">true</property>

        <!--2.2格式化sql-->

        <property name="hibernate.format_sql">true</property>

        <!--2.3自动建表,写好映射就可以-->

        <property name="hibernate.hbm2ddl.auto">update</property>

        <!--3.加载所有映射-->

    </session-factory>

</hibernate-configuration>

Dept.java

package com.cx.entity;

import java.util.HashSet;
import java.util.Set;

/**
 * Created by cxspace on 16-8-2.
 */
public class Dept {

    private int deptId;

    private String deptName;

    //一对多(一个部门对应多个员工)
    private Set<Employee> employees = new HashSet<>();

    public int getDeptId() {
        return deptId;
    }

    public void setDeptId(int deptId) {
        this.deptId = deptId;
    }

    public String getDeptName() {
        return deptName;
    }

    public void setDeptName(String deptName) {
        this.deptName = deptName;
    }

    public Set<Employee> getEmployees() {
        return employees;
    }

    public void setEmployees(Set<Employee> employees) {
        this.employees = employees;
    }
}

相关映射配置

<?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="com.cx.entity">

    <class name="Dept" table="t_dept">

        <id name="deptId">
            <generator class="native"></generator>
        </id>

        <property name="deptName" length="20"></property>

        <!--
            1.映射的集合属性:"emps"

            2.指定集合属性对应的集合表:"t_employee"

            3.指定集合表的外键字段

            4.指定集合元素的类型
        -->

        <!--table="t_employee",可以省略-->

        <set name="employees" table="t_employee">
            <key column="dept_id"></key>
            <one-to-many class="Employee"></one-to-many>
        </set>

    </class>

</hibernate-mapping>

Employee.java

package com.cx.entity;

/**
 * Created by cxspace on 16-8-2.
 */
public class Employee {

    private int empId;

    private String empName;

    private double salary;

    private Dept dept;

    public Dept getDept() {
        return dept;
    }

    public void setDept(Dept dept) {
        this.dept = dept;
    }

    public int getEmpId() {
        return empId;
    }

    public void setEmpId(int empId) {
        this.empId = empId;
    }

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

相关映射配置

<?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="com.cx.entity">

    <class name="Employee" table="t_employee">
        <id name="empId">
            <generator class="native"></generator>
        </id>

        <property name="empName" length="20"></property>

        <property name="salary" type="double"></property>

        <!--
        多对一映射配置
        Employee 映射关键点：
        1.  映射的部门属性  ：  dept
        2.  映射的部门属性，对应的外键字段: dept_id
        3.  部门的类型
        -->

        <many-to-one name="dept" column="dept_id" class="Dept"></many-to-one>

    </class>

</hibernate-mapping>

测试类

package com.cx.test;

import com.cx.entity.Dept;
import com.cx.entity.Employee;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.junit.Test;

/**
 * Created by cxspace on 16-8-2.
 */
public class Save {

    private static SessionFactory sf;
    static {
        sf = new Configuration()
                .configure()
                .addClass(Dept.class)
                .addClass(Employee.class)   // 测试时候使用
                .buildSessionFactory();
    }

    //保存,部门方 一对一方法操作

    public void save(){

        Session session = sf.openSession();
        session.beginTransaction();

        //部门对象
        Dept dept = new Dept();
        dept.setDeptName("应用开发部");

        //员工对象
        Employee emp_zs = new Employee();

        emp_zs.setEmpName("张三");

        Employee emp_ls = new Employee();

        emp_ls.setEmpName("李四");

        //关系
        dept.getEmployees().add(emp_zs);
        dept.getEmployees().add(emp_ls);

        //保存

        session.save(emp_zs);
        session.save(emp_ls);

        session.save(dept);

        session.getTransaction().commit();
        session.close();

        /*
        *

                Hibernate:
                    insert
                    into
                        t_employee
                        (empName, salary, dept_id)
                    values
                        (?, ?, ?)
                Hibernate:
                    insert
                    into
                        t_employee
                        (empName, salary, dept_id)
                    values
                        (?, ?, ?)
                Hibernate:
                    insert
                    into
                        t_dept
                        (deptName)
                    values
                        (?)
                Hibernate:
                    update
                        t_employee
                    set
                        dept_id=?
                    where
                        empId=?
                Hibernate:
                    update
                        t_employee
                    set
                        dept_id=?
                    where
                        empId=?

        * */

    }

    //保存,员工方[多对一保存],效率更高
    @Test

    public void save2(){

        Session session = sf.openSession();
        session.beginTransaction();

        Dept dept = new Dept();
        dept.setDeptName("综合部");

        Employee emp_zs = new Employee();
        emp_zs.setEmpName("张三");

        Employee emp_ls = new Employee();
        emp_ls.setEmpName("李四");

        emp_zs.setDept(dept);
        emp_ls.setDept(dept);

        session.save(dept);
        session.save(emp_ls);
        session.save(emp_zs);

        session.getTransaction().commit();
        session.close();

        /*
        *
        * 结果
        *
        *   Hibernate:
                insert
                into
                    t_dept
                    (deptName)
                values
                    (?)
            Hibernate:
                insert
                into
                    t_employee
                    (empName, salary, dept_id)
                values
                    (?, ?, ?)
            Hibernate:
                insert
                into
                    t_employee
                    (empName, salary, dept_id)
                values
                    (?, ?, ?)
        *
        *
        * */

    }

}

结果

package com.cx.test;

import com.cx.entity.Dept;
import com.cx.entity.Employee;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.junit.Test;

/**
 * Created by cxspace on 16-8-2.
 */
public class Get {

    private static SessionFactory sf;
    static {
        sf = new Configuration()
                .configure()
                .addClass(Dept.class)
                .addClass(Employee.class)   // 测试时候使用
                .buildSessionFactory();
    }

    @Test
    public void get(){

        Session session = sf.openSession();
        session.beginTransaction();

        //通过部门方获取另一方
//        Dept dept = (Dept) session.get(Dept.class , 1);
//        System.out.println(dept.getDeptName());
//        System.out.println(dept.getEmployees());

结果

Hibernate:
select
dept0_.deptId as deptId0_0_,
dept0_.deptName as deptName0_0_
from
t_dept dept0_
where
dept0_.deptId=?
应用开发部
Hibernate:
select
employees0_.dept_id as dept4_0_1_,
employees0_.empId as empId1_,
employees0_.empId as empId1_0_,
employees0_.empName as empName1_0_,
employees0_.salary as salary1_0_,
employees0_.dept_id as dept4_1_0_
from
t_employee employees0_
where
employees0_.dept_id=?
[[email protected], [email protected]]


        //通过员工获取部门
        Employee emp = (Employee)session.get(Employee.class,1);
        System.out.println(emp.getEmpName());
        System.out.println(emp.getDept().getDeptName());

        session.getTransaction().commit();
        session.close();

结果

Hibernate:
select
employee0_.empId as empId1_0_,
employee0_.empName as empName1_0_,
employee0_.salary as salary1_0_,
employee0_.dept_id as dept4_1_0_
from
t_employee employee0_
where
employee0_.empId=?
张三
Hibernate:
select
dept0_.deptId as deptId0_0_,
dept0_.deptName as deptName0_0_
from
t_dept dept0_
where
dept0_.deptId=?
应用开发部


    }

}

多对多映射

时间： 2024-08-05 20:14:16

Hibernate学习-7-关联映射的相关文章

Hibernate之1-N关联映射

一.Hibernate之1-N关联映射 1. 哪边是 1 , 哪边是多 ? 需要从业务的角度来说明.例如,Employee 和 Department 之间就是 n-1 的关联关系,Order 和 Customer 之间也是 n-1 的关联关系. 1). 关联关系是有方向的: 2). 如何在类中来建立关联关系呢 ? 解:通过成员变量的方式即可. 2. 单向 n-1 关联关系 1). 域对象中,在 Order 中声明一个 Customer 类型的成员变量,并提供 setter.getter publ

hibernate多对一关联映射

hibernate多对一关联映射: 实体类 (POJO) public class Student{ private int stuId; private String stuNum; private String stuName; private ClassRoom cr; } public class ClassRoom{ private int claId; private String claName; } 映射文件 <class name=" Student" tabl

Hibernate一对一双向关联映射

关键原因在于对象模型具有方向性: 单向:一端只能加载另一端,不能反过来. 双向:两端都可以加载另一端. 问题来了:如何我们想从身份证端(IdCard)加载人(Person),怎么办呢? 下面我们开始介绍一对一的双向关联映射. 映射原理 双向关联映射与单向关联映射的原理是一样的,双向关联映射并不影响存储,只影响加载.所以,双向关联映射和单向关联映射的关系模型是一样的即数据库的表结构是一样的,只是IdCard的实体类和配置文件(IdCard.hbm.xml)发生了一点点变化. 对象模型 从上图中可以

【Hibernate步步为营】--关联映射之多对一

上篇文章讨论了Hibernate的基本映射,一个实体类对应着一张表,在相应的Hibernate Mapping文件中使用<class>标签映射.并且实体类中的普通属性对应着表字段,使用<property>标签映射.另外在构造实体类时应注意:在实体类中应实现无参的默认的构造函数,提供一个标示,建议不要使用final修饰实体类,为实体类生成getter和setter方法,最后介绍了几种主要的主键生成策略,接下来讨论多对一映射. 一.关联映射之多对一 对于多对一关联映射其实很容易理解,在

【Hibernate】——一对一关联映射

两个对象之间如果是一对一的关系,如Person-IdCard.在Hibernate中有两种策略可以实现一对一的关联映射: 主键关联:即让两个对象具有相同的主键值,以表明它们之间的一一对应的关系:数据库表不会有额外的字段来维护它们之间的关系,仅通过表得主键来关联. 唯一外键关联:外键关联,本来是用于多对一的配置,但是如果加上唯一的限制之后,也可以用来表示一对一关联关系: 而每种策略又分为两种方向的对应关系,即单向一对一关系和双向一对一关系.分类的原因一般是由需求决定的,单双向是站在不同的角度去看人

hibernate的数据关联映射

数据关联映射分为:一对多.多对一,一对一,多对多. cascade属性• save-update:在执行保存和修改是进行级联操作• delete:在执行删除时进行级联操作• all:在所有情况下进行级联操作• none:不进行级联操作(默认) 抓取策略 一对多.多对一 一对多.多对一持久化类设计 // User类 public class User { private int id; private String name; private int age; private Set<Addres

[原创]java WEB学习笔记86：Hibernate学习之路-- -映射 n-n 关系,单向n-n，双向n-n

本博客的目的:①总结自己的学习过程,相当于学习笔记 ②将自己的经验分享给大家,相互学习,互相交流,不可商用 内容难免出现问题,欢迎指正,交流,探讨,可以留言,也可以通过以下方式联系. 本人互联网技术爱好者,互联网技术发烧友 微博:伊直都在0221 QQ:951226918 -----------------------------------------------------------------------------------------------------------------

Hibernate框架之关联映射入门

关联映射就是将关联关系映射到数据库里,在对象模型中就是一个或多个引用. 一:配置单向多对一关联 在Emp类中定义一个Dept属性,而在Dept类中无须定义用于存放Emp对象的集合属性 01.Dept.java package cn.zhang.entity; //部门实体类 public class Dept { private Integer deptid;//编号 private String deptname;//名称 public Integer getDeptid() { return

hibernate之关于关联映射的综合应用

[hibernate]之关于关联映射的综合应用 1.关联映射如何处理业务逻辑 2.如何指定中间表 3.如何进行级联操作 4.如何解决Hibenrate建表过程中主键错乱问题 现在有三张表 Student(学生表),Course(课程表),Score(学生,课程,分数,表) 那么我们分析业务逻辑可知,学生和课程是多对多的关系,学生和分数表是一对多的关系,课程和分数也是一对多的关系. 直接看Annotations配置,在这里我所有的配置都是双向关联,这样在分数,课程,学生,之中,可以任意找到彼此!