Hibernate超简单多表操作

最新推荐文章于 2021-07-22 20:59:00 发布
最新推荐文章于 2021-07-22 20:59:00 发布
阅读量1.1w 收藏 5
点赞数 1
分类专栏： Hibernate学习探索 文章标签： hibernate 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/marksinoberg/article/details/51460600
版权
MySQL 同时被 3 个专栏收录
41 篇文章 1 订阅
订阅专栏
J2EE
37 篇文章 0 订阅
订阅专栏
Hibernate
8 篇文章 0 订阅
订阅专栏

所谓一对多映射

在数据库中我们通常会通过添加外键的方式将表关联起来，表现一对多的关系。
而在Hibernate中，我们则要通过在一方持有多方的集合来实现，即在“一”的一端中使用元素表示持有“多”的一段的对象。
下面是针对这个知识点的一个小案例：

Grade.java:

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

    public class Grade implements Serializable {
        private int gid;
        private String gname;
        private String gdesc;
        private Set<Student> students;

        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 Grade() {
            super();
        }

        public Set<Student> getStudents() {
            return students;
        }

        public void setStudents(Set<Student> students) {
            this.students = students;
        }

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

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

    }

Student.java:

    import java.io.Serializable;

    public class Student implements Serializable {
        private int sid;
        private String sname;
        private String sex;

        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 Student() {
            super();
        }

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

    }

然后是hbm.xml文件的配置：
Grade.hbm.xml：

    <?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>
        <class name="com.imooc.entity.Grade" table="grade">
            <id name="gid" column="gid" type="java.lang.Integer">
                <generator class="increment"></generator>
            </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>

Student.hbm.xml：

    <?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>
        <class name="com.imooc.entity.Student" table="student">
            <id name="sid" column="sid" type="java.lang.Integer">
                <generator class="increment"></generator>
            </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>
        </class>
    </hibernate-mapping>

最后，在hibernate.cfg.xml文件中将映射声明一下即可：

    <mapping resource="com./xx/Grade.hbm.xml" />
    <mapping resource="com/XX/Student.hbm.xml" />

代码实现操作的结果：

    import java.util.Set;

    import org.hibernate.Session;
    import org.hibernate.Transaction;

    import com.imooc.entity.Grade;
    import com.imooc.entity.Student;
    import com.imooc.util.HibernateUtil;

    /*
     * 单向一对多关系关系（班级--->学生）
     * 建立关联关系后，可以方便的从一个对象导航到另一个对象
     * 注意关联的方向
     */
    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("穆女神", "女");

            //如果希望在学生表中添加对应的班级编号，需要在班级中添加学生，建立关联关系
            /*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);
        }

        //查询班级中包含的学生
        public static void findStudentsByGrade(){
            Session session=HibernateUtil.getSession();
            Grade grade=(Grade) session.get(Grade.class, 1);
            System.out.println(grade.getGname()+","+grade.getGdesc());

            /*Set<Student> students=grade.getStudents();
            for(Student stu:students){
                System.out.println(stu.getSname()+","+stu.getSex());
            }*/
        }

        //修改学生信息
        public static void update(){
            Grade g=new Grade("Java二班", "Java软件开发二班");

            Session session=HibernateUtil.getSession();
            Transaction tx=session.beginTransaction();
            Student stu=(Student) session.get(Student.class, 1);
            //g.getStudents().add(stu);
            session.save(g);
            tx.commit();
            HibernateUtil.closeSession(session);
        }

        //删除学生信息
        public static void delete(){
            Session session=HibernateUtil.getSession();
            Transaction tx=session.beginTransaction();
            Student stu=(Student) session.get(Student.class, 2);
            session.delete(stu);
            tx.commit();
            HibernateUtil.closeSession(session);
        }
    }

所谓单向多对一映射

多对一的关系和关系型数据库的外键参照关系最为匹配，即在乙方的表中的一个外键参照另一个表中的主键。 而在Hibernate中就可以通过

在多方持有乙方的引用来实现，需要在“多”的一段使用标签来进行设置。

下面是针对这个知识点的一个小案例：

Grade.java:

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

    public class Grade implements Serializable {
        private int gid;
        private String gname;
        private String 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 Grade() {
            super();
        }

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

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

    }

Student.java:

    import java.io.Serializable;

    public class Student implements Serializable {
        private int sid;
        private String sname;
        private String sex;
        // 在多方定义一个一方的引用
        private Grade grade;

        public Grade getGrade() {
            return grade;
        }

        public void setGrade(Grade grade) {
            this.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 Student() {
            super();
        }

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

    }

然后是hbm.xml文件的配置：
Grade.hbm.xml：

    <?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>
        <class name="com.imooc.entity.Grade" table="grade">
            <id name="gid" column="gid" type="java.lang.Integer">
                <generator class="increment"></generator>
            </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>
        </class>
    </hibernate-mapping>

Student.hbm.xml：

    <?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>
        <class name="com.imooc.entity.Student" table="student">
            <id name="sid" column="sid" type="java.lang.Integer">
                <generator class="increment"></generator>
            </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" cascade="all"></many-to-one>
        </class>
    </hibernate-mapping>

最后，在hibernate.cfg.xml文件中将映射声明一下即可：

    <mapping resource="com./xx/Grade.hbm.xml" />
    <mapping resource="com/XX/Student.hbm.xml" />

再来使用代码测试一下：

    import org.hibernate.Session;
import org.hibernate.Transaction;

import com.imooc.entity.Grade;
import com.imooc.entity.Student;
import com.imooc.util.HibernateUtil;

/*
 * 单向多对一（学生--->班级）
 */
public class Test02 {
    public static void main(String[] args) {
        save();
    }

    //保存
    public static void save(){
        Grade g=new Grade("Java一班","Java软件开发一班");
        Student stu1=new Student("慕女神", "女");
        Student stu2=new Student("小慕慕", "男");

        //设置关联关系
        g.getStudents().add(stu1);
        g.getStudents().add(stu2);
        stu1.setGrade(g);
        stu2.setGrade(g);

        Session session=HibernateUtil.getSession();
        Transaction tx=session.beginTransaction();
        session.save(g);
        session.save(stu1);
        session.save(stu2);
        tx.commit();
        HibernateUtil.closeSession(session);
    }
}

双向的多对一关系

只需要分别在其.hbm.xml文件中进行相关的声明就可以了。
Grade.hbm.xml文件中添加：

    <!-- 配置一对多关联关系 -->
    <set name="students" table="student">
        <key column="gid"></key>
        <one-to-many class="com.imooc.entity.Student"/>
    </set>

Student.hbm.xml文件中添加：

    <!-- 配置多对一关联关系 -->
    <many-to-one name="grade" class="com.imooc.entity.Grade" 
    column="gid" cascade="all"></many-to-one>

由此，便可完成多对一关系的映射了！

泰 戈 尔
关注
专栏目录
hibernate多表联合查询
05-11
hibernate多表联合查询实例,很经典的查询语句和总结.
struts2与hibernate整合单表增删改查（超完整）
05-26
通过配置XML文件，Hibernate可以将Java类与数据库表进行映射，使得开发者可以以面向对象的方式操作数据库，而无需编写大量的SQL语句。 **3. 整合Struts2与Hibernate** 整合Struts2和Hibernate主要是为了在Struts2的...
（转）Hibernate中的多表操作
06-08 133
http://blog.csdn.net/yerenyuan_pku/article/details/70556208 Hibernate中的多表操作 在实际开发中，我们不可能只是简简单单地去操作单表，绝大部分都是要对多表进行操作的。所以本文就来讲述Hibernate中的多表操作，讲之前，先复习一下使用SQL语句是如何进行多表操作的。提示：本文所有案例代码的编写都是建立在前文Hibe...
【Hibernate】Hibernate的多表查询
热门推荐
编程记录，亲测有效
06-27 1万+
在《【Hibernate】Hibernate的聚类查询、分组查询、排序与时间之差》（点击打开链接）一文中已经讲述过如何利用HQL语句取代SQL语句，进行聚类查询、分组查询、排序与时间之差的查询，同时指出hql能代替sql语句做任何事情。我原本以为hql语句的多表查询，要先对里面的实体做Java与xml的修改，其实并不需要，同样是一句HQL语句就能搞定的事情。SQL的多表查询已经在《【Mysql】利
hibernate多表操作
diaozeqi6995的博客
03-26 65
一、表之间的关系 　　1.一对一 　　2.一对多 　　3.多对多 二、表之间关系建表原则 　　1.一对多：在多的一方创建一个外键，指向一的一方的主键 　　 　　2.多对多：创建一个中间表，中间表至少有两个字段，分别作为外键指向多对多双方的主键 　　 3.一对一：主键一一对应，或当成一对多来看待。 三、一对多实现 　　1)定义 1.在1的domain类中定义： ...
hibernate的第一个例子
07-12
**描述分析：**描述提到这是一个超级简单的例子，包含一个持久化对象（通常是Java类，对应数据库中的表）、一个辅助类（可能是配置或者工具类，帮助操作数据库）以及一个测试类（用于验证代码功能）。这个例子特别...
超级简单的购物网后台(struts+hibernate)
03-12
【标题】：“超级简单的购物网后台(struts+hibernate)”是一个基于Struts和Hibernate框架构建的电子商务网站后台管理系统。这个系统旨在提供一个简洁而有效的平台，帮助管理员管理在线商店的商品、订单、用户等核心...
spring+hibernate+http+mysql jar包
05-25
Hibernate支持JPA（Java Persistence API），并且提供了一种映射机制，将Java类和数据库表关联起来，使得数据操作变得更加简单。 3. **HTTP协议**： HTTP（超文本传输协议）是互联网上应用最为广泛的一种网络协议...
Hibernate(多对多表操作)
10-09
Hibernate(多对多表操作)
hibernate 多表查询
03-24
hibernate 多表查询 hibernate 多表不同于一般的sql嵌套查询，嵌套查询是不支持的，所以必须要配置好才能实现多表！只要配置好了，还是特别好用的
hibernate 多表关联 中间表
11-14
hibernate 中间表 希望给予新手帮助
Hibernate多表关联
snowball_q的博客
11-15 169
多对一 配置信息 &lt;many-to-one name="province" column="provincecode" class="com.qy.domain.Province" property-ref="code" cascade="save-update"/&gt; cascade="save-update" 级联保存更新 cascade="d
Hibernate(多表操作)
zhouhe_的博客
07-22 349
表之间的关系 一对多：一个班级有多个学生，一个学生只能有一个班级 多对多：一个学生可以有多个老师，一个老师也可以教多个学生 一对一：一个公司只对应一个注册地址 表之间的关系建表原则 一对多：在多的一方创建外键，指向另一方的主键 多对多：创建一个中间表，中间表至少有两个字段，分别作为外键指向多对多双方的主键 一对一：主键一一对应 一对多关系配置 建立表 销售联系人：一个联系人只能属于一个客户 客户：一个客户可以有多个联系人 创建外键：alter table my_tab1 add [co
Hibernate 框架总结(四)：多张表的关联映射
llllllxj的博客
05-15 2508
Hibernate 框架总结(一)：简单开发Hibernate 框架总结(二)：session的获取方式及hibernate对象的生命周期Hibernate 框架总结(三)：主键的生成策略表与表之间的关系存在三种关系一对一：丈夫——妻子， 学生——学生证一对多：学生——班级， 皇帝——大臣多对多：学生——课程， 学生——老师配置关系映射的时候，无论是什么关系，要保证你中有我，我中有你的思想一对一开...
hibernate中多表设计
我想静静的博客
06-29 454
配置实体之间的关联关系 在实际开发中,数据库的表难免会有相互的关联关系,在操作表的时候就有可能会涉及到多张表的操作.例如,商品和分类,用户和订单,订单和商品 要想实现多表映射, 第一步:要先确定两张表之间的关系,如果关系确定错了,后面做的所有操作就都可能不正确. 第二步:在数据库中视线两张表的关系. 第三步:在实体类中描述出两个实体的关系, 第四步:配置出实体类的数据和数据库表的关系映
Hibernate深度解析：从入门到精通
"这篇hibernate学习笔记涵盖了从基础到进阶的各种概念，包括Hibernate的简介、首个示例、主要接口、对象的生命周期、查询接口的初步使用，以及各种映射方式的详细介绍，如基本映射标签、多对一、一对一主键和唯一...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

泰 戈 尔

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值