数据库表与表之间的关系

一对多

一个分类可以对应多个商品，一个商品是能属于一个分类。
一个客户对应多个联系人，一个联系人只能属于某一个客户。

一对多的建表原则：
在这里插入图片描述

多对多

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

多对多的建表原则
在这里插入图片描述

一对一（了解，不常用）

一个公司只能有一个注册地址，一个注册地址只能被一个公司注册。

一对一的建表原则

Hibernate的一对多的关联映射

Hibernate一对多的关系配置

创建一个java项目，引入相关jar包

创建数据库和表

CREATE TABLE cst_customer (
cust_id bigint(32) NOT NULL AUTO_INCREMENT COMMENT ‘客户编号(主键)’,
cust_name varchar(32) NOT NULL COMMENT ‘客户名称(公司名称)’,
cust_source varchar(32) DEFAULT NULL COMMENT ‘客户信息来源’,
cust_industry varchar(32) DEFAULT NULL COMMENT ‘客户所属行业’,
cust_level varchar(32) DEFAULT NULL COMMENT ‘客户级别’,
cust_phone varchar(64) DEFAULT NULL COMMENT ‘固定电话’,
cust_mobile varchar(16) DEFAULT NULL COMMENT ‘移动电话’,
PRIMARY KEY (cust_id)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

CREATE TABLE cst_linkman (
lkm_id bigint(32) NOT NULL AUTO_INCREMENT COMMENT ‘联系人编号(主键)’,
lkm_name varchar(16) DEFAULT NULL COMMENT ‘联系人姓名’,
lkm_cust_id bigint(32) DEFAULT NULL COMMENT ‘客户id’,
lkm_gender char(1) DEFAULT NULL COMMENT ‘联系人性别’,
lkm_phone varchar(16) DEFAULT NULL COMMENT ‘联系人办公电话’,
lkm_mobile varchar(16) DEFAULT NULL COMMENT ‘联系人手机’,
lkm_email varchar(64) DEFAULT NULL COMMENT ‘联系人邮箱’,
lkm_qq varchar(16) DEFAULT NULL COMMENT ‘联系人qq’,
lkm_position varchar(16) DEFAULT NULL COMMENT ‘联系人职位’,
lkm_memo varchar(512) DEFAULT NULL COMMENT ‘联系人备注’,
PRIMARY KEY (lkm_id),
KEY FK_cst_linkman_lkm_cust_id (lkm_cust_id),
CONSTRAINT FK_cst_linkman_lkm_cust_id FOREIGN KEY (lkm_cust_id) REFERENCES cst_customer (cust_id) ON DELETE NO ACTION ON UPDATE NO ACTION
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

在这里插入图片描述

创建实体类

一的一方的实体类

public class Customer {
    private Long cust_id;
    private String cust_name;
    private String cust_source;
    private String cust_industry;
    private String cust_level;
    private String cust_phone;
    private String cust_mobile;
    //一个客户对应多个联系人
    //放置多的一方的集合，注意Hibernate只能用Set集合
    private Set<LinkMans> linkMans = new HashSet<LinkMans>();
}

多的一方的实体类

public class LinkMans {
    private Long lkm_id;
    private String lkm_name;
    private String lkm_gender;
    private String lkm_phone;
    private String lkm_mobile;
    private String lkm_email;
    private String lkm_qq;
    private String lkm_position;
    private String lkm_memo;
    // 通过ORM方式表示：一个联系人只能属于某一个客户。
    // 放置的是一的一方的对象。
    private Customer customer;
    }

创建实体类的映射文件

Customer.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 table="cst_linkman" name="com.day02.LinkMans">
        <!-- 建立OID与主键映射 -->
        <id name="lkm_id" column="lkm_id">
            <generator class="native"/>
        </id>
        <!-- 建立普通属性与表字段映射 -->
        <property name="lkm_name"/>
        <property name="lkm_gender"/>
        <property name="lkm_phone"/>
        <property name="lkm_mobile"/>
        <property name="lkm_email"/>
        <property name="lkm_qq"/>
        <property name="lkm_position"/>
        <property name="lkm_memo"/>
        <!-- 配置多对一的关系：放置的是一的一方的对象 -->
        <!-- many-to-one标签 * name :一的一方的对象的属性名称。 * class :一的一方的类的全路径。 * column :在多的一方的表的外键的名称。 -->
        <many-to-one class="com.day02.Customer" name="customer" column="lkm_cust_id"/>
    </class>
</hibernate-mapping>

LinkMans.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 table="cst_customer" name="com.day02.Customer">
        <!-- 建立类中的属性与表中的主键对应 -->
        <id name="cust_id" column="cust_id">
            <!--主键生成规则-->
            <generator class="native"/>
        </id>
        <!-- 建立类中的普通的属性和表的字段的对应 -->
        <property name="cust_name" column="cust_name" length="32"/>
        <property name="cust_source" column="cust_source" length="32"/>
        <property name="cust_industry" column="cust_industry"/>
        <property name="cust_level" column="cust_level"/>
        <property name="cust_phone" column="cust_phone"/>
        <property name="cust_mobile" column="cust_mobile"/>

        <!-- 配置一对多的映射：放置的多的一方的集合 -->
        <!-- set标签 ： * name ：多的一方的对象集合的属性名称。 * cascade：级联 * inverse：放弃外键维护权。 -->
        <set name="linkMans" >
            <!-- key标签 * column：多的一方的外键的名称。 -->
            <key column="lkm_cust_id"/>
            <!-- one-to-many标签 * class :多的一方的类的全路径 -->
            <one-to-many class="com.day02.LinkMans"/>
        </set>
    </class>
</hibernate-mapping>

创建实体类的核心配置文件

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/hibernate</property>
        <property name="hibernate.connection.username">root</property>
        <property name="hibernate.connection.password">123456</property>
        <!-- 配置Hibernate的方言,使用的是Mysql数据库 -->
        <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">create</property>
        <property name="current_session_context_class">thread</property>

        <!-- 配置C3P0连接池 -->
        <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>

        <!--找到对象的映射文件-->
        <mapping resource="com/day02/Customer.hbm.xml"/>
        <mapping resource="com/day02/LinkMans.hbm.xml"/>

    </session-factory>
</hibernate-configuration>

引入工具类

HibernateUtils.java

编写测试代码

	 @Test
    //测试
    public void demo1(){
        Session session = HibernateUtils.getCurrentSession();
        Transaction transaction = session.beginTransaction();

        //创建两个用户
        Customer customer= new Customer();
        customer.setCust_name("张三");
        Customer customer2= new Customer();
        customer2.setCust_name("李四");

        //创建三个联系人
        LinkMans linkMans = new LinkMans();
        linkMans.setLkm_name("校花");
        LinkMans linkMans2 = new LinkMans();
        linkMans2.setLkm_name("小灶");
        LinkMans linkMans3 = new LinkMans();
        linkMans3.setLkm_name("翠花");

        //设置关系,双向关联
        customer.getLinkMans().add(linkMans);
        customer.getLinkMans().add(linkMans2);
        customer2.getLinkMans().add(linkMans3);
        linkMans.setCustomer(customer);
        linkMans2.setCustomer(customer);
        linkMans3.setCustomer(customer2);

        session.save(customer);
        session.save(customer2);
        session.save(linkMans);
        session.save(linkMans2);
        session.save(linkMans3);

        transaction.commit();
        //可以省略，因为获取的session对象绑定在了线程上了
//        session.close();
    }

Hibernate一对多的相关操作

一对多关系只保存（insert）一边是否可以：(不可以)

双向关联
customer.getLinkMans().add(linkMan);
linkMan.setCustomer(customer);

只有客户关联联系人 customer.getLinkMans().add(linkMan);一的一方
意思是当客户Customer关联联系人LinkMans时候，根据客户对应的Customer.hbm.xml文件中 set标签，进而关联到表中对应的外键，生成update语句进行修改表中的外键(先插入,再更新)，save()方法只是进行插入数据，

只有联系人关联客户 linkMan.setCustomer(customer);多的一方
意思是当联系人LinkMans关联客户Customer时候，根据客户对应的LinkMans.hbm.xml文件中 many-to-one标签，进而关联到表中对应的外键，直接插入相对应的外键，没有update的sql语句(只需要插入，不需要更新),save()方法只是进行插入数据。

双向关联customer.getLinkMans().add(linkMan); ----- linkMan.setCustomer(customer);
双向关联插入语句后，再更新

不关联
在save()方法之后，只是插入各自表中的数据，外键为null，没有指向主键

@Test
    // 一对多关系只保存一边是否可以？不可以
    public void demo2(){
        Session session = HibernateUtils.getCurrentSession();
        Transaction tx = session.beginTransaction();

        Customer customer = new Customer();
        customer.setCust_name("赵洪");

        LinkMans linkMan = new LinkMans();
        linkMan.setLkm_name("如花");
		//双向关联
        customer.getLinkMans().add(linkMan);
        linkMan.setCustomer(customer);

        // 只保存一边是否可以：不可以，
        //报一个瞬时对象异常：持久态对象关联了一个瞬时态对象。
        session.save(customer);
        session.save(linkMan);

        tx.commit();
    }

一对多的级联操作（解决只保存一边不可以的情况）

什么叫级联操作？

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

级联具有方向性

操作一的一方，级联操作多的一方

操作多的一方，级联操作一的一方

级联保存或更新

保存客户级联联系人

    @Test
    /**
     *  级联保存或更新操作：
     *  * 保存客户级联联系人，操作的主体是客户对象，需要在Customer.hbm.xml中进行配置
     *  * <set name="linkMans" cascade="save-update">
     */
    public void demo4(){
        Session session = HibernateUtils.getCurrentSession();
        Transaction tx = session.beginTransaction();
        Customer customer = new Customer();
        customer.setCust_name("赵洪");

        LinkMans linkMan = new LinkMans();
        linkMan.setLkm_name("如花");
        //双向关联
        customer.getLinkMans().add(linkMan);
        linkMan.setCustomer(customer);
        
        session.save(customer);
        tx.commit();
    }

保存联系人级联客户

@Test
	/**
	 *  级联保存或更新操作：
	 *  * 保存联系人级联客户，操作的主体是联系人对象，需要在LinkMan.hbm.xml中进行配置
	 *  * <many-to-one name="customer" cascade="save-update" class="com.itheima.hibernate.domain.Customer" column="lkm_cust_id"/>
	 */
	public void demo5(){
		Session session = HibernateUtils.getCurrentSession();
		Transaction tx = session.beginTransaction();
		
		Customer customer = new Customer();
		customer.setCust_name("李兵");

		LinkMans linkMan = new LinkMans();
		linkMan.setLkm_name("凤姐");
		
		customer.getLinkMans().add(linkMan);
		linkMan.setCustomer(customer);
		
		session.save(linkMan);
		
		tx.commit();
	}

测试对象导航

@Test
	/**
	 * 测试对象的导航
	 * * 前提：一对多的双方都设置cascade="save-update"
	 */
	public void demo5(){
		Session session = HibernateUtils.getCurrentSession();
		Transaction tx = session.beginTransaction();
		
		Customer customer = new Customer();
		customer.setCust_name("李兵");

		LinkMan linkMan1 = new LinkMan();
		linkMan1.setLkm_name("凤姐");
		LinkMan linkMan2 = new LinkMan();
		linkMan2.setLkm_name("如花");
		LinkMan linkMan3 = new LinkMan();
		linkMan3.setLkm_name("芙蓉");
		
		linkMan1.setCustomer(customer);
		customer.getLinkMans().add(linkMan2);
		customer.getLinkMans().add(linkMan3);
		
		// 双方都设置了cascade
//		session.save(linkMan1); // 发送几条insert语句  4条
//		session.save(customer); // 发送几条insert语句  3条
		session.save(linkMan2); // 发送几条insert语句  1条
		
		tx.commit();
	}

级联删除

不使用cascade属性，默认删除客户会吧客户下的联系人的外键设置为null，然后再删除客户

@Test
	/**
	 * 级联删除：
	 * * 删除客户级联删除联系人，删除的主体是客户，需要在Customer.hbm.xml中配置
	 * * <set name="linkMans" cascade="delete">
	 */
	public void demo6(){
		Session session = HibernateUtils.getCurrentSession();
		Transaction tx = session.beginTransaction();
		
		// 没有设置级联删除，默认情况:修改了联系人的外键，删除客户
		/*Customer customer = session.get(Customer.class, 1l);
		session.delete(customer);*/
		
		// 删除客户，同时删除联系人
		Customer customer = session.get(Customer.class, 1l);
		session.delete(customer);
		
		tx.commit();
	}
-------------------------------------------------------------------------
@Test
	/**
	 * 级联删除：
	 * * 删除联系人级联删除客户，删除的主体是联系人，需要在LinkMan.hbm.xml中配置
	 * * <many-to-one name="customer" cascade="delete">
	 */
	public void demo7(){
		Session session = HibernateUtils.getCurrentSession();
		Transaction tx = session.beginTransaction();
		
		// 删除客户，同时删除联系人
		LinkMan linkMan = session.get(LinkMan.class, 3l);
		session.delete(linkMan);
		
		tx.commit();
	}

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

在这里插入图片描述

解决方法

使用单向关联

使一方放弃外键维护，一般使一的一方放弃
在set 标签上设置inverse=“true”

区分cascade 和 inverse

@Test
	/**
	 * 区分cascade和inverse的区别
	 */
	public void demo9(){
		Session session = HibernateUtils.getCurrentSession();
		Transaction tx = session.beginTransaction();
		
		Customer customer = new Customer();
		customer.setCust_name("李兵");
		
		LinkMan linkMan = new LinkMan();
		linkMan.setLkm_name("凤姐");
		
		customer.getLinkMans().add(linkMan);
		
		// 条件在Customer.hbm.xml上的set中配置了cascade="save-update" inverse="true"
		 // 客户会插入到数据库，联系人也会插入到数据库，但是外键为null


		session.save(customer);
		
		tx.commit();
	}

Hibernate的多对多的关联映射

Hibernate的多对多的关系配置

创建表

用户表
CREATE TABLE sys_user (
user_id bigint(32) NOT NULL AUTO_INCREMENT COMMENT ‘用户id’,
user_code varchar(32) NOT NULL COMMENT ‘用户账号’,
user_name varchar(64) NOT NULL COMMENT ‘用户名称’,
user_password varchar(32) NOT NULL COMMENT ‘用户密码’,
user_state char(1) NOT NULL COMMENT ‘1:正常,0:暂停’,
PRIMARY KEY (user_id)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

角色表
CREATE TABLE sys_role (
role_id bigint(32) NOT NULL AUTO_INCREMENT,
role_name varchar(32) NOT NULL COMMENT ‘角色名称’,
role_memo varchar(128) DEFAULT NULL COMMENT ‘备注’,
PRIMARY KEY (role_id)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

中间表
CREATE TABLE sys_user_role (
role_id bigint(32) NOT NULL COMMENT ‘角色id’,
user_id bigint(32) NOT NULL COMMENT ‘用户id’,
PRIMARY KEY (role_id,user_id),
KEY FK_user_role_user_id (user_id),
CONSTRAINT FK_user_role_role_id FOREIGN KEY (role_id) REFERENCES sys_role (role_id) ON DELETE NO ACTION ON UPDATE NO ACTION,
CONSTRAINT FK_user_role_user_id FOREIGN KEY (user_id) REFERENCES sys_user (user_id) ON DELETE NO ACTION ON UPDATE NO ACTION
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

创建java实例

user.java

public class User {
	private Long user_id;
	private String user_code;
	private String user_name;
	private String user_password;
	private String user_state;
	// 设置多对多关系：表示一个用户选择多个角色？
	// 放置的是角色的集合
	private Set<Role> roles = new HashSet<Role>();
}

Role.java

public class Role {
	private Long role_id;
	private String role_name;
	private String role_memo;
	// 一个角色被多个用户选择：
	// 放置的是用户的集合
	private Set<User> users = new HashSet<User>();
	}

创建映射

User.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.itheima.hibernate.domain.User" table="sys_user">
		<!-- 建立OID与主键的映射 -->
		<id name="user_id" column="user_id">
			<generator class="native"/>
		</id>
		<!-- 建立普通属性与字段映射 -->
		<property name="user_code" column="user_code"/>
		<property name="user_name" column="user_name"/>
		<property name="user_password" column="user_password"/>
		<property name="user_state" column="user_state"/>
		<!-- 建立与角色的多对多的映射关系 -->
		<!-- 
			set标签
				* name		：对方的集合的属性名称。
				* table		：多对多的关系需要使用中间表，放的是中间表的名称。
		 -->
		<set name="roles" table="sys_user_role" cascade="save-update,delete"  >
			<!-- 
				key标签：
					* column	：当前的对象对应中间表的外键的名称。
			 -->
			<key column="user_id"/>
			<!-- 
				many-to-many标签：
					* class		：对方的类的全路径
					* column	：对方的对象在中间表中的外键的名称。
			 -->
			<many-to-many class="com.day03.Role" column="role_id"/>
		</set>
	</class>
</hibernate-mapping>

Role.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.itheima.hibernate.domain.Role" table="sys_role">
		<!-- 建立OID与主键的映射 -->
		<id name="role_id" column="role_id">
			<generator class="native"/>
		</id>
		<!-- 建立普通属性与字段的映射 -->
		<property name="role_name" column="role_name"/>
		<property name="role_memo" column="role_memo"/>
		<!-- 与用户的多对多的映射关系 -->
		<!-- 
			set标签
				* name		：对方的集合的属性名称。
				* table		：多对多的关系需要使用中间表，放的是中间表的名称。
		 -->
		<set name="users" table="sys_user_role" cascade="save-update,delete" inverse="true">
			<!-- 
				key标签：
					* column	：当前的对象对应中间表的外键的名称。
			 -->
			<key column="role_id"/>
			<!-- 
				many-to-many标签：
					* class		：对方的类的全路径
					* column	：对方的对象在中间表中的外键的名称。
			 -->
			<many-to-many class="com.day03.User" column="user_id"/>
		</set>
	</class>
</hibernate-mapping>

创建测试类

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

@Test
	/**
	 * 保存多条记录：保存多个用户和角色
	 */
	public void demo1(){
		Session session = HibernateUtils.getCurrentSession();
		Transaction tx = session.beginTransaction();
		
		// 创建2个用户
		User user1 = new User();
		user1.setUser_name("赵洪");
		User user2 = new User();
		user2.setUser_name("李兵");
		
		// 创建3个角色
		Role role1 = new Role();
		role1.setRole_name("研发部");
		Role role2 = new Role();
		role2.setRole_name("市场部");
		Role role3 = new Role();
		role3.setRole_name("公关部");
		
		// 设置双向的关联关系:
		user1.getRoles().add(role1);
		user1.getRoles().add(role2);
		user2.getRoles().add(role2);
		user2.getRoles().add(role3);
		role1.getUsers().add(user1);
		role2.getUsers().add(user1);
		role2.getUsers().add(user2);
		role3.getUsers().add(user2);
		
		// 保存操作:多对多建立了双向的关系必须有一方放弃外键维护。
		// 一般是被动方放弃外键维护权。
		session.save(user1);
		session.save(user2);
		session.save(role1);
		session.save(role2);
		session.save(role3);
		tx.commit();
	}

Hibernate的多对多的相关操作

多对多只保存一边是否可以

@Test
	/**
	 * 多对多的操作：
	 * * 只保存一边是否可以？不可以，瞬时对象异常
	 */
	public void demo2(){
		Session session = HibernateUtils.getCurrentSession();
		Transaction tx = session.beginTransaction();
		
		// 创建2个用户
		User user1 = new User();
		user1.setUser_name("赵洪");
		
		// 创建3个角色
		Role role1 = new Role();
		role1.setRole_name("研发部");
		
		// 设置双向的关联关系:
		user1.getRoles().add(role1);
		role1.getUsers().add(user1);
		// 只保存用户：
		// session.save(user1);
		session.save(role1);
		
		tx.commit();
	}

多对多的级联保存或更新

@Test
	/**
	 * 多对多的级联保存：
	 * * 保存用户级联保存角色。在用户的映射文件中配置。
	 * * 在User.hbm.xml中的set上配置 cascade="save-update"
	 */
	public void demo3(){
		Session session = HibernateUtils.getCurrentSession();
		Transaction tx = session.beginTransaction();
		
		// 创建2个用户
		User user1 = new User();
		user1.setUser_name("赵洪");
		
		// 创建3个角色
		Role role1 = new Role();
		role1.setRole_name("研发部");
		
		// 设置双向的关联关系:
		user1.getRoles().add(role1);
		role1.getUsers().add(user1);
		// 只保存用户：
		session.save(user1);
		
		tx.commit();
	}
	
	/**
	 * 多对多的级联保存：
	 * * 保存角色级联保存用户。在角色的映射文件中配置。
	 * * 在Role.hbm.xml中的set上配置 cascade="save-update"
	 */
	@Test
	public void demo4(){
		Session session = HibernateUtils.getCurrentSession();
		Transaction tx = session.beginTransaction();
		
		// 创建2个用户
		User user1 = new User();
		user1.setUser_name("李兵");
		
		// 创建3个角色
		Role role1 = new Role();
		role1.setRole_name("公关部");
		
		// 设置双向的关联关系:
		user1.getRoles().add(role1);
		role1.getUsers().add(user1);
		// 只保存用户：
		session.save(role1);
		
		tx.commit();
	}

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

/**
	 * 多对多的级联删除：
	 * * 删除用户级联删除角色
	 * * 在User.hbm.xml中的set上配置 cascade="delete"
	 */
	@Test
	public void demo5(){
		Session session = HibernateUtils.getCurrentSession();
		Transaction tx = session.beginTransaction();
		
		// 查询1号用户:
		User user  = session.get(User.class, 1l);
		session.delete(user);
		
		tx.commit();
	}
	
	/**
	 * 多对多的级联删除：
	 * * 删除角色级联删除用户
	 * * 在Role.hbm.xml中的set上配置 cascade="delete"
	 */
	@Test
	public void demo6(){
		Session session = HibernateUtils.getCurrentSession();
		Transaction tx = session.beginTransaction();
		
		// 查询2号角色:
		Role role  = session.get(Role.class, 2l);
		session.delete(role);
		
		tx.commit();
	}

多对多的其他的操作


	@Test
	/**
	 * 给用户选择角色
	 */
	public void demo7(){
		Session session = HibernateUtils.getCurrentSession();
		Transaction tx = session.beginTransaction();
		
		// 给1号用户多选2号角色
		// 查询1号用户
		User user  = session.get(User.class, 1l);
		// 查询2号角色
		Role role = session.get(Role.class, 2l);
		user.getRoles().add(role);
		
		tx.commit();
	}
	
	@Test
	/**
	 * 给用户改选角色
	 */
	public void demo8(){
		Session session = HibernateUtils.getCurrentSession();
		Transaction tx = session.beginTransaction();
		
		// 给2号用户将原有的2号角色改为3号角色
		// 查询2号用户
		User user  = session.get(User.class, 2l);
		// 查询2号角色
		Role role2 = session.get(Role.class, 2l);
		Role role3 = session.get(Role.class, 3l);
		user.getRoles().remove(role2);
		user.getRoles().add(role3);
		
		tx.commit();
	}
	
	@Test
	/**
	 * 给用户改选角色
	 */
	public void demo9(){
		Session session = HibernateUtils.getCurrentSession();
		Transaction tx = session.beginTransaction();
		
		// 给2号用户删除1号角色
		// 查询2号用户
		User user  = session.get(User.class, 2l);
		// 查询1号角色
		Role role = session.get(Role.class, 1l);
		user.getRoles().remove(role);
		
		tx.commit();
	}

侯侯侯先生

发布了60 篇原创文章 · 获赞 16 · 访问量 1万+

私信关注

Hibernate详解一对多、多对多的映射

目录

数据库表与表之间的关系

Hibernate的一对多的关联映射

Hibernate一对多的关系配置

创建一个java项目，引入相关jar包

创建数据库和表

创建实体类

创建实体类的映射文件

创建实体类的核心配置文件

引入工具类

编写测试代码

Hibernate一对多的相关操作

一对多关系只保存（insert）一边是否可以：(不可以)

一对多的级联操作（解决只保存一边不可以的情况）

测试对象导航

级联删除

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

区分cascade 和 inverse

Hibernate的多对多的关联映射

Hibernate的多对多的关系配置

创建表

创建java实例

创建映射

创建测试类

Hibernate的多对多的相关操作

多对多只保存一边是否可以

多对多的级联保存或更新

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

多对多的其他的操作

猜你喜欢

Hibernate详解 一对多、多对多的映射

目录

数据库表与表之间的关系

Hibernate的一对多的关联映射

Hibernate一对多的关系配置

创建一个java项目，引入相关jar包

创建数据库和表

创建实体类

创建实体类的映射文件

创建实体类的核心配置文件

引入工具类

编写测试代码

Hibernate一对多的相关操作

一对多关系只保存（insert）一边是否可以：(不可以)

一对多的级联操作（解决只保存一边不可以的情况）

测试对象导航

级联删除

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

区分cascade 和 inverse

Hibernate的多对多的关联映射

Hibernate的多对多的关系配置

创建表

创建java实例

创建映射

创建测试类

Hibernate的多对多的相关操作

多对多只保存一边是否可以

多对多的级联保存或更新

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

多对多的其他的操作

猜你喜欢

Hibernate详解一对多、多对多的映射