Hibernate(四)一对多映射 补充三：双向多对一关系（学生-->班级)

最新推荐文章于 2018-05-29 20:03:05 发布
最新推荐文章于 2018-05-29 20:03:05 发布
阅读量346 收藏
点赞数
分类专栏： hibernate
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yangfan5314/article/details/75012602
版权

数据库及其他文件见hibernate(四)一对多映射 补充一：单向一对多关系（班级->学生） 

package com.imooc.entity;

import java.io.Serializable;
import java.util.HashSet;
import java.util.Set;

/**
 * 班级
 * @author Administrator
 *
 */
public class Grade implements Serializable{
    /**
     * 
     */
    private static final long serialVersionUID = 1L;
    private int gid;
    private String gname;
    private String gdesc;
    //在一方定义一个多方的集合
    private Set<Student> students = new HashSet<Student>();

    public Grade() {
        super();
    }



    public Grade(String gname, String gdesc) {
        super();
        this.gname = gname;
        this.gdesc = gdesc;
    }



    public Grade(int gid, String gname, String gdesc, Set<Student> students) {
        super();
        this.gid = gid;
        this.gname = gname;
        this.gdesc = gdesc;
    }
    public int getGid() {
        return gid;
    }
    public void setGid(int gid) {
        this.gid = gid;
    }
    public String getGname() {
        return gname;
    }
    public void setGname(String gname) {
        this.gname = gname;
    }
    public String getGdesc() {
        return gdesc;
    }
    public void setGdesc(String gdesc) {
        this.gdesc = gdesc;
    }
    public Set<Student> getStudents() {
        return students;
    }
    public void setStudents(Set<Student> students) {
        this.students = students;
    }


}
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping>

    <class name="com.imooc.entity.Grade" table="grade" >
        <id name="gid" column="gid" type="java.lang.Integer">
            <generator class="increment"></generator><!--increment Hibernate自增  -->
        </id>
        <property name="gname" type="java.lang.String">
            <column name="gname" length="20" not-null="true"></column>
        </property>
        <property name="gdesc" >
            <column name="gdesc"></column>
        </property>
        <set name="students" table="student">
            <key column="gid"></key>
            <one-to-many class="com.imooc.entity.Student"/>
        </set>
    </class>

</hibernate-mapping>

package com.imooc.entity;

/**
 * 学生
 * @author Administrator
 *
 */
public class Student {

    public Student(String sname, String sex) {
        super();
        this.sname = sname;
        this.sex = sex;
    }

    public Student() {
        super();
    }


    private int sid;
    private String sname;
    private String sex;
    private Grade grade;
    public int getSid() {
        return sid;
    }
    public void setSid(int sid) {
        this.sid = sid;
    }
    public String getSname() {
        return sname;
    }
    public void setSname(String sname) {
        this.sname = sname;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }

    public Grade getGrade() {
        return grade;
    }

    public void setGrade(Grade grade) {
        this.grade = grade;
    }


}

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping>

    <class name="com.imooc.entity.Student" table="student" >
        <id name="sid" column="sid" type="java.lang.Integer">
            <generator class="increment"></generator><!--increment Hibernate自增  -->
        </id>
        <property name="sname" type="java.lang.String">
            <column name="sname" length="20" not-null="true"></column>
        </property>
        <property name="sex" >
            <column name="sex"></column>
        </property>
        <!-- 配置多对一关联关系 -->
        <many-to-one name="grade" class="com.imooc.entity.Grade" column="gid"></many-to-one>
    </class>

</hibernate-mapping>

package com.imooc.entity;

import java.util.Set;
import org.hibernate.Session;
import org.hibernate.Transaction;
import com.imooc.util.HibernateUtil;

/**
 * 双向多对一关系（学生--》班级）
 * @author Administrator
 *
 */
public class Test {

    public static void main(String[] args) {
        add();
        //findStudentsByGrade();
        //update();
        //delete();
    }

    //将学生添加到班级
    public static void add(){
        Grade g = new Grade("JAVA一班"," Java软件开发一班 ");
        Student stu1 = new Student("张三","男");
        Student stu2 = new Student("慕女神","女");
        //设置关联关系
        stu1.setGrade(g);
        stu2.setGrade(g);

        g.getStudents().add(stu1);
        g.getStudents().add(stu2);

        Session session = HibernateUtil.getSession();
        Transaction tx =  session.beginTransaction();
        //保存班级
        session.save(g);
        //保存学生
        session.save(stu1);
        session.save(stu2);

        tx.commit();
        HibernateUtil.closeSession(session);
    }
}

/*console执行结果: 下面两条update是赘余的浪费性能，不需要去更新student的gid在student在已经设置。所以可以在one的一方set标签中添加inverse="true"，表示由多的一方负责维护关联关系。
    Hibernate: select max(gid) from grade
Hibernate: select max(sid) from student
Hibernate: insert into grade (gname, gdesc, gid) values (?, ?, ?)
Hibernate: insert into student (sname, sex, gid, sid) values (?, ?, ?, ?)
Hibernate: insert into student (sname, sex, gid, sid) values (?, ?, ?, ?)
Hibernate: update student set gid=? where sid=?
Hibernate: update student set gid=? where sid=?
*/

优化一：修改在one的一方set标签中添加inverse=”true”

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping>

    <class name="com.imooc.entity.Grade" table="grade" >
        <id name="gid" column="gid" type="java.lang.Integer">
            <generator class="increment"></generator><!--increment Hibernate自增  -->
        </id>
        <property name="gname" type="java.lang.String">
            <column name="gname" length="20" not-null="true"></column>
        </property>
        <property name="gdesc" >
            <column name="gdesc"></column>
        </property>
        <!-- <set>节点的inverse属性指定关联关系的控制方向，默认由one方来维护
            关联关系中，inverse="false"则为主动方，由主动方负责维护关联关系
            在一对多关联中，只能设置one方的inverse为true，这将有助于性能的改善 -->
        <set name="students" table="student" inverse="true">
            <key column="gid"></key>
            <one-to-many class="com.imooc.entity.Student"/>
        </set>
    </class>

</hibernate-mapping>

/*
console:执行结果为：

Hibernate: select max(gid) from grade
Hibernate: select max(sid) from student
Hibernate: insert into grade (gname, gdesc, gid) values (?, ?, ?)
Hibernate: insert into student (sname, sex, gid, sid) values (?, ?, ?, ?)
Hibernate: insert into student (sname, sex, gid, sid) values (?, ?, ?, ?)
*/

优化二：保存班级的时候级联保存学生信息
cascade属性
1.all 对所有的操作进行级联操作
2.save-update 执行保存和更新操作时进行级联操作
3.delete 执行删除时进行级联操作
4.none 对所有操作不进行级联操作

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping>

    <class name="com.imooc.entity.Grade" table="grade" >
        <id name="gid" column="gid" type="java.lang.Integer">
            <generator class="increment"></generator><!--increment Hibernate自增  -->
        </id>
        <property name="gname" type="java.lang.String">
            <column name="gname" length="20" not-null="true"></column>
        </property>
        <property name="gdesc" >
            <column name="gdesc"></column>
        </property>
        <!-- <set>节点的inverse属性指定关联关系的控制方向，默认由one方来维护
            关联关系中，inverse="false"则为主动方，由主动方负责维护关联关系
            在一对多关联中，只能设置one方的inverse为true，这将有助于性能的改善 
            cascade="save-update" 保存和更新时级联操作
            -->
        <set name="students" table="student" inverse="true" cascade="save-update">
            <key column="gid"></key>
            <one-to-many class="com.imooc.entity.Student"/>
        </set>
    </class>

</hibernate-mapping>
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping>

    <class name="com.imooc.entity.Student" table="student" >
        <id name="sid" column="sid" type="java.lang.Integer">
            <generator class="increment"></generator><!--increment Hibernate自增  -->
        </id>
        <property name="sname" type="java.lang.String">
            <column name="sname" length="20" not-null="true"></column>
        </property>
        <property name="sex" >
            <column name="sex"></column>
        </property>
        <!-- 配置多对一关联关系 cascade="all" 增删改查student级联操作grade-->
        <many-to-one name="grade" class="com.imooc.entity.Grade" column="gid" cascade="all"></many-to-one>
    </class>

</hibernate-mapping>
package com.imooc.entity;

import java.util.Set;
import org.hibernate.Session;
import org.hibernate.Transaction;
import com.imooc.util.HibernateUtil;

/**
 * 双向多对一关系（学生--》班级）
 * @author Administrator
 *
 */
public class Test {

    public static void main(String[] args) {
        add();
        //findStudentsByGrade();
        //update();
        //delete();
    }

    //将学生添加到班级
    public static void add(){
        Grade g = new Grade("JAVA一班"," Java软件开发一班 ");
        Student stu1 = new Student("张三","男");
        Student stu2 = new Student("慕女神","女");
        //设置关联关系
        stu1.setGrade(g);
        stu2.setGrade(g);

        g.getStudents().add(stu1);
        g.getStudents().add(stu2);

        Session session = HibernateUtil.getSession();
        Transaction tx =  session.beginTransaction();
        //保存班级时级联保存学生信息
        session.save(g);

        tx.commit();
        HibernateUtil.closeSession(session);
    }

    //查询学生所在班级信息 
    public static void findGradeByStudent(){
        Session session = HibernateUtil.getSession();
        //学生信息
        Student student = (Student) session.get(Student.class, 2);
        System.out.println(student.getSid()+","+student.getSname());

        //班级信息 配置级联关系后直接.出来
        Grade grade = student.getGrade();
        System.out.println(grade.getGid()+","+grade.getGname());
    }
}

/*
    console:执行结果：
    Hibernate: select student0_.sid as sid1_1_0_, student0_.sname as sname2_1_0_, student0_.sex as sex3_1_0_, student0_.gid as gid4_1_0_ from student student0_ where student0_.sid=?
2,慕女神
Hibernate: select grade0_.gid as gid1_0_0_, grade0_.gname as gname2_0_0_, grade0_.gdesc as gdesc3_0_0_ from grade grade0_ where grade0_.gid=?
1,JAVA一班
*/
半切西瓜
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springmvc+spring4.x+hibernate4.x整合实现对学生信息的增删改查
09-15
springmvc+spring+hibernate框架整合实现对学生信息的增删改查实例，数据库采用SqlServer2005
hibernate+struts一对多增删改查demo（学生对班级）
05-10
利用struts1.2，hibernte3.0 mysql数据库 做的一个学生对班级增删改查的例子
3.一对一单向主键关联(人对身份证) hibernate.cfg.xml
03-25 261
<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd"> com.mysql.jdbc.Driver jdbc:mys
Hibernate(四)一对多映射 补充一：单向一对多关系（班级->学生）
yangfan5314的专栏
07-11 375
数据库表创建create table grade ( gid int primary key, gname varchar(20) not null, gdesc varchar(50) );create table student ( sid int primary key, sname varchar(20) not null, sex char(
hibernate创建表以及表的数据增删改查
07-16 134
5.1项目的整体框架; 5.2 Student.java packagecom.ask.pojo; //新建一个学生实体类; public class Student { private int id; privateString name; privateString password; 自己生成get和set方法以及其他方法; 5.2 Student.hbm....
Java的Hibernate框架中一对多的单向和双向关联映射
09-02
在Java的Hibernate框架中，一对多关联映射是一种常见的数据模型关系，用于表示一个实体（如班级）可以与多个其他实体（如学生）相关联。这种关系映射可以帮助简化数据库操作，使得在Java代码中处理这些关系变得更加...
Hibernate ORM - 一对多双向组合关联关系
03-28
这个标题表明我们要讨论的是Hibernate ORM框架中的一种特定的数据关系映射——一对多双向组合关联。在关系型数据库中，一对多关联意味着一个父实体可以与多个子实体相对应，而双向则表示这种关系是相互的，即父实体...
多对一双向关联关系实现源码
10-08
在Java编程语言中，特别是在开发企业级应用时，数据模型设计常常涉及到对象关系映射（ORM）框架，如Hibernate。本篇文章将详细讲解如何在Hibernate中实现多对一双向关联关系，并通过源码分析加深理解。 多对一关联...
Hibernate 一对多双向映射及乐观锁使用
04-23
1. **Hibernate 一对多映射**：在Hibernate中，可以通过配置XML映射文件或使用注解来定义一对多的关系。通常，一方会有一个集合属性，如`List<Many>`，而多的一方则有一个外键字段引用一方。 2. **双向映射**：在...
Hibernate双向一对多
03-12
标题"Hibernate双向一对多"指的是Hibernate框架中的一个重要关系映射概念，即在一个实体类中，一个实例可以与多个另一个实体类的实例相关联，而在另一个实体类中，每个实例也可以关联到该实体类的一个实例。这种关系...
学生班级的struts2-hibernate-spring
06-10
spring+hibernate+struts 添加，修改，删除、查找等功能
hibernate对单表的增删改查
weixin_30632899的博客
08-01 90
ORM: 对象关系映射（英语：Object Relational Mapping，简称ORM，或O/RM，或O/R mapping） 实现对单表的增删改查 向区域表中增加数据： 第一步： 新建一个Dao(实现add方法)： public void add(Emp emp){ Session session=HibernateSessionFactory.getSes...
Hibernate(四)一对多映射 补充二：单向多对一关系（学生->班级）
yangfan5314的专栏
07-12 620
数据库及其他文件见Hibernate(四)一对多映射 补充一：单向一对多关系（班级->学生） package com.imooc.entity;import java.io.Serializable;public class Grade implements Serializable{ /** * 班级 */ private static final long s
5.一对多双向关联(班级对学生):总结
06-15 780
hibernate一对多关联映射（双向ClassesStudent） 采用一对多双向关联映射的目的主要是为了主要是为了解决一对多单向关联的缺陷 而不是需求驱动的 一对多双向关联的映射方式：  * 在一的一端的集合上采用标签，在多的一端加入一个外键  * 在多的一端采用标签   ！！！注意：标签和标签加入的字段保持一直，否则会产生数据混乱 inverse属性：  * inverse
使用hibernate框架制作学生信息查询(多表查询)
qq_1460567153罗隽的博客
08-16 1312
需求：通过学院表和学生表进行关联，从浏览器点击学院信息，显示出各学院学生信息功能展示：代码演示：<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%> <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%> <!DOCTYPE HTML PUBLI
Hibernate的关系映射
年轻的心跳
05-29 1245
1、实验目的(1) 理解什么是单向、双向、多对一、一对多的含义(2) 掌握hibernate一对多映射关系2、实验设备与环境硬件：安装有Windows XP/7/8系统的微机一台。软件：JDK1.6以上、MyEclipse 8.0以上，oracle9i以上。3、实验内容(1) 使用hibernate配置文件创建学生信息表(学号、姓名、性别、出生日期、班级)、班级信息表(班级编号、班级名称、开班日期...
Java—遍历每个班级的所有学生，即一对多的关系
08-12 1302
import java.util.ArrayList; import java.util.Iterator; import java.util.List; import java.util.TreeMap; public class fanxing { public static void main(String args[]) { TreeMap> tm = new TreeMap> (
Hibernate实体关系映射：一对一、一对多、多对多
"该资源是关于Hibernate实体关系映射的PPT教程，涵盖了三种主要的关系类型：一对一、一对多和多对多。其中，详细解释了如何在Java中使用Hibernate框架进行这些关系的映射，并提供了相关的代码示例和映射文件配置。" ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值