Hibernate学习第三天

1.1数据库表与表之间的关系

1.1.1一对一关系

例：一个学生只能有一个学号，一个学号对应着一个学生。

1.1.2一对多关系

一个部门对应多个员工，一个员工只能属于某一个部门。

一个商品对应多张商品图片，一张商品图片只对应一个商品。

1.1.3多对多关系

一个学生可以选择多门课程，一门课程也可以被多个学生选择。

一个用户可以选择多个角色，一个角色也可以被多个用户选择。

1.2Hibernate一对多的关系配置

1.2.1.导包

log4j配置文件：src/log4j.properties

### direct log messages to stdout ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.err
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

### direct messages to file mylog.log ###
log4j.appender.file=org.apache.log4j.FileAppender
log4j.appender.file.File=c\:mylog.log
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

### set log levels - for more verbose logging change 'info' to 'debug' ###
# error warn info debug trace
log4j.rootLogger= info, stdout

1.2.2创建数据库和表

可以先建表也可以不建表（可以通过配置自动生成表）

1.用户表

CREATE TABLE `users` (

  `id` bigint(20) NOT NULL AUTO_INCREMENT,

  `name` varchar(20) COLLATE utf8_bin DEFAULT NULL,

  `age` int(11) DEFAULT NULL,

  `sex` varchar(2) COLLATE utf8_bin DEFAULT NULL,

  PRIMARY KEY (`id`)

) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8 COLLATE=utf8_bin;

2.汽车表

CREATE TABLE `car` (

  `car_id` bigint(20) NOT NULL AUTO_INCREMENT,

  `car_name` varchar(20) COLLATE utf8_bin DEFAULT NULL,

  `users_id` bigint(20) DEFAULT NULL,

  PRIMARY KEY (`car_id`),

  KEY `FKs40dwwjnjd3apfl0x2ju6oofi` (`users_id`),

  CONSTRAINT `FKs40dwwjnjd3apfl0x2ju6oofi` FOREIGN KEY (`users_id`) REFERENCES `users` (`id`)

) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8 COLLATE=utf8_bin;

1.2.3创建实体

1.一的一方的实体（用户）,一个用户可以拥有多辆车:Users.java

package com.entity;

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

public class Users {
    private Long id;
    private String name;
    private String sex;
    private Integer age;
    // 通过ORM方式表示 一个用户拥有多辆车
    // 放置多的一方的集合：hibernate默认使用的是Set集合 因为内部需要排序
    private Set<Car> set = new HashSet<>();

    public Long getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Set<Car> getSet() {
        return set;
    }

    public void setSet(Set<Car> set) {
        this.set = set;
    }

    @Override
    public String toString() {
        return "Users{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                ", age='" + age + '\'' +
                '}';
    }
}

2.多的一方的实体（车），一辆车只能被一个用户拥有：Car.java

package com.entity;

public class Car {
    private Long car_id;
    private String car_name;
    // 通过ORM方式表示 一两车只能属于某一个用户
    //放置的是一的一方的对象
    private Users users;

    public Long getCar_id() {
        return car_id;
    }

    public void setCar_id(Long car_id) {
        this.car_id = car_id;
    }

    public String getCar_name() {
        return car_name;
    }

    public void setCar_name(String car_name) {
        this.car_name = car_name;
    }

    public Users getUsers() {
        return users;
    }

    public void setUsers(Users users) {
        this.users = users;
    }

    @Override
    public String toString() {
        return "Car{" +
                "car_id=" + car_id +
                ", car_name='" + car_name + '\'' +
                ", users=" + users +
                '}';
    }
}

1.2.3创建映射文件

一的一方的映射的创建Users.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
<!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.entity.Users" table="users">
        <!--建立类中的属性与字段的主键对应-->
        <id name="id" column="id" length="10">
            <generator class="native"/>
        </id>
        <!--建立类中的普通属性和表的其他字段对应关系-->
        <property name="name" column="name" length="20"/>
        <property name="age" column="age" length="10"/>
        <property name="sex" column="sex" length="2"/>
        <!--配置一对多的映射：放置的多的一方的集合-->
        <!--
            set标签
                name   多的一方集合的属性名称
        -->
        <set name="set">
            <!--
                key标签
                    column   多的一方外键的名称
            -->
            <key column="users_id" />
                <!--
                    one-to-many标签
                        class   多的一方的类的全路径
                -->
                <one-to-many class="com.entity.Car"/>
        </set>
    </class>
</hibernate-mapping>

多的一方的映射的创建Car.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
<!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.entity.Car" table="car">
        <!--建立OID与之间映射-->
        <id name="car_id" column="car_id" length="10">
            <generator class="native"/>
        </id>
        <!--建立类中的普通属性和表的其他字段对应关系-->
        <property name="car_name" column="car_name" length="20"/>
        <!--配置多对一的关系：放置的是一的一方的对象-->
        <!--
            many-to-one标签
                name     一的一方的对象的属性名称
                class    一的一方类的全路径
                column   在多的一方外键的名称
        -->
        <many-to-one name="users" class="com.entity.Users" column="users_id" />
    </class>
</hibernate-mapping>

1.2.4创建核心配置文件

核心配置文件：src/hibernate.cfg,xml

<?xml version="1.0" encoding="UTF-8"?>
<!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>
        <!-- 连接数据库的基本参数 -->
        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernatedemo</property>
        <property name="hibernate.connection.username">root</property>
        <property name="hibernate.connection.password">mysql</property>
        <!-- 配置Hibernate的方言 -->
        <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>

        <!-- 是否在控制台打印SQL -->
        <property name="hibernate.show_sql">true</property>
        <!-- 格式化SQL -->
        <property name="hibernate.format_sql">true</property>
        <!-- 根据实体类自动创建表结构 -->
        <property name="hibernate.hbm2ddl.auto">update</property>

        <!-- 配置C3P0连接池（可以不用配置） Hibernate有内置的连接池-->
        <property name="connection.provider_class">org.hibernate.connection.C3P0ConnectionProvider</property>
        <!--在连接池中可用的数据库连接的最少数目 -->
        <property name="c3p0.min_size">5</property>
        <!--在连接池中所有数据库连接的最大数目  -->
        <property name="c3p0.max_size">20</property>
        <!--设定数据库连接的过期时间,以秒为单位,
        如果连接池中的某个数据库连接处于空闲状态的时间超过了timeout时间,就会从连接池中清除 -->
        <property name="c3p0.timeout">120</property>
        <!--每3000秒检查所有连接池中的空闲连接 以秒为单位-->
        <property name="c3p0.idle_test_period">3000</property>
        <!--
            事务隔离级别
            hibernate.connection.isolation=4
            1-Read uncommitted isolation
            2-Read Committed isolation
            4-Repeatable read isolation
            8-Serializable isolation
            -->
        <!-- 设置事务隔离级别 -->
        <property name="hibernate.connection.isolation">4</property>
        <!-- 配置当前线程绑定的Session -->
        <property name="hibernate.current_session_context_class">thread</property>

        <mapping resource="com/entity/Users.hbm.xml"/>
        <mapping resource="com/entity/Car.hbm.xml"/>
    </session-factory>
</hibernate-configuration>

1.2.5引入工具类

工具类 src/com/utils/HibernateUtils.java

package com.utils;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

/**
 * Hibernate工具类
 */
public class HibernateUtils {
    public static final Configuration CONFIGURATION;
    public static final SessionFactory SESSION_FACTORY;

    static {
        CONFIGURATION = new Configuration().configure();
        SESSION_FACTORY = CONFIGURATION.buildSessionFactory();
    }
    public static Session openSession(){
        return SESSION_FACTORY.openSession();
    }
    public static Session getCurrentSession(){
        return SESSION_FACTORY.getCurrentSession(); // 默认是不开启的必须在核心配置文件中配置了才能使用
    }
}

1.2.6测试

编写测试类：src/com/test/TestDemo01.java

package com.test;

import com.entity.Car;
import com.entity.Users;
import com.utils.HibernateUtils;
import org.hibernate.*;


import org.junit.Test;


public class TestDemo01 {


    @Test
    public void test01() {
        Session session = HibernateUtils.getCurrentSession();
        Transaction transaction = session.beginTransaction();
        // 创建两个用户
        Users users1 = new Users();
        users1.setName("张三");
        Users users2 = new Users();
        users2.setName("李四");
        // 创建三辆车
        Car car1 = new Car();
        car1.setCar_name("宝马");
        Car car2 = new Car();
        car2.setCar_name("奔驰");
        Car car3 = new Car();
        car3.setCar_name("大众");

        // 设置关系
        car1.setUsers(users1);
        car2.setUsers(users1);
        car3.setUsers(users2);

        users1.getSet().add(car1);
        users1.getSet().add(car2);

        users2.getSet().add(car3);

        // 保存数据
        session.save(users1);
        session.save(users2);
        session.save(car1);
        session.save(car2);
        session.save(car3);
        transaction.commit();
    }
}

1.2.7Hibernate的一对多相关操作

1.2.7.1测试一对多关系只保存一边是否可以

答案：不可以会抛出TransientObjectException

 @Test
    // 测试一对多关系只保存一边是否可以
    public void test02() {
        Session session = HibernateUtils.getCurrentSession();
        Transaction transaction = session.beginTransaction();
        // 创建两个用户
        Users users1 = new Users();
        users1.setName("王五");
        Car car = new Car();
        car.setCar_name("宾利");
        users1.getSet().add(car);
        car.setUsers(users1);
        // 保存一边是否可以 答案:不可以 会抛出TransientObjectException
        session.save(users1);
        transaction.commit();
    }

1.3一对多的级联操作

1.什么叫做级联

1.1级联指的是，操作一个对象的时候，是否会同时操作其关联的对象。

2级联是有方向性

2.1操作一的一方的时候，是否操作到多的一方

2.2操作多的一方的时候，是否操作到一的一方

1.3.1级联保存或更新

1.3.1.1保存用户级联保存车，操作的主题的对象是用户

更改映射文件 User.hbm.xml

set标签增加属性cascade

<set name="set" cascade="save-update">

 /**
     *  级联保存或更新
     *  保存用户级联保存车，操作的主题的对象时用户
     *  Users.hbm.xml  set标签增加属性cascade
     * <set name="set" cascade="save-update">
     */
    @Test
    public void test03() {
        Session session = HibernateUtils.getCurrentSession();
        Transaction transaction = session.beginTransaction();
        // 创建两个用户
        Users users1 = new Users();
        users1.setName("王五五");
        Car car = new Car();
        car.setCar_name("吉利");
        users1.getSet().add(car);
        car.setUsers(users1);
        session.save(users1);
        transaction.commit();
    }

1.3.1.2保存车级联保存用户，操作的主题的对象是车

更改映射文件 Car.hbm.xml

many-to-one标签增加属性cascade

<many-to-one name="users" cascade="save-update" class="com.entity.Users" column="users_id" />

 /**
     *  级联保存或更新
     *  保存用户级联保存车，操作的主题的对象时用户
     *  Car.hbm.xml  many-to-one标签增加属性cascade
     * <many-to-one name="users" cascade="save-update" class="com.entity.Users" column="users_id" />
     */
    @Test
    public void test04() {
        Session session = HibernateUtils.getCurrentSession();
        Transaction transaction = session.beginTransaction();
        // 创建两个用户
        Users users1 = new Users();
        users1.setName("lily");
        Car car = new Car();
        car.setCar_name("丰田");
        users1.getSet().add(car);
        car.setUsers(users1);
        session.save(car);
        transaction.commit();
    }

1.3.2测试对象的导航

/**
     *  测试对象导航
     *  前提条件 一对多关系的双方都配置了 cascade="save-update"
     */
    @Test
    public void test05() {
        Session session = HibernateUtils.getCurrentSession();
        Transaction transaction = session.beginTransaction();
        // 创建两个用户
        Users users1 = new Users();
        users1.setName("张张三"); // 语句1

        // 创建三辆车
        Car car1 = new Car();
        car1.setCar_name("宝马"); // 语句2
        Car car2 = new Car();
        car2.setCar_name("奔驰"); // 语句3
        Car car3 = new Car();
        car3.setCar_name("大众"); // 语句4
        car1.setUsers(users1);

        users1.getSet().add(car2);
        users1.getSet().add(car3);

        // 一对多关系的双方都配置了 cascade="save-update"
       // session.save(car1); // 会发送4条insert语句 1、2、3、4
        //session.save(users1); // 会发送3条insert语句 1、3、4
        session.save(car2);  // 会发送1条insert语句 // 3
        transaction.commit();
    }

1.3.3级联删除

1级联删除：

1.1删除一边的时候，同时将另一方的数据也一并删除。

2删除客户级联删除联系人

更改映射文件 User.hbm.xml

set标签增加属性cascade

<set name="set" cascade="save-update,delete">

/**
 * 级联删除
 * 删除用户级联删除车
*更改映射文件 User.hbm.xml
*set标签增加属性cascade
*<set name="set" cascade="save-update,delete">

 */
@Test
public void test06() {
    Session session = HibernateUtils.getCurrentSession();
    Transaction transaction = session.beginTransaction();
    // 没有配置级联删除，默认情况  修改了车的外建为null 在删除用户
    /*Users users = session.get(Users.class,1L);
    session.delete(users);*/
    // 设置用户的级联删除
    //  Users.hbm.xml  set标签增加属性cascade
    //  <set name="set" cascade="save-update,delete">
    Users users = session.get(Users.class, 2L);
    session.delete(users);
    transaction.commit();
}

3删除联系人级联删除客户（基本不用）

更改映射文件 Car.hbm.xml

many-to-one标签增加属性cascade

<many-to-one name="users" cascade="save-update,delete" class="com.entity.Users" column="users_id" />

1.3.4一对多设置了双向关联产生多余的SQL语句

引出问题：

车过户：原来归属于4号用户的4号车过户给5号用户

@Test
// 原来归属于4号用户的4号车过户给5号用户
public void test07() {
    Session session = HibernateUtils.getCurrentSession();
    Transaction transaction = session.beginTransaction();
    // 查询4号车
    Car car = session.get(Car.class,4L);
    // 查询5号联系人
    Users users = session.get(Users.class,5L);
    car.setUsers(users);
    users.getSet().add(car);
    transaction.commit();//对比缓冲区与快照区的数据是否一致，发现不一致，会发送update语句

}

此时会发送多于的update语句

1解决多余的SQL语句

1.1单向维护：

1.2使一方放弃外键维护权：

1.2.1一的一方放弃。在set上配置inverse=”true”

1.3一对多的关联查询的修改的时候会用inverse=”true”。

1.3.5区分cascade和inverse

@Test
// 区分cascade和inverse
public void test08() {
    Session session = HibernateUtils.getCurrentSession();
    Transaction transaction = session.beginTransaction();
    Users users = new Users();
    users.setName("遛遛刘");
    Car car =new Car();
    car.setCar_name("蹦蹦车");
    users.getSet().add(car);

    // 条件User.hbm.xml set标签为 <set name="set" cascade="save-update" inverse="true">
   // session.save(users); // 用户和车会插入到数据库中，但是外键为null 因为Users放弃了外键维护
    car.setUsers(users);
    session.save(car); // 用户和车会插入到数据库中，但是外键有值
    transaction.commit();
}

1.4Hibernate多对多的关系配置

1.4.1创建表

1.4.2创建实体

学生实体:Student.java

package com.entity;

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

public class Student {
    private Long id; // 主键id
    private String name; // 姓名
    private String sex; // 性别
    private String dept; // 所在系别

    // 设置多对多关系：表示一个学生选择多门课程
    // 放置的是课程的集合
    private Set<Course> coursesSet = new HashSet<>();

    public Set<Course> getCoursesSet() {
        return coursesSet;
    }

    public void setCoursesSet(Set<Course> coursesSet) {
        this.coursesSet = coursesSet;
    }

    public Long getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public String getDept() {
        return dept;
    }

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

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                ", dept='" + dept + '\'' +
                '}';
    }
}

课程实体：Course.java

package com.entity;

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

public class Course {
    private Long cid; // 主键
    private String cno; // 课程号
    private String cname;// 课程名
    private Integer creadet; // 学分
    // 一门课程可以被多个学生选择
    // 放置的是学生的集合
    private Set<Student> studentSet = new HashSet<>();

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

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

    public Long getCid() {
        return cid;
    }

    public void setCid(Long cid) {
        this.cid = cid;
    }

    public String getCno() {
        return cno;
    }

    public void setCno(String cno) {
        this.cno = cno;
    }

    public String getCname() {
        return cname;
    }

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


    public Integer getCreadet() {
        return creadet;
    }

    public void setCreadet(Integer creadet) {
        this.creadet = creadet;
    }

    @Override
    public String toString() {
        return "Course{" +
                "cid=" + cid +
                ", cno='" + cno + '\'' +
                ", cname='" + cname + '\'' +
                ", creadet=" + creadet +
                '}';
    }
}

1.4.3创建映射

学生的映射

<?xml version="1.0" encoding="UTF-8"?>
<!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.entity.Student" table="student">
        <!--建立类中的属性与字段的主键对应-->
        <id name="id" column="id" length="10">
            <generator class="native"/>
        </id>
        <!--建立类中的普通属性和表的其他字段对应关系-->
        <property name="name" column="name" length="20"/>
        <property name="sex" column="sex" length="2"/>
        <property name="dept" column="dept" length="50"/>
        <!--配置多对多的映射关系-->
        <!--
            set标签
                name   多的一方集合的属性名称
                table  多对多关系需要使用中间表，table的值是中间表的名称
                cascade 级联
                inverse 是否放弃外建维护
        -->
        <set name="coursesSet" table="sc">
            <!--
                key标签
                    column   当前的对象对应中间表的外键名称
            -->
            <key column="student_id" />
                <!--
                    many-to-many标签
                        class   对方类的全路径
                        column 对方对象在表中外键的名字
                -->
              <many-to-many class="com.entity.Course" column="course_id" />
        </set>
    </class>
</hibernate-mapping>

课程的映射

<?xml version="1.0" encoding="UTF-8"?>
<!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.entity.Course" table="course">
        <!--建立类中的属性与字段的主键对应-->
        <id name="cid" column="cid" length="10">
            <generator class="native"/>
        </id>
        <!--建立类中的普通属性和表的其他字段对应关系-->
        <property name="cno" column="cno" length="20" />
        <property name="cname" column="cname" length="20"/>
        <property name="credit" column="creadet" length="10"/>
        <!--配置多对多的映射关系-->
        <!--
            set标签
                name   多的一方集合的属性名称
                table  多对多关系需要使用中间表，table的值是中间表的名称
                cascade 级联
                inverse 是否放弃外建维护
        -->
        <set name="studentSet" table="sc" inverse="true">
            <!--
                key标签
                    column   当前的对象对应中间表的外键名称
            -->
            <key column="course_id" />
                <!--
                    many-to-many标签
                        class   对方类的全路径
                        column 对方对象在表中外键的名字
                -->
              <many-to-many class="com.entity.Student" column="student_id" />
        </set>
    </class>
</hibernate-mapping>

核心配置文件中映入映射文件

 <mapping resource="com/entity/Student.hbm.xml"/>
 <mapping resource="com/entity/Course.hbm.xml"/>

1.4.4编写测试

// 保存操作：多对多建立了双向的关系必须有一方放弃外键维护
// 一般被动方放弃外键维护

package com.test;

import com.entity.Course;
import com.entity.Student;
import com.utils.HibernateUtils;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test;

public class TestDemo02 {
    @Test
    public void test01() {
        Session session = HibernateUtils.getCurrentSession();
        Transaction transaction = session.beginTransaction();
        // 创建两个学生
        Student student1 = new Student();
        student1.setName("李勇");
        student1.setDept("计算机");
        Student student2 = new Student();
        student2.setName("刘晨");
        student2.setDept("数学");
        // 创建三门课程
        Course course1 = new Course();
        course1.setCno("1001");
        course1.setCname("数据库");
        Course course2 = new Course();
        course2.setCno("1002");
        course2.setCname("数学");
        Course course3 = new Course();
        course3.setCno("1003");
        course3.setCname("信息系统");

        // 设置双向的关联关系
        student1.getCoursesSet().add(course1);
        student2.getCoursesSet().add(course1);
        student2.getCoursesSet().add(course3);
        course1.getStudentSet().add(student1);
        course1.getStudentSet().add(student2);
        course3.getStudentSet().add(student2);
        // 保存操作： 多对多建立了双向的关系必须有一方放弃外键维护
        // 一般被动方放弃外键维护
        session.save(student1);
        session.save(student2);
        session.save(course1);
        session.save(course2);
        session.save(course3);

        transaction.commit();
    }
}

1.4.5.1多对多的级联保存或更新

1.只保存一边是否可以（不可以）

不配置cascade只保存一边会抛出瞬时对象异常

需要配置 <set name="coursesSet" cascade="save-update" table="sc"> 并且有外键维护

  @Test
    public void test02() {
        Session session = HibernateUtils.getCurrentSession();
        Transaction transaction = session.beginTransaction();

        Student student1 = new Student();
        student1.setName("李大勇");
        student1.setDept("计算机");

        // 创建三门课程
        Course course1 = new Course();
        course1.setCno("1004");
        course1.setCname("数据库");


        // 设置双向的关联关系
        student1.getCoursesSet().add(course1);

        course1.getStudentSet().add(student1);
        // 需要在Student.hbm.xml
        //配置 <set name="coursesSet" cascade="save-update" table="sc"> 并且有外键维护
        session.save(student1);

       /* // 需要在Couese.hbm.xml
        //配置 <set name="StudentSet" cascade="save-update" table="sc"> 并且有外键维护
        session.save(course1);*/
        transaction.commit();
    }

1.4.5.2多对多的级联删除（基本用不上）

1.删除学生级联删除学生所选课程

/**
     * 删除学生级联删除学生所选课程
     * 在Student.hbm.xml 配置
     * <set name="coursesSet" cascade="save-update,delete" table="sc" >
     */

 /**
     * 删除学生级联删除学生所选课程
     * 在Student.hbm.xml 配置
     * <set name="coursesSet" cascade="save-update,delete" table="sc" >
     */
    @Test
    // 删除一号学生及其习所选课程
    public void test03() {
        Session session = HibernateUtils.getCurrentSession();
        Transaction transaction = session.beginTransaction();

        // 查询一号学生
        Student student = session.get(Student.class,1L);
        session.delete(student);
        transaction.commit();
    }

2.删除课程级联删除学生

与1相反

1.4.5多对多的其他的操作

1.给学生选择课程

 @Test
    // 给一号学生多选一个2号课程
    public void test04() {
        Session session = HibernateUtils.getCurrentSession();
        Transaction transaction = session.beginTransaction();
        // 查一号学生
        Student student = session.get(Student.class, 1L);
        // 查2号课程
        Course course = session.get(Course.class,2L);

        student.getCoursesSet().add(course);
        // 持久态对象会自动发送更新语句
        transaction.commit();
    }

2.给学生改选课程

 @Test
    // 给2号学生原本选的2号课程改为3号课程
    public void test05() {
        Session session = HibernateUtils.getCurrentSession();
        Transaction transaction = session.beginTransaction();
        // 查2号学生
        Student student2 = session.get(Student.class, 2L);
        // 查2号课程
        Course course2 = session.get(Course.class,2L);
        // 查3号课程
        Course course3 = session.get(Course.class,3L);
        student2.getCoursesSet().remove(course2); // 删除2号课程
        student2.getCoursesSet().add(course3);
        // 持久态对象会自动发送更新语句
        transaction.commit();
    }

3.给学生删除课程

 @Test
    // 给2号学生删除3号课程
    public void test06() {
        Session session = HibernateUtils.getCurrentSession();
        Transaction transaction = session.beginTransaction();
        // 查2号学生
        Student student2 = session.get(Student.class, 2L);

        // 查3号课程
        Course course3 = session.get(Course.class,3L);
        student2.getCoursesSet().remove(course3); // 删除3号课程
        // 持久态对象会自动发送更新语句
        transaction.commit();
    }

项目源码码云地址：hibernate_day3

https://gitee.com/greatdistance/hibernate