Hibernate级联操作（学生和班级）

最新推荐文章于 2021-10-28 13:44:23 发布
最新推荐文章于 2021-10-28 13:44:23 发布
阅读量471 收藏 2
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43343423/article/details/100164628
版权

建一个学生类

package model;


import java.util.Set;

public class Student {

    private Integer id;
    private String sname;
    /**
     * 多对一关系:外键在类中无需声明,取而代之用POJO类型进行声明
     */
    private Clazz clazz;

    /**
     *多对多关系
     */
    private Set<Teacher> teacherSet;


    /**
     * 一对一
     */
    private Card card;




    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getSname() {
        return sname;
    }

    public void setSname(String sname) {
        this.sname = sname;
    }

    public Clazz getClazz() {
        return clazz;
    }

    public void setClazz(Clazz clazz) {
        this.clazz = clazz;
    }

    public Set<Teacher> getTeacherSet() {
        return teacherSet;
    }

    public void setTeacherSet(Set<Teacher> teacherSet) {
        this.teacherSet = teacherSet;
    }

    public Card getCard() {
        return card;
    }

    public void setCard(Card card) {
        this.card = card;
    }
//重写equals和hascode比较俩对象是否相同
    /*
    @Override
    public boolean equals(Object obj) {

        if(this==obj){
            return true;
        }
        Student student = (Student) obj;
        if(this.getId()==student.getId()){

            return true;
        }

        return false;

    }

    @Override
    public int hashCode() {

        return this.getId()+1000;
    }*/
}

配置文件
多个学生对应一个班级，多个学生对应多个老师，一个学生对应一个学生卡

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


<hibernate-mapping package="model">

    <class name="Student" table="STUDENT" lazy="false">
        <id name="id" column="ID">
            <generator class="increment"></generator>
        </id>
        <property name="sname" column="SNAME"></property>

        <!--多对一关系的映射说明:
         name是指Student类中的pojo类型属性
         column指的是关联外键
         class:属性的类型,完全限定名-->
        <many-to-one name="clazz" column="CID" class="Clazz" lazy="false" cascade="save-update" ></many-to-one>
        
        
        <!--多对多关系的映射说明:
        table:表示中间表的名称-->
        <set name="teacherSet" table="STU_TEACH" lazy="false">
            <!--主动方表到中间表的外键-->
            <key column="SID"></key>
            <!--Column:中间表到关联表的外键-->
            <many-to-many class="Teacher" column="TID"></many-to-many>
        </set>

        <!--一对一关系的映射说明-->
        <one-to-one name="card" class="Card"></one-to-one>

    </class>

</hibernate-mapping>

建班级类

package model;

import java.util.Set;

public class Clazz {

    private Integer id;
    private String cname;

    /**
     * 一对多关联
     */
    private Set<Student> studentSet;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getCname() {
        return cname;
    }

    public void setCname(String cname) {
        this.cname = cname;
    }

    public Set<Student> getStudentSet() {
        return studentSet;
    }

    public void setStudentSet(Set<Student> studentSet) {
        this.studentSet = studentSet;
    }

}

配置文件

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


<hibernate-mapping package="model">

    <class name="Clazz" table="CLAZZ" lazy="false">
        <id name="id" column="ID">
            <generator class="increment"></generator>
        </id>
        <property name="cname" column="CNAME"></property>


        <!--一对多关联关系说明:
           set标签:集合属性的说明
           key标签:对外键说明
           class:对集合中元素类型的说明
        -->

        <!--Cascade:
        1.none(默认取值),不支持级联
        2.save-update,在保存和更新时进行级联
        3.delete,在删除时进行级联
        4.all,在增删改时都进行级联-->

        <!--
        inverse:表示关联关系的维护权要不要交给另一方维护,true表示交出去,false表示本方维护
        一方可以设置是否把关联关系维护权交出去,但多方没有这个属性,也hibernate默认,多方肯定要维护外键关系.
        一般情况下,最好的做法是让一方不维护关联关系.
        -->
        <set name="studentSet" cascade="save-update,delete" lazy="false" inverse="true">
            <!--外键说明-->
            <key column="CID"></key>
            <one-to-many class="Student"></one-to-many>
        </set>

    </class>

</hibernate-mapping>

建一个老师类

package model;

import java.util.Set;

public class Teacher {

    private Integer id;
    private String tname;

    private Set<Student> studentSet;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getTname() {
        return tname;
    }

    public void setTname(String tname) {
        this.tname = tname;
    }

    public Set<Student> getStudentSet() {
        return studentSet;
    }

    public void setStudentSet(Set<Student> studentSet) {
        this.studentSet = studentSet;
    }
}

配置

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


<hibernate-mapping package="model">

    <class name="Teacher" table="TEACHER" lazy="false">
        <id name="id" column="ID">
            <generator class="increment"></generator>
        </id>
        <property name="tname" column="TNAME"></property>

        <!--多对多关系-->
        <set name="studentSet" table="STU_TEACH">
            <!--主动方表到中间表的外键-->
            <key column="TID"></key>
            <!--Column:中间表到关联表的外键-->
            <many-to-many class="Student" column="SID"></many-to-many>
        </set>
    </class>

</hibernate-mapping>

学生卡类

package model;

public class Card {

    private Integer id;
    private String cardname;

    private Student student;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getCardname() {
        return cardname;
    }

    public void setCardname(String cardname) {
        this.cardname = cardname;
    }

    public Student getStudent() {
        return student;
    }

    public void setStudent(Student student) {
        this.student = student;
    }
}

配置

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


<hibernate-mapping package="model">

    <class name="Card" table="CARD" lazy="false">
        <id name="id" column="ID">
            <generator class="increment"></generator>
        </id>
        <property name="cardname" column="CARDNAME"></property>

        <!--一对一关系的映射说明-->
        <one-to-one name="student" class="Student"></one-to-one>

    </class>

</hibernate-mapping>

因为是级联操作所以dao书写比较简单

package dao;

import model.Clazz;
import org.hibernate.Session;
import util.SessionUtil;

public class ClazzDao {

    public Clazz selectById(int id){

        Session session = SessionUtil.getCurrentSession();

        return session.load(Clazz.class, id);

    }

    public void insert(Clazz clazz){

        Session session = SessionUtil.getCurrentSession();

        session.save(clazz);

    }

    public void delete(Clazz clazz){

        Session session = SessionUtil.getCurrentSession();

        session.delete(clazz);
    }

    public void update(Clazz clazz){

        Session session = SessionUtil.getCurrentSession();

        session.update(clazz);
    }
}
package dao;

import model.Student;
import org.hibernate.Session;
import util.SessionUtil;

public class StudentDao {

    public Student selectById(int id){

        Session session  = SessionUtil.getCurrentSession();

        return session.load(Student.class, id);

    }


    public void insert(Student student){

        Session session  = SessionUtil.getCurrentSession();

        session.save(student);

    }
}

service

package service;

import dao.ClazzDao;
import dao.StudentDao;
import jdk.nashorn.internal.runtime.UserAccessorProperty;
import model.Clazz;
import model.Student;
import org.hibernate.Session;
import org.hibernate.Transaction;
import util.SessionUtil;

public class ClazzService {

    ClazzDao dao = new ClazzDao();

    public Clazz findById(int id){

        Session session = SessionUtil.getCurrentSession();

        Transaction tx = session.beginTransaction();

        Clazz clazz = dao.selectById(id);

        tx.commit();

        return clazz;


    }

    public void save (Clazz clazz){

        Session session = SessionUtil.getCurrentSession();

        Transaction tx = session.beginTransaction();

         dao.insert(clazz);

        tx.commit();


    }


    public void remove (Clazz clazz){

        Session session = SessionUtil.getCurrentSession();

        Transaction tx = session.beginTransaction();

        dao.delete(clazz);

        tx.commit();


    }

    public void modify (Clazz clazz){

        Session session = SessionUtil.getCurrentSession();

        Transaction tx = session.beginTransaction();

        dao.update(clazz);

        tx.commit();


    }
}
package service;

import dao.StudentDao;
import model.Student;
import org.hibernate.Session;
import org.hibernate.Transaction;
import util.SessionUtil;

public class StudentService {

    StudentDao dao = new StudentDao();

    public Student findById(int id){

        Session session = SessionUtil.getCurrentSession();

        Transaction tx = session.beginTransaction();

        Student student = dao.selectById(id);

        tx.commit();

        return student;


    }

    public void  save(Student student){

        Session session = SessionUtil.getCurrentSession();

        Transaction tx = session.beginTransaction();

        dao.insert(student);

        tx.commit();

    }
}

测试班级级联学生操作

package test;

import model.Clazz;
import model.Student;
import org.hibernate.Session;
import org.junit.Test;
import service.ClazzService;
import service.StudentService;

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

public class ClazzTest {

    ClazzService service = new ClazzService();

    StudentService service2 = new StudentService();


    /**
     * 新增加一个班级,同时向班级中添加两个学生
     * Hibernate的级联操作(Cascade),Hibernate默认不支持级联操作
     *
     * 从一方进行级联操作时,会发送额外的update语句去维护外键关系(关联关系)
     */
    @Test
    public void testSave() {

        Clazz clazz = new Clazz();
        clazz.setCname("java四班");

        Student student1 = new Student();
        student1.setSname("aaaa");

        Student student2 = new Student();
        student2.setSname("bbbb");

        Set<Student> set = new HashSet<Student>();
        set.add(student1);
        set.add(student2);

        //对像间关系维护
        clazz.setStudentSet(set);

        service.save(clazz);

    }

    /**
     * 删除一个班级,同时删除班级中的所有学生(尽量使用逻辑删除,不用物理删除)
     */
    @Test
    public void testRemove() {

        Clazz clazz = new Clazz();
        clazz.setId(4);

        Student student1 = new Student();
        student1.setId(9);

        Student student2 = new Student();
        student2.setId(10);

        Set<Student> set = new HashSet<Student>();
        set.add(student1);
        set.add(student2);

        //对像间关系维护
        clazz.setStudentSet(set);

        service.remove(clazz);
    }

    /**
     * 如果学生的ID相同,在逻辑上就认为他们是同一个对像
     */
    @Test
    public void testModify() {

        Clazz clazz = service.findById(4);
        //通过重写equals()和hashcode()方法判断对像相等
       /* Student student = new Student();
        student.setId(10);
        clazz.getStudentSet().remove(student);
        */
       /* System.out.println(clazz.getStudentSet().size());
//集合不能for循环删除操作！！！！！！会报并发异常
        for (Student student : clazz.getStudentSet()) {
            if (student.getId() == 10) {
                clazz.getStudentSet().remove(student);
            }
        }
        System.out.println(clazz.getStudentSet().size());*/
        Iterator<Student>iterator = clazz.getStudentSet().iterator();
        while(iterator.hasNext()){
           Student student = iterator.next();
           if(student.getId()==10){
               iterator.remove();
           }
        }

        service.modify(clazz);
    }



}

学生级联班级操作

package test;

import model.Clazz;
import model.Student;
import org.junit.Test;
import service.StudentService;

public class StudentTest {

    StudentService service = new StudentService();

    /**
     * 增加两个学生,并添加到一个新的班级中
     *
     * 默认情况下:默认情况下,多方和一方都会发送update语句去维护外键关系,
     * 在一方有inverse属性,通常把一方的inverse设置为true,即交出关联关系维护权,
     * 多方没有inverse属性,hibernate要求多方必须维护外键关系.
     * 这样做的好外是,当从多方进行操作时,会减少update语句(对关联关系维护的update语句)
     */
    @Test
    public void testSave(){

        Clazz clazz = new Clazz();
        clazz.setCname("java五班");

        Student student1 = new Student();
        student1.setSname("cccc");

        Student student2 = new Student();
        student2.setSname("dddd");

        //维护对像间关系
        student1.setClazz(clazz);
        student2.setClazz(clazz);


        service.save(student1);
        service.save(student2);

    }


    /**
     * 多对多查询:查询一个学生,把其授课老师会部关联出来
     */
    @Test
    public void testFindById(){

        Student student = service.findById(1);

        System.out.println(student.getTeacherSet());

        System.out.println(student.getCard());

    }
}
砂锅大的拳头
关注
Hibernate 的级联操作
weixin_47619153的博客
06-29 413
Hibernate 级联操作 1、⼀对多关系 客户和订单：客户可以购买多个产品，⽣成多个订单，但是⼀个订单只能属于⼀个客户 数据库中⼀的⼀⽅是主表，多的⼀⽅时候从表，通过主外键关系来维护。 Customer @Data public class Customer { private Integer id; private String name; private Set<Orders> orders; } Orders @Data public class Orders { private
Hibernate级联查找
热门推荐
John-Peng的专栏
05-27 1万+
Hibernate级联查找 一 、工作目的： 本例主要演示在SSH架构下实现hibernate的级联查找，通过配置文件将多张有关联的表联系在一起，只需一次检索数据库便可查询多表记录，好处是避免多次单表查找影响系统效率，不过目前数据库设计一般不推荐添加外键，而通过配置hibernate级联查找，会在数据库中自动生成索引、外键，使用时需要根据具体场景慎重选择。 二 、开发环境： Mye
hibernate的级联操作
03-24 8867
save-update: 级联保存(load以后如果子对象发生了更新,也会级联更新). 但它不会级联删除delete: 级联删除, 但不具备级联保存和更新all-delete-orphan: 在解除父子关系时,自动删除不属于父对象的子对象, 也支持级联删除和级联保存更新.all: 级联删除, 级联更新,但解除父子关系时不会自动删除子对象. delete-orphan:删除所有和当前对象解除关联
Hibernate-级联操作
qq_41607217的博客
08-05 231
Hibernate 级联操作 关联关系 【1】一对多关系 一的一方是主表，多的一方是从表，通过主外键维护 @Data public class Customer{ private int id; private String name; private Set<Orders> orders; } @Data public class Orders{ private int id; private String name; private Customer cu
hibernate级联操作
Captain249的博客
01-04 305
CascadeType.REMOVE 级联删除操作。 删除当前实体时，与它有映射关系的实体也会跟着被删除。 CascadeType.MERGE 级联更新（合并）操作。当Student中的数据改变，会相应地更新Course中的数据。 CascadeType.DETACH 级联脱管/游离操作。 如果你要删除一个实体，但是它有外键无法删除，你就需要这个级联权限了。它会撤销所有相关的外键关联。...
hibernate级联配置
xiashan17的专栏
12-03 578
级联更新1.级联是指两个对象之间的操作联动关系，对一个对象执行了操作之后，对其指定的级联对象也需要执行相同的操作； 2.级联配置通过many-to-one的cascade属性实现； 3.cascade属性有四种取值：   all：所有操作都执行级联操作；   none：所有操作都不执行级联操作；   save-update：保存和更新时执行级联操作；   delete：删除时执行级联操作； 4.通过级联操作可以解决持久化对象不能直接引用瞬时对象的问题。第一.一对多处理 Group.hbm.xml:
hibernate-基础部分
小喵的博客
06-13 267
hibernate-基础部分1、jdbc的缺点： 1、代码比较麻烦 2、不是面向对象编程 3、如果碰到一个很复杂的需求分析，需要很次很数据库交互，这样效率比较低 4、jdbc技术没有做到数据的缓存2、hibenrnate 1、面向对象的编程 2、缓存 一级缓存    二级缓存     查询缓存 3、代码操作比较简单 4、如果该项目对sql的优化要求特别高，不适合用hibernate   如果数据...
10_传智播客JPA详解_JPA中的一对多双向关联与级联操作
03-25
本教程将深入探讨JPA中的一对多双向关联及级联操作，这对于理解和使用JPA进行复杂数据模型管理至关重要。 首先，我们来理解一下一对多关联。在数据库设计中，一对多关联是指一个实体（表）可以与多个其他实体相关联...
hibernate学习之表关联和级联
海恩的博客
04-29 139
班级学生一对多表关联 建立关联关系的话首先至少要有两个表，那就要有两个实体类，通常是一对多的关系，比如学生和班级，可以在其中一个类加入另一个类的实例，比如在学生中包含班级这个类（如果是班级中包含学生的话那应该是一个班级包含一个学生集合） public class Student { private long id; private String name; ...
Hibernate的级联操作(增，删，该)
06-28
Hibernate的级联操作(增，删，该)
利用Hibernate框架实现学生管理信息系统
05-18
开源项目Hibernate是一个实现对象/关系映射的框架,它在Java对象和关系数据库中数据之间建立相应的映射关系,简化了数据库访问操作。将此框架应用于学生信息管理系统中,可充分发挥其优点,提高系统开发效率。
jsp+servlet+hibernate学生教务选课系统毕业设计
12-31
系统主要功能说明 (1)系统分三种身份:学生,教师和管理,每种身份登陆系统后进入不同的权限操作界面. (2)学生信息管理:管理员可以添加新的学生学籍信息,教师只能查询,管理员可以进行学生信息维护管理。 (3)教师信息管理:管理员可以添加新的教师，可以修改教师信息，教师身份只能修改自己的个人信息。 (4)课程信息管理:管理员可以给某个学期某个班级添加新的课程，可以给某个学期某个专业添加选修课程，也可以修改和维护这些信息 (5)排课和选课信息管理:管理员可以指定某个学期每个班级的必修课程，可以为每个专业设置选修课程，学生登陆系统后可以在指定的时间内对该学期的选修课程进行选择，专业课程不需要选择,学生可以生成自己的课表 (6)成绩信息管理:通过期末考试后，相关课程的教师需要登陆系统后对每个学生的成绩信息进行登记或修改，学生登陆系统后可以对自己的成绩信息进行查询 系统开发环境: MyEclipse + Tomcat + mysql数据库,数据库操作使用hibernate框架!
hibernate+struts一对多增删改查demo（学生对班级）
05-10
利用struts1.2，hibernte3.0 mysql数据库 做的一个学生对班级增删改查的例子
Hibernate的级联操作
Kato_op的博客
05-14 1449
Hibernate的级联操作 所谓的级联操作，Hibernate支持根据配置的关联关系，实现通过一个实体类的对象，可以操作多个表的数据。（操作：增删改）。我们将这个现象称为级联操作。 配置级联操作的属性: - cascade用于启动级联操作 - save-update:启动级联保存和更新 - detele:启动级联删除 级联增加 配置步骤： 1. 配置关联关系支...
Hibernate 级联操作
千里之行始于足下
07-07 630
– Start 我们已经知道了表与表之间的关系，如果我们对一个表进行操作，同时自动对相关表进行同样的操作，这时我们可以配置表的级联操作，级联操作的类型定义在枚举类 CascadeType 中。 package shangbo.hibernate.demo029; import javax.persistence.CascadeType; import javax.persistence.Enti...
Hibernate级联操作
天天向上
10-28 244
基础知识 框架概述 工作原理 一对多关系 数据库： 一个客户对应多个订单，数据库中一是主表，多是从表，通过主键外键来维系。 Customer(id,name) orders(id,name,cid)。【注意：加粗的是主键】 java: Customer类定义如下，Orders略 hibernate xml文件如下 set 配置实体类中集合属性，name实体类的属性名，table表名，key外键，onetomany 结合泛型的实体类对应。 many-to-one 实体类对应的对象属性，name
Hibernate表间关联与对象关系映射讲解
- 建立两个POJO类，如Banji（班级）和Student（学生），并为它们创建对应的Hibernate配置文件。 - 在主动方（Banji）中创建一个`Set`类型的属性，用来存储所有关联的被动方（Student）对象。 - 在主动方的映射...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值